Animare oggetti di gioco con la libreria Arcade

L'animazione gioca un ruolo fondamentale nel migliorare l'appeal visivo e il coinvolgimento dei videogiochi. La libreria Arcade è un framework Python per la creazione di giochi 2D. Offre un modo semplice ed efficace per incorporare animazioni nei tuoi progetti di gioco.

Puoi utilizzare la libreria Arcade per creare animazioni di movimento di base e animazioni sincronizzate con eventi di gioco.

Crea un gioco semplice

Prima di iniziare, assicurati di averlo pip installato sul tuo dispositivo. Usa questo comando per installare la libreria arcade:

pip installa sala giochi

Successivamente, crea un file Python denominato gioco-semplice.py e inizia impostando un gioco in cui il giocatore può muoversi a destra ea sinistra.

Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub ed è gratuito per l'uso con la licenza MIT.

Utilizzando la libreria Arcade, puoi creare una finestra, impostare l'ambiente di gioco e gestire l'input del giocatore. Ecco uno snippet di codice per iniziare:

importare sala giochi
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(se stesso):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Il mio gioco")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
defon_draw(se stesso):
 arcade.start_render()
 col = arcade.color. BLU
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, colonna)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 10
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 10
defprincipale():
 gioco = Il mio gioco()
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Aggiungi animazione di movimento di base

Ora, fai un ulteriore passo avanti nel tuo gioco e aggiungi l'animazione di movimento di base all'oggetto del giocatore. Per animare il giocatore in movimento, crea 3 diversi cerchi e itera tra loro in sequenza quando il giocatore inizia a muoversi. Ecco lo snippet di codice aggiornato per il file movimento-animazione.py file:

classeIl mio gioco(sala giochi. Finestra):
def__dentro__(se stesso):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Il mio gioco")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(se stesso):
 arcade.start_render()
 col1 = arcade.color. BLU
 col2 = arcade.color. VERDE
 col3 = arcade.color. ROSSO
Se self.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1 )
elif self.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2 )
altro:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Ecco un frame di output di esempio:

Controllo della velocità e della direzione dell'animazione

Per controllare la velocità dell'animazione, puoi introdurre un sistema di frame rate. Puoi anche cambiare l'ordine dei fotogrammi a seconda della direzione del movimento del giocatore. Quando il giocatore si sposta da sinistra a destra, i frame verranno visualizzati in ordine inverso.

Ecco lo snippet di codice modificato per il file frame-rate.py file:

classeIl mio gioco(sala giochi. Finestra):
def__dentro__(se stesso):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Il mio gioco")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arcade.color. BLU
 col2 = arcade.color. VERDE
 col3 = arcade.color. ROSSO
 self.frame = [col1, col2, col3]
 self.frame_rate = 10
defon_draw(se stesso):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
Se self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 -frame_index
 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, indice)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 10
 self.frame_counter += 1
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 10
 self.frame_counter += 1

Usa l'operatore modulo % con len (self.frames) per garantire che il frame_index rimane sempre all'interno della gamma di frame disponibili. Questo impedisce il IndexError dal verificarsi quando l'animazione scorre attraverso i fotogrammi.

Aggiusta il frequenza dei fotogrammi valore per controllare la velocità dell'animazione e goderti il ​​movimento animato dei tuoi oggetti di gioco.

Comprese funzionalità aggiuntive

La libreria Arcade offre varie funzionalità per migliorare le tue animazioni.

Effetti particellari

Puoi creare effetti particellari, come esplosioni o fumo, per aggiungere realismo al tuo gioco. Crea un file denominato particella.py e aggiungi il codice seguente per una semplice implementazione del sistema particellare usando Python e la libreria arcade:

importare sala giochi
importare casuale
# Dimensioni dello schermo
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Colori
BIANCO = (255, 255, 255)
# Classe di particelle
classeParticella:
def__dentro__(self, x, y, dx, dy, raggio, colore, durata della vita):
 self.x = x
 self.y = y
 self.dx = dx
 self.dy = dy
 self.raggio = raggio
 self.color = colore
 self.lifespan = durata della vita
defaggiornamento(se stesso):
 self.x += self.dx
 self.y += self.dy
 self.lifespan -= 1
defdisegno(se stesso):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Classe di gioco
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza, "Esempio di particelle")
 self.particelle = []
defimpostare(se stesso):
# Crea particelle
per _ In allineare(100):
 x = casuale.randrange (SCREEN_WIDTH)
 y = random.randrange (SCREEN_HEIGHT)
 dx = random.uniform(-1, 1)
 dy = random.uniform(-1, 1)
 raggio = random.uniform(2, 5)
 colore = arcade.colore. BIANCO
 durata della vita = random.randint(60, 120)
 particella = Particella (x, y, dx, dy, raggio, colore, durata della vita)
 self.particelle.append (particella)
defon_draw(se stesso):
 arcade.start_render()
per particella In self.particelle:
 particella.draw()
defaggiornamento(self, delta_time):
per particella In self.particelle:
 particella.aggiornamento()
Se particella.durata della vita <= 0:
 self.particles.remove (particella)
defprincipale():
 gioco = Il mio gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
 gioco.setup()
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Dovresti vedere un'animazione che coinvolge molte particelle in movimento:

Animazioni interattive

Implementa animazioni interattive che rispondono all'input dell'utente o agli eventi di gioco. Ad esempio, quando il giocatore interagisce con un oggetto, potrebbe animarsi, cambiare colore o trasformarsi in qualche modo. Queste animazioni interattive forniscono feedback e migliorano il coinvolgimento del giocatore con il gioco. Ecco il codice per il animazione-interattiva.py file:

importare sala giochi
# Dimensioni dello schermo
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Colori
BIANCO = (255, 255, 255)
ROSSO = (255, 0, 0)
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza, "Animazione interattiva")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = ROSSO
 self.animation_radius = 60
 self.animation_color = BIANCO
 self.animation_active = Falso
defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)
Se self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)
defon_mouse_press(self, x, y, pulsante, modificatori):
Se (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius E
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = VERO
defaggiornamento(self, delta_time):
Se self.animation_active:
 self.animation_radius += 1
Se self.animation_radius > 100:
 self.animation_active = Falso
 self.animation_radius = 0
defprincipale():
 gioco = Il mio gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Eseguire l'override dei metodi necessari, ad esempio on_draw, on_mouse_press, E aggiornamento, per gestire il disegno del giocatore e l'animazione, la gestione dei clic del mouse e l'aggiornamento dell'animazione.

Per disegnare il giocatore, usa il arcade.draw_circle_filled funzione, che prende il (x, y) coordinate del centro, del raggio e del colore come argomenti. La funzione draw_circle_filled è una delle Gli strumenti di Arcade che puoi utilizzare per disegnare risorse di gioco. In questo caso, puoi disegnare un cerchio crescente variando il raggio nel tempo.

IL on_mouse_press Il metodo viene eseguito quando l'utente fa clic con il mouse. Controlla se le coordinate del mouse sono all'interno dei limiti dell'oggetto giocatore e attiva l'animazione se lo sono.

Best practice per l'aggiunta di animazioni

Quando aggiungi l'animazione ai tuoi giochi, considera le seguenti best practice:

Limita il numero di animazioni

Avere molte animazioni con molti fotogrammi può influire sulle prestazioni. Prendi in considerazione la possibilità di ridurre al minimo il numero di animazioni o fotogrammi richiesti, in particolare per gli elementi non critici del gioco. La semplificazione delle animazioni può aiutare a mantenere una frequenza dei fotogrammi costante e ottimizzare l'utilizzo delle risorse.

Rendering in batch di oggetti simili

Raggruppa oggetti simili che condividono gli stessi fotogrammi e trame di animazione e renderli in batch. Il raggruppamento riduce il numero di chiamate di estrazione, con conseguente miglioramento delle prestazioni. Questa tecnica è particolarmente utile quando si animano oggetti che utilizzano lo stesso foglio sprite o hanno sequenze di animazione simili.

Usa l'interpolazione per un'animazione fluida

Applicare tecniche di interpolazione, come l'interpolazione lineare (lerping), per ottenere transizioni di animazione fluide. L'interpolazione calcola i valori intermedi tra i fotogrammi chiave dell'animazione per creare movimenti fluidi. Questo approccio impedisce salti improvvisi o movimenti a scatti tra i fotogrammi, risultando in animazioni visivamente più accattivanti.

Considera la velocità e il tempismo dell'animazione

Sperimenta con diverse velocità e tempi di animazione per trovare il giusto equilibrio per il tuo gioco. Regola la durata del fotogramma o utilizza diverse sequenze di animazione per creare variazioni di velocità, accelerazione o decelerazione. Queste regolazioni possono aggiungere profondità e carattere alle animazioni del tuo gioco.

Testare e ottimizzare

Testa regolarmente le tue animazioni su diversi dispositivi e monitora le prestazioni. Cerca potenziali colli di bottiglia o rallentamenti e ottimizza di conseguenza. Questo processo aiuta a garantire esperienze di animazione fluide e coerenti su un'ampia gamma di dispositivi.

Rendi i giochi più coinvolgenti con l'animazione

L'aggiunta di animazioni ai tuoi giochi può migliorare notevolmente il coinvolgimento e l'immersione dei giocatori. Le animazioni forniscono un feedback visivo alle azioni del giocatore, rendendo il gameplay più intuitivo e divertente. Danno vita ai mondi di gioco, creando un senso di realismo ed eccitazione.

Che si tratti di un personaggio che corre, di un oggetto che esplode o di un semplice effetto di transizione, le animazioni contribuiscono a rendere l'esperienza di gioco più dinamica e accattivante.