Urobte svoje arkádové hry ešte zábavnejšie a vzrušujúcejšie pridaním náhodne sa pohybujúcich objektov.

Náhodné pohybujúce sa objekty môžu do hier priniesť vzrušenie a nepredvídateľnosť. Vďaka tomu sú pre hráčov pútavejšie a náročnejšie. Knižnica Arcade v Pythone poskytuje jednoduchý a efektívny spôsob, ako začleniť náhodne sa pohybujúce objekty do vašich hier.

Vytvorte jednoduchú hru

Pred začatím sa uistite, že máte pip nainštalovaný na vašom zariadení. Tento príkaz použite na inštaláciu pasáž knižnica:

arkáda na inštaláciu pipu

Potom vytvorte okno pomocou pasáž. okno triedy a nastavte farbu pozadia na bielu.

Kód použitý v tomto článku je dostupný v tomto úložisko GitHub a môžete ho bezplatne používať na základe licencie MIT.

Nastavte pozíciu prehrávača do stredu obrazovky horizontálne a pridajte malú vzdialenosť zhora. Pohyb hráča môžete ovládať pomocou šípok.

Tu je kód pre našu základnú hru:

importovať pasáž
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15


triedaMyGame(arkáda. okno):
def__init__(ja, šírka, výška):





instagram viewer


 super().__init__(šírka, výška)
 arcade.set_background_color (arcade.color. BIELY)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


defon_draw(ja):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. MODRÁ)


defaktualizovať(self, delta_time):
prejsť


defon_key_press(ja, kľúč, modifikátory):
ak kľúč == arcade.key. VĽAVO:
 self.player_x -= 5
elif kľúč == arcade.key. SPRÁVNY:
 self.player_x += 5
ak __meno__ == "__Hlavná__":
 hra = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Pridanie viacerých objektov

Ak chcete do hry pridať náhodne sa pohybujúce objekty, vytvorte zoznam na uloženie pozícií objektov a aktualizujte ich v každom snímku. Môžete tiež použiť škriatky ako predmety.

Do kódu hry pridajte zoznam s názvom predmety na uloženie pozícií náhodne sa pohybujúcich objektov. Potom vygenerujte počet objektov (NUM_OBJECTS) s náhodnými súradnicami x a y v rámci hraníc obrazovky. Objekty sú nakreslené ako červené kruhy pomocou arcade.draw_circle_filled funkciu.

importovať pasáž
importovať náhodný
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


triedaMyGame(arkáda. okno):
def__init__(ja, šírka, výška):
 super().__init__(šírka, výška)
 arcade.set_background_color (arcade.color. BIELY)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
pre _ v rozsah (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(ja):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. MODRÁ)


pre obj v vlastné.objekty:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ČERVENÁ)


defaktualizovať(self, delta_time):
prejsť


defon_key_press(ja, kľúč, modifikátory):
ak kľúč == arcade.key. VĽAVO:
 self.player_x -= 5
elif kľúč == arcade.key. SPRÁVNY:
 self.player_x += 5
ak __meno__ == "__Hlavná__":
 hra = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Nižšie je výstup:

Implementácia algoritmu náhodného pohybu

Ak chcete, aby sa objekty pohybovali náhodne, aktualizujte ich polohu v aktualizovať metóda využívajúca algoritmus náhodného pohybu.

Iterujte každý objekt a generujte preň náhodné hodnoty dx a D Y, ktorá predstavuje zmenu súradníc x a y. Potom aktualizujte polohu objektu pridaním týchto hodnôt. Tu je upravený kód:

defaktualizovať(self, delta_time):
pre i v rozsah (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x + = dx
 y + = dy
 self.objects[i] = (x, y)

Nižšie je výstup:

Objekty pohybujúce sa smerom k hráčovi

Ak chcete pridať viac interakcie, posuňte objekty smerom k prehrávaču. Môžete to dosiahnuť tak, že vypočítate smerový vektor medzi objektom a prehrávačom a podľa toho upravíte polohu objektu.

Na tento účel vypočítajte rozdiely v súradniciach x a y medzi objektom a prehrávačom. Normalizáciou týchto hodnôt získate smerový vektor. Potom vynásobte tento vektor faktorom rýchlosti (v tomto prípade 3) a pridajte ho k polohe objektu. Tu je aktualizácia aktualizovať metóda:

defaktualizovať(self, delta_time):
pre i v rozsah (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 vzdialenosť = math.sqrt (dx ** 2 + dy ** 2)
 dx /= vzdialenosť
 dy /= vzdialenosť
 x += dx * 3
 y + = dy * 3
 self.objects[i] = (x, y)

Nižšie je výstup:

Objekty sa začnú pohybovať, keď hráč vstúpi do okolia

Ak chcete pridať ďalšiu dynamiku, upravte kód tak, aby sa objekty začali pohybovať až vtedy, keď hráč vstúpi do ich okolia. Pridajte kód pre pohyb hráča a definujte polomer, v rámci ktorého sa objekty stanú aktívnymi.

defaktualizovať(self, delta_time):
pre i v rozsah (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 vzdialenosť = math.sqrt (dx ** 2 + dy ** 2)

ak vzdialenosť < 100: # Podľa potreby upravte polomer
 dx /= vzdialenosť
 dy /= vzdialenosť
 x += dx * 3
 y + = dy * 3
 self.objects[i] = (x, y)

Detekcia a interakcia kolízie

Teraz pridajte detekciu kolízie medzi prehrávačom a objektmi a definujte správanie, keď dôjde ku kolízii. Upravte aktualizovať spôsob riešenia kolízií:

defaktualizovať(self, delta_time):
pre i v rozsah (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 vzdialenosť = math.sqrt (dx ** 2 + dy ** 2)

ak vzdialenosť < PLAYER_RADIUS + OBJECT_RADIUS:
# ak došlo ku kolízii, vyriešte ju tu
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif vzdialenosť < 100:
 dx /= vzdialenosť
 dy /= vzdialenosť
 x += dx * 3
 y + = dy * 3
 self.objects[i] = (x, y)

Vyvažovanie náhodnosti

Na vytvorenie vyváženého herného zážitku je dôležité doladiť náhodný pohyb a spawnovanie predmetov. Tu je niekoľko príkladov, ako môžete upraviť kód, aby ste dosiahli lepšiu rovnováhu vo svojej hre:

Obmedzenie maximálnej rýchlosti

Ak chcete zabrániť tomu, aby sa predmety pohybovali príliš rýchlo, môžete zaviesť obmedzenie maximálnej rýchlosti. Upravte aktualizovať metóda na zahrnutie rýchlostných obmedzení:

defaktualizovať(self, delta_time):
pre i v rozsah (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 vzdialenosť = math.sqrt (dx ** 2 + dy ** 2)
ak vzdialenosť < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif vzdialenosť < 100:
 dx /= vzdialenosť
 dy /= vzdialenosť


 rýchlosť = 3# Podľa potreby upravte hodnotu rýchlosti
 dx = min (max (dx * rýchlosť, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * rýchlosť, -MAX_SPEED), MAX_SPEED)
 x + = dx
 y + = dy
 self.objects[i] = (x, y)

Riadenie miery výskytu

Môžete tiež ovládať rýchlosť, akou sa v hre vytvárajú nové objekty. Upravte kód tak, aby zahŕňal oneskorenie medzi vytváraním nových objektov:

importovať čas
triedaMyGame(arkáda. okno):
def__init__(ja, šírka, výška):
 super().__init__(šírka, výška)
 arcade.set_background_color (arcade.color. BIELY)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
 self.last_spawn_time = time.time()


defaktualizovať(self, delta_time):
# tu môžete ovládať rýchlosť neresenia
ak time.time() - self.last_spawn_time > SPAWN_DELAY:
ak len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = time.time()


pre i v rozsah (len (self.objects)):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 vzdialenosť = math.sqrt (dx ** 2 + dy ** 2)


ak vzdialenosť < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif vzdialenosť < 100:
 dx /= vzdialenosť
 dy /= vzdialenosť
 x += dx * 3
 y + = dy * 3
 self.objects[i] = (x, y)

Upravte SPAWN_DELAY a MAX_OBJECTS hodnoty, aby ste našli správnu rovnováhu pre vašu hru. Väčšie oneskorenie alebo menší maximálny počet predmetov spôsobí, že hra bude menej preplnená. Zatiaľ čo kratšie oneskorenie alebo väčšie maximum zvýšia náročnosť.

Urobte hry zábavnejšie pomocou pohyblivých predmetov

Pridávanie náhodných pohybujúcich sa objektov do hier môže výrazne zlepšiť celkový zážitok. Predstavujú nepredvídateľnosť a výzvu, vďaka čomu je hra pútavejšia a dynamickejšia. Hráči sa budú musieť prispôsobiť a rýchlo reagovať, aby sa vyhli kolíziám alebo zachytili predmety, čo im poskytne pocit vzrušenia a úspechu.