Condimentează-ți jocurile arcade introducând inamici.

Inamicii joacă un rol crucial în crearea de jocuri captivante și provocatoare. Ele oferă obstacole și adversari pentru jucători, făcând experiența de joc mai interesantă. Biblioteca Arcade a lui Python oferă o modalitate simplă de a încorpora inamicii în jocurile tale.

Creați un joc simplu

Înainte de a începe, asigurați-vă că aveți pip instalat pe dispozitivul dvs. Utilizați această comandă pentru a instala arcadă bibliotecă:

pip install arcade

După aceea, începeți prin a crea un joc simplu în care jucătorul se poate deplasa la stânga și la dreapta folosind tastele săgeți.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

import arcadă
# Dimensiunile ferestrei
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Atributele jucătorului
PLAYER_RADIUS = 25
PLAYER_SPEED = 5


clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
 super().__init__(lățime, înălțime)
 arcade.set_background_color (arcade.color. ALB)
 self.player_x = latime // 2







instagram viewer



defon_draw(de sine):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. ALBASTRU)


defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
 self.player_x -= PLAYER_SPEED
elif cheie == arcade.key. DREAPTA:
 self.player_x += PLAYER_SPEED


defActualizați(self, delta_time):
trece


defprincipal():
 fereastra = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
dacă __nume__ == "__principal__":
 principal()

Crearea unui inamic simplu

Pentru a crea un inamic care ucide jucătorul la ciocnire, creați un alt cerc pe ecran. În on_draw funcția, puteți desena acest cerc inamic și puteți verifica dacă există coliziuni în Actualizați metodă. Poti de asemenea folosește sprite-uri pentru inamici.

# Adăugați la clasa GameWindow
clasăGame Window(arcadă. Fereastră):
# ...


def__init__(sine, lățime, înălțime):
# ...


# Atributele inamicului
 self.enemy_x = latime // 2
 self.enemy_y = înălțime - PLAYER_RADIUS
 self.enemy_radius = 20


defon_draw(de sine):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROȘU)
defActualizați(self, delta_time):
dacă self.is_colision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 imprimare("Joc încheiat!")

defeste_coliziune(self, x1, y1, x2, y2, radius1, radius2):
 distanta_patrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (raza1 + raza2) ** 2
întoarcere distanta_squared <= radius_sum_squared

Făcând inamicul să urmeze jucătorul

În unele jocuri, inamicii pot urmări jucătorul, adăugând un element dinamic jocului. Pentru a crea următorul inamic, trebuie să-i actualizați poziția în funcție de poziția jucătorului. Oricând jucătorul se mișcă, inamicul se mișcă în aceeași direcție. Puteți realiza acest lucru modificând Actualizați metodă. Creați un fișier nou numit enemy-follow-player.py și adăugați codul cu actualizările de mai jos:

# Adăugați la clasa GameWindow
clasăGame Window(arcadă. Fereastră):
# ...


defActualizați(self, delta_time):
dacă self.player_x < self.enemy_x:
 self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x:
 self.enemy_x += PLAYER_SPEED
dacă self.is_colision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 imprimare("Joc încheiat!")

defeste_coliziune(self, x1, y1, x2, y2, radius1, radius2):
 distanta_patrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (raza1 + raza2) ** 2
întoarcere distanta_squared <= radius_sum_squared

Mai jos este rezultatul:

Adăugarea gloanțelor inamice

Pentru a crea un inamic care trage gloanțe, creați a Glonţ clasă și o listă pentru a ține evidența gloanțelor active. Inamicul va crea periodic un nou glonț și își va actualiza poziția. Creați un fișier nou numit gloanțe.py și adăugați codul cu actualizările de mai jos:

# Adăugați la clasa GameWindow
clasăGlonţ:
def__init__(auto, x, y, raza, viteza):
 sine.x = x
 self.y = y
 self.radius = raza
 self.speed = viteza


defActualizați(de sine):
 self.y -= self.speed


clasăGame Window(arcadă. Fereastră):
# ...


def__init__(sine, lățime, înălțime):
# ...


# Atributele inamicului
 self.bullets = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Numărul de cadre între aparițiile glonțului
 self.bullet_timer = 0


defon_draw(de sine):
# ...
pentru glonţ în self.bullets:
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 self.bullet_radius, arcade.color. NEGRU)


defActualizați(self, delta_time):
# ...


 self.bullet_timer += 1
dacă 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
pentru glonţ în self.bullets:
 bullet.update()
dacă self.is_colision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 imprimare("Joc încheiat!")

defeste_coliziune(self, x1, y1, x2, y2, radius1, radius2):
 distanta_patrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (raza1 + raza2) ** 2
întoarcere distanta_squared <= radius_sum_squared

Mai jos este rezultatul:

Adăugarea de puncte de sănătate pentru inamici

În multe jocuri, inamicii pot avea puncte de sănătate (HP), permițându-le să suporte mai multe lovituri înainte de a fi învinși. Adăugarea de puncte de sănătate inamicilor poate introduce elemente strategice de joc și poate oferi un sentiment de progres și provocare. Creați un fișier nou numit heat-point.py și adăugați codul cu actualizările de mai jos:

# Dimensiunile ferestrei
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Atributele jucătorului
PLAYER_RADIUS = 25
PLAYER_SPEED = 5


# Atributele inamicului
RAZA_VÂŞNICULUI = 20
SĂNĂTATEA_DUSTRĂJULUI = 100


clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
 super().__init__(lățime, înălțime)
 arcade.set_background_color (arcade.color. ALB)
 self.player_x = latime // 2
 self.player_y = înălțime // 2
 self.enemy_x = latime // 2
 self.enemy_y = înălțime - PLAYER_RADIUS
 self.enemy_health = SĂNĂTATE_DE_VĂMÂNĂ
 imprimare (self.enemy_health)
defon_draw(de sine):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 PLAYER_RADIUS,
 arcade.culoare. ALBASTRU)
dacă sine.sănătate_dușman > 0:
 arcade.draw_circle_filled (self.enemy_x,
 self.enemy_y,
 ENEMY_RADIUS,
 arcade.culoare. ROȘU)
defActualizați(self, delta_time):
dacă self.is_colision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 sine.sănătate_dușman -= 10
 imprimare (self.enemy_health)

The SĂNĂTATEA_DUSTRĂMULUI constanta are o valoare de 100 pentru a reprezenta punctele inițiale de sănătate ale inamicului. Când jucătorul se ciocnește de inamicul, puteți deduce câteva puncte din sănătatea inamicului. Pentru a afișa valoarea de sănătate actualizată, puteți imprima un obiect text self.health_text care arată starea actuală de sănătate a inamicului.

Încorporând puncte de sănătate pentru inamici, puteți introduce un strat de provocare și strategie pentru jucători. Valoarea de sănătate afișată oferă feedback vizual și permite jucătorilor să urmărească starea de sănătate rămasă a inamicului.

În plus, puteți extinde codul adăugând mai multă logică și elemente vizuale, cum ar fi afișarea barelor de sănătate sau implementarea condițiilor de înfrângere atunci când sănătatea inamicului ajunge la zero.

Cele mai bune practici pentru crearea de inamici

Când proiectați inamici pentru jocul dvs., este important să luați în considerare câteva bune practici pentru a vă asigura că acestea contribuie la o experiență de joc provocatoare și plăcută. Iată câteva recomandări de urmat atunci când creați inamici:

Atribute diverse

Creați inamici cu diferite atribute, cum ar fi viteza, dimensiunea, sănătatea și puterea de atac. Diferite tipuri de inamici ar trebui să prezinte niveluri diferite de dificultate, necesitând jucătorilor să-și adapteze strategiile în consecință. Prin introducerea unui amestec de atribute inamice, puteți păstra jocul proaspăt și captivant.

Comportamente unice

Oferă fiecărui tip de inamic propriile modele de comportament unice. Unii inamici se pot mișca într-un mod previzibil, în timp ce alții pot prezenta mișcări mai complexe sau mai neregulate. Luați în considerare încorporarea algoritmilor AI inamici pentru a le face comportamentul mai inteligent și mai imprevizibil, adăugând un nivel suplimentar de provocare pentru jucători.

Puncte de sănătate (HP)

Implementați puncte de sănătate pentru inamici pentru a introduce un sentiment de progresie și durabilitate. Acest lucru le permite inamicilor să suporte mai multe lovituri înainte de a fi învinși. Prin atribuirea unor cantități diferite de HP diferitelor tipuri de inamici, puteți crea o ierarhie a dificultăților și puteți încuraja jucătorii să-și stabilească strategii și să-și prioritizeze țintele.

Faceți jocurile mai distractive cu inamicii

Adăugarea de inamici la jocurile tale poate îmbunătăți semnificativ experiența de joc. Ei introduc provocări și motivează jucătorii să-și îmbunătățească abilitățile. Dușmanii pot apărea sub diferite forme, de la simple obstacole la adversari complexi conduși de AI. Implementând inamicii în mod eficient, vă puteți face jocurile mai captivante și mai plăcute pentru jucători.