Maak je arcadespellen nog leuker en spannender door willekeurig bewegende objecten toe te voegen.

Willekeurig bewegende objecten kunnen games spannend en onvoorspelbaar maken. Het maakt ze aantrekkelijker en uitdagender voor spelers. De Arcade-bibliotheek van Python biedt een eenvoudige en efficiënte manier om willekeurig bewegende objecten in je games op te nemen.

Maak een eenvoudig spel

Controleer voordat u begint of u dat hebt gedaan pip op uw apparaat geïnstalleerd. Gebruik deze opdracht om het arcade bibliotheek:

pip installeer arcade

Maak daarna een venster met behulp van de arcade. Raam class en stel de achtergrondkleur in op wit.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Zet de speler horizontaal in het midden van het scherm en voeg een kleine afstand vanaf de bovenkant toe. Je kunt de bewegingen van de speler besturen met de pijltjestoetsen.

Hier is de code voor ons basisspel:

importeren





instagram viewer

 arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
SPELER_RADIUS = 15


klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 arcade.set_background_color (arcade.kleur. WIT)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLAUW)


defupdate(zelf, delta_tijd):
doorgang


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 5
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 5
als __naam__ == "__voornaamst__":
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()

Meerdere objecten toevoegen

Om willekeurig bewegende objecten aan je game toe te voegen, maak je een lijst om de posities van de objecten op te slaan en werk je ze elk frame bij. Je kan ook gebruiken sprites als objecten.

Voeg in je spelcode een lijst toe met de naam voorwerpen om de posities van de willekeurig bewegende objecten op te slaan. Genereer daarna het aantal objecten (NUM_OBJECTS) met willekeurige x- en y-coördinaten binnen de schermgrenzen. De objecten worden getekend als rode cirkels met behulp van de arcade.draw_circle_gevuld functie.

importeren arcade
importeren willekeurig
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
SPELER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 arcade.set_background_color (arcade.kleur. WIT)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 zelf.objecten = []
voor _ in bereik (NUM_OBJECTS):
 x = willekeurig.randint(0, SCREEN_WIDTH)
 y = willekeurig.randint(0, SCREEN_HEIGHT)
 zelf.objecten.toevoegen((x, y))


defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLAUW)


voor obj in zelf.objecten:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROOD)


defupdate(zelf, delta_tijd):
doorgang


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 5
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 5
als __naam__ == "__voornaamst__":
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()

Hieronder is de uitvoer:

Algoritme voor willekeurige bewegingen implementeren

Om de objecten willekeurig te laten bewegen, werkt u hun posities in de update methode met behulp van een willekeurig bewegingsalgoritme.

Doorloop elk object en genereer willekeurige waarden voor dx En dood, die de verandering in x- en y-coördinaten weergeeft. Werk vervolgens de positie van het object bij door deze waarden toe te voegen. Hier is de gewijzigde code:

defupdate(zelf, delta_tijd):
voor i in bereik (NUM_OBJECTS):
 x, y = zelf.objecten[i]
 dx = willekeurig.randint(-5, 5)
 dy = willekeurig.randint(-5, 5)
 x +=dx
 j += dood
 zelf.objecten[i] = (x, y)

Hieronder is de uitvoer:

Objecten die naar de speler bewegen

Om meer interactie toe te voegen, laat je de objecten naar de speler toe bewegen. U kunt dit bereiken door de richtingsvector tussen het object en de speler te berekenen en de positie van het object dienovereenkomstig aan te passen.

Bereken hiervoor de verschillen in x- en y-coördinaten tussen het object en de speler. Door deze waarden te normaliseren, verkrijgt u een richtingsvector. Vermenigvuldig deze vector vervolgens met een snelheidsfactor (in dit geval 3) en tel deze op bij de positie van het object. Hier is de bijgewerkte update methode:

defupdate(zelf, delta_tijd):
voor i in bereik (NUM_OBJECTS):
 x, y = zelf.objecten[i]
 dx = zelf.speler_x - x
 dy = zelf.speler_y - y
 afstand = wiskunde.sqrt (dx ** 2 + sterf ** 2)
 dx /= afstand
 dy /= afstand
 x +=dx * 3
 y += dy * 3
 zelf.objecten[i] = (x, y)

Hieronder is de uitvoer:

Objecten beginnen te bewegen wanneer de speler de omgeving betreedt

Om meer dynamiek toe te voegen, past u de code aan zodat de objecten alleen beginnen te bewegen wanneer de speler hun omgeving betreedt. Voeg de code voor de beweging van de speler en definieer een straal waarbinnen de objecten actief worden.

defupdate(zelf, delta_tijd):
voor i in bereik (NUM_OBJECTS):
 x, y = zelf.objecten[i]
 dx = zelf.speler_x - x
 dy = zelf.speler_y - y
 afstand = wiskunde.sqrt (dx ** 2 + sterf ** 2)

als afstand < 100: # Pas de straal naar behoefte aan
 dx /= afstand
 dy /= afstand
 x +=dx * 3
 y += dy * 3
 zelf.objecten[i] = (x, y)

Botsingsdetectie en interactie

Voeg nu botsingsdetectie toe tussen de speler en de objecten en definieer het gedrag wanneer er een botsing plaatsvindt. Wijzig de update methode om botsingen te behandelen:

defupdate(zelf, delta_tijd):
voor i in bereik (NUM_OBJECTS):
 x, y = zelf.objecten[i]
 dx = zelf.speler_x - x
 dy = zelf.speler_y - y
 afstand = wiskunde.sqrt (dx ** 2 + sterf ** 2)

als afstand < PLAYER_RADIUS + OBJECT_RADIUS:
# als er een aanrijding is opgetreden, handel deze dan hier af
 zelf.objecten.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), willekeurig.randint(0, SCREEN_HEIGHT)))

elif afstand < 100:
 dx /= afstand
 dy /= afstand
 x +=dx * 3
 y += dy * 3
 zelf.objecten[i] = (x, y)

Willekeurigheid balanceren

Om een ​​evenwichtige gameplay-ervaring te creëren, is het belangrijk om de willekeurige beweging en spawning van objecten nauwkeurig af te stemmen. Hier zijn een paar voorbeelden van hoe je de code kunt aanpassen om een ​​betere balans in je spel te krijgen:

Maximale snelheid beperken

Om te voorkomen dat objecten te snel bewegen, kun je een maximumsnelheid invoeren. Wijzig de update methode om snelheidsbeperkingen op te nemen:

defupdate(zelf, delta_tijd):
voor i in bereik (NUM_OBJECTS):
 x, y = zelf.objecten[i]
 dx = zelf.speler_x - x
 dy = zelf.speler_y - y
 afstand = wiskunde.sqrt (dx ** 2 + sterf ** 2)
als afstand < PLAYER_RADIUS + OBJECT_RADIUS:
 zelf.objecten.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), willekeurig.randint(0, SCREEN_HEIGHT)))
elif afstand < 100:
 dx /= afstand
 dy /= afstand


 snelheid = 3# Pas de snelheidswaarde naar wens aan
 dx = min (max (dx * snelheid, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * snelheid, -MAX_SPEED), MAX_SPEED)
 x +=dx
 j += dood
 zelf.objecten[i] = (x, y)

Spawnsnelheid regelen

Je kunt ook de snelheid bepalen waarmee nieuwe objecten in het spel verschijnen. Pas de code aan om een ​​vertraging op te nemen tussen het spawnen van nieuwe objecten:

importeren tijd
klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 arcade.set_background_color (arcade.kleur. WIT)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 zelf.objecten = []
 self.last_spawn_time = tijd.tijd()


defupdate(zelf, delta_tijd):
# bepaal hier de paaisnelheid
als time.time() - self.last_spawn_time > SPAWN_DELAY:
als len (zelfobjecten) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), willekeurig.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = tijd.tijd()


voor i in bereik (len (zelf.objecten)):
 x, y = zelf.objecten[i]
 dx = zelf.speler_x - x
 dy = zelf.speler_y - y
 afstand = wiskunde.sqrt (dx ** 2 + sterf ** 2)


als afstand < PLAYER_RADIUS + OBJECT_RADIUS:
 zelf.objecten.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), willekeurig.randint(0, SCREEN_HEIGHT)))
elif afstand < 100:
 dx /= afstand
 dy /= afstand
 x +=dx * 3
 y += dy * 3
 zelf.objecten[i] = (x, y)

Pas de... aan SPAWN_DELAY En MAX_OBJECTS waarden om de juiste balans voor uw spel te vinden. Een langere vertraging of een kleiner maximum aantal objecten maakt het spel minder druk. Terwijl een kortere vertraging of een groter maximum de moeilijkheidsgraad vergroot.

Maak games leuker met behulp van bewegende objecten

Het toevoegen van willekeurig bewegende objecten aan games kan de algehele ervaring aanzienlijk verbeteren. Ze introduceren onvoorspelbaarheid en uitdaging, waardoor de gameplay boeiender en dynamischer wordt. Spelers zullen zich moeten aanpassen en snel moeten reageren om botsingen te voorkomen of objecten te vangen, en dat zorgt voor een gevoel van opwinding en prestatie.