Aprenda a modelar una cámara que pueda desplazarse por el mundo de su juego para agregar realismo y funcionalidad.

Una característica común que encontrarás en muchos juegos es una cámara de desplazamiento que te sigue mientras te mueves por el mundo del juego. Este efecto puede agregar profundidad y realismo a tu juego y mejorar la experiencia de juego en general.

Hay muchas formas diferentes de implementar una cámara de desplazamiento en PyGame, así que asegúrese de comprender sus diferencias.

Crear un juego simple

Antes de empezar, instala pip en tu dispositivo y use el siguiente comando para instalar el módulo PyGame:

pip instalar pygame

Ahora, puede crear un juego simple con un rectángulo de jugador y dos plataformas estáticas. El jugador puede moverse hacia la izquierda y hacia la derecha usando las teclas de flecha.

Puede encontrar el código completo para el proyecto en este repositorio de GitHub.

Comience importando el módulo pygame. Luego, inicialícelo y cree la ventana del juego usando el

instagram viewer
pygame.display.set_mode() función. Luego, establezca el título de la ventana y cree el objeto de reloj para gestionar la velocidad de fotogramas.

importar Pygame
pygame.init()


WINDOW_WIDTH = 800
VENTANA_ALTURA = 600


pantalla = pygame.display.set_mode((VENTANA_ANCHO, VENTANA_ALTO))


pygame.display.set_caption("Mi juego simple")


reloj = pygame.hora. Reloj()
COLOR_FONDO = (255, 255, 255)

A continuación, configure el reproductor y las plataformas estáticas. Define el tamaño del jugador y su posición inicial.

JUGADOR_ANCHO = 50
JUGADOR_ALTURA = 50
jugador_x = ANCHO_VENTANA // 2 - ANCHO_JUGADOR // 2
player_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20


VELOCIDAD DEL JUGADOR = 10


RECTÁNGULO_COLOR_1 = (255, 0, 0)
RECTÁNGULO_COLOR_2 = (0, 0, 255)
rectángulo_1 = pygame. Rect(200, 200, 100, 100)
rectángulo_2 = pygame. Rect(500, 300, 150, 50)

Luego, cree un bucle de juego que maneje eventos y actualice la pantalla. En el ciclo, verifica eventos como salir del juego o mover al jugador usando las teclas de flecha.

mientrasVerdadero:
# Manejar eventos
para evento en pygame.event.get():
si evento.tipo == pygame. ABANDONAR:
 pygame.quit()
 abandonar()
# Dibuja el fondo
 pantalla.rellenar (BACKGROUND_COLOR)


# Dibuja los rectángulos estáticos
 pygame.draw.rect (pantalla, RECTANGLE_COLOR_1, rectángulo_1)
 pygame.draw.rect (pantalla, RECTANGLE_COLOR_2, rectángulo_2)


# Dibuja al jugador
 player_rect = pygame. Rect (player_x, player_y, PLAYER_WIDTH,
 JUGADOR_ALTURA)


 pygame.draw.rect (pantalla, (0, 0, 0), player_rect)


# Actualizar la pantalla
 pygame.display.update()
# Limitar la velocidad de fotogramas
 reloj.tick(30)

Configuración de la cámara

Ahora que tiene un juego simple con un rectángulo de jugador y dos plataformas estáticas, puede comenzar a trabajar en la cámara. En PyGame, la cámara es esencialmente solo un desplazamiento que actúa sobre todos los objetos que dibujas en la pantalla. Esto significa que si mueve la cámara hacia la izquierda, todo en la pantalla parecerá moverse hacia la derecha.

Para configurar la cámara, primero debe definir una variable para mantener el desplazamiento X de la cámara. Llame a esta variable cámara_offset_x e inicializarlo a 0.

# Establecer el desplazamiento de la cámara
cámara_offset_x = 0

A continuación, actualice las posiciones de todos los objetos que dibuje en la pantalla, para tener en cuenta el desplazamiento de la cámara. Puede hacer esto agregando el cámara_offset_x valor a la posición X de cada objeto. Por ejemplo, puede actualizar la posición del jugador de esta manera:

# Dibuja al jugador
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 JUGADOR_ALTURA)
pygame.draw.rect (pantalla, (0, 0, 0), player_rect)

Del mismo modo, puede actualizar las posiciones de las plataformas estáticas de la siguiente manera:

# Dibuja los rectángulos estáticos
rectángulo_1_dibujar_pos = rectángulo_1.mover (cámara_desplazamiento_x, 0)
pygame.draw.rect (pantalla, RECTANGLE_COLOR_1, rectángulo_1_draw_pos)

rectángulo_2_dibujar_pos = rectángulo_2.mover (cámara_desplazamiento_x, 0)
pygame.draw.rect (pantalla, RECTANGLE_COLOR_2, rectángulo_2_draw_pos)

Mover la cámara con entradas de teclado

Ahora que tiene la cámara configurada, puede comenzar a moverla. Una forma de hacer esto es mover la cámara en respuesta a las entradas del teclado. Por ejemplo, puede mover la cámara hacia la izquierda cuando el jugador presiona la tecla de flecha izquierda.

Para hacer esto, agregue el siguiente código dentro del ciclo de eventos que maneja las entradas del teclado:

si evento.tipo == pygame. TECLADO:
si evento.clave == pygame. K_IZQUIERDA:
 camera_offset_x -= PLAYER_SPEED
elif evento.clave == pygame. K_DERECHO:
 camera_offset_x += PLAYER_SPEED

Otra forma es cambiar la coordenada x del jugador al presionar el teclado y luego actualizar el desplazamiento de la cámara. Puedes implementar esto así:

# Manejar eventos
para evento en pygame.event.get():
si evento.tipo == pygame. ABANDONAR:
 pygame.quit()
 abandonar()
si evento.tipo == pygame. TECLADO:
si evento.clave == pygame. K_IZQUIERDA:
 player_x -= PLAYER_SPEED
elif evento.clave == pygame. K_DERECHO:
 jugador_x += VELOCIDAD DEL JUGADOR

Luego, puede actualizar el desplazamiento de la cámara con respecto a la coordenada x del jugador de la siguiente manera:

camera_offset_x = VENTANA_ANCHO // 2 - jugador_x - JUGADOR_ANCHO // 2

Mover la cámara con entradas de ratón

Otra forma de mover la cámara es usar el mouse. Puede permitir que el jugador arrastre la pantalla haciendo clic y arrastrando el mouse.

Para hacer esto, siga la posición del mouse cuando el jugador presiona el botón izquierdo del mouse. Cuando mueva el mouse, actualice la coordenada x del jugador. Debería cambiar por la diferencia entre la posición actual del mouse y la posición inicial que rastreó, mouse_start_pos.

# Manejar eventos
para evento en pygame.event.get():
si evento.tipo == pygame. ABANDONAR:
 pygame.quit()
 abandonar()
si evento.tipo == pygame. BOTÓN DEL RATÓN:
si evento.boton == 1:
 mouse_start_pos = pygame.mouse.get_pos()
si evento.tipo == pygame. MOVIMIENTO DEL RATÓN:
si pygame.mouse.get_pressed()[0]:
 mouse_current_pos = pygame.mouse.get_pos()
 mouse_offset_x = mouse_current_pos[0] - mouse_start_pos[0]
 player_x -= mouse_offset_x
 mouse_start_pos = mouse_current_pos

Adición de más funciones de cámara

Además del efecto de desplazamiento de la cámara, puede agregar otras funciones relacionadas con la cámara para mejorar la experiencia de juego. Una de esas características es un efecto de cámara con zoom que permite al jugador acercar o alejar el mundo del juego. Puedes lograr este efecto cambiando el tamaño de la ventana del juego y escalando los objetos dibujados en la pantalla.

Para hacer esto, defina una variable de zoom que almacenará el nivel de zoom actual del juego. Establezca su valor inicial en 1,0, lo que representa que no hay zoom. Luego, defina una función que calcule el tamaño escalado de un objeto en función del nivel de zoom actual.

acercar = 1.0
definitivamenteget_scaled_size(tamaño):
devolver int (tamaño * zoom)

A continuación, actualice las posiciones y tamaños de los objetos dibujados en la pantalla usando el get_scaled_size función. Por ejemplo, puede actualizar la posición y el tamaño del jugador de la siguiente manera:

player_rect = pygame. Rect(
 get_scaled_size (player_x + camera_offset_x),
 get_scaled_size (jugador_y),
 get_scaled_size (PLAYER_WIDTH),
 get_scaled_size (PLAYER_HEIGHT)
)

Del mismo modo, actualice las posiciones y tamaños de las plataformas estáticas de la siguiente manera:

rectángulo_1_draw_pos = pygame. Rect(
 get_scaled_size (rectangle_1.x + camera_offset_x),
 get_scaled_size (rectángulo_1.y),
 get_scaled_size (rectangle_1.width),
 get_scaled_size (rectangle_1.height)
)
pygame.draw.rect (pantalla, RECTANGLE_COLOR_1, rectángulo_1_draw_pos)


rectángulo_2_dibujar_pos = pygame. Rect(
 get_scaled_size (rectangle_2.x + camera_offset_x),
 get_scaled_size (rectángulo_2.y),
 get_scaled_size (rectangle_2.width),
 get_scaled_size (rectangle_2.height)
)
pygame.draw.rect (pantalla, RECTANGLE_COLOR_2, rectángulo_2_draw_pos)

Aumenta o disminuye el nivel de zoom en 0,1 cuando el jugador presiona el = o - clave, respectivamente. Establece el nuevo tamaño de la ventana del juego según el nivel de zoom actual. Para hacer esto, agregue el siguiente código dentro del ciclo de eventos que maneja las entradas del teclado:

si evento.tipo == pygame. TECLADO:
si evento.clave == pygame. K_IGUAL:
 acercar += 0.1
 pantalla = pygame.display.set_mode((
 int (ANCHO_VENTANA * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))
elif evento.clave == pygame. K_MINUS:
 acercar -= 0.1


si acercar < 0.1:
 acercar = 0.1
 pantalla = pygame.display.set_mode((
 int (ANCHO_VENTANA * zoom),
 int (WINDOW_HEIGHT * zoom)
 ))

Con el código anterior, ha agregado con éxito un efecto de zoom de cámara a nuestro juego PyGame. Al combinar esta función con el efecto de desplazamiento de la cámara, puede crear una experiencia de juego dinámica y atractiva.

Mejorar el juego con movimientos de cámara

Agregar una cámara de desplazamiento a un juego PyGame no solo mejora la experiencia visual sino que también mejora el juego. Le permite al jugador ver más del mundo del juego, brindándole una mejor comprensión de su entorno y facilitando la navegación.

También puede usar el movimiento de la cámara para crear efectos especiales, como acercar y alejar o agitar la pantalla para simular explosiones o terremotos.