¿Cómo se escala una resolución de diseño a otras resoluciones con Pygame?

Bienvenido a proyecto online, en este lugar vas a hallar la solucíon que estabas buscando.

Solución:

Pasó un tiempo jugando y armando una demostración que muestra cómo podría abordar este problema. Búscate una imagen para probar y pon la string ruta a esa imagen en el script para el valor de imagePath.

La funcionalidad de este script es simple. Al golpear a la izquierda o a la derecha en la flecha keysla resolución de la pantalla cambia a través de una tupla de resoluciones aceptables y la pantalla cambia de tamaño en consecuencia mientras escala su imagen de prueba a la nueva resolución.

import pygame,sys
from pygame import *
from pygame.locals import *


displayIndex = 0
pygame.init()

##standard 16:9 display ratios
DISPLAYS = [(1024,576),(1152,648),(1280,720),(1600,900),(1920,1080),(2560,1440)] 
screen = pygame.display.set_mode(DISPLAYS[displayIndex])
screen.fill((0,0,0))
### change image path to a string that names an image you'd like to load for testing. I just used a smiley face from google image search.
### Put it in the same place as this file or set up your paths appropriately
imagePath = "Smiley-icon.png"


class Icon(pygame.sprite.Sprite):
    def __init__(self,x,y):
        pygame.sprite.Sprite.__init__(self)
        self.smileyImage = pygame.image.load(imagePath)
        self.image = self.smileyImage.convert_alpha()
        ### need to assume a default scale, DISPLAYS[0] will be default for us
        self.rect = self.image.get_rect()
        self.posX = x
        self.posY = y
        self.rect.x = x
        self.rect.y = y
        self.defaultx = (float(self.rect[2])/DISPLAYS[0][0])*100
        self.defaulty = (float(self.rect[3])/DISPLAYS[0][1])*100
        ## this is the percent of the screen that the image should take up in the x and y planes



    def updateSize(self,):
        self.image = ImageRescaler(self.smileyImage,(self.defaultx,self.defaulty))
        self.rect = self.image.get_rect()
        self.rect.x = self.posX
        self.rect.y = self.posY


def ImageRescaler(image,originalScaleTuple): #be sure to restrict to only proper ratios
    newImage = pygame.transform.scale(image,(int(DISPLAYS[displayIndex][0]*(originalScaleTuple[0]/100)),
                                         int(DISPLAYS[displayIndex][1]*(originalScaleTuple[1]/100))))
    return newImage


def resizeDisplay():
    screen = pygame.display.set_mode(DISPLAYS[displayIndex])
    ## this is where you'd have'd probably want your sprite groups set to resize themselves
    ## Just gonna call it on icon here
    icon.updateSize()


icon = Icon(100,100)
while True:
    screen.fill((0,0,0))
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()

        if event.type == KEYDOWN:
            if event.key == K_LEFT:
                displayIndex -=1
                if displayIndex < 0:
                    displayIndex = 5
                resizeDisplay()
            elif event.key == K_RIGHT:
                displayIndex+=1
                if displayIndex > 5:
                    displayIndex = 0
                resizeDisplay()




    screen.blit(icon.image,(icon.rect.x,icon.rect.y))  
    pygame.display.update()

La mejor manera de hacerlo es reducir la escala de las imágenes para preservar la calidad de la imagen. Aquí hay dos opciones:

Opción 1

Este método es probablemente el más rápido.

1. Cree imágenes para que sean compatibles con la mayor resolución que pretenda admitir.

2. Cree una pantalla con el tamaño deseado por el usuario.

   screen = pygame.display.set_mode((user_x, user_y))
   

3. Reducir la escala de imágenes en el momento de la carga

   image = pygame.image.load("a.png").convert_alpha()
   pygame.transform.scale(image, (screen.width() / your_max_width, screen.height() / your_max_height), DestSurface=image)
   

4. Ahora, solo límpialos normalmente. Debe funcionar a velocidades normales.

opcion 2

1. Cree una pantalla con el tamaño deseado por el usuario.

   screen = pygame.display.set_mode((user_x, user_y))
   

2. A continuación, cree un pygame.Superficie con la más alta resolución tú tienen la intención de apoyar.

   surface = pygame.Surface((1920, 1080))
   

3. Luego, blit todo a esa superficie.

   surface.blit(image, rect)
   # Etc...
   

4. Después de completar todos los blits, reduzca la escala de la superficie (según sea necesario) a la resolución que desee el usuario. Preferiblemente, solo permitiría resoluciones con la misma relación de aspecto.

   pygame.transform.scale(surface, ((screen.width() / your_max_width, screen.height() / your_max_height), DestSurface=surface)
   

5. Finalmente, aplique un blit a la superficie de la pantalla y muéstrelo.

   screen.blit(surface, (0, 0))
   pygame.display.update()
   

Este proceso (reducción de escala) le permite conservar la calidad de la imagen y, al mismo tiempo, permitir que el usuario elija la resolución de su pantalla. Será más lento porque estás constantemente manipulando imágenes.

---

---

Utiliza Nuestro Buscador