Padariet savas arkādes spēles vēl patīkamākas un aizraujošākas, pievienojot nejauši kustīgus objektus.

Nejauši kustīgi objekti spēlēs var radīt aizrautību un neparedzamību. Tas padara tos spēlētājiem saistošākus un izaicinošākus. Python Arcade bibliotēka nodrošina vienkāršu un efektīvu veidu, kā savās spēlēs iekļaut nejauši kustīgus objektus.

Izveidojiet vienkāršu spēli

Pirms sākat, pārliecinieties, ka jums ir pip ir instalēts jūsu ierīcē. Izmantojiet šo komandu, lai instalētu arkāde bibliotēka:

pip instalēšanas arkāde

Pēc tam izveidojiet logu, izmantojot arkāde. Logs klasē un iestatiet fona krāsu uz baltu.

Šajā rakstā izmantotais kods ir pieejams šajā GitHub repozitorijs un to varat izmantot bez maksas saskaņā ar MIT licenci.

Iestatiet atskaņotāja pozīciju horizontāli ekrāna vidū un pievienojiet nelielu attālumu no augšas. Spēlētāja kustību var kontrolēt, izmantojot bulttaustiņus.

Šeit ir mūsu pamata spēles kods:

imports arkāde
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15


klasēMana spēle(pasāža. logs):





instagram viewer


def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 arcade.set_background_color (arcade.color. BALTS)


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


defon_draw(pats):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. ZILS)


defAtjaunināt(self, delta_time):
caurlaide


defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. PA kreisi:
 self.player_x -= 5
elifs taustiņš == arcade.key. PA LABI:
 self.player_x += 5
ja __nosaukums__ == "__galvenais__":
 spēle = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Vairāku objektu pievienošana

Lai spēlei pievienotu nejauši kustīgus objektus, izveidojiet sarakstu, kurā saglabātu objekta pozīcijas, un atjauniniet tās katrā kadrā. Varat arī izmantot spraiti kā objekti.

Spēles kodā pievienojiet sarakstu ar nosaukumu objektus lai saglabātu nejauši kustīgo objektu pozīcijas. Pēc tam ģenerējiet objektu skaitu (NUM_OBJECTS) ar nejaušām x un y koordinātām ekrāna robežās. Objekti tiek uzzīmēti kā sarkani apļi, izmantojot arcade.draw_circle_filled funkciju.

imports arkāde
imports nejauši
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


klasēMana spēle(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 arcade.set_background_color (arcade.color. BALTS)


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


 self.objects = []
priekš _ iekšā diapazons (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(pats):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. ZILS)


priekš obj iekšā self.objects:
 x, y = objekts
 arcade.draw_circle_filled (x, y, OBJEKTA_RADIUSS, arcade.color. SARKANS)


defAtjaunināt(self, delta_time):
caurlaide


defon_key_press(pašs, atslēga, modifikatori):
ja taustiņš == arcade.key. PA kreisi:
 self.player_x -= 5
elifs taustiņš == arcade.key. PA LABI:
 self.player_x += 5
ja __nosaukums__ == "__galvenais__":
 spēle = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Zemāk ir izvade:

Izlases kustības algoritma ieviešana

Lai objekti pārvietotos nejauši, atjauniniet to pozīcijas Atjaunināt metode, izmantojot nejaušas kustības algoritmu.

Atkārtojiet katru objektu un ģenerējiet izlases vērtības dx un dy, kas atspoguļo x un y koordinātu izmaiņas. Pēc tam atjauniniet objekta pozīciju, pievienojot šīs vērtības. Šeit ir modificēts kods:

defAtjaunināt(self, delta_time):
priekš i iekšā diapazons (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)

Zemāk ir izvade:

Objekti, kas virzās uz spēlētāju

Lai pievienotu vairāk mijiedarbības, lieciet objektiem virzīties uz atskaņotāju. To var panākt, aprēķinot virziena vektoru starp objektu un atskaņotāju un attiecīgi pielāgojot objekta pozīciju.

Šim nolūkam aprēķiniet x un y koordinātu atšķirības starp objektu un atskaņotāju. Normalizējot šīs vērtības, jūs iegūstat virziena vektoru. Pēc tam reiziniet šo vektoru ar ātruma koeficientu (šajā gadījumā 3) un pievienojiet to objekta pozīcijai. Šeit ir atjaunināts Atjaunināt metode:

defAtjaunināt(self, delta_time):
priekš i iekšā diapazons (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 attālums = math.sqrt (dx ** 2 + dy** 2)
 dx /= attālums
 dy /= attālums
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Zemāk ir izvade:

Objekti sāk kustēties, kad atskaņotājs ieiet apkārtējā vidē

Lai pievienotu papildu dinamiku, modificējiet kodu tā, lai objekti sāktu kustēties tikai tad, kad spēlētājs ieiet to apkārtnē. Pievienojiet spēlētāja kustības kods un definējiet rādiusu, kurā objekti kļūst aktīvi.

defAtjaunināt(self, delta_time):
priekš i iekšā diapazons (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 attālums = math.sqrt (dx ** 2 + dy** 2)

ja attālums < 100: # Pielāgojiet rādiusu pēc vajadzības
 dx /= attālums
 dy /= attālums
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Sadursmju noteikšana un mijiedarbība

Tagad pievienojiet sadursmes noteikšanu starp atskaņotāju un objektiem un definējiet uzvedību sadursmes gadījumā. Modificēt Atjaunināt metode sadursmju novēršanai:

defAtjaunināt(self, delta_time):
priekš i iekšā diapazons (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 attālums = math.sqrt (dx ** 2 + dy** 2)

ja attālums < PLAYER_RADIUS + OBJECT_RADIUS:
# ja notikusi sadursme, rīkojieties šeit
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elifs attālums < 100:
 dx /= attālums
 dy /= attālums
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Nejaušības līdzsvarošana

Lai radītu līdzsvarotu spēles pieredzi, ir svarīgi precīzi noregulēt objektu nejaušo kustību un nārstot. Šeit ir daži piemēri, kā pielāgot kodu, lai panāktu labāku līdzsvaru spēlē:

Maksimālā ātruma ierobežošana

Lai novērstu objektu pārāk ātru kustību, varat ieviest maksimālā ātruma ierobežojumu. Modificēt Atjaunināt metode ātruma ierobežojumu iekļaušanai:

defAtjaunināt(self, delta_time):
priekš i iekšā diapazons (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 attālums = math.sqrt (dx ** 2 + dy** 2)
ja attālums < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elifs attālums < 100:
 dx /= attālums
 dy /= attālums


 ātrums = 3# Pielāgojiet ātruma vērtību pēc vajadzības
 dx = min (maks. (dx * ātrums, -MAX_SPEED), MAX_SPEED)
 dy = min (maks. (dy * ātrums, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Nārsta ātruma kontrole

Varat arī kontrolēt ātrumu, kādā spēlē parādās jauni objekti. Pielāgojiet kodu, lai iekļautu aizkavi starp jaunu objektu rašanos:

imports laiks
klasēMana spēle(pasāža. logs):
def__tajā__(pats, platums, augstums):
 super().__init__(platums, augstums)
 arcade.set_background_color (arcade.color. BALTS)


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


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


defAtjaunināt(self, delta_time):
# šeit kontrolējiet nārsta ātrumu
ja time.time() — self.last_spawn_time > SPAWN_DELAY:
ja len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = laiks.laiks()


priekš i iekšā diapazons (len (self.objects)):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 attālums = math.sqrt (dx ** 2 + dy** 2)


ja attālums < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elifs attālums < 100:
 dx /= attālums
 dy /= attālums
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Pielāgojiet SPAWN_DELAY un MAX_OBJECTS vērtības, lai atrastu savai spēlei pareizo līdzsvaru. Ilgāka kavēšanās vai mazāks maksimālais objektu skaits padarīs spēli mazāk pārpildītu. Tā kā īsāka aizkave vai lielāks maksimums palielinās grūtības.

Padariet spēles jautrākas, izmantojot kustīgus objektus

Nejauši kustīgu objektu pievienošana spēlēm var ievērojami uzlabot kopējo pieredzi. Tie rada neparedzamību un izaicinājumus, padarot spēli saistošāku un dinamiskāku. Spēlētājiem būs jāpielāgojas un ātri jāreaģē, lai izvairītos no sadursmēm vai noķertu objektus, un tas radīs satraukuma un sasnieguma sajūtu.