Specialiųjų efektų pridėjimas prie Pygame žaidimų: dalelių sistemos ir vaizdo patobulinimai

Pygame yra populiari žaidimų kūrimo naudojant Python biblioteka. Kuriant žaidimus specialiųjų efektų pridėjimas gali labai pagerinti žaidėjų vizualinį patrauklumą ir bendrą patirtį.

Dalelių sistemos yra galingas būdas sukurti dinamiškus ir vizualiai įdomius efektus, tokius kaip dulkių debesys, sprogimai, rūkas ir kt.

Sukurkite paprastą žaidimą

Prieš pasinerdami į dalelių sistemas ir vizualinius patobulinimus, pradėkite nuo paprasto žaidimo kūrimo naudodami Pygame. Sukurkite naują failą pavadinimu paprastas žaidimas.py ir pradėkite importuodami reikiamas bibliotekas ir inicijuodami Pygame. Nustatykite žaidimo langą su nurodytu pločiu ir aukščiu.

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

Pagrindinėje žaidimo kilpoje tvarkykite naudotojo įvykius ir atnaujinkite žaidėjo poziciją pagal klavišų paspaudimus. Nubrėžkite stačiakampį grotuvo objektui naudojant pygame.draw.rect().

Galiausiai atnaujinkite žaidimo langą naudodami pygame.display.flip() ir išeiti iš žaidimo, kai žaidėjas išeina iš ciklo. Šis paprastas žaidimas bus pagrindas pridėti specialiųjų efektų naudojant dalelių sistemas.

Turėtumėte pamatyti baltą kvadratą, vaizduojantį žaidėją, kurį galite perkelti į kairę ir į dešinę:

Įvairių tipų dalelių kūrimas

Dabar, kai sukūrėte savo paprastą žaidimą, galite pridėti įvairių dalelių sistemų. Sukurkite dalelių klases kiekvienam efektui ir dalelių sistemos klasę, kad galėtumėte valdyti ir atnaujinti daleles.

Dalelių efektas, kai žaidėjas juda

Pirmasis dalelių efektas bus dulkių dalelių pėdsakas, išsiskiriantis iš žaidėjo nugaros, kai žaidėjas pradeda žaisti. perkelti naudojant pelės arba klaviatūros įvestį. Be to, kai grotuvas pakeičia kryptį, pasikeis dulkių dalelių kryptis.

Apibrėžkite a Dalelė klasė, vaizduojanti atskirą dalelę. Kiekviena dalelė turi pradinę padėtį (x ir y), atsitiktinis greitis (dx ir dy), ir gyvavimo laikas, kuris lemia, kiek laiko dalelė egzistuos.

Taip pat apibrėžkite a Dalelių sistema klasė, kuri valdo dalelių rinkinį. Galite pridėti naują dalelę į sistemą naudodami pridėti_dalelė() metodas. The atnaujinti () metodas atnaujina visas sistemoje esančias daleles ir pašalina daleles, kurių gyvavimo laikas baigėsi.

# Dalelių klasė
klasėDalelė:
def__init__(savaime, x, y):
 savarankiškai.x = x
 pats.y = y
 self.dx = atsitiktinis.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 save.visą gyvenimą = 60
defatnaujinti(savarankiškai):
 self.x += self.dx
 self.y += self.dy
 save.visą gyvenimą -= 1
defpiešti(savaime, langas):
 spalva = (200, 200, 200)
 pozicija = (int (self.x), int (self.y))
 pygame.draw.circle (langas, spalva, padėtis, 2)
# Dalelių sistemos klasė
klasėDalelių sistema:
def__init__(savarankiškai):
 self.partticles = []
defpridėti_dalelė(savaime, x, y):
 savarankiškai.dalelės.pridėti (dalelė (x, y))
defatnaujinti(savarankiškai):
dėl dalelė in savaiminės dalelės:
 particle.update()
jeigu dalelė.gyvenimo trukmė <= 0:
 self.partticles.remove (dalelė)
defpiešti(savaime, langas):
dėl dalelė in savaiminės dalelės:
 dalelė.piešti (langas)

Norėdami integruoti dalelių sistemą į savo žaidimą, turite atlikti keletą pagrindinių žaidimo ciklo modifikacijų. Sukurkite naują failą pavadinimu judėjimas-dalelės.py ir pridėkite kodą su toliau pateiktais atnaujinimais:

# Sukurkite dalelių sistemą
dalelių_sistema = DaleliųSistema()
# Pagrindinė žaidimo kilpa
bėgimas = Tiesa
laikrodis = pygame.time. Laikrodis()
kol veikia:
 dt = laikrodis.tick(60) / 1000.0
dėl įvykis in pygame.event.get():
jeigu event.type == pygame. UŽDARYTI:
 bėgimas = Netiesa
 dalelė_y = žaidėjas_y + žaidėjo_aukštis // 2
 dalelė_x = žaidėjas_x + grotuvo_plotis
 klavišai = pygame.key.get_pressed()
 riba = žaidėjas_x < lango_plotis – grotuvo_plotis
jeigu raktai[pygame. K_LEFT] ir žaidėjas_x > 0:
 žaidėjas_x -= 5
 dalelių_sistema.add_partticle (dalelė_x, dalelė_y)
jeigu raktai[pygame. K_RIGHT] ir riba:
 žaidėjas_x += 5
 dalelių_sistema.add_particle (player_x, particle_y)
 particle_system.update()
 window.fill (JUODAS)
 player_pos = (žaidėjas_x, žaidėjas_y, žaidėjo_plotis, žaidėjo_aukštis)
 pygame.draw.rect (langas, BALTAS, player_pos)
 particle_system.draw (langas)
 pygame.display.flip()
# Išeikite iš žaidimo
pygame.quit()

Kai dabar perkeliate žaidėjo objektą, turėtumėte pamatyti daleles, pabrėžiančias judėjimą:

Sprogimo efektas

Kitas dalelių efektas bus sprogimo efektas, atsirandantis žaidėjui šaudant kulką. Sprogimo efektą sudarys raudonos spalvos dalelės, išsiskiriančios iš kulkos padėties.

Apibrėžkite a Dalelė klasė panaši į ankstesnę, tačiau šį kartą įtraukiama a spalva parametras, nurodantis dalelės spalvą.

Taip pat atnaujinkite Dalelių sistema klasė, skirta valdyti naują dalelių tipą. The pridėti_dalelė() metodas dabar reikalauja papildomo spalva parametrą ir sukuria nurodytos spalvos daleles.

# Dalelių klasė
klasėDalelė:
def__init__(savaime, x, y, spalva):
 savarankiškai.x = x
 pats.y = y
 self.dx = atsitiktinis.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 save.visą gyvenimą = 30
 savaime.spalva = spalva
defatnaujinti(savarankiškai):
 self.x += self.dx
 self.y += self.dy
 save.visą gyvenimą -= 1
defpiešti(savaime, langas):
 pozicija = (int (self.x), int (self.y))
 pygame.draw.circle (langas, self.color, pozicija, 3)
# Dalelių sistemos klasė
klasėDalelių sistema:
def__init__(savarankiškai):
 self.partticles = []
defpridėti_dalelė(savaime, x, y, spalva):
 self.partticles.append (dalelė (x, y, spalva)
defatnaujinti(savarankiškai):
dėl dalelė in savaiminės dalelės:
 particle.update()
jeigu dalelė.gyvenimo trukmė <= 0:
 self.partticles.remove (dalelė)
defpiešti(savaime, langas):
dėl dalelė in savaiminės dalelės:
 dalelė.piešti (langas)

Norėdami integruoti sprogimo efektą į žaidimą, turite atlikti keletą pagrindinių žaidimo ciklo modifikacijų. Sukurkite naują failo pavadinimą šaudyti-dalelė.py ir pridėkite kodą su toliau pateiktais atnaujinimais:

# Sukurkite dalelių sistemą
dalelių_sistema = DaleliųSistema()
# Pagrindinė žaidimo kilpa
bėgimas = Tiesa
laikrodis = pygame.time. Laikrodis()
kol veikia:
 dt = laikrodis.tick(60) / 1000.0
dėl įvykis in pygame.event.get():
jeigu event.type == pygame. UŽDARYTI:
 bėgimas = Netiesa
 klavišai = pygame.key.get_pressed()
 riba = žaidėjas_x < lango_plotis – grotuvo_plotis
jeigu raktai[pygame. K_LEFT] ir žaidėjas_x > 0:
 žaidėjas_x -= 5
jeigu raktai[pygame. K_RIGHT] ir riba:
 žaidėjas_x += 5
jeigu raktai[pygame. K_SPACE]:
 bullet_x = žaidėjas_x + grotuvo_plotis // 2
 bullet_y = žaidėjas_y
 dalelių_sistema.add_dalelė (bullet_x, bullet_y, RED)
 particle_system.update()
 window.fill (JUODAS)
 player_pos = (žaidėjas_x, žaidėjas_y, žaidėjo_plotis, žaidėjo_aukštis)
 pygame.draw.rect (langas, BALTAS, player_pos)
 particle_system.draw (langas)
 pygame.display.flip()
# Išeikite iš žaidimo
pygame.quit()

Štai išvestis:

Kai tarpo klavišas ( pygame. K_SPACE) yra paspaustas, į dalelių sistemą įtraukite dalelę kulkos vietoje. Tai sukuria sprogimo efektą su raudonomis dalelėmis.

Dulkių efektas

Paskutinis vizualinis patobulinimas, kurį galite įgyvendinti, yra dulkėto fono efektas. Dulkių efektą sudarys mažos pilkos dalelės, judančios apskritimu, sukurdamos dinamišką ir dulkėtą foną.

Atnaujinkite Dalelė klasė įtraukti an kampu ir greitis kiekvienai dalelei. Kampas nustato judėjimo kryptį, o greitis kontroliuoja, kaip greitai dalelės juda savo apskritimu. Modifikuoti atnaujinti () būdas atnaujinti kiekvienos dalelės padėtį pagal jos kampą ir greitį.

Taip pat atnaujinkite Dalelių sistema klasėje, kad būtų galima valdyti naują dalelių elgesį. Dabar dalelės žaidimo lange juda apskritimu.

# Dalelių klasė
klasėDalelė:
def__init__(savaime, x, y, spindulys):
 savarankiškai.x = x
 pats.y = y
 savaime.spindulys = spindulys
 self.angle = atsitiktinis.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
defatnaujinti(savarankiškai):
 savaime.kampas += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (self.kampas) * self.greitis
jeigu save.x < 0:
 self.x = lango_plotis
elifas self.x > window_width:
 save.x = 0
jeigu save.y < 0:
 self.y = lango_aukštis
elifas self.y > window_height:
 save.y = 0
defpiešti(savaime, langas):
 spalva = (128, 128, 128)
 poz = (int (self.x), int (self.y))
 spindulys = int (self.radius)
 pygame.draw.circle (langas, spalva, padėtis, spindulys)
# Dalelių sistemos klasė
klasėDalelių sistema:
def__init__(savarankiškai):
 self.partticles = []
defpridėti_dalelė(savaime, x, y, spindulys):
 self.partticles.apend (dalelė (x, y, spindulys))
defatnaujinti(savarankiškai):
dėl dalelė in savaiminės dalelės:
 particle.update()
defpiešti(savaime, langas):
dėl dalelė in savaiminės dalelės:
 dalelė.piešti (langas)

Norėdami integruoti dulkių efektą į žaidimą, turite atlikti keletą pagrindinių žaidimo ciklo modifikacijų. Sukurkite naują failą pavadinimu dulkių dalelė.py ir pridėkite kodą su toliau pateiktais atnaujinimais:

# Sukurkite dalelių sistemą dulkių efektui
dalelių_sistema = DaleliųSistema()
# Pagrindinė žaidimo kilpa
bėgimas = Tiesa
laikrodis = pygame.time. Laikrodis()
kol veikia:
 dt = laikrodis.tick(60) / 1000.0
dėl įvykis in pygame.event.get():
jeigu event.type == pygame. UŽDARYTI:
 bėgimas = Netiesa
 dalelė_x = atsitiktinis.randint(0, lango_plotis)
 dalelė_y = atsitiktinis.randint(0, lango_aukštis)
 dalelių_sistema.add_dalelė (dalelė_x, dalelė_y, 1)
 particle_system.update()
 window.fill((0, 0, 0))
 particle_system.draw (langas)
 pygame.display.flip()
# Išeikite iš žaidimo
pygame.quit()

Atsitiktinai pridėkite daleles žaidimo lange naudodami random.randint() funkcija. Kiekviena dalelė turi pradinį spindulį 1. Atnaujinkite ir nupieškite dalelių sistemą žaidimo lange, sukurdami dinamišką ir dulkėtą fono efektą.

Ekrane turėtumėte matyti daug dalelių, kurios juda atsitiktinai, bet sklandžiai:

Geriausia specialiųjų efektų praktika

Pridėdami specialiųjų efektų į savo Pygame žaidimą, atsižvelkite į šiuos geriausios praktikos pavyzdžius:

Našumo optimizavimas

Dalelių sistemose gali būti daug dalelių, o tai gali turėti įtakos žaidimo veikimui. Įdiekite tokius metodus kaip erdvinis skaidymas (pvz., Quadtree), kad optimizuotumėte dalelių atnaujinimus ir piešimą.

Dalelių perdirbimas

Užuot kūrę ir sunaikinę daleles kiekviename kadre, apsvarstykite galimybę pakartotinai panaudoti daleles iš naujo nustatydami jų savybes, kai jos pasibaigs. Tai padeda sumažinti atminties paskirstymą ir paskirstymą.

Dalelių kaupimas

Palaikykite iš anksto paskirstytų dalelių telkinį, kad išvengtumėte papildomų išlaidų kuriant naujus egzempliorius vykdymo metu. Tai gali pagerinti našumą ir sumažinti atminties susiskaidymą.

Ribinis dalelių skaičius

Kad dalelių sistemos neužgožtų žaidimo ekrano, nustatykite maksimalaus dalelių skaičiaus ribas ir pašalinkite daleles, kai jos pasiekia šią ribą. Tai užtikrina, kad efektai išliks vizualiai patrauklūs, netrukdydami žaidimui.

Vizualinis nuoseklumas

Viso žaidimo metu išlaikykite nuoseklų vaizdo stilių, įskaitant dalelių efektus. Įsitikinkite, kad dalelių spalvos, dydžiai ir judėjimo modeliai atitinka bendrą temą ir meno stilių.

Garso efektai

Pridėkite garso efektus papildyti jūsų dalelių poveikį. Pavyzdžiui, leiskite sprogimo garsus, kai įvyksta sprogimo efektas, arba aplinkos garsus, kai aktyvūs rūko ar dulkių efektai.

Padarykite žaidimus linksmesnius naudodami specialiuosius efektus

Specialiųjų efektų, pvz., dalelių sistemų, pridėjimas prie savo Pygame žaidimų gali labai pagerinti žaidėjo patirtį ir padaryti žaidimus patrauklesnius bei linksmesnius. Įdiegę dalelių efektus, pvz., pėdsakus, sprogimus, rūką ir dulkes, galite sukurti vizualiai stulbinančią ir dinamišką aplinką.

Nepamirškite apsvarstyti našumo optimizavimo, dalelių perdirbimo ir vaizdo nuoseklumo įtraukdami specialiuosius efektus į savo žaidimus. Kūrybingai ir eksperimentuodami galite perkelti savo Pygame žaidimus į kitą lygį ir sužavėti žaidėjus įtraukiančiais ir jaudinančiais potyriais.