Specefektu pievienošana Pygame spēlēm: daļiņu sistēmas un vizuālie uzlabojumi

Pygame ir populāra bibliotēka spēļu izstrādei, izmantojot Python. Veidojot spēles, speciālo efektu pievienošana var ievērojami uzlabot spēlētāju vizuālo pievilcību un vispārējo pieredzi.

Daļiņu sistēmas ir spēcīgs paņēmiens dinamisku un vizuāli interesantu efektu, piemēram, putekļu mākoņu, sprādzienu, miglas un citu, radīšanai.

Izveidojiet vienkāršu spēli

Pirms iedziļināties daļiņu sistēmās un vizuālajos uzlabojumos, vispirms izveidojiet vienkāršu spēli, izmantojot Pygame. Izveidojiet jaunu failu ar nosaukumu simple-game.py un sāciet ar nepieciešamo bibliotēku importēšanu un Pygame inicializēšanu. Iestatiet spēles logu ar noteiktu platumu un augstumu.

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

Galvenās spēles cilpas ietvaros apstrādājiet lietotāju notikumus un atjauniniet spēlētāja pozīciju, pamatojoties uz taustiņu nospiešanu.

Uzzīmējiet taisnstūri spēlētāja objektam, izmantojot pygame.draw.rect().

Visbeidzot atjauniniet spēles logu, izmantojot pygame.display.flip() un iziet no spēles, kad spēlētājs iziet no cikla. Šī vienkāršā spēle kalpos par pamatu specefektu pievienošanai, izmantojot daļiņu sistēmas.

Jums vajadzētu redzēt baltu kvadrātu, kas apzīmē spēlētāju, kuru varat pārvietot pa kreisi un pa labi:

Dažādu daļiņu veidu izveide

Tagad, kad esat iestatījis savu vienkāršo spēli, varat pievienot dažādas daļiņu sistēmas. Izveidojiet daļiņu klases katram efektam un daļiņu sistēmas klasi, lai pārvaldītu un atjauninātu daļiņas.

Daļiņu efekts, kad spēlētājs kustas

Pirmais daļiņu efekts būs putekļu daļiņu pēdas, kas izplūst no spēlētāja muguras, kad spēlētājs sāk pārvietot, izmantojot peles vai tastatūras ievadi. Turklāt, kad atskaņotājs mainīs virzienu, putekļu daļiņu virziens mainīsies.

Definējiet a Daļiņa klase, kas pārstāv atsevišķu daļiņu. Katrai daļiņai ir sākotnējā pozīcija (x un y), nejaušs ātrums (dx un dy), un kalpošanas laiks, kas nosaka, cik ilgi daļiņa pastāvēs.

Tāpat definējiet a Daļiņu sistēma klase, kas pārvalda daļiņu kolekciju. Jūs varat pievienot sistēmai jaunu daļiņu, izmantojot add_partticle() metodi. The Atjaunināt() metode atjaunina visas daļiņas sistēmā un noņem daļiņas, kas ir sasniegušas savas dzīves beigas.

# Daļiņu klase
klasēDaļiņa:
def__tajā__(sevis, x, y):
 pats.x = x
 self.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 self.lifetime = 60
defAtjaunināt(pats):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defizdarīt(pats, logs):
 krāsa = (200, 200, 200)
 pozīcija = (int (self.x), int (self.y))
 pygame.draw.circle (logs, krāsa, pozīcija, 2)
# Daļiņu sistēmas klase
klasēDaļiņu sistēma:
def__tajā__(pats):
 self.partticles = []
defpievieno_daļiņa(sevis, x, y):
 self.partticles.append (daļiņa (x, y))
defAtjaunināt(pats):
priekš daļiņa iekšā pašdaļiņas:
 particle.update()
ja daļiņa.dzīves laiks <= 0:
 self.partticles.remove (daļiņa)
defizdarīt(pats, logs):
priekš daļiņa iekšā pašdaļiņas:
 particle.draw (logs)

Lai integrētu daļiņu sistēmu savā spēlē, jums ir jāveic dažas izmaiņas galvenajā spēles ciklā. Izveidojiet jaunu failu ar nosaukumu kustība-daļiņas.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

# Izveidojiet daļiņu sistēmu
particle_system = DaļiņuSistēma()
# Galvenā spēles cilpa
skriešana = Taisnība
pulkstenis = pygame.time. Pulkstenis ()
kamēr darbojas:
 dt = pulkstenis.tick(60) / 1000.0
priekš notikumu iekšā pygame.event.get():
ja event.type == pygame. IZIET:
 skriešana = Nepatiesi
 particle_y = player_y + player_height // 2
 daļiņa_x = spēlētājs_x + atskaņotāja_platums
 taustiņi = pygame.key.get_pressed()
 robeža = player_x < window_width - player_width
ja atslēgas [pygame. K_LEFT] un player_x > 0:
 player_x -= 5
 particle_system.add_partticle (daļiņa_x, daļiņa_y)
ja atslēgas [pygame. K_RIGHT] un robeža:
 player_x += 5
 particle_system.add_partticle (player_x, particle_y)
 particle_system.update()
 window.fill (MELNS)
 player_pos = (spēlētājs_x, player_y, player_width, player_height)
 pygame.draw.rect (logs, BALTS, player_pos)
 particle_system.draw (logs)
 pygame.display.flip()
# Iziet no spēles
pygame.quit()

Kad jūs tagad pārvietojat atskaņotāja objektu, jums vajadzētu redzēt daļiņas, kas uzsver kustību:

Sprādziena efekts

Nākamais daļiņu efekts būs sprādziena efekts, kas rodas, kad spēlētājs izšauj lodi. Sprādziena efekts sastāvēs no sarkanas krāsas daļiņām, kas izplūst no lodes stāvokļa.

Definējiet a Daļiņa klase līdzīga iepriekšējai, bet šoreiz iekļauta a krāsa parametrs, kas attēlo daļiņas krāsu.

Tāpat atjauniniet Daļiņu sistēma klase, lai apstrādātu jauno daļiņu veidu. The add_partticle() metode tagad aizņem papildu krāsa parametru un izveido daļiņas ar norādīto krāsu.

# Daļiņu klase
klasēDaļiņa:
def__tajā__(pats, x, y, krāsa):
 pats.x = x
 self.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 self.lifetime = 30
 self.color = krāsa
defAtjaunināt(pats):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defizdarīt(pats, logs):
 pozīcija = (int (self.x), int (self.y))
 pygame.draw.circle (logs, self.color, position, 3)
# Daļiņu sistēmas klase
klasēDaļiņu sistēma:
def__tajā__(pats):
 self.partticles = []
defpievieno_daļiņa(pats, x, y, krāsa):
 self.partticles.append (daļiņa (x, y, krāsa)
defAtjaunināt(pats):
priekš daļiņa iekšā pašdaļiņas:
 particle.update()
ja daļiņa.dzīves laiks <= 0:
 self.partticles.remove (daļiņa)
defizdarīt(pats, logs):
priekš daļiņa iekšā pašdaļiņas:
 particle.draw (logs)

Lai savā spēlē integrētu sprādziena efektu, jums ir jāveic dažas izmaiņas galvenajā spēles ciklā. Izveidojiet jaunu faila nosaukumu šaut-daļiņa.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

# Izveidojiet daļiņu sistēmu
particle_system = DaļiņuSistēma()
# Galvenā spēles cilpa
skriešana = Taisnība
pulkstenis = pygame.time. Pulkstenis ()
kamēr darbojas:
 dt = pulkstenis.tick(60) / 1000.0
priekš notikumu iekšā pygame.event.get():
ja event.type == pygame. IZIET:
 skriešana = Nepatiesi
 taustiņi = pygame.key.get_pressed()
 robeža = player_x < window_width - player_width
ja atslēgas [pygame. K_LEFT] un player_x > 0:
 player_x -= 5
ja atslēgas [pygame. K_RIGHT] un robeža:
 player_x += 5
ja atslēgas [pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 bullet_y = spēlētājs_y
 particle_system.add_partticle (bullet_x, bullet_y, RED)
 particle_system.update()
 window.fill (MELNS)
 player_pos = (spēlētājs_x, player_y, player_width, player_height)
 pygame.draw.rect (logs, BALTS, player_pos)
 particle_system.draw (logs)
 pygame.display.flip()
# Iziet no spēles
pygame.quit()

Šeit ir izvade:

Kad atstarpes taustiņš ( pygame. K_SPACE) tiek nospiests, pievienojiet daļiņu daļiņu sistēmai lodes vietā. Tas rada sprādziena efektu ar sarkanām daļiņām.

Putekļu efekts

Pēdējais vizuālais uzlabojums, ko varat ieviest, ir putekļains fona efekts. Putekļu efekts sastāvēs no mazām pelēkām daļiņām, kas kustēsies apļveida rakstā, radot dinamisku un putekļainu fonu.

Atjauniniet Daļiņa klasē iekļaut an leņķis un ātrumu katrai daļiņai. Leņķis nosaka kustības virzienu, un ātrums kontrolē to, cik ātri daļiņas pārvietojas to apļveida veidā. Modificēt Atjaunināt() metode, lai atjauninātu katras daļiņas pozīciju, pamatojoties uz tās leņķi un ātrumu.

Tāpat atjauniniet Daļiņu sistēma klase, lai apstrādātu jauno daļiņu uzvedību. Tagad daļiņas spēles logā pārvietojas apļveida veidā.

# Daļiņu klase
klasēDaļiņa:
def__tajā__(self, x, y, rādiuss):
 pats.x = x
 self.y = y
 self.radius = rādiuss
 self.angle = random.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
defAtjaunināt(pats):
 paš.leņķis += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (self.angle) * self.speed
ja pats.x < 0:
 self.x = loga_platums
elifs self.x > window_width:
 pats.x = 0
ja sevi.y < 0:
 self.y = loga_augstums
elifs self.y > window_height:
 self.y = 0
defizdarīt(pats, logs):
 krāsa = (128, 128, 128)
 pozīcija = (int (self.x), int (self.y))
 rādiuss = int (self.radius)
 pygame.draw.circle (logs, krāsa, pozīcija, rādiuss)
# Daļiņu sistēmas klase
klasēDaļiņu sistēma:
def__tajā__(pats):
 self.partticles = []
defpievieno_daļiņa(self, x, y, rādiuss):
 self.partticles.append (daļiņa (x, y, rādiuss))
defAtjaunināt(pats):
priekš daļiņa iekšā pašdaļiņas:
 particle.update()
defizdarīt(pats, logs):
priekš daļiņa iekšā pašdaļiņas:
 particle.draw (logs)

Lai savā spēlē integrētu putekļu efektu, jums ir jāveic dažas izmaiņas galvenajā spēles ciklā. Izveidojiet jaunu failu ar nosaukumu putekļu daļiņa.py un pievienojiet kodu ar tālāk norādītajiem atjauninājumiem:

# Izveidojiet daļiņu sistēmu putekļu efektam
particle_system = DaļiņuSistēma()
# Galvenā spēles cilpa
skriešana = Taisnība
pulkstenis = pygame.time. Pulkstenis ()
kamēr darbojas:
 dt = pulkstenis.tick(60) / 1000.0
priekš notikumu iekšā pygame.event.get():
ja event.type == pygame. IZIET:
 skriešana = Nepatiesi
 particle_x = random.randint(0, loga_platums)
 particle_y = random.randint(0, loga_augstums)
 particle_system.add_partticle (daļiņa_x, daļiņa_y, 1)
 particle_system.update()
 window.fill((0, 0, 0))
 particle_system.draw (logs)
 pygame.display.flip()
# Iziet no spēles
pygame.quit()

Pievienojiet daļiņas nejauši spēles logā, izmantojot random.randint() funkciju. Katrai daļiņai ir sākotnējais rādiuss 1. Atjauniniet un uzzīmējiet daļiņu sistēmu spēles logā, radot dinamisku un putekļainu fona efektu.

Ekrānā vajadzētu redzēt daudzas daļiņas, kas pārvietojas nejauši, bet vienmērīgi:

Specefektu paraugprakse

Pievienojot savai Pygame spēlei īpašus efektus, ņemiet vērā tālāk norādīto paraugpraksi.

Veiktspējas optimizācija

Daļiņu sistēmās var būt liels skaits daļiņu, kas var ietekmēt spēles veiktspēju. Ieviesiet tādas metodes kā telpiskā sadalīšana (piemēram, Quadtree), lai optimizētu daļiņu atjauninājumus un zīmēšanu.

Daļiņu pārstrāde

Tā vietā, lai radītu un iznīcinātu daļiņas katrā kadrā, apsveriet iespēju atkārtoti izmantot daļiņas, atiestatot to īpašības, kad tās sasniedz mūža beigas. Tas palīdz samazināt atmiņas piešķiršanu un atdalīšanu.

Daļiņu apvienošana

Saglabājiet iepriekš piešķirto daļiņu kopu, lai izvairītos no papildu izdevumiem, radot jaunus gadījumus izpildlaikā. Tas var uzlabot veiktspēju un samazināt atmiņas sadrumstalotību.

Daļiņu skaita ierobežojums

Lai daļiņu sistēmas nepārslogotu spēles ekrānu, iestatiet ierobežojumus maksimālajam daļiņu skaitam un noņemiet daļiņas, kad tās sasniedz šo robežu. Tas nodrošina, ka efekti paliek vizuāli pievilcīgi, netraucējot spēlei.

Vizuālā konsekvence

Saglabājiet konsekventu vizuālo stilu spēles laikā, tostarp daļiņu efektus. Pārliecinieties, ka daļiņu krāsas, izmēri un kustības modeļi ir saskaņoti ar vispārējo tēmu un mākslas stilu.

Skaņas efekti

Pievienojiet skaņas efektus lai papildinātu jūsu daļiņu efektus. Piemēram, atskaņojiet sprādziena skaņas, kad notiek sprādziena efekts, vai apkārtējās skaņas, kad ir aktīvi miglas vai putekļu efekti.

Padariet spēles jautrākas, izmantojot specefektus

Specefektu, piemēram, daļiņu sistēmu, pievienošana Pygame spēlēm var ievērojami uzlabot spēlētāja pieredzi un padarīt spēles saistošākas un jautrākas spēlētājiem. Ieviešot daļiņu efektus, piemēram, takas, sprādzienus, miglu un putekļus, varat izveidot vizuāli satriecošu un dinamisku vidi.

Neaizmirstiet apsvērt veiktspējas optimizāciju, daļiņu pārstrādi un vizuālo konsekvenci, vienlaikus spēlēs iekļaujot īpašus efektus. Izmantojot radošumu un eksperimentēšanu, jūs varat pacelt savas Pygame spēles uz nākamo līmeni un aizraut spēlētājus ar aizraujošu un aizraujošu pieredzi.