Krydr dine arkadespil ved at introducere fjender.

Fjender spiller en afgørende rolle i at skabe engagerende og udfordrende spil. De giver forhindringer og modstandere for spillere, hvilket gør spiloplevelsen mere spændende. Pythons Arcade-bibliotek tilbyder en ligetil måde at inkorporere fjender i dine spil.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på din enhed. Brug denne kommando til at installere arkade bibliotek:

pip installere arkade

Start derefter med at lave et simpelt spil, hvor spilleren kan bevæge sig til venstre og højre ved hjælp af piletasterne.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

importere arkade

# Vindues dimensioner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Spilleregenskaber
PLAYER_RADIUS = 25
PLAYER_SPEED = 5

klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
super().__init__(bredde, højde)
arcade.set_background_color (arcade.color. HVID)
self.player_x = bredde // 2

instagram viewer

defon_draw(selv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. BLÅ)

defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
self.player_x -= PLAYER_SPEED
elif nøgle == arkade.nøgle. HØJRE:
self.player_x += PLAYER_SPEED

defopdatering(selv, delta_tid):
passere

defvigtigste():
vindue = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()

hvis __navn__ == "__main__":
hoved()

At skabe en simpel fjende

For at skabe en fjende, der dræber spilleren ved kollision, skal du oprette en anden cirkel på skærmen. I den on_draw funktion, kan du tegne denne fjendecirkel og tjekke for kollisioner i opdatering metode. Du kan også brug sprites til fjender.

# Føj til GameWindow-klassen

klasseGameWindow(arkade. Vindue):
# ...

def__i det__(selv, bredde, højde):
# ...

# Fjendens egenskaber
self.enemy_x = bredde // 2
self.enemy_y = højde - PLAYER_RADIUS
self.enmy_radius = 20

defon_draw(selv):
# ...
arcade.draw_circle_filled (self.enmy_x, self.enmy_y, self.enmy_radius, arcade.color. RØD)

defopdatering(selv, delta_tid):
hvis self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
Print("Spillet er slut!")

defer_kollision(selv, x1, y1, x2, y2, radius1, radius2):
afstand_kvadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_kvadrat = (radius1 + radius2) ** 2
Vend tilbage distance_squared <= radius_sum_squared

Få fjenden til at følge spilleren

I nogle spil kan fjender jagte spilleren, hvilket tilføjer et dynamisk element til gameplayet. For at oprette en følgende fjende skal du opdatere dens position baseret på spillerens position. Hver gang spilleren bevæger sig, fjenden bevæger sig i samme retning. Du kan opnå dette ved at ændre opdatering metode. Opret en ny fil med navnet enemy-follow-player.py og tilføj koden med nedenstående opdateringer:

# Føj til GameWindow-klassen

klasseGameWindow(arkade. Vindue):
# ...

defopdatering(selv, delta_tid):
hvis self.player_x < self.enemy_x:
self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x:
self.enemy_x += PLAYER_SPEED

hvis self.is_collision (self.player_x, self.player_y,
self.enmy_x, self.enmy_y,
PLAYER_RADIUS, ENEMY_RADIUS):
Print("Spillet er slut!")

defer_kollision(selv, x1, y1, x2, y2, radius1, radius2):
afstand_kvadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_kvadrat = (radius1 + radius2) ** 2
Vend tilbage distance_squared <= radius_sum_squared

Nedenfor er output:

Tilføjelse af fjendens kugler

For at skabe en fjende, der skyder kugler, skal du oprette en Kugle klasse og en liste for at holde styr på aktive kugler. Fjenden vil med jævne mellemrum skabe en ny kugle og opdatere sin position. Opret en ny fil med navnet bullets.py og tilføj koden med nedenstående opdateringer:

# Føj til GameWindow-klassen

klasseKugle:
def__i det__(selv, x, y, radius, hastighed):
selv.x = x
self.y = y
self.radius = radius
selv.hastighed = fart

defopdatering(selv):
self.y -= self.speed

klasseGameWindow(arkade. Vindue):
# ...

def__i det__(selv, bredde, højde):
# ...

# Fjendens egenskaber
self.bullets = []
self.bullet_radius = 5
self.bullet_speed = 3
self.bullet_cooldown = 60# Antal rammer mellem bullet spawns
self.bullet_timer = 0

defon_draw(selv):
# ...
til kugle i self.bullets:
arcade.draw_circle_filled (bullet.x, bullet.y,
self.bullet_radius, arcade.color. SORT)

defopdatering(selv, delta_tid):
# ...

self.bullet_timer += 1
hvis 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

til kugle i self.bullets:
bullet.update()
hvis self.is_collision (self.player_x, self.player_y, self.enemy_x,
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
Print("Spillet er slut!")

defer_kollision(selv, x1, y1, x2, y2, radius1, radius2):
afstand_kvadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_kvadrat = (radius1 + radius2) ** 2
Vend tilbage distance_squared <= radius_sum_squared

Nedenfor er output:

Tilføjelse af sundhedspoint til fjender

I mange spil kan fjender have sundhedspoint (HP), hvilket giver dem mulighed for at opretholde flere hits, før de bliver besejret. Tilføjelse af sundhedspoint til fjender kan introducere strategiske gameplay-elementer og give en følelse af progression og udfordring. Opret en ny fil med navnet heath-point.py og tilføj koden med nedenstående opdateringer:

# Vindues dimensioner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Spilleregenskaber
PLAYER_RADIUS = 25
PLAYER_SPEED = 5

# Fjendens egenskaber
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100

klasseGameWindow(arkade. Vindue):
def__i det__(selv, bredde, højde):
super().__init__(bredde, højde)
arcade.set_background_color (arcade.color. HVID)
self.player_x = bredde // 2
self.player_y = højde // 2
self.enemy_x = bredde // 2
self.enemy_y = højde - PLAYER_RADIUS
self.enemy_health = Fjende_HEALTH
print (self.enemy_health)
defon_draw(selv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x,
self.player_y,
PLAYER_RADIUS,
arkade.farve. BLÅ)
hvis self.enmy_health > 0:
arcade.draw_circle_filled (self.enemy_x,
self.enmy_y,
ENEMY_RADIUS,
arkade.farve. RØD)

defopdatering(selv, delta_tid):
hvis self.is_collision (self.player_x, self.player_y,
self.enmy_x, self.enmy_y,
PLAYER_RADIUS, ENEMY_RADIUS):
self.enmy_health -= 10
print (self.enemy_health)

Det ENEMY_HEALTH konstant har en værdi på 100 for at repræsentere fjendens indledende sundhedspoint. Når spilleren kolliderer med fjenden, kan du trække nogle point fra fjendens helbred. For at få vist den opdaterede sundhedsværdi kan du udskrive et tekstobjekt self.health_text der viser fjendens nuværende helbred.

Ved at inkorporere sundhedspoint til fjender kan du introducere et lag af udfordring og strategi for spillere. Den viste sundhedsværdi giver visuel feedback og giver spillerne mulighed for at spore fjendens resterende helbred.

Derudover kan du udvide koden ved at tilføje yderligere logik og visuals, såsom at vise sundhedsbjælker eller implementere nederlagsbetingelser, når fjendens helbred når nul.

Bedste fremgangsmåder til at skabe fjender

Når du designer fjender til dit spil, er det vigtigt at overveje adskillige bedste praksisser for at sikre, at de bidrager til en udfordrende og fornøjelig spiloplevelse. Her er nogle retningslinjer, du skal følge, når du opretter fjender:

Forskellige egenskaber

Skab fjender med forskellige egenskaber såsom hastighed, størrelse, sundhed og angrebskraft. Forskellige fjendetyper bør have forskellige sværhedsgrader, hvilket kræver, at spillere tilpasser deres strategier i overensstemmelse hermed. Ved at introducere en blanding af fjendens egenskaber kan du holde gameplayet frisk og engagerende.

Unik adfærd

Giv hver fjendetype sine egne unikke adfærdsmønstre. Nogle fjender kan bevæge sig på en forudsigelig måde, mens andre kan udvise mere komplekse eller uberegnelige bevægelser. Overvej at inkorporere fjendens AI-algoritmer for at gøre deres adfærd mere intelligent og uforudsigelig og tilføje et ekstra lag af udfordring for spillerne.

Sundhedspoint (HP)

Implementer sundhedspunkter for fjender for at introducere en følelse af progression og holdbarhed. Dette gør det muligt for fjender at opretholde flere hits, før de bliver besejret. Ved at tildele forskellige mængder HP til forskellige fjendetyper, kan du skabe et sværhedsgradshierarki og tilskynde spillere til at planlægge og prioritere deres mål.

Gør spil sjovere med fjender

Tilføjelse af fjender til dine spil kan forbedre gameplay-oplevelsen markant. De introducerer udfordringer og motiverer spillere til at forbedre deres færdigheder. Fjender kan komme i forskellige former, fra simple forhindringer til komplekse AI-drevne modstandere. Ved at implementere fjender effektivt kan du gøre dine spil mere engagerende og underholdende for spillerne.