Pythons Arcade-bibliotek har dig dækket, fra de enkleste farvebaserede animationer til kompleks partikelmodellering.

Animation spiller en afgørende rolle i at forbedre videospils visuelle appel og engagement. Arcade-biblioteket er en Python-ramme til at skabe 2D-spil. Det tilbyder en ligetil og effektiv måde at inkorporere animationer i dine spilprojekter.

Du kan bruge Arcade-biblioteket til at skabe grundlæggende bevægelsesanimationer og synkroniserede animationer med spilbegivenheder.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på din enhed. Brug denne kommando til at installere arkadebiblioteket:

pip installere arkade

Derefter skal du oprette en Python-fil med navnet simple-game.py og start med at sætte et spil op, hvor spilleren kan bevæge sig til venstre og højre.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Ved at bruge Arcade-biblioteket kan du oprette et vindue, opsætte spilmiljøet og håndtere spillerinput. Her er et kodestykke for at komme i gang:

instagram viewer 
importere arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


klasseMit Spil(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mit spil")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2


defon_draw(selv):
 arcade.start_render()
 col = arkade.farve. BLÅ
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)


defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 10
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 10


defvigtigste():
 spil = Mit Spil()
 arcade.run()
hvis __navn__ == "__main__":
 hoved()

Tilføj grundlæggende bevægelsesanimation

Tag nu dit spil et skridt videre og tilføj grundlæggende bevægelsesanimation til spillerobjektet. At animere spiller på bevægelse, opret 3 forskellige cirkler og gentag mellem dem i rækkefølge, når spilleren begynder at bevæge sig. Her er det opdaterede kodestykke til bevægelse-animation.py fil:

klasseMit Spil(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mit spil")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(selv):
 arcade.start_render()
 col1 = arkade.farve. BLÅ
 col2 = arkade.farve. GRØN
 col3 = arkade.farve. 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)
andet:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Her er et eksempel på en outputramme:

Styring af animationshastighed og retning

For at styre animationshastigheden kan du introducere et billedhastighedssystem. Du kan også ændre rækkefølgen af ​​rammerne afhængigt af afspillerens bevægelsesretning. Når afspilleren bevæger sig fra venstre mod højre, vises rammerne i omvendt rækkefølge.

Her er det ændrede kodestykke til frame-rate.py fil:

klasseMit Spil(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mit spil")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arkade.farve. BLÅ
 col2 = arkade.farve. GRØN
 col3 = arkade.farve. 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 - ramme_indeks


 indeks = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, indeks)
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 10
 self.frame_counter += 1
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 10
 self.frame_counter += 1

Brug modulusoperatoren % med len (self.frames) at sikre, at ramme_indeks forbliver altid inden for rækkevidden af ​​tilgængelige rammer. Dette forhindrer Indeksfejl opstår, når animationen går gennem rammerne.

Juster frame_rate værdi for at kontrollere animationshastigheden og nyde den animerede bevægelse af dine spilobjekter.

Inklusiv yderligere funktioner

Arcade-biblioteket tilbyder forskellige funktioner til at forbedre dine animationer.

Partikeleffekter

Du kan skabe partikeleffekter, såsom eksplosioner eller røg, for at tilføje realisme til dit spil. Opret en fil med navnet partikel.py og tilføj nedenstående kode for en simpel partikelsystemimplementering ved hjælp af Python og arkadebiblioteket:

importere arkade
importere tilfældig
# Skærmdimensioner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Farver
HVID = (255, 255, 255)


# Partikelklasse
klassePartikel:
def__i det__(selv, x, y, dx, dy, radius, farve, levetid):
 selv.x = x
 self.y = y
 self.dx = dx
 self.dy = dy
 self.radius = radius
 selv.farve = farve
 self.lifespan = levetid


defopdatering(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)


# Spilklasse
klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde, "Partikeleksempel")
 selv.partikler = []


defOpsætning(selv):
# Skab partikler
til _ i rækkevidde(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)
 farve = arkade.farve. HVID
 levetid = random.randint(60, 120)
 partikel = Partikel (x, y, dx, dy, radius, farve, levetid)
 self.particles.append (partikel)


defon_draw(selv):
 arcade.start_render()
til partikel i selv.partikler:
 particle.draw()


defopdatering(selv, delta_tid):
til partikel i selv.partikler:
 particle.update()


hvis partikel.levetid <= 0:
 selv.partikler.fjerne (partikel)


defvigtigste():
 spil = Mit spil (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()
hvis __navn__ == "__main__":
 hoved()

Du bør se en animation, der involverer mange bevægelige partikler:

Interaktive animationer

Implementer interaktive animationer, der reagerer på brugerinput eller spilbegivenheder. For eksempel, når spilleren interagerer med et objekt, kan det animere, ændre farve eller transformere på en eller anden måde. Disse interaktive animationer giver feedback og øger spillerens engagement i spillet. Her er koden til interaktiv-animation.py fil:

importere arkade
# Skærmdimensioner
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Farver
HVID = (255, 255, 255)
RØD = (255, 0, 0)


klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde, "Interaktiv animation")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = RØD
 self.animation_radius = 60
 self.animation_color = HVID
 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, knap, 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 = Rigtigt


defopdatering(selv, delta_tid):
hvis self.animation_active:
 self.animation_radius += 1


hvis self.animation_radius > 100:
 self.animation_active = Falsk
 self.animation_radius = 0


defvigtigste():
 spil = Mit spil (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
hvis __navn__ == "__main__":
 hoved()

Tilsidesæt de nødvendige metoder, som f.eks on_draw, on_mouse_press, og opdatering, til at håndtere tegning af afspilleren og animationen, håndtering af museklik og opdatering af animationen.

For at tegne afspilleren skal du bruge arcade.draw_circle_filled funktion, som tager (x, y) koordinater for centrum, radius og farven som argumenter. Funktionen draw_circle_filled er en af Arcades værktøjer, som du kan bruge til at tegne spilaktiver. I dette tilfælde kan du tegne en voksende cirkel ved at variere radius over tid.

Det on_mouse_press metoden kører, når brugeren klikker med musen. Den kontrollerer, om musens koordinater er inden for grænserne af spillerobjektet, og aktiverer animationen, hvis de er.

Bedste praksis for tilføjelse af animation

Når du tilføjer animation til dine spil, skal du overveje følgende bedste praksis:

Begræns antallet af animationer

At have mange animationer med mange frames kan påvirke ydeevnen. Overvej at minimere antallet af krævede animationer eller frames, især for ikke-kritiske elementer i spillet. Forenkling af animationer kan hjælpe med at opretholde en ensartet billedhastighed og optimere ressourceforbruget.

Batchrender lignende objekter

Gruppér lignende objekter, der deler de samme animationsrammer og teksturer, og gengiv dem som en batch. Batching reducerer antallet af draw calls, hvilket resulterer i forbedret ydeevne. Denne teknik er især nyttig, når du animerer objekter, der bruger det samme sprite-ark eller har lignende animationssekvenser.

Brug interpolation til glat animation

Anvend interpolationsteknikker, såsom lineær interpolation (lerping), for at opnå jævne animationsovergange. Interpolation beregner mellemværdier mellem animations keyframes for at skabe flydende bevægelser. Denne tilgang forhindrer pludselige hop eller rykkende bevægelser mellem billederne, hvilket resulterer i mere visuelt tiltalende animationer.

Overvej animationshastighed og timing

Eksperimenter med forskellige animationshastigheder og timing for at finde den rigtige balance til dit spil. Juster billedvarigheden, eller brug forskellige animationssekvenser til at skabe variationer i hastighed, acceleration eller deceleration. Disse justeringer kan tilføje dybde og karakter til dit spils animationer.

Test og optimer

Test jævnligt dine animationer på forskellige enheder og overvåg ydeevnen. Se efter potentielle flaskehalse eller opbremsninger og optimer i overensstemmelse hermed. Denne proces hjælper med at sikre jævne og ensartede animationsoplevelser på tværs af en bred vifte af enheder.

Gør spil mere engagerende med animation

Tilføjelse af animationer til dine spil kan forbedre spillerens engagement og fordybelse markant. Animationer giver visuel feedback til spillerens handlinger, hvilket gør gameplayet mere intuitivt og underholdende. De bringer spilverdener til live og skaber en følelse af realisme og spænding.

Uanset om det er en karakter, der løber, et objekt, der eksploderer, eller en simpel overgangseffekt, bidrager animationer til en mere dynamisk og fængslende spiloplevelse.