Animer spillobjekter med arkadebibliotek

Animasjon spiller en viktig rolle for å forbedre den visuelle appellen og engasjementet til videospill. Arcade-biblioteket er et Python-rammeverk for å lage 2D-spill. Det tilbyr en enkel og effektiv måte å inkorporere animasjoner i spillprosjektene dine.

Du kan bruke Arcade-biblioteket til å lage grunnleggende bevegelsesanimasjoner og synkroniserte animasjoner med spillhendelser.

Lag et enkelt spill

Før du starter, sørg for at du har pip installert på enheten din. Bruk denne kommandoen for å installere arkadebiblioteket:

pip installer arkade

Etter det, lag en Python-fil med navnet simple-game.py og begynn med å sette opp et spill hvor spilleren kan bevege seg til venstre og høyre.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Ved å bruke Arcade-biblioteket kan du opprette et vindu, sette opp spillmiljøet og håndtere spillerinndata. Her er en kodebit for å komme i gang:

import arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
klasseMitt Spill(arkade. Vindu):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spill")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
defon_draw(selv):
 arcade.start_render()
 col = arkade.farge. BLÅ
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= 10
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += 10
defhoved-():
 spill = MyGame()
 arcade.run()
hvis __navn__ == "__hoved__":
 hoved()

Legg til grunnleggende bevegelsesanimasjon

Ta spillet ditt et skritt videre og legg til grunnleggende bevegelsesanimasjon til spillerobjektet. For å animere spiller på bevegelse, lag 3 forskjellige sirkler og iterer mellom dem sekvensielt når spilleren begynner å bevege seg. Her er den oppdaterte kodebiten for bevegelse-animasjon.py fil:

klasseMitt Spill(arkade. Vindu):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spill")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(selv):
 arcade.start_render()
 col1 = arkade.farge. BLÅ
 col2 = arkade.farge. GRØNN
 col3 = arkade.farge. RØD
hvis self.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1)
elif self.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2)
ellers:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Her er et eksempel på utdataramme:

Kontrollere animasjonshastighet og -retning

For å kontrollere animasjonshastigheten kan du introdusere et bildefrekvenssystem. Du kan også endre rekkefølgen på rammene avhengig av spillerens bevegelsesretning. Når spilleren beveger seg fra venstre til høyre, vil rammene vises i omvendt rekkefølge.

Her er den modifiserte kodebiten for frame-rate.py fil:

klasseMitt Spill(arkade. Vindu):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spill")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arkade.farge. BLÅ
 col2 = arkade.farge. GRØNN
 col3 = arkade.farge. RØD
 self.frames = [col1, col2, col3]
 self.frame_rate = 10
defon_draw(selv):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
hvis self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 - frame_index
 indeks = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, indeks)
defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= 10
 self.frame_counter += 1
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += 10
 self.frame_counter += 1

Bruk modulusoperatoren % med len (self.frames) for å sikre at frame_index forblir alltid innenfor rekkevidden av tilgjengelige rammer. Dette forhindrer Indeksfeil fra å oppstå når animasjonen går gjennom rammene.

Juster frame_rate verdi for å kontrollere animasjonshastigheten, og nyte den animerte bevegelsen til spillobjektene dine.

Inkludert tilleggsfunksjoner

Arcade-biblioteket tilbyr ulike funksjoner for å forbedre animasjonene dine.

Partikkeleffekter

Du kan lage partikkeleffekter, for eksempel eksplosjoner eller røyk, for å legge til realisme i spillet ditt. Lag en fil med navnet partikkel.py og legg til koden nedenfor for en enkel partikkelsystemimplementering ved bruk av Python og arkadebiblioteket:

import arkade
import tilfeldig
# Skjermdimensjoner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Farger
HVIT = (255, 255, 255)
# Partikkelklasse
klassePartikkel:
def__i det__(selv, x, y, dx, dy, radius, farge, levetid):
 selv.x = x
 self.y = y
 self.dx = dx
 self.dy = dy
 self.radius = radius
 self.color = farge
 self.lifespan = levetid
defOppdater(selv):
 self.x += self.dx
 self.y += self.dy
 self.lifespan -= 1
deftegne(selv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Spillklasse
klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde, "Partikkeleksempel")
 self.particles = []
defoppsett(selv):
# Lag partikler
til _ i område(100):
 x = random.randrange (SCREEN_WIDTH)
 y = random.randrange (SCREEN_HEIGHT)
 dx = random.uniform(-1, 1)
 dy = random.uniform(-1, 1)
 radius = random.uniform(2, 5)
 farge = arkade.farge. HVIT
 levetid = random.randint(60, 120)
 partikkel = partikkel (x, y, dx, dy, radius, farge, levetid)
 self.particles.append (partikkel)
defon_draw(selv):
 arcade.start_render()
til partikkel i self.particles:
 particle.draw()
defOppdater(selv, delta_tid):
til partikkel i self.particles:
 particle.update()
hvis partikkel.levetid <= 0:
 selv.partikler.fjerne (partikkel)
defhoved-():
 spill = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()
hvis __navn__ == "__hoved__":
 hoved()

Du bør se en animasjon som involverer mange bevegelige partikler:

Interaktive animasjoner

Implementer interaktive animasjoner som reagerer på brukerinnspill eller spillhendelser. For eksempel, når spilleren samhandler med et objekt, kan det animere, endre farge eller transformere på en eller annen måte. Disse interaktive animasjonene gir tilbakemelding og forbedrer spillerens engasjement i spillet. Her er koden for interaktiv-animasjon.py fil:

import arkade
# Skjermdimensjoner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Farger
HVIT = (255, 255, 255)
RØD = (255, 0, 0)
klasseMitt Spill(arkade. Vindu):
def__i det__(selv, bredde, høyde):
 super().__init__(bredde, høyde, "Interaktiv animasjon")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = RØD
 self.animation_radius = 60
 self.animation_color = HVIT
 self.animation_active = Falsk
defon_draw(selv):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)
hvis self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)
defon_mouse_press(selv, x, y, knapp, modifikatorer):
hvis (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius og
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = ekte
defOppdater(selv, delta_tid):
hvis self.animation_active:
 self.animation_radius += 1
hvis self.animation_radius > 100:
 self.animation_active = Falsk
 self.animation_radius = 0
defhoved-():
 spill = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
hvis __navn__ == "__hoved__":
 hoved()

Overstyr de nødvendige metodene, som f.eks on_draw, on_mouse_press, og Oppdater, for å håndtere tegning av spilleren og animasjonen, håndtering av museklikk og oppdatering av animasjonen.

For å tegne spilleren, bruk arcade.draw_circle_filled funksjon, som tar (x, y) koordinater til sentrum, radius og fargen som argumenter. Funksjonen draw_circle_filled er en av Arcades verktøy som du kan bruke til å tegne spillressurser. I dette tilfellet kan du tegne en voksende sirkel ved å variere radiusen over tid.

De on_mouse_press metoden kjører når brukeren klikker med musen. Den sjekker om musekoordinatene er innenfor grensene til spillerobjektet og aktiverer animasjonen hvis de er det.

Beste fremgangsmåter for å legge til animasjon

Når du legger til animasjon i spillene dine, bør du vurdere følgende beste fremgangsmåter:

Begrens antall animasjoner

Å ha mange animasjoner med mange rammer kan påvirke ytelsen. Vurder å minimere antallet animasjoner eller rammer som kreves, spesielt for ikke-kritiske elementer i spillet. Å forenkle animasjoner kan bidra til å opprettholde en konsistent bildefrekvens og optimalisere ressursbruken.

Batch gjengi lignende objekter

Grupper lignende objekter som deler de samme animasjonsrammer og teksturer sammen og gjengi dem som en batch. Batching reduserer antallet trekningsanrop, noe som resulterer i forbedret ytelse. Denne teknikken er spesielt nyttig når du animerer objekter som bruker det samme sprite-arket eller har lignende animasjonssekvenser.

Bruk interpolasjon for jevn animasjon

Bruk interpolasjonsteknikker, for eksempel lineær interpolasjon (lerping), for å oppnå jevne animasjonsoverganger. Interpolering beregner mellomverdier mellom animasjonsnøkkelbilder for å skape flytende bevegelser. Denne tilnærmingen forhindrer plutselige hopp eller rykkende bevegelser mellom bilder, noe som resulterer i mer visuelt tiltalende animasjoner.

Vurder animasjonshastighet og timing

Eksperimenter med forskjellige animasjonshastigheter og timing for å finne den rette balansen for spillet ditt. Juster bildevarigheten eller bruk forskjellige animasjonssekvenser for å lage variasjoner i hastighet, akselerasjon eller retardasjon. Disse justeringene kan legge til dybde og karakter til spillets animasjoner.

Test og optimaliser

Test animasjonene dine regelmessig på forskjellige enheter og overvåk ytelsen. Se etter potensielle flaskehalser eller nedganger og optimaliser deretter. Denne prosessen bidrar til å sikre jevne og konsistente animasjonsopplevelser på tvers av et bredt spekter av enheter.

Gjør spill mer engasjerende med animasjon

Å legge til animasjoner i spillene dine kan forbedre spillerengasjementet og innlevelsen betydelig. Animasjoner gir visuell tilbakemelding til spillerhandlinger, noe som gjør spillingen mer intuitiv og morsom. De vekker spillverdener til live, skaper en følelse av realisme og spenning.

Enten det er en karakter som løper, et objekt som eksploderer eller en enkel overgangseffekt, bidrar animasjoner til en mer dynamisk og fengslende spillopplevelse.