Geef je arcadespellen meer pit door vijanden te introduceren.

Vijanden spelen een cruciale rol bij het maken van boeiende en uitdagende games. Ze zorgen voor obstakels en tegenstanders voor spelers, waardoor de spelervaring spannender wordt. De Arcade-bibliotheek van Python biedt een eenvoudige manier om vijanden 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

Begin daarna met het maken van een eenvoudig spel waarbij de speler met de pijltjestoetsen naar links en rechts kan bewegen.

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.

importeren arcade
# Raamafmetingen
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600


# Spelersattributen
SPELER_RADIUS = 25
SPELER_SPEED = 5


klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 arcade.set_background_color (arcade.kleur. WIT)
 self.player_x = breedte // 2







instagram viewer



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


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.player_x -= PLAYER_SPEED
elif sleutel == arcade.sleutel. RECHTS:
 self.player_x += PLAYER_SPEED


defupdate(zelf, delta_tijd):
doorgang


defvoornaamst():
 venster = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Een eenvoudige vijand creëren

Om een ​​vijand te creëren die de speler bij een botsing doodt, maak je een nieuwe cirkel op het scherm. In de on_draw functie, kun je deze vijandelijke cirkel tekenen en controleren op botsingen in de update methode. Je kan ook gebruik sprites voor vijanden.

# Toevoegen aan GameWindow-klasse
klasGameWindow(arcade. Raam):
# ...


def__in het__(zelf, breedte, hoogte):
# ...


# Vijandelijke attributen
 self.enemy_x = breedte // 2
 self.enemy_y = hoogte - PLAYER_RADIUS
 zelf.enemy_radius = 20


defon_draw(zelf):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROOD)
defupdate(zelf, delta_tijd):
als self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 afdrukken("Spel is over!")

defis_botsing(zelf, x1, y1, x2, y2, straal1, straal2):
 afstand_kwadraat = (x1 - x2) ** 2 + (j1 - j2) ** 2
 radius_sum_squared = (straal1 + straal2) ** 2
opbrengst distance_squared <= radius_sum_squared

De vijand de speler laten volgen

In sommige games kunnen vijanden de speler achtervolgen, wat een dynamisch element aan de gameplay toevoegt. Om een ​​volgende vijand te creëren, moet je zijn positie bijwerken op basis van de positie van de speler. Wanneer dan ook de speler beweegt, beweegt de vijand in dezelfde richting. U kunt dit bereiken door de update methode. Maak een nieuw bestand met de naam vijand-volg-speler.py en voeg de code toe met de onderstaande updates:

# Toevoegen aan GameWindow-klasse
klasGameWindow(arcade. Raam):
# ...


defupdate(zelf, delta_tijd):
als self.player_x < self.enemy_x:
 self.enemy_x -= PLAYER_SPEED
elif zelf.speler_x > zelf.vijand_x:
 self.enemy_x += PLAYER_SPEED
als self.is_collision (self.player_x, self.player_y,
 zelf.vijand_x, zelf.vijand_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 afdrukken("Spel is over!")

defis_botsing(zelf, x1, y1, x2, y2, straal1, straal2):
 afstand_kwadraat = (x1 - x2) ** 2 + (j1 - j2) ** 2
 radius_sum_squared = (straal1 + straal2) ** 2
opbrengst distance_squared <= radius_sum_squared

Hieronder is de uitvoer:

Vijandelijke kogels toevoegen

Om een ​​vijand te maken die kogels afschiet, maak je een Kogel class en een lijst om actieve bullets bij te houden. De vijand zal periodiek een nieuwe kogel maken en zijn positie bijwerken. Maak een nieuw bestand met de naam kogels.py en voeg de code toe met de onderstaande updates:

# Toevoegen aan GameWindow-klasse
klasKogel:
def__in het__(zelf, x, y, straal, snelheid):
 zelf.x = x
 zelf.y = y
 self.radius = straal
 zelf.snelheid = snelheid


defupdate(zelf):
 zelf.y -= zelf.snelheid


klasGameWindow(arcade. Raam):
# ...


def__in het__(zelf, breedte, hoogte):
# ...


# Vijandelijke attributen
 zelf.kogels = []
 zelf.bullet_radius = 5
 self.bullet_speed = 3
 zelf.bullet_cooldown = 60# Aantal frames tussen bullet-spawns
 zelf.bullet_timer = 0


defon_draw(zelf):
# ...
voor kogel in zelf.kogels:
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 self.bullet_radius, arcade.color. ZWART)


defupdate(zelf, delta_tijd):
# ...


 self.bullet_timer += 1
als 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))
 zelf.bullet_timer = 0
voor kogel in zelf.kogels:
 opsommingsteken.update()
als self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 afdrukken("Spel is over!")

defis_botsing(zelf, x1, y1, x2, y2, straal1, straal2):
 afstand_kwadraat = (x1 - x2) ** 2 + (j1 - j2) ** 2
 radius_sum_squared = (straal1 + straal2) ** 2
opbrengst distance_squared <= radius_sum_squared

Hieronder is de uitvoer:

Gezondheidspunten toevoegen voor vijanden

In veel games kunnen vijanden gezondheidspunten (HP) hebben, waardoor ze meerdere treffers kunnen verdragen voordat ze worden verslagen. Het toevoegen van gezondheidspunten aan vijanden kan strategische gameplay-elementen introduceren en een gevoel van vooruitgang en uitdaging geven. Maak een nieuw bestand met de naam heide-punt.py en voeg de code toe met de onderstaande updates:

# Raamafmetingen
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
# Spelersattributen
SPELER_RADIUS = 25
SPELER_SPEED = 5


# Vijandelijke attributen
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100


klasGameWindow(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 arcade.set_background_color (arcade.kleur. WIT)
 self.player_x = breedte // 2
 self.player_y = hoogte // 2
 self.enemy_x = breedte // 2
 self.enemy_y = hoogte - PLAYER_RADIUS
 self.enemy_health = ENEMY_HEALTH
 afdrukken (self.enemy_health)
defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 zelf.speler_y,
 SPELER_RADIUS,
 arcade.kleur. BLAUW)
als zelf.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 zelf.enemy_y,
 ENEMY_RADIUS,
 arcade.kleur. ROOD)
defupdate(zelf, delta_tijd):
als self.is_collision (self.player_x, self.player_y,
 zelf.vijand_x, zelf.vijand_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 zelf.enemy_health -= 10
 afdrukken (self.enemy_health)

De ENEMY_HEALTH constant heeft een waarde van 100 om de aanvankelijke gezondheidspunten van de vijand weer te geven. Wanneer de speler in botsing komt met de vijand, kun je enkele punten aftrekken van de gezondheid van de vijand. Om de bijgewerkte gezondheidswaarde weer te geven, kunt u een tekstobject afdrukken zelf.gezondheid_tekst dat de huidige gezondheid van de vijand laat zien.

Door gezondheidspunten voor vijanden op te nemen, kun je een laag uitdaging en strategie voor spelers introduceren. De weergegeven gezondheidswaarde geeft visuele feedback en stelt spelers in staat om de resterende gezondheid van de vijand te volgen.

Bovendien kun je de code uitbreiden door meer logica en visuals toe te voegen, zoals het weergeven van gezondheidsbalken of het implementeren van nederlaagvoorwaarden wanneer de gezondheid van de vijand nul bereikt.

Best practices voor het maken van vijanden

Bij het ontwerpen van vijanden voor je game is het belangrijk om verschillende best practices in overweging te nemen om ervoor te zorgen dat ze bijdragen aan een uitdagende en plezierige gameplay-ervaring. Hier zijn enkele richtlijnen die u moet volgen bij het maken van vijanden:

Diverse attributen

Creëer vijanden met verschillende attributen zoals snelheid, grootte, gezondheid en aanvalskracht. Verschillende soorten vijanden zouden verschillende moeilijkheidsgraden moeten hebben, waardoor spelers hun strategieën dienovereenkomstig moeten aanpassen. Door een mix van vijandelijke attributen te introduceren, kun je de gameplay fris en boeiend houden.

Uniek gedrag

Geef elk type vijand zijn eigen unieke gedragspatronen. Sommige vijanden kunnen op een voorspelbare manier bewegen, terwijl andere meer complexe of grillige bewegingen kunnen vertonen. Overweeg om vijandelijke AI-algoritmen op te nemen om hun gedrag intelligenter en onvoorspelbaarder te maken, wat een extra laag uitdaging voor spelers toevoegt.

Gezondheidspunten (HP)

Implementeer gezondheidspunten voor vijanden om een ​​gevoel van vooruitgang en duurzaamheid te introduceren. Hierdoor kunnen vijanden meerdere treffers doorstaan ​​voordat ze worden verslagen. Door verschillende hoeveelheden HP toe te wijzen aan verschillende soorten vijanden, kun je een hiërarchie van moeilijkheidsgraad creëren en spelers aanmoedigen om strategieën te bedenken en hun doelen te prioriteren.

Maak games leuker met vijanden

Het toevoegen van vijanden aan je games kan de gameplay-ervaring aanzienlijk verbeteren. Ze introduceren uitdagingen en motiveren spelers om hun vaardigheden te verbeteren. Vijanden kunnen verschillende vormen aannemen, van eenvoudige obstakels tot complexe AI-gestuurde tegenstanders. Door vijanden effectief te implementeren, kun je je games aantrekkelijker en leuker maken voor spelers.