Uatrakcyjnij swoje gry zręcznościowe, wprowadzając wrogów.

Wrogowie odgrywają kluczową rolę w tworzeniu wciągających i wymagających gier. Zapewniają graczom przeszkody i przeciwników, dzięki czemu gra jest bardziej ekscytująca. Biblioteka Python's Arcade oferuje prosty sposób na włączenie wrogów do twoich gier.

Stwórz prostą grę

Zanim zaczniesz, upewnij się, że masz pip zainstalowany na twoim urządzeniu. Użyj tego polecenia, aby zainstalować arkada biblioteka:

zręcznościowa instalacja pip

Następnie zacznij od stworzenia prostej gry, w której gracz może poruszać się w lewo iw prawo za pomocą klawiszy strzałek.

Kod użyty w tym artykule jest dostępny w this Repozytorium GitHub i jest darmowy do użytku na licencji MIT.

import arkada
# Wymiary okna
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600


# Atrybuty gracza
PROMIEŃ_GRACZA = 25
PRĘDKOŚĆ_GRACZA = 5


klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (arcade.color. BIAŁY)
 self.player_x = szerokość // 2







instagram viewer



pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. NIEBIESKI)


pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 self.player_x -= PRĘDKOŚĆ_GRACZA
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 self.player_x += PRĘDKOŚĆ_GRACZA


pokaktualizacja(ja, delta_czas):
przechodzić


pokgłówny():
 okno = okno gry (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Jeśli __nazwa__ == "__główny__":
 główny()

Tworzenie prostego wroga

Aby stworzyć wroga, który zabije gracza po zderzeniu, utwórz kolejny okrąg na ekranie. w on_draw funkcji, możesz narysować ten krąg wroga i sprawdzić kolizje w aktualizacja metoda. Możesz również używaj sprite'ów dla wrogów.

# Dodaj do klasy GameWindow
klasaOkno gry(arkada. Okno):
# ...


pok__w tym__(ja, szerokość, wysokość):
# ...


# Atrybuty wroga
 self.enemy_x = szerokość // 2
 self.enemy_y = wzrost - PROMIEŃ_GRACZA
 własny.promień_wroga = 20


pokon_draw(samego siebie):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. CZERWONY)
pokaktualizacja(ja, delta_czas):
Jeśli self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 wydrukować("Koniec gry!")

pokis_collision(ja, x1, y1, x2, y2, promień1, promień2):
 odległość_kwadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (promień1 + promień2) ** 2
powrót odległość_kwadrat <= promień_sum_kwadrat

Sprawianie, by wróg podążał za graczem

W niektórych grach wrogowie mogą ścigać gracza, dodając dynamiczny element do rozgrywki. Aby stworzyć kolejnego wroga, musisz zaktualizować jego pozycję na podstawie pozycji gracza. Zawsze, gdy gracz się porusza, wróg porusza się w tym samym kierunku. Możesz to osiągnąć, modyfikując plik aktualizacja metoda. Utwórz nowy plik o nazwie wróg-follow-player.py i dodaj kod z poniższymi aktualizacjami:

# Dodaj do klasy GameWindow
klasaOkno gry(arkada. Okno):
# ...


pokaktualizacja(ja, delta_czas):
Jeśli sam.gracz_x < sam.wróg_x:
 self.enemy_x -= PRĘDKOŚĆ_GRACZA
Elif sam.gracz_x > sam.wróg_x:
 self.enemy_x += PRĘDKOŚĆ_GRACZA
Jeśli self.is_collision (self.player_x, self.player_y,
 własny.wróg_x, własny.wróg_y,
 PROMIEŃ_GRACZA, PROMIEŃ_WROGA):
 wydrukować("Koniec gry!")

pokis_collision(ja, x1, y1, x2, y2, promień1, promień2):
 odległość_kwadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (promień1 + promień2) ** 2
powrót odległość_kwadrat <= promień_sum_kwadrat

Poniżej znajduje się wyjście:

Dodawanie pocisków wroga

Aby stworzyć wroga strzelającego kulami, utwórz Pocisk class i listę do śledzenia aktywnych punktorów. Wróg będzie okresowo tworzył nowy pocisk i aktualizował swoją pozycję. Utwórz nowy plik o nazwie kule.py i dodaj kod z poniższymi aktualizacjami:

# Dodaj do klasy GameWindow
klasaPocisk:
pok__w tym__(ja, x, y, promień, prędkość):
 ja.x = x
 ja.y = y
 promień własny = promień
 prędkość własna = prędkość


pokaktualizacja(samego siebie):
 self.y -= self.speed


klasaOkno gry(arkada. Okno):
# ...


pok__w tym__(ja, szerokość, wysokość):
# ...


# Atrybuty wroga
 własne.pociski = []
 self.promień_pocisku = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Liczba klatek między spawnami pocisków
 self.bullet_timer = 0


pokon_draw(samego siebie):
# ...
Do pocisk W pociski własne:
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 własny.promień_pocisku, zręcznościowy.kolor. CZARNY)


pokaktualizacja(ja, delta_czas):
# ...


 self.bullet_timer += 1
Jeśli self.bullet_timer >= self.bullet_cooldown:
 self.bullets.append (Pocisk (self.enemy_x, self.enemy_y - self.enemy_radius, 
własny.promień_pocisku, własny.szybkość_pocisku))
 self.bullet_timer = 0
Do pocisk W pociski własne:
 punktor.aktualizacja()
Jeśli self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PROMIEŃ_GRACZA, PROMIEŃ_WROGA):
 wydrukować("Koniec gry!")

pokis_collision(ja, x1, y1, x2, y2, promień1, promień2):
 odległość_kwadrat = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (promień1 + promień2) ** 2
powrót odległość_kwadrat <= promień_sum_kwadrat

Poniżej znajduje się wyjście:

Dodawanie punktów życia dla wrogów

W wielu grach wrogowie mogą posiadać punkty zdrowia (HP), co pozwala im wytrzymać wiele trafień, zanim zostaną pokonani. Dodawanie punktów zdrowia wrogom może wprowadzić strategiczne elementy rozgrywki i zapewnić poczucie postępu i wyzwania. Utwórz nowy plik o nazwie Heathpoint.py i dodaj kod z poniższymi aktualizacjami:

# Wymiary okna
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
# Atrybuty gracza
PROMIEŃ_GRACZA = 25
PRĘDKOŚĆ_GRACZA = 5


# Atrybuty wroga
PROMIEŃ_WROGA = 20
ZDROWIE_WROGA = 100


klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (arcade.color. BIAŁY)
 self.player_x = szerokość // 2
 self.player_y = wzrost // 2
 self.enemy_x = szerokość // 2
 self.enemy_y = wzrost - PROMIEŃ_GRACZA
 zdrowie_wroga = ZDROWIE_WROGA
 drukuj (self.enemy_health)
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 sam.gracz_y,
 PLAYER_RADIUS,
 arkadowy.kolor. NIEBIESKI)
Jeśli zdrowie_wroga > 0:
 arcade.draw_circle_filled (self.enemy_x,
 własny.wróg_y,
 PROMIEŃ_WROGA,
 arkadowy.kolor. CZERWONY)
pokaktualizacja(ja, delta_czas):
Jeśli self.is_collision (self.player_x, self.player_y,
 własny.wróg_x, własny.wróg_y,
 PROMIEŃ_GRACZA, PROMIEŃ_WROGA):
 self.enemy_health -= 10
 drukuj (self.enemy_health)

The ZDROWIE_WROGA stała ma wartość 100, która reprezentuje początkowe punkty zdrowia wroga. Kiedy gracz zderzy się z wrogiem, możesz odjąć kilka punktów od zdrowia wroga. Aby wyświetlić zaktualizowaną wartość kondycji, możesz wydrukować obiekt tekstowy własny.tekst_zdrowie który pokazuje aktualne zdrowie wroga.

Włączając punkty zdrowia dla wrogów, możesz wprowadzić warstwę wyzwań i strategii dla graczy. Wyświetlana wartość zdrowia zapewnia wizualną informację zwrotną i pozwala graczom śledzić pozostałe zdrowie wroga.

Dodatkowo możesz rozszerzyć kod, dodając dalszą logikę i efekty wizualne, takie jak wyświetlanie pasków zdrowia lub wprowadzanie warunków porażki, gdy zdrowie wroga spadnie do zera.

Najlepsze praktyki tworzenia wrogów

Projektując wrogów do swojej gry, należy wziąć pod uwagę kilka najlepszych praktyk, aby upewnić się, że przyczynią się one do wymagającej i przyjemnej rozgrywki. Oto kilka wskazówek, których należy przestrzegać podczas tworzenia wrogów:

Różnorodne atrybuty

Twórz wrogów o różnych atrybutach, takich jak szybkość, rozmiar, zdrowie i siła ataku. Różne typy wrogów powinny stwarzać różne poziomy trudności, co wymaga od graczy odpowiedniego dostosowania strategii. Wprowadzając mieszankę atrybutów wroga, możesz zachować świeżość i wciągającą rozgrywkę.

Unikalne zachowania

Nadaj każdemu typowi wroga własne, unikalne wzorce zachowań. Niektórzy wrogowie mogą poruszać się w przewidywalny sposób, podczas gdy inni mogą wykazywać bardziej złożone lub chaotyczne ruchy. Rozważ włączenie algorytmów sztucznej inteligencji wrogów, aby uczynić ich zachowanie bardziej inteligentnym i nieprzewidywalnym, dodając dodatkową warstwę wyzwań dla graczy.

Punkty życia (HP)

Zaimplementuj punkty zdrowia dla wrogów, aby wprowadzić poczucie postępu i wytrzymałości. Dzięki temu wrogowie mogą wytrzymać wiele trafień, zanim zostaną pokonani. Przydzielając różną ilość HP różnym typom wrogów, możesz stworzyć hierarchię trudności i zachęcić graczy do planowania strategii i ustalania priorytetów dla swoich celów.

Spraw, by gry były zabawniejsze z wrogami

Dodawanie wrogów do gier może znacznie poprawić wrażenia z gry. Wprowadzają wyzwania i motywują graczy do doskonalenia swoich umiejętności. Wrogowie mogą przybierać różne formy, od prostych przeszkód po złożonych przeciwników kierowanych przez sztuczną inteligencję. Skutecznie wdrażając wrogów, możesz sprawić, że Twoje gry będą bardziej wciągające i przyjemne dla graczy.