Bilder in Pygame skalieren

Um die Größe eines Bildes in Pygame zu ändern, übergeben Sie seine Surface und die Zielgröße (width, height) an pygame.transform.scale(). Die Funktion gibt eine neue Surface mit diesen Abmessungen zurück. Verwenden Sie einen gemeinsamen Skalierungsfaktor für proportionale Größenänderungen oder aktualisieren Sie den Faktor, wenn sich Eingaben oder der Spielzustand ändern. (pygame.transform.scale2x())

Ein Bild in Pygame laden

pygame.image.load() liest eine Bilddatei und gibt eine Surface zurück, die Sie an eine Transformation übergeben und mit screen.blit() zeichnen können. Erstellen Sie das Display, bevor Sie convert() oder convert_alpha() aufrufen, damit die Surface an dieses Display angepasst wird. Verwenden Sie convert_alpha(), wenn das Bild Transparenz pro Pixel benötigt, und behalten Sie die ursprüngliche Surface, damit spätere Größenänderungen frühere Skalierungen nicht aufsummieren.

Laden Sie beispielsweise ein Projekt-Asset mit image = pygame.image.load("assets/ship.png").convert_alpha(). Ersetzen Sie den Pfad durch den Speicherort Ihres eigenen Bildes; die Datei muss verfügbar sein, wenn das Programm läuft.

Ein Bild auf eine bestimmte Größe skalieren

Rufen Sie pygame.transform.scale(image, (400, 300)) auf, um eine Surface mit 400 mal 300 anzufordern. Breite und Höhe sind unabhängig: Wenn dieses Paar ein anderes Seitenverhältnis als die Quelle hat, wird das Bild gestreckt oder gestaucht. Wählen Sie Abmessungen mit demselben Verhältnis, wenn die Form unverändert bleiben muss.

Für Pixel-Art, die genau doppelt so breit und hoch werden soll, ist pygame.transform.scale2x(image) eine knappe Option. Es verdoppelt jede Abmessung und ist nützlich, wenn diese doppelte Größe zum Layout passt; es ist kein allgemeiner Ersatz für die Wahl beliebiger Abmessungen mit pygame.transform.scale().

Ein Bild proportional skalieren

Beginnen Sie mit den Abmessungen der ursprünglichen Surface und multiplizieren Sie beide mit demselben Faktor. Wandeln Sie die berechneten Abmessungen in Ganzzahlen um, bevor Sie sie an pygame.transform.scale() übergeben. Um ein Bild in eine Box einzupassen, ohne seine Form zu ändern, verwenden Sie das kleinere Verhältnis von verfügbarer Breite zu Quellbreite und verfügbarer Höhe zu Quellhöhe. Dadurch bleibt die skalierte Surface innerhalb beider Grenzen.

Wenn die Quelle beispielsweise 640 mal 400 groß ist und die maximale Box 320 mal 240 beträgt, ist der begrenzende Faktor min(320 / 640, 240 / 400), also 0.5. Die resultierenden Abmessungen sind 320 mal 200. Rechnen Sie jedes Mal von den ursprünglichen Abmessungen aus, damit wiederholte Änderungen die Details nicht fortschreitend verringern.

Ein Bild dynamisch in der Größe ändern

Ein Spiel kann einen Skalierungsfaktor als Reaktion auf Tasten, eine Zoom-Einstellung oder einen anderen Spielzustandswert ändern. Berechnen Sie jede angeforderte Größe aus der ursprünglichen Surface, damit frühere Transformationen spätere nicht beeinflussen. Dieses eigenständige Beispiel zeigt die Abmessungsberechnung für ein Bild mit 48 mal 32 Pixeln; es verwendet nur die Python-Standardbibliothek.

original_size = (48, 32)
scale_factor = 2.0
scaled_size = tuple(int(dimension * scale_factor) for dimension in original_size)
print(f"Scaled size: {scaled_size[0]} x {scaled_size[1]}")

Scaled size: 96 x 64

Verwenden Sie in einer Pygame-Schleife die berechneten Abmessungen in pygame.transform.scale(original, scaled_size), zeichnen Sie die zurückgegebene Surface mit screen.blit() und aktualisieren Sie das Display. Behandeln Sie pygame.QUIT, um die Schleife zu verlassen, und rufen Sie dann beim Beenden pygame.quit() auf. Wenn eine Taste den Faktor ändert, berechnen Sie die Surface einmal neu und verwenden Sie sie in anderen Frames weiter. Vergleichen Sie bei einer sich kontinuierlich ändernden Größe die angeforderten Abmessungen mit der vorherigen Größe, bevor Sie transformieren. Wiederholtes Skalieren kann zusätzliche Arbeit verursachen; speichern Sie daher transformierte Surfaces für häufig verwendete Größen zwischen und verwenden Sie sie wieder; eine Leistungsmessung wird hier nicht behauptet.

Dieses vollständige Beispiel erzeugt eine kleine Surface im Code und hat daher keine Bilddatei als Voraussetzung. Es behandelt Fensterereignisse und die Tasten + und - und verwendet einen Frame, sodass das Beispiel auch von selbst endet. Entfernen Sie in einem Spiel das Frame-Limit, um das Fenster offen zu halten; ersetzen Sie die erzeugte Surface durch eine, die von pygame.image.load() zurückgegeben wird.

import os

os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
os.environ.setdefault("SDL_AUDIODRIVER", "dummy")

import pygame

pygame.display.init()
try:
    screen = pygame.display.set_mode((320, 240))
    original = pygame.Surface((48, 32), pygame.SRCALPHA)
    original.fill((40, 150, 220, 255))
    pygame.draw.rect(original, (245, 210, 60, 255), (8, 8, 32, 16))

    scale_factor = 2.0
    scaled = pygame.transform.scale(
        original,
        (int(original.get_width() * scale_factor), int(original.get_height() * scale_factor)),
    )
    running = True
    frame_count = 0

    while running and frame_count < 1:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key in (pygame.K_PLUS, pygame.K_EQUALS):
                    scale_factor += 0.25
                elif event.key == pygame.K_MINUS:
                    scale_factor = max(0.25, scale_factor - 0.25)
                else:
                    continue

                size = (
                    int(original.get_width() * scale_factor),
                    int(original.get_height() * scale_factor),
                )
                scaled = pygame.transform.scale(original, size)

        screen.fill((30, 30, 30))
        screen.blit(scaled, (20, 20))
        pygame.display.flip()
        frame_count += 1
finally:
    pygame.display.quit()
    pygame.quit()