Come implementare i livelli di gioco in Python's Arcade

Lo sviluppo del gioco è un processo entusiasmante e creativo che ti consente di dare vita alle tue idee fantasiose. Quando si progetta un gioco, uno degli elementi chiave che può migliorare notevolmente l'esperienza del giocatore è l'implementazione dei livelli di gioco.

I livelli forniscono struttura, progressione e sfide, dando ai giocatori un senso di realizzazione e coinvolgimento mentre navigano attraverso le diverse fasi del gioco.

Crea un gioco semplice

Prima di iniziare, assicurati di averlo pip installato sul tuo dispositivo. Utilizzare questo comando per installare il file sala giochi biblioteca:

pip installa sala giochi

Crea un gioco di base 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.

Utilizza le funzionalità della libreria Arcade per gestire l'input dell'utente e aggiornare lo stato del gioco di conseguenza. Crea un nuovo file denominato

gioco-semplice.py e aggiungi il codice seguente:

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")
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = SCREEN_WIDTH // 2
defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. BLU)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 10
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 10
defon_key_release(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA O chiave == arcade.chiave. GIUSTO:
passaggio
defprincipale():
 gioco = Il mio gioco()
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Di seguito è riportato l'output:

Crea più livelli

Ora espandi il gioco aggiungendo più livelli. Ogni livello avrà le sue caratteristiche uniche, fornendo diverse sfide per il giocatore. È possibile modificare il codice precedente per includere livelli aggiuntivi. Ecco un esempio:

classeLivello uno:
def__dentro__(se stesso):
 self.player_x = SCREEN_WIDTH // 2
defaggiornamento(se stesso):
passaggio
defdisegno(se stesso):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. BLU)
classeLivello Due:
def__dentro__(se stesso):
 self.player_x = SCREEN_WIDTH // 2
defaggiornamento(se stesso):
passaggio
defdisegno(se stesso):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.color. ROSSO)
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(se stesso):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Il mio gioco")
 arcade.set_background_color (arcade.color. BIANCO)
 self.levels = [LivelloUno(), LivelloDue()]
 self.current_level = 0
defon_draw(se stesso):
 arcade.start_render()
 self.levels[self.current_level].draw()
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.levels[self.current_level].player_x -= 10
elif chiave == arcade.chiave. GIUSTO:
 self.levels[self.current_level].player_x += 10
defon_key_release(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA O chiave == arcade.chiave. GIUSTO:
passaggio
defaggiornamento(self, delta_time):
 self.levels[self.current_level].update()
defprincipale():
 gioco = Il mio gioco()
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Transizione tra livelli

Per creare una transizione fluida tra i livelli, rileva quando il giocatore attraversa un confine specifico. Puoi seguire il movimento del giocatoree una volta che il giocatore attraversa il confine, puoi passare al livello successivo. Crea un nuovo file denominato transizione-tra-livelli.py e aggiungi il codice con i seguenti aggiornamenti:

classeIl mio gioco(sala giochi. Finestra):
# ...
defaggiornamento(self, delta_time):
 self.levels[self.current_level].update()
# Controlla se il giocatore ha attraversato il confine
Se self.levels[self.current_level].player_x < 0:
 self.livello_corrente += 1
 self.current_level %= len (self.livelli)
 self.levels[self.current_level].player_x = SCREEN_WIDTH
elif self.levels[self.current_level].player_x > SCREEN_WIDTH:
 self.livello_corrente += 1
 self.current_level %= len (self.livelli)
 self.levels[self.current_level].player_x = 0
# ...

Di seguito è riportato l'output:

Comprese funzionalità aggiuntive

Per rendere i tuoi livelli di gioco più coinvolgenti, puoi incorporare funzionalità aggiuntive come power-up e obiettivi.

Obiettivi

Gli obiettivi forniscono obiettivi o obiettivi specifici che il giocatore deve raggiungere all'interno di un livello. Aggiungono un senso di scopo e progresso. Ecco un esempio di implementazione di una funzione obiettivo:

classeObbiettivo:
def__dentro__(sé, x, y):
 self.x = x
 self.y = y
 self.raggio = 20
defdisegno(se stesso):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. VERDE)
classeLivello uno:
def__dentro__(se stesso):
 self.objective = Obiettivo(600, 400)
# ...
defaggiornamento(se stesso):
# Controlla se il giocatore raggiunge l'obiettivo
Se arcade.check_for_collision (self.player, self.objective):
 self.complete_objective()
defdisegno(se stesso):
 self.objective.draw()
# ...
defobiettivo_completo(se stesso):
# Codice per gestire il completamento dell'obiettivo
passaggio

Oggetti da collezione

I collezionabili sono oggetti o bonus che il giocatore può raccogliere durante i livelli. Ecco un esempio di implementazione di una funzione collezionabile:

classeDa collezione:
def__dentro__(sé, x, y):
 self.x = x
 self.y = y
 self.raggio = 10
 self.è_raccolto = Falso
defdisegno(se stesso):
Senon self.è_raccolto:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ARANCIA)
defraccogliere(se stesso):
 self.è_raccolto = VERO
# Codice per gestire l'effetto del collezionabile sul giocatore
classeLivello uno:
def__dentro__(se stesso):
 self.collezionabile = Collezionabile(300, 300)
# ...
defaggiornamento(se stesso):
# Controlla se il giocatore raccoglie l'oggetto
Se arcade.check_for_collision (self.player, self.collectible):
 self.collectible.collect()
defdisegno(se stesso):
 self.collezionabile.draw()
# ...

Ostacoli

Gli ostacoli possono essere oggetti statici o entità in movimento che ostacolano il percorso del giocatore. Richiedono al giocatore di elaborare strategie e trovare modi per superarli. Ecco un esempio di implementazione della funzione ostacoli:

classeOstacolo:
def__dentro__(self, x, y, larghezza, altezza):
 self.x = x
 self.y = y
 self.width = larghezza
 self.altezza = altezza
defdisegno(se stesso):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. GRIGIO)
classeLivello uno:
def__dentro__(se stesso):
 self.ostacoli = [Ostacolo(400, 200, 100, 50), Ostacolo(600, 500, 80, 120)]
# ...

Potenziamento

I potenziamenti possono migliorare le abilità del giocatore o fornire vantaggi temporanei. Ecco un esempio di implementazione di una funzione di accensione:

classeAccendere:
def__dentro__(sé, x, y):
 self.x = x
 self.y = y
 self.raggio = 10
 self.is_active = VERO
defdisegno(se stesso):
Se self.è_attivo:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GIALLO)
defactivate_power_up(se stesso):
 self.is_active = VERO
defdisattiva_accensione_up(se stesso):
 self.is_active = Falso
classeLivello uno:
def__dentro__(se stesso):
 self.power_up = Accensione(200, 200)
# ...
defaggiornamento(se stesso):
# Controlla se il giocatore si scontra con il potenziamento
Se arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 self.power_up.deactivate_power_up()
defdisegno(se stesso):
 self.power_up.draw()
# ...

Best practice per la progettazione dei livelli

Il level design gioca un ruolo cruciale nella creazione di esperienze di gioco coinvolgenti e divertenti. Ecco alcune best practice da considerare durante la progettazione dei livelli per il tuo gioco:

Obiettivi chiari

Ogni livello dovrebbe avere un obiettivo o un obiettivo chiaro che il giocatore deve raggiungere. Che si tratti di raggiungere un luogo specifico, sconfiggere nemici o risolvere enigmi, l'obiettivo dovrebbe essere ben definito e comunicato al giocatore.

Curva di difficoltà graduale

Progetta livelli con un graduale aumento della difficoltà per fornire una curva di apprendimento fluida per i giocatori. Inizia con sfide più semplici e introduci gradualmente nuove meccaniche o ostacoli man mano che il giocatore avanza. Picchi improvvisi di difficoltà possono frustrare i giocatori, quindi è importante mantenere una progressione equilibrata.

Chiarezza visiva

Assicurati che il design dei livelli e gli elementi visivi comunichino chiaramente informazioni importanti al giocatore. Incorporando musica ed effetti sonori può anche trasmettere indizi cruciali e fornire informazioni essenziali al giocatore.

Playtest e iterazione

Il playtest regolare è essenziale per perfezionare e migliorare il design dei livelli. Raccogli il feedback dei giocatori e osserva le loro esperienze per identificare le aree che potrebbero richiedere aggiustamenti. Itera il tuo level design in base a questo feedback per creare un gameplay più divertente ed equilibrato.

Equilibrio ricompensa e sfida

Premia i giocatori per aver superato le sfide nei tuoi livelli. Ciò può essere ottenuto tramite potenziamenti, oggetti da collezione, sblocco di nuove aree o progressione narrativa. Bilanciare la difficoltà delle sfide con ricompense significative aiuta a motivare i giocatori e fornisce un senso di realizzazione.

Rendi i giochi più coinvolgenti con i livelli

Implementando i livelli di gioco, puoi migliorare l'esperienza complessiva del giocatore e creare un ambiente di gioco più coinvolgente. I livelli forniscono progressione, sfida e varietà, mantenendo i giocatori coinvolti e motivati. Ti consentono di introdurre nuove meccaniche, ostacoli, nemici e ricompense, assicurando che ogni livello sia distinto ed emozionante.