Tegye még élvezetesebbé és izgalmasabbá arcade játékait véletlenszerű mozgó tárgyak hozzáadásával.

A véletlenszerűen mozgó tárgyak izgalmat és kiszámíthatatlanságot okozhatnak a játékokban. Ez vonzóbbá és nagyobb kihívást jelent a játékosok számára. A Python Arcade könyvtára egyszerű és hatékony módot kínál arra, hogy véletlenszerűen mozgó objektumokat építsen be játékaiba.

Hozzon létre egy egyszerű játékot

Mielőtt elkezdené, győződjön meg arról, hogy rendelkezik pip telepítve van a készülékére. Ezzel a paranccsal telepítheti a árkád könyvtár:

pip install arcade

Ezután hozzon létre egy ablakot a árkád. Ablak osztályt, és állítsa a háttérszínt fehérre.

A cikkben használt kód itt érhető el GitHub adattár és az MIT licence alapján ingyenesen használható.

Állítsa a lejátszót vízszintesen a képernyő közepére, és adjon hozzá egy kis távolságot a képernyő tetejétől. A játékos mozgását a nyílbillentyűkkel irányíthatja.

Íme az alapjátékunk kódja:

import árkád
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15



osztályAz én játékom(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 arcade.set_background_color (arcade.color. FEHÉR)


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


defon_draw(maga):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. KÉK)


deffrissítés(self, delta_time):
pass


defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. BAL:
 self.player_x -= 5
elif kulcs == arcade.key. JOBB:
 self.player_x += 5
ha __név__ == "__fő__":
 játék = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Több objektum hozzáadása

Ha véletlenszerűen mozgó objektumokat szeretne hozzáadni a játékhoz, hozzon létre egy listát az objektumok pozícióinak tárolására, és minden képkockánként frissítse azokat. Használhatod is sprite-ok mint tárgyak.

A játék kódjában adjon hozzá egy listát tárgyakat a véletlenszerűen mozgó objektumok pozícióinak tárolására. Ezután állítsa elő az objektumok számát (NUM_OBJECTS) véletlenszerű x és y koordinátákkal a képernyő határain belül. Az objektumok piros körökként vannak megrajzolva a arcade.draw_circle_filled funkció.

import árkád
import véletlen
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


osztályAz én játékom(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 arcade.set_background_color (arcade.color. FEHÉR)


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


 self.objects = []
számára _ ban ben tartomány (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(maga):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. KÉK)


számára obj ban ben self.objects:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. PIROS)


deffrissítés(self, delta_time):
pass


defon_key_press(én, kulcs, módosítók):
ha kulcs == arcade.key. BAL:
 self.player_x -= 5
elif kulcs == arcade.key. JOBB:
 self.player_x += 5
ha __név__ == "__fő__":
 játék = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Alább látható a kimenet:

Véletlenszerű mozgási algoritmus megvalósítása

Ahhoz, hogy az objektumok véletlenszerűen mozogjanak, frissítse helyzetüket a frissítés módszer véletlenszerű mozgási algoritmust használva.

Iteráljon végig minden objektumon, és generáljon véletlenszerű értékeket a számára dx és dy, amely az x és y koordináták változását jelenti. Ezután frissítse az objektum pozícióját ezen értékek hozzáadásával. Íme a módosított kód:

deffrissítés(self, delta_time):
számára én ban ben tartomány (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)

Alább látható a kimenet:

A játékos felé mozgó tárgyak

További interakció létrehozásához mozgassa az objektumokat a lejátszó felé. Ezt úgy érheti el, hogy kiszámítja az irányvektort az objektum és a lejátszó között, és ennek megfelelően állítja be az objektum helyzetét.

Ehhez számítsa ki az x és y koordináták különbségét az objektum és a lejátszó között. Ezen értékek normalizálásával irányvektort kapunk. Ezután szorozza meg ezt a vektort egy sebességtényezővel (ebben az esetben 3), és adja hozzá az objektum pozíciójához. Itt a frissített frissítés módszer:

deffrissítés(self, delta_time):
számára én ban ben tartomány (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 távolság = math.sqrt (dx ** 2 + dy** 2)
 dx /= távolság
 dy /= távolság
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Alább látható a kimenet:

Az objektumok elkezdenek mozogni, amikor a lejátszó belép a környezetbe

További dinamika hozzáadásához módosítsa a kódot úgy, hogy az objektumok csak akkor kezdjenek el mozogni, amikor a játékos belép a környező területükbe. Add hozzá a a játékos mozgásának kódja és határozzon meg egy sugarat, amelyen belül az objektumok aktívvá válnak.

deffrissítés(self, delta_time):
számára én ban ben tartomány (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 távolság = math.sqrt (dx ** 2 + dy** 2)

ha távolság < 100: # Szükség szerint állítsa be a sugarat
 dx /= távolság
 dy /= távolság
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Ütközésészlelés és interakció

Most adjon hozzá ütközésérzékelést a lejátszó és az objektumok között, és határozza meg a viselkedést ütközés esetén. Módosítsa a frissítés Az ütközések kezelésének módja:

deffrissítés(self, delta_time):
számára én ban ben tartomány (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 távolság = math.sqrt (dx ** 2 + dy** 2)

ha távolság < PLAYER_RADIUS + OBJECT_RADIUS:
# Ha ütközés történt, kezelje itt
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif távolság < 100:
 dx /= távolság
 dy /= távolság
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Balancing véletlenszerűség

A kiegyensúlyozott játékélmény megteremtéséhez fontos az objektumok véletlenszerű mozgásának és megjelenésének finomhangolása. Íme néhány példa arra, hogyan módosíthatja a kódot, hogy jobb egyensúlyt érjen el a játékban:

Maximális sebesség korlátozása

Az objektumok túl gyors mozgásának megakadályozása érdekében bevezethet egy maximális sebességkorlátozást. Módosítsa a frissítés módszer a sebességkorlátozások felvételére:

deffrissítés(self, delta_time):
számára én ban ben tartomány (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 távolság = math.sqrt (dx ** 2 + dy** 2)
ha távolság < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif távolság < 100:
 dx /= távolság
 dy /= távolság


 sebesség = 3# Szükség szerint állítsa be a sebességértéket
 dx = min (max (dx * sebesség, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * sebesség, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Szabályozása Spawn Rate

Azt is szabályozhatod, hogy milyen sebességgel jelenjenek meg az új tárgyak a játékban. Állítsa be a kódot úgy, hogy késleltetést tartalmazzon az új objektumok megjelenése között:

import idő
osztályAz én játékom(árkád. Ablak):
def__benne__(önmagasság, szélesség, magasság):
 szuper().__init__(szélesség, magasság)
 arcade.set_background_color (arcade.color. FEHÉR)


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


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


deffrissítés(self, delta_time):
# itt szabályozhatja az ívási arányt
ha time.time() - self.last_spawn_time > SPAWN_DELAY:
ha len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = time.time()


számára én ban ben tartomány (len (self.objects)):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 távolság = math.sqrt (dx ** 2 + dy** 2)


ha távolság < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif távolság < 100:
 dx /= távolság
 dy /= távolság
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Állítsa be a SPAWN_DELAY és MAX_OBJECTS értékeket, hogy megtalálja a megfelelő egyensúlyt a játékához. A hosszabb késleltetés vagy az objektumok kisebb maximális száma kevésbé zsúfoltja a játékot. Míg a rövidebb késleltetés vagy a nagyobb maximum növeli a nehézséget.

Tedd szórakoztatóbbá a játékokat mozgó tárgyak segítségével

Ha véletlenszerűen mozgó objektumokat ad hozzá a játékokhoz, jelentősen javíthatja az általános élményt. Kiszámíthatatlanságot és kihívást jelentenek, vonzóbbá és dinamikusabbá téve a játékmenetet. A játékosoknak gyorsan kell alkalmazkodniuk és reagálniuk, hogy elkerüljék az ütközéseket vagy elkapják a tárgyakat, és ez izgalmat és sikerélményt nyújt.