Aggiungi una telecamera a scorrimento ai tuoi giochi PyGame

Una caratteristica comune che troverai in molti giochi è una telecamera a scorrimento che ti segue mentre ti muovi nel mondo di gioco. Questo effetto può aggiungere profondità e realismo al tuo gioco e migliorare l'esperienza di gioco complessiva.

Esistono molti modi diversi per implementare una telecamera a scorrimento in PyGame, quindi assicurati di comprendere le loro differenze.

Creazione di un gioco semplice

Prima di cominciare, installa pip sul tuo dispositivo e usa il comando seguente per installare il modulo PyGame:

pip installa pygame

Ora puoi creare un gioco semplice con un rettangolo giocatore e due piattaforme statiche. Il giocatore può spostarsi a sinistra ea destra usando i tasti freccia.

Puoi trovare il codice completo per il progetto in questo Repository GitHub.

Inizia importando il modulo pygame. Quindi, inizializzalo e crea la finestra di gioco usando il file

pygame.display.set_mode() funzione. Quindi, imposta la didascalia della finestra e crea il file oggetto orologio per gestire il frame rate.

importare pygame
pygame.init()
WINDOW_WIDTH = 800
ALTEZZA_FINESTRA = 600
schermo = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Il mio gioco semplice")
orologio = pygame.time. Orologio()
COLORE_SFONDO = (255, 255, 255)

Successivamente, imposta il lettore e le piattaforme statiche. Definisci la dimensione del giocatore e la sua posizione iniziale.

PLAYER_WIDTH = 50
ALTEZZA_GIOCATORE = 50
player_x = WINDOW_WIDTH // 2 - PLAYER_WIDTH // 2
player_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20
GIOCATORE_VELOCITÀ = 10
RETTANGOLO_COLORE_1 = (255, 0, 0)
RETTANGOLO_COLORE_2 = (0, 0, 255)
rettangolo_1 = pygame. Rett(200, 200, 100, 100)
rettangolo_2 = pygame. Rett(500, 300, 150, 50)

Quindi, crea un ciclo di gioco che gestisce gli eventi e aggiorna lo schermo. Nel ciclo, verifica la presenza di eventi come l'uscita dal gioco o lo spostamento del giocatore utilizzando i tasti freccia.

MentreVERO:
# Gestisci gli eventi
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 pygame.quit()
 esentato()
# Disegna lo sfondo
 schermo.riempimento (BACKGROUND_COLOR)
# Disegna i rettangoli statici
 pygame.draw.rect (schermo, RECTANGLE_COLOR_1, rettangolo_1)
 pygame.draw.rect (schermo, RECTANGLE_COLOR_2, rettangolo_2)
# Disegna il giocatore
 player_rect = pygame. Rect (giocatore_x, giocatore_y, PLAYER_WIDTH,
 ALTEZZA_GIOCATORE)
 pygame.draw.rect (schermo, (0, 0, 0), player_rect)
# Aggiorna il display
 pygame.display.update()
# Limita la frequenza dei fotogrammi
 clock.tick(30)

Configurazione della fotocamera

Ora che hai un gioco semplice con un rettangolo del giocatore e due piattaforme statiche, puoi iniziare a lavorare sulla telecamera. In PyGame, la telecamera è essenzialmente solo un offset che agisce su tutti gli oggetti che disegni sullo schermo. Ciò significa che se sposti la telecamera a sinistra, tutto sullo schermo sembrerà spostarsi a destra.

Per impostare la fotocamera, devi prima definire una variabile per contenere l'offset X della fotocamera. Chiama questa variabile camera_offset_x e inizializzarlo a 0.

# Imposta l'offset della fotocamera
camera_offset_x = 0

Successivamente, aggiorna le posizioni di tutti gli oggetti che disegni sullo schermo, per tenere conto dell'offset della telecamera. Puoi farlo aggiungendo il file camera_offset_x valore alla posizione X di ciascun oggetto. Ad esempio, puoi aggiornare la posizione del giocatore in questo modo:

# Disegna il giocatore
player_rect = pygame. Rect (player_x + camera_offset_x, player_y, PLAYER_WIDTH,
 ALTEZZA_GIOCATORE)
pygame.draw.rect (schermo, (0, 0, 0), player_rect)

Allo stesso modo, puoi aggiornare le posizioni delle pedane statiche come segue:

# Disegna i rettangoli statici
rettangolo_1_draw_pos = rettangolo_1.move (offset_camera_x, 0)
pygame.draw.rect (schermo, RECTANGLE_COLOR_1, rettangolo_1_draw_pos)

rettangolo_2_draw_pos = rettangolo_2.move (offset_camera_x, 0)
pygame.draw.rect (schermo, RECTANGLE_COLOR_2, rettangolo_2_draw_pos)

Spostamento della telecamera con input da tastiera

Ora che hai configurato la videocamera, puoi iniziare a spostarla. Un modo per farlo è spostare la telecamera in risposta agli input da tastiera. Ad esempio, puoi spostare la telecamera a sinistra quando il giocatore preme il tasto freccia sinistra.

Per fare ciò, aggiungi il seguente codice all'interno del ciclo di eventi che gestisce gli input da tastiera:

Se event.type == pygame. TASTO GIÙ:
Se event.key == pygame. K_SINISTRA:
 camera_offset_x -= PLAYER_SPEED
elif event.key == pygame. K_DESTRA:
 camera_offset_x += PLAYER_SPEED

Un altro modo è cambiare la coordinata x del giocatore premendo la tastiera e quindi aggiornare l'offset della telecamera. Puoi implementarlo in questo modo:

# Gestisci gli eventi
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 pygame.quit()
 esentato()
Se event.type == pygame. TASTO GIÙ:
Se event.key == pygame. K_SINISTRA:
 player_x -= PLAYER_SPEED
elif event.key == pygame. K_DESTRA:
 player_x += PLAYER_SPEED

Quindi, puoi aggiornare l'offset della visuale rispetto alla coordinata x del giocatore come segue:

camera_offset_x = WINDOW_WIDTH // 2 - player_x - PLAYER_WIDTH // 2

Spostare la telecamera con gli input del mouse

Un altro modo per spostare la telecamera è usare il mouse. Puoi consentire al giocatore di trascinare lo schermo facendo clic e trascinando il mouse.

Per fare ciò, traccia la posizione del mouse quando il giocatore preme il pulsante sinistro del mouse. Quando muovono il mouse, aggiorna la coordinata x del giocatore. Dovrebbe cambiare in base alla differenza tra la posizione corrente del mouse e la posizione iniziale che hai tracciato, mouse_start_pos.

# Gestisci gli eventi
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 pygame.quit()
 esentato()
Se event.type == pygame. MOUSEBUTTONDOWN:
Se evento.pulsante == 1:
 mouse_start_pos = pygame.mouse.get_pos()
Se event.type == pygame. MOVIMENTO DEL MOUSE:
Se 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

Aggiunta di altre funzioni della fotocamera

Oltre all'effetto della fotocamera a scorrimento, puoi aggiungere molte altre funzionalità relative alla fotocamera per migliorare l'esperienza di gioco. Una di queste funzionalità è un effetto zoom della fotocamera che consente al giocatore di ingrandire o ridurre il mondo di gioco. Puoi ottenere questo effetto modificando le dimensioni della finestra di gioco e ridimensionando gli oggetti disegnati sullo schermo.

Per fare ciò, definisci una variabile di zoom che memorizzerà l'attuale livello di zoom del gioco. Imposta il suo valore iniziale su 1.0, che rappresenta nessuno zoom. Quindi, definisci una funzione che calcolerà la dimensione in scala di un oggetto in base al livello di zoom corrente.

ingrandimento = 1.0
defget_scaled_size(misurare):
ritorno int (dimensione * zoom)

Successivamente, aggiorna le posizioni e le dimensioni degli oggetti disegnati sullo schermo utilizzando il file get_scaled_size funzione. Ad esempio, puoi aggiornare la posizione e le dimensioni del giocatore come segue:

player_rect = pygame. Rett(
 get_scaled_size (player_x + camera_offset_x),
 get_scaled_size (giocatore_y),
 get_scaled_size (PLAYER_WIDTH),
 get_scaled_size (PLAYER_HEIGHT)
)

Allo stesso modo, aggiornare le posizioni e le dimensioni delle piattaforme statiche come segue:

rettangolo_1_draw_pos = pygame. Rett(
 get_scaled_size (rectangle_1.x + camera_offset_x),
 get_scaled_size (rectangle_1.y),
 get_scaled_size (rectangle_1.width),
 get_scaled_size (rectangle_1.height)
)
pygame.draw.rect (schermo, RECTANGLE_COLOR_1, rettangolo_1_draw_pos)
rettangolo_2_draw_pos = pygame. Rett(
 get_scaled_size (rectangle_2.x + camera_offset_x),
 get_scaled_size (rectangle_2.y),
 get_scaled_size (rectangle_2.width),
 get_scaled_size (rectangle_2.height)
)
pygame.draw.rect (schermo, RECTANGLE_COLOR_2, rettangolo_2_draw_pos)

Aumenta o diminuisci il livello di zoom di 0,1 quando il giocatore preme il tasto = O - chiave, rispettivamente. Imposta la nuova dimensione della finestra di gioco in base al livello di zoom corrente. Per fare ciò, aggiungi il seguente codice all'interno del ciclo di eventi che gestisce gli input da tastiera:

Se event.type == pygame. TASTO GIÙ:
Se event.key == pygame. K_EQUALS:
 ingrandimento += 0.1
 schermo = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT *zoom)
 ))
elif event.key == pygame. K_MINUS:
 ingrandimento -= 0.1
Se ingrandisci < 0.1:
 ingrandimento = 0.1
 schermo = pygame.display.set_mode((
 int (WINDOW_WIDTH * zoom),
 int (WINDOW_HEIGHT *zoom)
 ))

Con il codice sopra, hai aggiunto con successo un effetto zoom della fotocamera al nostro gioco PyGame. Combinando questa funzione con l'effetto della fotocamera a scorrimento, puoi creare un'esperienza di gioco dinamica e coinvolgente.

Miglioramento del gameplay con i movimenti della telecamera

L'aggiunta di una telecamera a scorrimento a un gioco PyGame non solo migliora l'esperienza visiva, ma migliora anche il gameplay. Consente al giocatore di vedere più parti del mondo di gioco, fornendo loro una migliore comprensione dell'ambiente circostante e facilitando la navigazione.

Puoi anche utilizzare il movimento della fotocamera per creare effetti speciali come lo zoom avanti e indietro o scuotere lo schermo per simulare esplosioni o terremoti.