Animera spelobjekt med arkadbibliotek

Animation spelar en viktig roll för att förbättra den visuella dragningskraften och engagemanget hos videospel. Arcade-biblioteket är ett Python-ramverk för att skapa 2D-spel. Det erbjuder ett enkelt och effektivt sätt att införliva animationer i dina spelprojekt.

Du kan använda Arcade-biblioteket för att skapa grundläggande rörelseanimationer och synkroniserade animationer med spelhändelser.

Skapa ett enkelt spel

Innan du börjar, se till att du har pip installerad på din enhet. Använd detta kommando för att installera arkadbiblioteket:

pip installera arkad

Efter det skapar du en Python-fil med namnet simple-game.py och börja med att skapa ett spel där spelaren kan röra sig åt vänster och höger.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Med hjälp av Arcade-biblioteket kan du skapa ett fönster, ställa in spelmiljön och hantera spelarinmatning. Här är ett kodavsnitt för att komma igång:

importera arkad
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
klassMitt spel(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
defon_draw(själv):
 arcade.start_render()
 col = arkad.färg. BLÅ
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, kol)
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= 10
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += 10
defhuvud():
 spel = MyGame()
 arcade.run()
om __namn__ == "__huvud__":
 main()

Lägg till grundläggande rörelseanimering

Ta nu ditt spel ett steg längre och lägg till grundläggande rörelseanimering till spelarobjektet. För att animera spelare på rörelse, skapa 3 olika cirklar och iterera mellan dem i tur och ordning när spelaren börjar röra sig. Här är det uppdaterade kodavsnittet för rörelse-animation.py fil:

klassMitt spel(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(själv):
 arcade.start_render()
 col1 = arkad.färg. BLÅ
 col2 = arcade.color. GRÖN
 col3 = arkad.färg. RÖD
om 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)
annan:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Här är ett exempel på utdataram:

Styra animeringshastighet och riktning

För att styra animeringshastigheten kan du introducera ett bildhastighetssystem. Du kan också ändra ordningen på ramarna beroende på spelarens rörelseriktning. När spelaren rör sig från vänster till höger visas ramarna i omvänd ordning.

Här är det modifierade kodavsnittet för frame-rate.py fil:

klassMitt spel(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arkad.färg. BLÅ
 col2 = arcade.color. GRÖN
 col3 = arkad.färg. RÖD
 self.frames = [col1, col2, col3]
 self.frame_rate = 10
defon_draw(själv):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
om self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 - frame_index
 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, index)
defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= 10
 self.frame_counter += 1
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += 10
 self.frame_counter += 1

Använd moduloperatorn % med len (self.frames) för att säkerställa att frame_index förblir alltid inom intervallet för tillgängliga ramar. Detta förhindrar IndexError från att inträffa när animeringen går genom bildrutorna.

Justera frame_rate värde för att kontrollera animeringshastigheten och njuta av den animerade rörelsen av dina spelobjekt.

Inklusive ytterligare funktioner

Arcade-biblioteket erbjuder olika funktioner för att förbättra dina animationer.

Partikeleffekter

Du kan skapa partikeleffekter, som explosioner eller rök, för att ge ditt spel realism. Skapa en fil med namnet partikel.py och lägg till koden nedan för en enkel implementering av partikelsystem med Python och arkadbiblioteket:

importera arkad
importera slumpmässig
# Skärmens mått
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Färger
VIT = (255, 255, 255)
# Partikelklass
klassPartikel:
def__i det__(själv, x, y, dx, dy, radie, färg, livslängd):
 själv.x = x
 själv.y = y
 self.dx = dx
 self.dy = dy
 self.radius = radie
 self.color = färg
 self.lifespan = livslängd
defuppdatering(själv):
 self.x += self.dx
 self.y += self.dy
 self.lifespan -= 1
defdra(själv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Spelklass
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd, "Partikelexempel")
 self.particles = []
defuppstart(själv):
# Skapa partiklar
för _ i räckvidd(100):
 x = random.randrange (SCREEN_WIDTH)
 y = random.randrange (SCREEN_HEIGHT)
 dx = random.uniform(-1, 1)
 dy = random.uniform(-1, 1)
 radie = random.uniform(2, 5)
 färg = arkad.färg. VIT
 livslängd = random.randint(60, 120)
 partikel = Partikel (x, y, dx, dy, radie, färg, livslängd)
 self.particles.append (partikel)
defon_draw(själv):
 arcade.start_render()
för partikel i self.particles:
 particle.draw()
defuppdatering(själv, delta_tid):
för partikel i self.particles:
 particle.update()
om partikel.livslängd <= 0:
 self.particles.remove (partikel)
defhuvud():
 spel = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()
om __namn__ == "__huvud__":
 main()

Du bör se en animation som involverar många rörliga partiklar:

Interaktiva animationer

Implementera interaktiva animationer som svarar på användarinput eller spelhändelser. Till exempel, när spelaren interagerar med ett objekt kan det animera, ändra färg eller transformera på något sätt. Dessa interaktiva animationer ger feedback och förbättrar spelarens engagemang i spelet. Här är koden för interaktiv-animation.py fil:

importera arkad
# Skärmens mått
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Färger
VIT = (255, 255, 255)
RÖD = (255, 0, 0)
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
 super().__init__(bredd, höjd, "Interaktiv animering")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = RÖD
 self.animation_radius = 60
 self.animation_color = VIT
 self.animation_active = Falsk
defon_draw(själv):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)
om self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)
defon_mouse_press(själv, x, y, knapp, modifierare):
om (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius och
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = Sann
defuppdatering(själv, delta_tid):
om self.animation_active:
 self.animation_radius += 1
om self.animation_radius > 100:
 self.animation_active = Falsk
 self.animation_radius = 0
defhuvud():
 spel = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
om __namn__ == "__huvud__":
 main()

Åsidosätt nödvändiga metoder, som t.ex on_draw, on_mouse_press, och uppdatering, för att hantera att rita spelaren och animeringen, hantera musklick och uppdatera animationen.

För att rita spelaren, använd arcade.draw_circle_filled funktion, som tar (x, y) koordinater för mitten, radien och färgen som argument. Funktionen draw_circle_filled är en av Arcades verktyg som du kan använda för att rita speltillgångar. I det här fallet kan du rita en växande cirkel genom att variera radien över tiden.

De on_mouse_press metoden körs när användaren klickar med musen. Den kontrollerar om muskoordinaterna är inom gränserna för spelarobjektet och aktiverar animeringen om de är det.

Bästa metoder för att lägga till animering

När du lägger till animationer i dina spel bör du tänka på följande bästa praxis:

Begränsa antalet animationer

Att ha många animationer med många bildrutor kan påverka prestandan. Överväg att minimera antalet animationer eller bildrutor som krävs, särskilt för icke-kritiska element i spelet. Att förenkla animationer kan hjälpa till att upprätthålla en konsekvent bildhastighet och optimera resursanvändningen.

Batchrendera liknande objekt

Gruppera liknande objekt som delar samma animationsramar och texturer tillsammans och rendera dem som en batch. Batchning minskar antalet draganrop, vilket resulterar i förbättrad prestanda. Den här tekniken är särskilt användbar när du animerar objekt som använder samma sprite-ark eller har liknande animeringssekvenser.

Använd interpolation för smidig animering

Använd interpolationstekniker, såsom linjär interpolation (lerping), för att uppnå mjuka animeringsövergångar. Interpolation beräknar mellanvärden mellan animerade nyckelrutor för att skapa flytande rörelser. Detta tillvägagångssätt förhindrar plötsliga hopp eller ryckiga rörelser mellan bildrutor, vilket resulterar i mer visuellt tilltalande animationer.

Tänk på animeringshastighet och timing

Experimentera med olika animeringshastigheter och timing för att hitta rätt balans för ditt spel. Justera bildrutelängden eller använd olika animeringssekvenser för att skapa variationer i hastighet, acceleration eller retardation. Dessa justeringar kan lägga till djup och karaktär till ditt spels animationer.

Testa och optimera

Testa regelbundet dina animationer på olika enheter och övervaka prestandan. Leta efter potentiella flaskhalsar eller avmattningar och optimera därefter. Denna process hjälper till att säkerställa smidiga och konsekventa animationsupplevelser över ett brett utbud av enheter.

Gör spel mer engagerande med animering

Att lägga till animationer i dina spel kan avsevärt förbättra spelarnas engagemang och fördjupning. Animationer ger visuell feedback till spelarnas handlingar, vilket gör spelet mer intuitivt och njutbart. De väcker spelvärldar till liv, skapar en känsla av realism och spänning.

Oavsett om det är en karaktär som springer, ett objekt som exploderar eller en enkel övergångseffekt, bidrar animationer till en mer dynamisk och fängslande spelupplevelse.