Gjør arkadespillene dine enda morsommere og spennende ved å legge til tilfeldige bevegelige objekter.
Tilfeldige bevegelige objekter kan gi spenning og uforutsigbarhet til spill. Det gjør dem mer engasjerende og utfordrende for spillere. Pythons Arcade-bibliotek gir en enkel og effektiv måte å inkorporere tilfeldige bevegelige objekter i spillene dine.
Lag et enkelt spill
Før du starter, sørg for at du har pip installert på enheten din. Bruk denne kommandoen til å installere arkade bibliotek:
pip installer arkadeEtter det oppretter du et vindu ved å bruke arkade. Vindu klasse og sett bakgrunnsfargen til hvit.
Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.
Sett spillerens posisjon til midten av skjermen horisontalt og legg til en liten avstand fra toppen. Du kan kontrollere spillerens bevegelse ved hjelp av piltastene.
Her er koden for vårt grunnleggende spill:
import arkadeSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
super().__init__(bredde, høyde)
arcade.set_background_color (arcade.color. HVIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10defon_draw(selv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)defOppdater(selv, delta_tid):
sendedefon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
self.player_x -= 5
elif nøkkel == arkade.nøkkel. IKKE SANT:
self.player_x += 5
hvis __navn__ == "__hoved__":
spill = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Legge til flere objekter
For å legge til tilfeldige bevegelige objekter til spillet ditt, lag en liste for å lagre objektets posisjoner og oppdatere dem hver ramme. Du kan også bruke sprites som objekter.
Legg til en liste som heter i spillkoden gjenstander for å lagre posisjonene til de tilfeldige bevegelige objektene. Deretter genererer du antall objekter (NUM_OBJECTS) med tilfeldige x- og y-koordinater innenfor skjermgrensene. Objektene tegnes som røde sirkler ved hjelp av arcade.draw_circle_filled funksjon.
import arkade
import tilfeldigSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
super().__init__(bredde, høyde)
arcade.set_background_color (arcade.color. HVIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
til _ i område (NUM_OBJECTS):
x = random.randint(0, SCREEN_WIDTH)
y = random.randint(0, SCREEN_HEIGHT)
self.objects.append((x, y))defon_draw(selv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)til obj i self.objects:
x, y = obj
arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. RØD)defOppdater(selv, delta_tid):
sendedefon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
self.player_x -= 5
elif nøkkel == arkade.nøkkel. IKKE SANT:
self.player_x += 5
hvis __navn__ == "__hoved__":
spill = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Nedenfor er utgangen:
Implementering av tilfeldig bevegelsesalgoritme
For å få objektene til å bevege seg tilfeldig, oppdater posisjonene deres i Oppdater metode som bruker en tilfeldig bevegelsesalgoritme.
Iterer gjennom hvert objekt og generer tilfeldige verdier for dx og dy, som representerer endringen i x- og y-koordinater. Oppdater deretter objektets posisjon ved å legge til disse verdiene. Her er den endrede koden:
defOppdater(selv, delta_tid):
til Jeg i område (NUM_OBJECTS):
x, y = selv.objekter[i]
dx = random.randint(-5, 5)
dy = random.randint(-5, 5)
x += dx
y += dy
self.objects[i] = (x, y)Nedenfor er utgangen:
Objekter som beveger seg mot spilleren
For å legge til mer interaksjon, få objektene til å bevege seg mot spilleren. Du kan oppnå dette ved å beregne retningsvektoren mellom objektet og spilleren og justere objektets posisjon deretter.
For dette, beregne forskjellene i x- og y-koordinater mellom objektet og spilleren. Ved å normalisere disse verdiene får du en retningsvektor. Multipliser deretter denne vektoren med en hastighetsfaktor (3 i dette tilfellet) og legg den til objektets posisjon. Her er den oppdaterte Oppdater metode:
defOppdater(selv, delta_tid):
til Jeg i område (NUM_OBJECTS):
x, y = selv.objekter[i]
dx = self.player_x - x
dy = self.player_y - y
avstand = math.sqrt (dx ** 2 + dy ** 2)
dx /= avstand
dy /= avstand
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Nedenfor er utgangen:
Objekter begynner å bevege seg når spilleren går inn i omgivelsene
For å legge til ytterligere dynamikk, endre koden slik at objektene begynner å bevege seg først når spilleren går inn i området rundt. Legg til kode for spillerens bevegelse og definere en radius som objektene blir aktive innenfor.
defOppdater(selv, delta_tid):
til Jeg i område (NUM_OBJECTS):
x, y = selv.objekter[i]
dx = self.player_x - x
dy = self.player_y - y
avstand = math.sqrt (dx ** 2 + dy ** 2)
hvis avstand < 100: # Juster radiusen etter behov
dx /= avstand
dy /= avstand
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Kollisjonsdeteksjon og interaksjon
Legg nå til kollisjonsdeteksjon mellom spilleren og objektene, og definer atferd når en kollisjon oppstår. Endre Oppdater metode for å håndtere kollisjoner:
defOppdater(selv, delta_tid):
til Jeg i område (NUM_OBJECTS):
x, y = selv.objekter[i]
dx = self.player_x - x
dy = self.player_y - y
avstand = math.sqrt (dx ** 2 + dy ** 2)
hvis avstand < PLAYER_RADIUS + OBJECT_RADIUS:
# hvis kollisjonen skjedde, håndter den her
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstand < 100:
dx /= avstand
dy /= avstand
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Balanserende tilfeldighet
For å skape en balansert spillopplevelse er det viktig å finjustere den tilfeldige bevegelsen og gytingen av objekter. Her er noen eksempler på hvordan du kan justere koden for å oppnå en bedre balanse i spillet ditt:
Begrenser maksimal hastighet
For å hindre at objekter beveger seg for fort, kan du innføre en maksimal fartsgrense. Endre Oppdater metode for å inkludere hastighetsbegrensninger:
defOppdater(selv, delta_tid):
til Jeg i område (NUM_OBJECTS):
x, y = selv.objekter[i]
dx = self.player_x - x
dy = self.player_y - y
avstand = math.sqrt (dx ** 2 + dy ** 2)hvis avstand < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstand < 100:
dx /= avstand
dy /= avstandhastighet = 3# Juster hastighetsverdien etter behov
dx = min (maks (dx * hastighet, -MAX_SPEED), MAX_SPEED)
dy = min (maks (dy * hastighet, -MAX_SPEED), MAX_SPEED)
x += dx
y += dy
self.objects[i] = (x, y)
Kontrollere spawn rate
Du kan også kontrollere hastigheten som nye objekter gyter med i spillet. Juster koden for å inkludere en forsinkelse mellom gyting av nye objekter:
import tidklasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
super().__init__(bredde, høyde)
arcade.set_background_color (arcade.color. HVIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
self.last_spawn_time = time.time()defOppdater(selv, delta_tid):
# kontroller gytehastigheten her
hvis time.time() - self.last_spawn_time > SPAWN_DELAY:
hvis len (self.objects) < MAX_OBJECTS:
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
self.last_spawn_time = time.time()til Jeg i område (len (self.objects)):
x, y = selv.objekter[i]
dx = self.player_x - x
dy = self.player_y - y
avstand = math.sqrt (dx ** 2 + dy ** 2)hvis avstand < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstand < 100:
dx /= avstand
dy /= avstand
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)
Juster SPAWN_DELAY og MAX_OBJECTS verdier for å finne den rette balansen for spillet ditt. En lengre forsinkelse eller et mindre maksimalt antall objekter vil gjøre spillet mindre overfylt. Mens en kortere forsinkelse eller et større maksimum vil øke vanskelighetsgraden.
Gjør spill morsommere ved å bruke bevegelige objekter
Å legge til tilfeldige bevegelige objekter til spill kan forbedre den generelle opplevelsen betydelig. De introduserer uforutsigbarhet og utfordringer, noe som gjør spillingen mer engasjerende og dynamisk. Spillere må tilpasse seg og reagere raskt for å unngå kollisjoner eller fange gjenstander, og det vil gi en følelse av spenning og prestasjon.
