Escalar imágenes en Pygame

Para cambiar el tamaño de una imagen en Pygame, pasa su superficie y el tamaño objetivo (width, height) a pygame.transform.scale(). La función devuelve una nueva superficie con esas dimensiones. Usa un factor de escala compartido para cambios de tamaño proporcionales, o actualiza el factor cuando cambie la entrada o el estado del juego. (pygame.transform.scale2x())

Cargar una imagen en Pygame

pygame.image.load() lee un archivo de imagen y devuelve una Surface, que puedes pasar a una transformación y dibujar con screen.blit(). Crea la pantalla antes de llamar a convert() o convert_alpha() para adaptar la superficie a esa pantalla. Usa convert_alpha() cuando la imagen necesita transparencia por píxel, y conserva la superficie original para que los cambios de tamaño posteriores no acumulen las escalas anteriores.

Por ejemplo, carga un recurso del proyecto con image = pygame.image.load("assets/ship.png").convert_alpha(). Reemplaza la ruta por la ubicación de tu propia imagen; el archivo debe estar disponible cuando el programa se ejecuta.

Escalar una imagen a un tamaño específico

Llama a pygame.transform.scale(image, (400, 300)) para solicitar una superficie de 400 por 300. El ancho y el alto son independientes: si ese par tiene una relación de aspecto diferente de la fuente, la imagen se estirará o se comprimirá. Elige dimensiones con la misma relación cuando la forma debe permanecer sin cambios.

Para pixel art que debe tener exactamente el doble de ancho y alto, pygame.transform.scale2x(image) es una opción concisa. Duplica cada dimensión y es útil cuando ese tamaño doble se adapta al diseño; no es un reemplazo general para elegir dimensiones arbitrarias con pygame.transform.scale().

Escalar una imagen proporcionalmente

Comienza con las dimensiones de la superficie original y multiplica ambas por el mismo factor. Convierte las dimensiones calculadas a enteros antes de pasarlas a pygame.transform.scale(). Para encajar una imagen dentro de una caja sin cambiar su forma, usa la menor de las relaciones entre el ancho disponible y el ancho de la fuente y entre el alto disponible y el alto de la fuente. Esto mantiene la superficie escalada dentro de ambos límites.

Por ejemplo, si la fuente es de 640 por 400 y la caja máxima es de 320 por 240, el factor limitante es min(320 / 640, 240 / 400), es decir, 0.5. Las dimensiones resultantes son 320 por 200. Calcula cada vez desde las dimensiones originales para que los cambios repetidos no reduzcan progresivamente el detalle.

Cambiar el tamaño de una imagen dinámicamente

Un juego puede cambiar un factor de escala en respuesta a teclas, un ajuste de zoom u otro valor del estado del juego. Calcula cada tamaño solicitado desde la superficie original para que las transformaciones anteriores no afecten a las posteriores. Este ejemplo independiente muestra el cálculo de dimensiones para una imagen de 48 por 32 píxeles; usa solo la biblioteca estándar de Python.

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

En un bucle de Pygame, usa las dimensiones calculadas en pygame.transform.scale(original, scaled_size), dibuja la superficie devuelta con screen.blit() y actualiza la pantalla. Maneja pygame.QUIT para salir del bucle y luego llama a pygame.quit() durante el cierre. Cuando una tecla cambie el factor, recalcula la superficie una vez y reutilízala en otros fotogramas. Para un tamaño que cambia continuamente, compara las dimensiones solicitadas con el tamaño anterior antes de transformar. Escalar repetidamente puede añadir trabajo, así que guarda en caché y reutiliza las superficies transformadas para los tamaños usados con frecuencia; aquí no se implica ninguna medición de rendimiento.

Este ejemplo completo crea una pequeña superficie en el código, por lo que no tiene como requisito un archivo de imagen. Maneja los eventos de ventana y las teclas + y -, y usa un fotograma para que el ejemplo también termine por sí solo. En un juego, elimina el límite de fotogramas para mantener la ventana abierta; reemplaza la superficie generada por una devuelta por pygame.image.load().

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()