Padarykite savo arkadinius žaidimus dar malonesnius ir įdomesnius pridėdami atsitiktinių judančių objektų.

Atsitiktinai judantys objektai žaidimuose gali sukelti jaudulį ir nenuspėjamumą. Tai daro juos patrauklesnius ir sudėtingesnius žaidėjams. Python Arcade biblioteka yra paprastas ir efektyvus būdas įtraukti atsitiktinius judančius objektus į žaidimus.

Sukurkite paprastą žaidimą

Prieš pradėdami įsitikinkite, kad turite pip įdiegtas jūsų įrenginyje. Naudokite šią komandą norėdami įdiegti arkada biblioteka:

pip diegimo pasažas

Po to sukurkite langą naudodami arkada. Langas klasę ir nustatykite fono spalvą į baltą.

Šiame straipsnyje naudojamas kodas pateikiamas čia GitHub saugykla ir jūs galite nemokamai naudotis pagal MIT licenciją.

Nustatykite grotuvo padėtį į ekrano vidurį horizontaliai ir pridėkite nedidelį atstumą nuo viršaus. Galite valdyti žaidėjo judėjimą naudodami rodyklių klavišus.

Štai mūsų pagrindinio žaidimo kodas:

importuoti arkada
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15







instagram viewer



klasėMano žaidimas(arkada. Langas):
def__init__(savaime, plotis, aukštis):
 super().__init__(plotis, aukštis)
 arcade.set_background_color (arcade.color. BALTAS)


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


defon_draw(savarankiškai):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. MĖLYNA)


defatnaujinti(savaime, delta_laikas):
praeiti


defyra_key_press(savaime, raktas, modifikatoriai):
jeigu raktas == arcade.key. KAIRĖ:
 self.player_x -= 5
elifas raktas == arcade.key. DEŠINĖJE:
 self.player_x += 5
jeigu __vardas__ == "__pagrindinis__":
 žaidimas = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Kelių objektų pridėjimas

Norėdami prie žaidimo pridėti atsitiktinai judančių objektų, sukurkite objektų pozicijų saugojimo sąrašą ir atnaujinkite jas kiekvieną kadrą. Taip pat galite naudoti spritai kaip objektai.

Žaidimo kode pridėkite sąrašą pavadinimu objektų atsitiktinai judančių objektų padėtims išsaugoti. Po to sugeneruokite objektų skaičių (NUM_OBJECTS) su atsitiktinėmis x ir y koordinatėmis ekrano ribose. Objektai nupiešti kaip raudoni apskritimai naudojant arcade.draw_circle_filled funkcija.

importuoti arkada
importuoti atsitiktinis
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


klasėMano žaidimas(arkada. Langas):
def__init__(savaime, plotis, aukštis):
 super().__init__(plotis, aukštis)
 arcade.set_background_color (arcade.color. BALTAS)


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


 self.objects = []
dėl _ in diapazonas (NUM_OBJECTS):
 x = atsitiktinis.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(savarankiškai):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. MĖLYNA)


dėl obj in self.objektai:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. RAUDONA)


defatnaujinti(savaime, delta_laikas):
praeiti


defyra_key_press(savaime, raktas, modifikatoriai):
jeigu raktas == arcade.key. KAIRĖ:
 self.player_x -= 5
elifas raktas == arcade.key. DEŠINĖJE:
 self.player_x += 5
jeigu __vardas__ == "__pagrindinis__":
 žaidimas = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Žemiau yra išvestis:

Atsitiktinių judesių algoritmo įgyvendinimas

Norėdami, kad objektai judėtų atsitiktinai, atnaujinkite jų padėtis atnaujinti metodas, naudojant atsitiktinio judėjimo algoritmą.

Pakartokite kiekvieną objektą ir generuokite atsitiktines reikšmes dx ir dy, reiškiantis x ir y koordinačių pokytį. Tada atnaujinkite objekto padėtį pridėdami šias reikšmes. Štai pakeistas kodas:

defatnaujinti(savaime, delta_laikas):
dėl i in diapazonas (NUM_OBJECTS):
 x, y = savaime.objektai[i]
 dx = random.randint(-5, 5)
 dy = atsitiktinis.randint(-5, 5)
 x += dx
 y += dy
 self.objects [i] = (x, y)

Žemiau yra išvestis:

Objektai, judantys žaidėjo link

Norėdami pridėti daugiau sąveikos, priverskite objektus judėti link grotuvo. Tai galite pasiekti apskaičiuodami krypties vektorių tarp objekto ir grotuvo ir atitinkamai pakoreguodami objekto padėtį.

Tam apskaičiuokite x ir y koordinačių skirtumus tarp objekto ir grotuvo. Normalizuodami šias reikšmes, gausite krypties vektorių. Tada padauginkite šį vektorių iš greičio koeficiento (šiuo atveju 3) ir pridėkite jį prie objekto padėties. Štai atnaujintas atnaujinti metodas:

defatnaujinti(savaime, delta_laikas):
dėl i in diapazonas (NUM_OBJECTS):
 x, y = savaime.objektai[i]
 dx = self.player_x - x
 dy = self.player_y – y
 atstumas = math.sqrt (dx ** 2 + dy** 2)
 dx /= atstumas
 dy /= atstumas
 x += dx * 3
 y += dy * 3
 self.objects [i] = (x, y)

Žemiau yra išvestis:

Objektai pradeda judėti, kai žaidėjas patenka į aplinką

Norėdami pridėti daugiau dinamikos, pakeiskite kodą taip, kad objektai pradėtų judėti tik tada, kai žaidėjas patenka į aplinkinę zoną. Pridėkite žaidėjo judėjimo kodas ir apibrėžkite spindulį, kuriame objektai tampa aktyvūs.

defatnaujinti(savaime, delta_laikas):
dėl i in diapazonas (NUM_OBJECTS):
 x, y = savaime.objektai[i]
 dx = self.player_x - x
 dy = self.player_y – y
 atstumas = math.sqrt (dx ** 2 + dy** 2)

jeigu atstumas < 100: # Sureguliuokite spindulį pagal poreikį
 dx /= atstumas
 dy /= atstumas
 x += dx * 3
 y += dy * 3
 self.objects [i] = (x, y)

Susidūrimų aptikimas ir sąveika

Dabar pridėkite žaidėjo ir objektų susidūrimo aptikimą ir apibrėžkite elgesį įvykus susidūrimui. Modifikuoti atnaujinti susidūrimų valdymo būdas:

defatnaujinti(savaime, delta_laikas):
dėl i in diapazonas (NUM_OBJECTS):
 x, y = savaime.objektai[i]
 dx = self.player_x - x
 dy = self.player_y – y
 atstumas = math.sqrt (dx ** 2 + dy** 2)

jeigu atstumas < PLAYER_RADIUS + OBJECT_RADIUS:
# jei įvyko susidūrimas, tvarkykite jį čia
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

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

Atsitiktinumo balansavimas

Norint sukurti subalansuotą žaidimo patirtį, svarbu tiksliai sureguliuoti atsitiktinį objektų judėjimą ir atsiradimą. Štai keli pavyzdžiai, kaip galite koreguoti kodą, kad žaidimo balansas būtų geresnis:

Maksimalaus greičio ribojimas

Kad objektai nejudėtų per greitai, galite įvesti maksimalaus greičio apribojimą. Modifikuoti atnaujinti greičio apribojimų įtraukimo būdas:

defatnaujinti(savaime, delta_laikas):
dėl i in diapazonas (NUM_OBJECTS):
 x, y = savaime.objektai[i]
 dx = self.player_x - x
 dy = self.player_y – y
 atstumas = math.sqrt (dx ** 2 + dy** 2)
jeigu atstumas < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elifas atstumas < 100:
 dx /= atstumas
 dy /= atstumas


 greitis = 3# Sureguliuokite greičio vertę pagal poreikį
 dx = min (maks. (dx * greitis, -MAX_SPEED), MAX_SPEED)
 dy = min (maks. (dy * greitis, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects [i] = (x, y)

Neršto greičio valdymas

Taip pat galite valdyti naujų objektų atsiradimo greitį žaidime. Koreguokite kodą, kad įtrauktumėte delsą tarp naujų objektų atsiradimo:

importuoti laikas
klasėMano žaidimas(arkada. Langas):
def__init__(savaime, plotis, aukštis):
 super().__init__(plotis, aukštis)
 arcade.set_background_color (arcade.color. BALTAS)


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


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


defatnaujinti(savaime, delta_laikas):
# čia valdykite neršto greitį
jeigu time.time() – self.last_spawn_time > SPAWN_DELAY:
jeigu len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = laikas.laikas()


dėl i in diapazonas (len (self.objektai)):
 x, y = savaime.objektai[i]
 dx = self.player_x - x
 dy = self.player_y – y
 atstumas = math.sqrt (dx ** 2 + dy** 2)


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

Sureguliuokite SPAWN_DELAY ir MAX_OBJECTS vertybes, kad rastumėte tinkamą žaidimo pusiausvyrą. Ilgesnis delsimas arba mažesnis maksimalus objektų skaičius sumažins žaidimą. Tuo tarpu trumpesnis delsimas arba didesnis maksimumas padidins sunkumus.

Padarykite žaidimus linksmesnius naudodami judančius objektus

Atsitiktinai judančių objektų pridėjimas prie žaidimų gali žymiai pagerinti bendrą patirtį. Jie suteikia nenuspėjamumo ir iššūkių, todėl žaidimas tampa patrauklesnis ir dinamiškesnis. Žaidėjai turės prisitaikyti ir greitai reaguoti, kad išvengtų susidūrimų ar nesugautų daiktų, o tai suteiks jaudulio ir pasiekimų jausmą.