Muutke oma arkaadmängud veelgi nauditavamaks ja põnevamaks, lisades juhuslikke liikuvaid objekte.

Juhuslikult liikuvad objektid võivad tuua mängudesse põnevust ja ettearvamatust. See muudab need mängijate jaoks kaasahaaravamaks ja väljakutseid pakkuvamaks. Pythoni arkaadide teek pakub lihtsat ja tõhusat viisi juhuslike liikuvate objektide lisamiseks oma mängudesse.

Looge lihtne mäng

Enne alustamist veenduge, et teil on pip teie seadmesse installitud. Kasutage seda käsku installimiseks arkaad raamatukogu:

pip install arkaad

Pärast seda looge aken, kasutades nuppu arkaad. Aken klassi ja määrake taustavärviks valge.

Selles artiklis kasutatud kood on saadaval selles GitHubi hoidla ja seda saate MIT-i litsentsi alusel tasuta kasutada.

Seadke mängija asend horisontaalselt ekraani keskele ja lisage ülaosast väike vahemaa. Mängija liikumist saate juhtida nooleklahvide abil.

Siin on meie põhimängu kood:

importida arkaad
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15


klassMinu Mäng(arkaad. aken):

def__selles__(ise, laius, kõrgus):
 super().__init__(laius, kõrgus)
 arcade.set_background_color (arcade.color. VALGE)


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


defon_draw(ise):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. SININE)


defvärskendada(ise, delta_aeg):
üle andma


defon_key_press(ise, võti, muutjad):
kui võti == arcade.key. VASAKULE:
 self.player_x -= 5
elif võti == arcade.key. PAREMALE:
 self.player_x += 5
kui __nimi__ == "__main__":
 mäng = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Mitme objekti lisamine

Juhuslike liikuvate objektide lisamiseks mängu looge loend objektide asukohtade salvestamiseks ja värskendage neid iga kaadri järel. Võite ka kasutada spraidid kui objektid.

Lisage oma mängukoodisse loend nimega objektid juhuslikult liikuvate objektide asukohtade salvestamiseks. Pärast seda genereerige objektide arv (NUM_OBJECTS) juhuslike x- ja y-koordinaatidega ekraani piirides. Objektid joonistatakse punaste ringidena, kasutades arcade.draw_circle_filled funktsiooni.

importida arkaad
importida juhuslik
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


klassMinu Mäng(arkaad. aken):
def__selles__(ise, laius, kõrgus):
 super().__init__(laius, kõrgus)
 arcade.set_background_color (arcade.color. VALGE)


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


 self.objects = []
jaoks _ sisse vahemik (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(ise):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. SININE)


jaoks obj sisse self.objects:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. PUNANE)


defvärskendada(ise, delta_aeg):
üle andma


defon_key_press(ise, võti, muutjad):
kui võti == arcade.key. VASAKULE:
 self.player_x -= 5
elif võti == arcade.key. PAREMALE:
 self.player_x += 5
kui __nimi__ == "__main__":
 mäng = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Allpool on väljund:

Juhusliku liikumise algoritmi rakendamine

Objektide juhuslikuks liikumiseks värskendage nende asukohti värskendada juhusliku liikumise algoritmi kasutav meetod.

Korda läbi iga objekti ja genereeri juhuslikud väärtused dx ja dy, mis tähistab x ja y koordinaatide muutust. Seejärel värskendage objekti asukohta, lisades need väärtused. Siin on muudetud kood:

defvärskendada(ise, delta_aeg):
jaoks i sisse vahemik (NUM_OBJECTS):
 x, y = ise.objektid[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x += dx
 y += dy
 ise.objektid[i] = (x, y)

Allpool on väljund:

Mängija poole liikuvad objektid

Suurema suhtluse lisamiseks pange objektid mängija poole liikuma. Seda saate saavutada, kui arvutate objekti ja mängija vahelise suunavektori ning kohandate selle järgi objekti asukohta.

Selleks arvutage x ja y koordinaatide erinevused objekti ja mängija vahel. Nende väärtuste normaliseerimisel saate suunavektori. Seejärel korrutage see vektor kiirusteguriga (antud juhul 3) ja lisage see objekti asukohale. Siin on värskendatud värskendada meetod:

defvärskendada(ise, delta_aeg):
jaoks i sisse vahemik (NUM_OBJECTS):
 x, y = ise.objektid[i]
 dx = ise.mängija_x – x
 dy = ise.mängija_y - y
 kaugus = math.sqrt (dx ** 2 + dy** 2)
 dx /= kaugus
 dy /= kaugus
 x += dx * 3
 y += dy * 3
 ise.objektid[i] = (x, y)

Allpool on väljund:

Objektid hakkavad liikuma, kui mängija siseneb ümbritsevasse

Täiendava dünaamika lisamiseks muutke koodi nii, et objektid hakkaksid liikuma alles siis, kui mängija siseneb ümbritsevasse piirkonda. Lisage mängija liikumise kood ja määrake raadius, mille sees objektid muutuvad aktiivseks.

defvärskendada(ise, delta_aeg):
jaoks i sisse vahemik (NUM_OBJECTS):
 x, y = ise.objektid[i]
 dx = ise.mängija_x – x
 dy = ise.mängija_y - y
 kaugus = math.sqrt (dx ** 2 + dy** 2)

kui kaugus < 100: # Reguleerige raadiust vastavalt vajadusele
 dx /= kaugus
 dy /= kaugus
 x += dx * 3
 y += dy * 3
 ise.objektid[i] = (x, y)

Kokkupõrke tuvastamine ja interaktsioon

Nüüd lisage mängija ja objektide vaheline kokkupõrketuvastus ning määrake käitumine kokkupõrke korral. Muutke värskendada kokkupõrgete käsitlemise meetod:

defvärskendada(ise, delta_aeg):
jaoks i sisse vahemik (NUM_OBJECTS):
 x, y = ise.objektid[i]
 dx = ise.mängija_x – x
 dy = ise.mängija_y - y
 kaugus = math.sqrt (dx ** 2 + dy** 2)

kui kaugus < PLAYER_RADIUS + OBJECT_RADIUS:
# kui toimus kokkupõrge, käsitle seda siin
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif kaugus < 100:
 dx /= kaugus
 dy /= kaugus
 x += dx * 3
 y += dy * 3
 ise.objektid[i] = (x, y)

Juhuslikkuse tasakaalustamine

Tasakaalustatud mängukogemuse loomiseks on oluline objektide juhuslikku liikumist ja kudemist täpselt häälestada. Siin on mõned näited selle kohta, kuidas saate oma mängus parema tasakaalu saavutamiseks koodi kohandada.

Maksimaalse kiiruse piiramine

Objektide liiga kiire liikumise vältimiseks võite kehtestada maksimaalse kiirusepiirangu. Muutke värskendada meetod kiiruspiirangute lisamiseks:

defvärskendada(ise, delta_aeg):
jaoks i sisse vahemik (NUM_OBJECTS):
 x, y = ise.objektid[i]
 dx = ise.mängija_x – x
 dy = ise.mängija_y - y
 kaugus = math.sqrt (dx ** 2 + dy** 2)
kui kaugus < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif kaugus < 100:
 dx /= kaugus
 dy /= kaugus


 kiirus = 3# Reguleerige kiiruse väärtust vastavalt vajadusele
 dx = min (maksimaalne (dx * kiirus, -MAX_SPEED), MAX_SPEED)
 dy = min (maksimaalne (dy * kiirus, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 ise.objektid[i] = (x, y)

Kudemissageduse juhtimine

Samuti saate juhtida uute objektide kudemise kiirust mängus. Kohandage koodi nii, et see hõlmaks viivitust uute objektide loomise vahel:

importida aega
klassMinu Mäng(arkaad. aken):
def__selles__(ise, laius, kõrgus):
 super().__init__(laius, kõrgus)
 arcade.set_background_color (arcade.color. VALGE)


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


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


defvärskendada(ise, delta_aeg):
# kontrolli siin kudemissagedust
kui time.time() - self.last_spawn_time > SPAWN_DELAY:
kui len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = aeg.aeg()


jaoks i sisse ulatus (len (self.objektid)):
 x, y = ise.objektid[i]
 dx = ise.mängija_x – x
 dy = ise.mängija_y - y
 kaugus = math.sqrt (dx ** 2 + dy** 2)


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

Reguleerige SPAWN_DELAY ja MAX_OBJECTS väärtusi, et leida oma mängu jaoks õige tasakaal. Pikem viivitus või väiksem maksimaalne objektide arv muudab mängu vähem rahvarohkeks. Kusjuures lühem viivitus või suurem maksimum suurendab raskust.

Muutke mängud liikuvate objektide abil lõbusamaks

Juhuslike liikuvate objektide lisamine mängudele võib üldist kogemust oluliselt parandada. Need toovad sisse ettearvamatuse ja väljakutse, muutes mängu kaasahaaravamaks ja dünaamilisemaks. Mängijad peavad kohanema ja kiiresti reageerima, et vältida kokkupõrkeid või esemeid kinni püüda, ning see annab põnevuse ja saavutuste tunde.