Peppen Sie Ihre Arcade-Spiele auf, indem Sie Feinde einführen.

Feinde spielen eine entscheidende Rolle bei der Entwicklung spannender und herausfordernder Spiele. Sie bieten den Spielern Hindernisse und Gegner und machen das Spielerlebnis spannender. Die Arcade-Bibliothek von Python bietet eine unkomplizierte Möglichkeit, Feinde in Ihre Spiele einzubinden.

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

Beginnen Sie anschließend damit, ein einfaches Spiel zu erstellen, bei dem sich der Spieler mit den Pfeiltasten nach links und rechts bewegen kann.

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

importieren Arkade
# Fensterabmessungen
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Spielerattribute
PLAYER_RADIUS = 25
PLAYER_SPEED = 5







instagram viewer



KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (arcade.color. WEISS)
 self.player_x = Breite // 2


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


defon_key_press(selbst, Schlüssel, Modifikatoren):
Wenn Schlüssel == arcade.key. LINKS:
 self.player_x -= PLAYER_SPEED
elif Schlüssel == arcade.key. RECHTS:
 self.player_x += PLAYER_SPEED


defaktualisieren(self, delta_time):
passieren


defhauptsächlich():
 window = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Wenn __name__ == "__hauptsächlich__":
 hauptsächlich()

Einen einfachen Feind erschaffen

Um einen Feind zu erschaffen, der den Spieler bei einer Kollision tötet, erstellen Sie einen weiteren Kreis auf dem Bildschirm. Im on_draw Mit der Funktion können Sie diesen Feindkreis zeichnen und auf Kollisionen prüfen aktualisieren Methode. Du kannst auch Benutze Sprites für Feinde.

# Zur GameWindow-Klasse hinzufügen
KlasseGameWindow(Arkade. Fenster):
# ...


def__drin__(Selbst, Breite, Höhe):
# ...


# Feindattribute
 self.enemy_x = Breite // 2
 self.enemy_y = Höhe – PLAYER_RADIUS
 self.enemy_radius = 20


defon_draw(selbst):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROT)
defaktualisieren(self, delta_time):
Wenn self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 drucken("Spiel ist aus!")

defis_collision(selbst, x1, y1, x2, y2, Radius1, Radius2):
 distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
zurückkehren distance_squared <= radius_sum_squared

Den Feind dazu bringen, dem Spieler zu folgen

In einigen Spielen können Feinde den Spieler verfolgen, was dem Gameplay ein dynamisches Element hinzufügt. Um einen folgenden Feind zu erstellen, müssen Sie dessen Position basierend auf der Position des Spielers aktualisieren. Wann immer Der Spieler bewegt sich, der Feind bewegt sich in die gleiche Richtung. Sie können dies erreichen, indem Sie die ändern aktualisieren Methode. Erstellen Sie eine neue Datei mit dem Namen Feind-Folgen-Spieler.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Zur GameWindow-Klasse hinzufügen
KlasseGameWindow(Arkade. Fenster):
# ...


defaktualisieren(self, delta_time):
Wenn self.player_x < self.enemy_x:
 self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x:
 self.enemy_x += PLAYER_SPEED
Wenn self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 drucken("Spiel ist aus!")

defis_collision(selbst, x1, y1, x2, y2, Radius1, Radius2):
 distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
zurückkehren distance_squared <= radius_sum_squared

Unten ist die Ausgabe:

Feindliche Kugeln hinzufügen

Um einen Feind zu erschaffen, der Kugeln abfeuert, erstellen Sie einen Patrone Klasse und eine Liste, um den Überblick über aktive Aufzählungszeichen zu behalten. Der Feind erzeugt regelmäßig eine neue Kugel und aktualisiert seine Position. Erstellen Sie eine neue Datei mit dem Namen Bullets.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Zur GameWindow-Klasse hinzufügen
KlassePatrone:
def__drin__(Selbst, x, y, Radius, Geschwindigkeit):
 self.x = x
 self.y = y
 self.radius = Radius
 self.speed = Geschwindigkeit


defaktualisieren(selbst):
 self.y -= self.speed


KlasseGameWindow(Arkade. Fenster):
# ...


def__drin__(Selbst, Breite, Höhe):
# ...


# Feindattribute
 self.bullets = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Anzahl der Frames zwischen den Bullet-Spawns
 self.bullet_timer = 0


defon_draw(selbst):
# ...
für Patrone In self.bullets:
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 self.bullet_radius, arcade.color. SCHWARZ)


defaktualisieren(self, delta_time):
# ...


 self.bullet_timer += 1
Wenn self.bullet_timer >= self.bullet_cooldown:
 self.bullets.append (Bullet (self.enemy_x, self.enemy_y - self.enemy_radius, 
self.bullet_radius, self.bullet_speed))
 self.bullet_timer = 0
für Patrone In self.bullets:
 Bullet.update()
Wenn self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 drucken("Spiel ist aus!")

defis_collision(selbst, x1, y1, x2, y2, Radius1, Radius2):
 distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
zurückkehren distance_squared <= radius_sum_squared

Unten ist die Ausgabe:

Gesundheitspunkte für Feinde hinzufügen

In vielen Spielen können Feinde über Gesundheitspunkte (HP) verfügen, die es ihnen ermöglichen, mehrere Treffer auszuhalten, bevor sie besiegt werden. Das Hinzufügen von Gesundheitspunkten zu Gegnern kann strategische Gameplay-Elemente einführen und ein Gefühl von Fortschritt und Herausforderung vermitteln. Erstellen Sie eine neue Datei mit dem Namen heath-point.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Fensterabmessungen
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Spielerattribute
PLAYER_RADIUS = 25
PLAYER_SPEED = 5


# Feindattribute
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100


KlasseGameWindow(Arkade. Fenster):
def__drin__(Selbst, Breite, Höhe):
 super().__init__(Breite, Höhe)
 arcade.set_background_color (arcade.color. WEISS)
 self.player_x = Breite // 2
 self.player_y = Höhe // 2
 self.enemy_x = Breite // 2
 self.enemy_y = Höhe – PLAYER_RADIUS
 self.enemy_health = ENEMY_HEALTH
 drucken (self.enemy_health)
defon_draw(selbst):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 PLAYER_RADIUS,
 arcade.color. BLAU)
Wenn self.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 self.enemy_y,
 ENEMY_RADIUS,
 arcade.color. ROT)
defaktualisieren(self, delta_time):
Wenn self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 self.enemy_health -= 10
 drucken (self.enemy_health)

Der ENEMY_HEALTH Die Konstante hat einen Wert von 100, um die anfänglichen Gesundheitspunkte des Feindes darzustellen. Wenn der Spieler mit dem Feind kollidiert, können Sie einige Punkte von der Gesundheit des Feindes abziehen. Um den aktualisierten Gesundheitswert anzuzeigen, können Sie ein Textobjekt drucken self.health_text Das zeigt die aktuelle Gesundheit des Feindes an.

Durch die Einbeziehung von Gesundheitspunkten für Feinde können Sie den Spielern eine Ebene voller Herausforderungen und Strategien bieten. Der angezeigte Gesundheitswert bietet visuelles Feedback und ermöglicht es den Spielern, die verbleibende Gesundheit des Gegners zu verfolgen.

Darüber hinaus können Sie den Code erweitern, indem Sie weitere Logik und visuelle Elemente hinzufügen, z. B. die Anzeige von Gesundheitsbalken oder die Implementierung von Niederlagebedingungen, wenn die Gesundheit des Gegners Null erreicht.

Best Practices zum Erstellen von Feinden

Beim Entwerfen von Gegnern für Ihr Spiel ist es wichtig, mehrere Best Practices zu berücksichtigen, um sicherzustellen, dass sie zu einem herausfordernden und unterhaltsamen Spielerlebnis beitragen. Hier sind einige Richtlinien, die Sie beim Erstellen von Feinden befolgen sollten:

Vielfältige Attribute

Erschaffe Feinde mit unterschiedlichen Eigenschaften wie Geschwindigkeit, Größe, Gesundheit und Angriffskraft. Unterschiedliche Gegnertypen sollten unterschiedliche Schwierigkeitsgrade aufweisen, sodass die Spieler ihre Strategien entsprechend anpassen müssen. Durch die Einführung einer Mischung aus Gegnerattributen können Sie das Gameplay frisch und fesselnd halten.

Einzigartige Verhaltensweisen

Geben Sie jedem Feindtyp seine eigenen, einzigartigen Verhaltensmuster. Einige Feinde bewegen sich möglicherweise auf vorhersehbare Weise, während andere komplexere oder unregelmäßigere Bewegungen zeigen. Erwägen Sie die Einbindung feindlicher KI-Algorithmen, um deren Verhalten intelligenter und unvorhersehbarer zu machen und so den Spielern eine zusätzliche Herausforderung zu bieten.

Gesundheitspunkte (HP)

Implementieren Sie Gesundheitspunkte für Feinde, um ein Gefühl von Fortschritt und Haltbarkeit zu vermitteln. Dadurch können Feinde mehrere Treffer aushalten, bevor sie besiegt werden. Indem Sie unterschiedlichen Gegnertypen unterschiedliche HP-Mengen zuweisen, können Sie eine Schwierigkeitshierarchie erstellen und die Spieler dazu ermutigen, Strategien zu entwickeln und ihre Ziele zu priorisieren.

Machen Sie Spiele mit Feinden unterhaltsamer

Das Hinzufügen von Feinden zu Ihren Spielen kann das Spielerlebnis erheblich verbessern. Sie stellen Herausforderungen dar und motivieren die Spieler, ihre Fähigkeiten zu verbessern. Feinde können in verschiedenen Formen auftreten, von einfachen Hindernissen bis hin zu komplexen KI-gesteuerten Gegnern. Durch den effektiven Einsatz von Feinden können Sie Ihre Spiele für die Spieler ansprechender und unterhaltsamer gestalten.