Come aggiungere oggetti in movimento casuali utilizzando la libreria Arcade di Python

Gli oggetti in movimento casuali possono portare eccitazione e imprevedibilità ai giochi. Li rende più coinvolgenti e stimolanti per i giocatori. La libreria Arcade di Python fornisce un modo semplice ed efficiente per incorporare oggetti in movimento casuali 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, crea una finestra usando il file sala giochi. Finestra class e impostare il colore di sfondo su bianco.

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

Imposta la posizione del giocatore al centro dello schermo orizzontalmente e aggiungi una piccola distanza dall'alto. Puoi controllare il movimento del giocatore usando i tasti freccia.

Ecco il codice per il nostro gioco base:

importare sala giochi
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
RAGGIO_GIOCATORE = 15
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza)
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLU)
defaggiornamento(self, delta_time):
passaggio
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 5
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 5
Se __nome__ == "__principale__":
 gioco = Il mio gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Aggiunta di più oggetti

Per aggiungere oggetti in movimento casuali al tuo gioco, crea un elenco per memorizzare le posizioni dell'oggetto e aggiornarle ogni fotogramma. Puoi anche usare sprite come oggetti.

Nel tuo codice di gioco, aggiungi un elenco chiamato oggetti per memorizzare le posizioni degli oggetti in movimento casuali. Successivamente, genera il numero di oggetti (NUM_OGGETTI) con coordinate x e y casuali all'interno dei limiti dello schermo. Gli oggetti sono disegnati come cerchi rossi usando il arcade.draw_circle_filled funzione.

importare sala giochi
importare casuale
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
RAGGIO_GIOCATORE = 15
OBJECT_RADIUS = 10
NUM_OGGETTI = 10
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza)
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
 self.oggetti = []
per _ In intervallo (NUM_OBJECTS):
 x = casuale.randint(0, SCREEN_WIDTH)
 y = casuale.randint(0, SCREEN_HEIGHT)
 self.oggetti.append((x, y))
defon_draw(se stesso):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLU)
per ogg In self.oggetti:
 x, y = ogg
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROSSO)
defaggiornamento(self, delta_time):
passaggio
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
 self.player_x -= 5
elif chiave == arcade.chiave. GIUSTO:
 self.giocatore_x += 5
Se __nome__ == "__principale__":
 gioco = Il mio gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Di seguito è riportato l'output:

Implementazione dell'algoritmo di movimento casuale

Per far muovere gli oggetti in modo casuale, aggiorna le loro posizioni nel file aggiornamento metodo utilizzando un algoritmo di movimento casuale.

Scorri ogni oggetto e genera valori casuali per dx E morire, che rappresenta la modifica delle coordinate x e y. Quindi aggiorna la posizione dell'oggetto aggiungendo questi valori. Ecco il codice modificato:

defaggiornamento(self, delta_time):
per io In intervallo (NUM_OBJECTS):
 x, y = self.oggetti[i]
 dx = casuale.randint(-5, 5)
 dy = casuale.randint(-5, 5)
 x += dx
 y += dy
 self.oggetti[i] = (x, y)

Di seguito è riportato l'output:

Oggetti che si muovono verso il giocatore

Per aggiungere più interazione, fai muovere gli oggetti verso il giocatore. Puoi ottenere ciò calcolando il vettore di direzione tra l'oggetto e il giocatore e regolando la posizione dell'oggetto di conseguenza.

Per questo, calcola le differenze nelle coordinate x e y tra l'oggetto e il giocatore. Normalizzando questi valori si ottiene un vettore di direzione. Quindi moltiplica questo vettore per un fattore di velocità (3 in questo caso) e aggiungilo alla posizione dell'oggetto. Ecco l'aggiornamento aggiornamento metodo:

defaggiornamento(self, delta_time):
per io In intervallo (NUM_OBJECTS):
 x, y = self.oggetti[i]
 dx = self.giocatore_x - x
 dy = self.giocatore_y - y
 distanza = math.sqrt (dx ** 2 + giorno** 2)
 dx /= distanza
 dy /= distanza
 x += dx * 3
 si += giorno * 3
 self.oggetti[i] = (x, y)

Di seguito è riportato l'output:

Gli oggetti iniziano a muoversi quando il giocatore entra nell'ambiente circostante

Per aggiungere ulteriori dinamiche, modifica il codice in modo che gli oggetti inizino a muoversi solo quando il giocatore entra nell'area circostante. Aggiungi il codice per il movimento del giocatore e definire un raggio entro il quale gli oggetti diventano attivi.

defaggiornamento(self, delta_time):
per io In intervallo (NUM_OBJECTS):
 x, y = self.oggetti[i]
 dx = self.giocatore_x - x
 dy = self.giocatore_y - y
 distanza = math.sqrt (dx ** 2 + giorno** 2)

Se distanza < 100: # Regola il raggio secondo necessità
 dx /= distanza
 dy /= distanza
 x += dx * 3
 si += giorno * 3
 self.oggetti[i] = (x, y)

Rilevamento e interazione delle collisioni

Ora aggiungi il rilevamento delle collisioni tra il giocatore e gli oggetti e definisci il comportamento quando si verifica una collisione. Modifica il aggiornamento metodo per gestire le collisioni:

defaggiornamento(self, delta_time):
per io In intervallo (NUM_OBJECTS):
 x, y = self.oggetti[i]
 dx = self.giocatore_x - x
 dy = self.giocatore_y - y
 distanza = math.sqrt (dx ** 2 + giorno** 2)

Se distanza < PLAYER_RADIUS + OBJECT_RADIUS:
# se si è verificata una collisione, gestiscila qui
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif distanza < 100:
 dx /= distanza
 dy /= distanza
 x += dx * 3
 si += giorno * 3
 self.oggetti[i] = (x, y)

Bilanciamento della casualità

Per creare un'esperienza di gioco bilanciata, è importante mettere a punto il movimento casuale e la generazione degli oggetti. Ecco alcuni esempi di come puoi regolare il codice per ottenere un migliore equilibrio nel tuo gioco:

Limitazione della velocità massima

Per evitare che gli oggetti si muovano troppo velocemente, puoi introdurre un limite massimo di velocità. Modifica il aggiornamento metodo per includere vincoli di velocità:

defaggiornamento(self, delta_time):
per io In intervallo (NUM_OBJECTS):
 x, y = self.oggetti[i]
 dx = self.giocatore_x - x
 dy = self.giocatore_y - y
 distanza = math.sqrt (dx ** 2 + giorno** 2)
Se distanza < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distanza < 100:
 dx /= distanza
 dy /= distanza
 velocità = 3# Regolare il valore della velocità secondo necessità
 dx = min (max (dx * velocità, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * velocità, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.oggetti[i] = (x, y)

Controllo del tasso di spawn

Puoi anche controllare la velocità con cui i nuovi oggetti si generano nel gioco. Regola il codice per includere un ritardo tra la generazione di nuovi oggetti:

importare tempo
classeIl mio gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
 super().__init__(larghezza, altezza)
 arcade.set_background_color (arcade.color. BIANCO)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
 self.oggetti = []
 self.last_spawn_time = tempo.tempo()
defaggiornamento(self, delta_time):
# controlla qui il tasso di deposizione delle uova
Se time.time() - self.last_spawn_time > SPAWN_DELAY:
Se len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = tempo.tempo()
per io In intervallo (len (self.objects)):
 x, y = self.oggetti[i]
 dx = self.giocatore_x - x
 dy = self.giocatore_y - y
 distanza = math.sqrt (dx ** 2 + giorno** 2)
Se distanza < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distanza < 100:
 dx /= distanza
 dy /= distanza
 x += dx * 3
 si += giorno * 3
 self.oggetti[i] = (x, y)

Aggiusta il SPAWN_DELAY E MAX_OGGETTI valori per trovare il giusto equilibrio per il tuo gioco. Un ritardo più lungo o un numero massimo di oggetti inferiore renderanno il gioco meno affollato. Considerando che un ritardo più breve o un massimo maggiore aumenteranno la difficoltà.

Rendi i giochi più divertenti usando oggetti in movimento

L'aggiunta di oggetti in movimento casuali ai giochi può migliorare notevolmente l'esperienza complessiva. Introducono imprevedibilità e sfida, rendendo il gameplay più coinvolgente e dinamico. I giocatori dovranno adattarsi e reagire rapidamente per evitare collisioni o catturare oggetti, e questo fornirà un senso di eccitazione e realizzazione.