Come creare nemici nei giochi arcade Python

I nemici svolgono un ruolo cruciale nella creazione di giochi avvincenti e stimolanti. Forniscono ostacoli e avversari per i giocatori, rendendo l'esperienza di gioco più emozionante. La libreria Arcade di Python offre un modo semplice per incorporare i nemici nei tuoi giochi.

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

Successivamente, inizia creando un semplice gioco in cui il giocatore può spostarsi a sinistra ea destra usando i tasti freccia.

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

importare sala giochi
# Dimensioni della finestra
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Attributi del giocatore
RAGGIO_GIOCATORE = 25
GIOCATORE_VELOCITÀ = 5
classeFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):





instagram viewer

 super().__init__(larghezza, altezza)
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = larghezza // 2

defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. BLU)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= PLAYER_SPEED
elif chiave == arcade.chiave. GIUSTO:
 self.player_x += PLAYER_SPEED
defaggiornamento(self, delta_time):
passaggio
defprincipale():
 finestra = Finestra di gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Se __nome__ == "__principale__":
 principale()

Creare un nemico semplice

Per creare un nemico che uccida il giocatore in caso di collisione, crea un altro cerchio sullo schermo. Nel on_draw funzione, puoi disegnare questo cerchio nemico e controllare le collisioni nel aggiornamento metodo. Puoi anche usa gli sprite per i nemici.

# Aggiungi alla classe GameWindow
classeFinestra di gioco(sala giochi. Finestra):
# ...
def__dentro__(auto, larghezza, altezza):
# ...
# Attributi nemici
 self.enemy_x = larghezza // 2
 self.enemy_y = altezza - PLAYER_RADIUS
 self.enemy_radius = 20
defon_draw(se stesso):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROSSO)
defaggiornamento(self, delta_time):
Se self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 stampa("Game Over!")

defis_collision(self, x1, y1, x2, y2, raggio1, raggio2):
 distanza_quadrato = (x1 - x2) ** 2 + (y1 - y2) ** 2
 raggio_somma_quadrato = (raggio1 + raggio2) ** 2
ritorno distance_squared <= radius_sum_squared

Fare in modo che il nemico segua il giocatore

In alcuni giochi, i nemici possono inseguire il giocatore, aggiungendo un elemento dinamico al gameplay. Per creare un nemico successivo, devi aggiornare la sua posizione in base alla posizione del giocatore. Ogni volta il giocatore si muove, il nemico si muove nella stessa direzione. È possibile ottenere ciò modificando il file aggiornamento metodo. Crea un nuovo file denominato nemico-follow-player.py e aggiungi il codice con i seguenti aggiornamenti:

# Aggiungi alla classe GameWindow
classeFinestra di gioco(sala giochi. Finestra):
# ...
defaggiornamento(self, delta_time):
Se self.giocatore_x < self.nemico_x:
 self.enemy_x -= PLAYER_SPEED
elif self.giocatore_x > self.nemico_x:
 self.enemy_x += PLAYER_SPEED
Se self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 stampa("Game Over!")

defis_collision(self, x1, y1, x2, y2, raggio1, raggio2):
 distanza_quadrato = (x1 - x2) ** 2 + (y1 - y2) ** 2
 raggio_somma_quadrato = (raggio1 + raggio2) ** 2
ritorno distance_squared <= radius_sum_squared

Di seguito è riportato l'output:

Aggiunta di proiettili nemici

Per creare un nemico che spara proiettili, crea un Proiettile classe e un elenco per tenere traccia dei proiettili attivi. Il nemico creerà periodicamente un nuovo proiettile e aggiornerà la sua posizione. Crea un nuovo file denominato proiettili.py e aggiungi il codice con i seguenti aggiornamenti:

# Aggiungi alla classe GameWindow
classeProiettile:
def__dentro__(self, x, y, raggio, velocità):
 self.x = x
 self.y = y
 self.raggio = raggio
 self.speed = velocità
defaggiornamento(se stesso):
 self.y -= self.velocità
classeFinestra di gioco(sala giochi. Finestra):
# ...
def__dentro__(auto, larghezza, altezza):
# ...
# Attributi nemici
 self.proiettili = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Numero di fotogrammi tra la generazione di proiettili
 self.bullet_timer = 0
defon_draw(se stesso):
# ...
per proiettile In self.proiettili:
 arcade.draw_circle_filled (proiettile.x, proiettile.y, 
 self.bullet_radius, arcade.color. NERO)
defaggiornamento(self, delta_time):
# ...
 self.bullet_timer += 1
Se self.bullet_timer >= self.bullet_cooldown:
 self.bullets.append (Proiettile (self.enemy_x, self.enemy_y - self.enemy_radius, 
self.bullet_radius, self.bullet_speed))
 self.bullet_timer = 0
per proiettile In self.proiettili:
 proiettile.aggiornamento()
Se self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 stampa("Game Over!")

defis_collision(self, x1, y1, x2, y2, raggio1, raggio2):
 distanza_quadrato = (x1 - x2) ** 2 + (y1 - y2) ** 2
 raggio_somma_quadrato = (raggio1 + raggio2) ** 2
ritorno distance_squared <= radius_sum_squared

Di seguito è riportato l'output:

Aggiunta di punti salute per i nemici

In molti giochi, i nemici possono possedere punti salute (HP), consentendo loro di sostenere più colpi prima di essere sconfitti. L'aggiunta di punti salute ai nemici può introdurre elementi di gioco strategici e fornire un senso di progressione e sfida. Crea un nuovo file denominato heat-point.py e aggiungi il codice con i seguenti aggiornamenti:

# Dimensioni della finestra
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Attributi del giocatore
RAGGIO_GIOCATORE = 25
GIOCATORE_VELOCITÀ = 5
# Attributi nemici
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100
classeFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza)
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = larghezza // 2
 self.player_y = altezza // 2
 self.enemy_x = larghezza // 2
 self.enemy_y = altezza - PLAYER_RADIUS
 self.enemy_health = ENEMY_HEALTH
 stampa (self.enemy_health)
defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 RAGGIO_GIOCATORE,
 arcade.color. BLU)
Se self.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 self.enemy_y,
 ENEMY_RADIUS,
 arcade.color. ROSSO)
defaggiornamento(self, delta_time):
Se self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 self.enemy_health -= 10
 stampa (self.enemy_health)

IL ENEMY_HEALTH costante ha un valore di 100 per rappresentare i punti vita iniziali del nemico. Quando il giocatore si scontra con il nemico, puoi sottrarre alcuni punti dalla salute del nemico. Per visualizzare il valore di integrità aggiornato, è possibile stampare un oggetto di testo self.health_text che mostra l'attuale salute del nemico.

Incorporando i punti salute per i nemici, puoi introdurre un livello di sfida e strategia per i giocatori. Il valore della salute visualizzato fornisce un feedback visivo e consente ai giocatori di tenere traccia della salute rimanente del nemico.

Inoltre, puoi espandere il codice aggiungendo ulteriore logica e immagini, come la visualizzazione di barre della salute o l'implementazione di condizioni di sconfitta quando la salute del nemico raggiunge lo zero.

Migliori Pratiche per Creare Nemici

Quando si progettano i nemici per il proprio gioco, è importante considerare diverse best practice per assicurarsi che contribuiscano a un'esperienza di gioco stimolante e divertente. Ecco alcune linee guida da seguire durante la creazione di nemici:

Diversi attributi

Crea nemici con attributi diversi come velocità, dimensioni, salute e potenza d'attacco. Diversi tipi di nemici dovrebbero porre diversi livelli di difficoltà, richiedendo ai giocatori di adattare le loro strategie di conseguenza. Introducendo un mix di attributi nemici, puoi mantenere il gameplay fresco e coinvolgente.

Comportamenti unici

Assegna a ogni tipo di nemico i propri modelli di comportamento unici. Alcuni nemici possono muoversi in modo prevedibile, mentre altri potrebbero esibire movimenti più complessi o irregolari. Prendi in considerazione l'idea di incorporare algoritmi IA nemici per rendere il loro comportamento più intelligente e imprevedibile, aggiungendo un ulteriore livello di sfida per i giocatori.

Punti vita (HP)

Implementa punti salute per i nemici per introdurre un senso di progressione e durata. Ciò consente ai nemici di sostenere più colpi prima di essere sconfitti. Assegnando quantità variabili di HP a diversi tipi di nemici, puoi creare una gerarchia di difficoltà e incoraggiare i giocatori a elaborare strategie e dare priorità ai loro obiettivi.

Rendi i giochi più divertenti con i nemici

L'aggiunta di nemici ai tuoi giochi può migliorare notevolmente l'esperienza di gioco. Introducono sfide e motivano i giocatori a migliorare le proprie abilità. I nemici possono presentarsi in varie forme, da semplici ostacoli a complessi avversari guidati dall'IA. Implementando i nemici in modo efficace, puoi rendere i tuoi giochi più coinvolgenti e divertenti per i giocatori.