Machen Sie Ihre Arcade-Spiele noch unterhaltsamer und spannender, indem Sie sich zufällig bewegende Objekte hinzufügen.

Zufällig bewegte Objekte können Spannung und Unvorhersehbarkeit in Spiele bringen. Dadurch werden sie für die Spieler ansprechender und herausfordernder. Die Arcade-Bibliothek von Python bietet eine einfache und effiziente Möglichkeit, sich zufällig bewegende Objekte in Ihre Spiele zu integrieren.

Erstellen Sie ein einfaches Spiel

Bevor Sie beginnen, stellen Sie sicher, dass Sie dies getan haben pip auf Ihrem Gerät installiert. Verwenden Sie diesen Befehl, um die zu installieren Arkade Bibliothek:

Pip Arcade installieren

Erstellen Sie anschließend ein Fenster mit Arkade. Fenster Klasse und stellen Sie die Hintergrundfarbe auf Weiß ein.

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

Stellen Sie die Position des Players horizontal auf die Mitte des Bildschirms ein und fügen Sie einen kleinen Abstand von der Oberseite hinzu. Mit den Pfeiltasten können Sie die Bewegung des Spielers steuern.

instagram viewer

Hier ist der Code für unser Basisspiel:

importieren Arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15


KlasseMein Spiel(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (arcade.color. WEISS)


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


defon_draw(selbst):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLAU)


defaktualisieren(self, delta_time):
passieren


defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= 5
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += 5
Wenn __name__ == "__hauptsächlich__":
 game = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Mehrere Objekte hinzufügen

Um Ihrem Spiel zufällig bewegte Objekte hinzuzufügen, erstellen Sie eine Liste, um die Positionen der Objekte zu speichern und sie in jedem Frame zu aktualisieren. Sie können auch verwenden Sprites als Objekte.

Fügen Sie in Ihrem Spielcode eine Liste mit dem Namen hinzu Objekte um die Positionen der sich zufällig bewegenden Objekte zu speichern. Generieren Sie anschließend die Anzahl der Objekte (NUM_OBJECTS) mit zufälligen x- und y-Koordinaten innerhalb der Bildschirmgrenzen. Die Objekte werden mit dem als rote Kreise gezeichnet arcade.draw_circle_filled Funktion.

importieren Arkade
importieren willkürlich
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


KlasseMein Spiel(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (arcade.color. WEISS)


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


 self.objects = []
für _ In Bereich (NUM_OBJECTS):
 x = random.randint(0, BILDSCHIRMBREITE)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(selbst):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLAU)


für obj In self.objects:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROT)


defaktualisieren(self, delta_time):
passieren


defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= 5
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += 5
Wenn __name__ == "__hauptsächlich__":
 game = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Unten ist die Ausgabe:

Implementierung eines Zufallsbewegungsalgorithmus

Um die Objekte zufällig zu bewegen, aktualisieren Sie ihre Positionen im aktualisieren Methode, die einen Zufallsbewegungsalgorithmus verwendet.

Durchlaufen Sie jedes Objekt und generieren Sie Zufallswerte für dx Und dy, was die Änderung der x- und y-Koordinaten darstellt. Aktualisieren Sie dann die Position des Objekts, indem Sie diese Werte hinzufügen. Hier ist der geänderte Code:

defaktualisieren(self, delta_time):
für ich In Bereich (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Unten ist die Ausgabe:

Objekte, die sich auf den Spieler zubewegen

Um mehr Interaktion zu ermöglichen, bewegen Sie die Objekte auf den Spieler zu. Dies erreichen Sie, indem Sie den Richtungsvektor zwischen dem Objekt und dem Spieler berechnen und die Position des Objekts entsprechend anpassen.

Berechnen Sie dazu die Unterschiede in den x- und y-Koordinaten zwischen dem Objekt und dem Spieler. Durch Normalisierung dieser Werte erhalten Sie einen Richtungsvektor. Dann multiplizieren Sie diesen Vektor mit einem Geschwindigkeitsfaktor (in diesem Fall 3) und addieren ihn zur Position des Objekts. Hier ist die Aktualisierung aktualisieren Methode:

defaktualisieren(self, delta_time):
für ich In Bereich (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)
 dx /= Abstand
 dy /= Distanz
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Unten ist die Ausgabe:

Objekte beginnen sich zu bewegen, wenn der Spieler die Umgebung betritt

Um weitere Dynamik hinzuzufügen, ändern Sie den Code so, dass sich die Objekte erst dann bewegen, wenn der Spieler ihre Umgebung betritt. Ergänzen Sie die Code für die Bewegung des Spielers und definieren Sie einen Radius, innerhalb dessen die Objekte aktiv werden.

defaktualisieren(self, delta_time):
für ich In Bereich (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)

Wenn Abstand < 100: # Passen Sie den Radius nach Bedarf an
 dx /= Abstand
 dy /= Distanz
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Kollisionserkennung und Interaktion

Fügen Sie nun eine Kollisionserkennung zwischen dem Spieler und den Objekten hinzu und definieren Sie das Verhalten bei einer Kollision. Modifiziere den aktualisieren Methode zur Behandlung von Kollisionen:

defaktualisieren(self, delta_time):
für ich In Bereich (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)

Wenn Abstand < PLAYER_RADIUS + OBJECT_RADIUS:
# Wenn eine Kollision aufgetreten ist, behandeln Sie diese hier
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif Abstand < 100:
 dx /= Abstand
 dy /= Distanz
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Zufälligkeit ausgleichen

Um ein ausgewogenes Spielerlebnis zu schaffen, ist es wichtig, die zufällige Bewegung und das Erscheinen von Objekten genau abzustimmen. Hier sind ein paar Beispiele, wie Sie den Code anpassen können, um eine bessere Balance in Ihrem Spiel zu erreichen:

Begrenzung der Höchstgeschwindigkeit

Um zu verhindern, dass sich Objekte zu schnell bewegen, können Sie eine Höchstgeschwindigkeit einführen. Modifiziere den aktualisieren Methode zur Einbeziehung von Geschwindigkeitsbeschränkungen:

defaktualisieren(self, delta_time):
für ich In Bereich (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)
Wenn Abstand < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif Abstand < 100:
 dx /= Abstand
 dy /= Distanz


 Geschwindigkeit = 3# Passen Sie den Geschwindigkeitswert nach Bedarf an
 dx = min (max (dx * Geschwindigkeit, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * Geschwindigkeit, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Kontrolle der Spawn-Rate

Sie können auch die Geschwindigkeit steuern, mit der neue Objekte im Spiel erscheinen. Passen Sie den Code an, um eine Verzögerung zwischen dem Erscheinen neuer Objekte einzuschließen:

importieren Zeit
KlasseMein Spiel(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (arcade.color. WEISS)


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


 self.objects = []
 self.last_spawn_time = time.time()


defaktualisieren(self, delta_time):
# Kontrolliere hier die Laichrate
Wenn time.time() - self.last_spawn_time > SPAWN_DELAY:
Wenn len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = time.time()


für ich In range (len (self.objects)):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)


Wenn Abstand < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif Abstand < 100:
 dx /= Abstand
 dy /= Distanz
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Verstelle die SPAWN_DELAY Und MAX_OBJECTS Werte, um die richtige Balance für Ihr Spiel zu finden. Eine längere Verzögerung oder eine geringere maximale Anzahl von Objekten führt dazu, dass das Spiel weniger überfüllt ist. Eine kürzere Verzögerung oder ein größeres Maximum hingegen erhöhen den Schwierigkeitsgrad.

Machen Sie Spiele mit beweglichen Objekten unterhaltsamer

Das Hinzufügen zufällig bewegter Objekte zu Spielen kann das Gesamterlebnis erheblich verbessern. Sie sorgen für Unvorhersehbarkeit und Herausforderungen und machen das Gameplay ansprechender und dynamischer. Die Spieler müssen sich schnell anpassen und reagieren, um Kollisionen zu vermeiden oder Gegenstände zu fangen, und das wird ein Gefühl der Spannung und des Erfolgs vermitteln.