Animeer spelobjecten met arcadebibliotheek

Animatie speelt een cruciale rol bij het verbeteren van de visuele aantrekkingskracht en betrokkenheid van videogames. De Arcade-bibliotheek is een Python-framework voor het maken van 2D-games. Het biedt een eenvoudige en effectieve manier om animaties op te nemen in uw gameprojecten.

U kunt de Arcade-bibliotheek gebruiken om basisbewegingsanimaties en gesynchroniseerde animaties met spelgebeurtenissen te maken.

Maak een eenvoudig spel

Controleer voordat u begint of u dat hebt gedaan pip op uw apparaat geïnstalleerd. Gebruik deze opdracht om de arcadebibliotheek te installeren:

pip installeer arcade

Maak daarna een Python-bestand met de naam simpel-spel.py en begin met het opzetten van een spel waarbij de speler naar links en rechts kan bewegen.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Met behulp van de Arcade-bibliotheek kunt u een venster maken, de spelomgeving instellen en de invoer van spelers verwerken. Hier is een codefragment om aan de slag te gaan:

importeren arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
klasMijn spel(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mijn spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
defon_draw(zelf):
 arcade.start_render()
 col = arcade.kleur. BLAUW
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10
defvoornaamst():
 spel = MijnSpel()
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Voeg basisbewegingsanimatie toe

Ga nu een stap verder in je spel en voeg basisbewegingsanimatie toe aan het spelerobject. Om de speler in beweging, maak 3 verschillende cirkels en herhaal ze opeenvolgend wanneer de speler begint te bewegen. Hier is het bijgewerkte codefragment voor de bewegingsanimatie.py bestand:

klasMijn spel(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mijn spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 zelf.frame_counter = 0
defon_draw(zelf):
 arcade.start_render()
 col1 = arcade.kleur. BLAUW
 col2 = arcade.kleur. GROENTE
 col3 = arcade.kleur. ROOD
als zelf.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col1 )
elif zelf.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2 )
anders:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
 self.frame_counter = (zelf.frame_counter + 1) % 30
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10
 self.frame_counter = (zelf.frame_counter + 1) % 30

Hier is een voorbeeld van een uitvoerframe:

Snelheid en richting van animatie regelen

Om de animatiesnelheid te regelen, kunt u een framesnelheidssysteem introduceren. U kunt ook de volgorde van de frames wijzigen, afhankelijk van de bewegingsrichting van de speler. Wanneer de speler van links naar rechts beweegt, worden de frames in omgekeerde volgorde weergegeven.

Hier is het gewijzigde codefragment voor de framesnelheid.py bestand:

klasMijn spel(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mijn spel")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 zelf.frame_counter = 0
 col1 = arcade.kleur. BLAUW
 col2 = arcade.kleur. GROENTE
 col3 = arcade.kleur. ROOD
 zelf.frames = [col1, col2, col3]
 zelf.frame_rate = 10
defon_draw(zelf):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
als self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (zelf.frames) - 1 - frame_index
 index = zelf.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, inhoudsopgave)
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
 zelf.frame_counter += 1
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10
 zelf.frame_counter += 1

Gebruik de modulus-operator % met len (zelf.frames) om ervoor te zorgen dat de frame_index blijft altijd binnen het bereik van beschikbare frames. Dit voorkomt de IndexFout voorkomen wanneer de animatie door de frames loopt.

Pas de... aan frame rate waarde om de animatiesnelheid te regelen en te genieten van de geanimeerde beweging van uw spelobjecten.

Inclusief extra functies

De Arcade-bibliotheek biedt verschillende functies om uw animaties te verbeteren.

Deeltjeseffecten

U kunt partikeleffecten creëren, zoals explosies of rook, om uw spel realistischer te maken. Maak een bestand met de naam deeltje.py en voeg de onderstaande code toe voor een eenvoudige partikelsysteemimplementatie met behulp van Python en de arcadebibliotheek:

importeren arcade
importeren willekeurig
# Schermafmetingen
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
# Kleuren
WIT = (255, 255, 255)
# Deeltjesklasse
klasDeeltje:
def__in het__(zelf, x, y, dx, dy, straal, kleur, levensduur):
 zelf.x = x
 zelf.y = y
 zelf.dx = dx
 zelf.dy = dy
 self.radius = straal
 zelf.kleur = kleur
 self.lifespan = levensduur
defupdate(zelf):
 zelf.x += zelf.dx
 zelf.y += zelf.dy
 zelf.levensduur -= 1
deftekenen(zelf):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Spelles
klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte, "Particle Voorbeeld")
 self.particles = []
defopgericht(zelf):
# Maak deeltjes
voor _ in bereik(100):
 x = willekeurig.randbereik (SCREEN_WIDTH)
 y = willekeurig.randbereik (SCREEN_HEIGHT)
 dx = willekeurig.uniform(-1, 1)
 dy = willekeurig.uniform(-1, 1)
 radius = willekeurig.uniform(2, 5)
 kleur = arcade.kleur. WIT
 levensduur = willekeurig.randint(60, 120)
 deeltje = Deeltje (x, y, dx, dy, straal, kleur, levensduur)
 self.particles.append (deeltje)
defon_draw(zelf):
 arcade.start_render()
voor deeltje in zelf.deeltjes:
 deeltje.tekenen()
defupdate(zelf, delta_tijd):
voor deeltje in zelf.deeltjes:
 deeltje.update()
als deeltje.levensduur <= 0:
 self.particles.remove (deeltje)
defvoornaamst():
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 spel.setup()
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Je zou een animatie moeten zien met veel bewegende deeltjes:

Interactieve animaties

Implementeer interactieve animaties die reageren op gebruikersinvoer of spelgebeurtenissen. Wanneer de speler bijvoorbeeld interactie heeft met een object, kan het animeren, van kleur veranderen of op de een of andere manier transformeren. Deze interactieve animaties geven feedback en vergroten de betrokkenheid van de speler bij het spel. Hier is de code voor de interactieve-animatie.py bestand:

importeren arcade
# Schermafmetingen
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
# Kleuren
WIT = (255, 255, 255)
ROOD = (255, 0, 0)
klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte, "Interactieve animatie")
 zelf.speler_x = 400
 zelf.speler_y = 300
 self.player_radius = 30
 self.player_color = ROOD
 zelf.animatie_radius = 60
 zelf.animatie_kleur = WIT
 zelf.animatie_actief = Vals
defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 zelf.speler_y,
 self.player_radius,
 zelf.speler_kleur)
als zelf.animatie_actief:
 arcade.draw_circle_filled (self.player_x,
 zelf.speler_y,
 zelf.animatie_radius,
 zelf.animatie_kleur)
defon_mouse_press(zelf, x, y, knop, modifiers):
als (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius En
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 zelf.animatie_actief = WAAR
defupdate(zelf, delta_tijd):
als zelf.animatie_actief:
 self.animation_radius += 1
als self.animation_radius > 100:
 zelf.animatie_actief = Vals
 zelf.animatie_radius = 0
defvoornaamst():
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Negeer de noodzakelijke methoden, zoals on_draw, on_mouse_press, En update, om de speler en de animatie te tekenen, muisklikken af ​​te handelen en de animatie bij te werken.

Gebruik de om de speler te tekenen arcade.draw_circle_gevuld functie, die de (x, y) coördinaten van het middelpunt, de straal en de kleur als argumenten. De functie draw_circle_filled is er een van Arcade-tools die u kunt gebruiken om game-items te tekenen. In dit geval kunt u een groeiende cirkel tekenen door de straal in de loop van de tijd te variëren.

De on_mouse_press methode wordt uitgevoerd wanneer de gebruiker met de muis klikt. Het controleert of de muiscoördinaten binnen de grenzen van het spelerobject vallen en activeert de animatie als dat zo is.

Best practices voor het toevoegen van animatie

Houd rekening met de volgende best practices wanneer u animatie aan uw games toevoegt:

Beperk het aantal animaties

Het hebben van veel animaties met veel frames kan de prestaties beïnvloeden. Overweeg om het aantal vereiste animaties of frames te minimaliseren, vooral voor niet-kritieke elementen in het spel. Het vereenvoudigen van animaties kan helpen een consistente framesnelheid te behouden en het gebruik van bronnen te optimaliseren.

Batch Render vergelijkbare objecten

Groepeer vergelijkbare objecten die dezelfde animatieframes en texturen delen en render ze als een batch. Door batchverwerking wordt het aantal trekkingsoproepen verminderd, wat resulteert in betere prestaties. Deze techniek is vooral handig bij het animeren van objecten die dezelfde sprite-sheet gebruiken of vergelijkbare animatiereeksen hebben.

Gebruik interpolatie voor vloeiende animatie

Pas interpolatietechnieken toe, zoals lineaire interpolatie (lerping), om vloeiende animatie-overgangen te bereiken. Interpolatie berekent tussenliggende waarden tussen animatiehoofdframes om vloeiende bewegingen te creëren. Deze aanpak voorkomt plotselinge sprongen of schokkerige bewegingen tussen frames, wat resulteert in visueel aantrekkelijkere animaties.

Overweeg animatiesnelheid en -timing

Experimenteer met verschillende animatiesnelheden en timing om de juiste balans voor je game te vinden. Pas de frameduur aan of gebruik verschillende animatiereeksen om variaties in snelheid, versnelling of vertraging te creëren. Deze aanpassingen kunnen diepte en karakter toevoegen aan de animaties van je game.

Testen en optimaliseren

Test uw animaties regelmatig op verschillende apparaten en bewaak de prestaties. Zoek naar mogelijke knelpunten of vertragingen en optimaliseer dienovereenkomstig. Dit proces zorgt voor soepele en consistente animatie-ervaringen op een breed scala aan apparaten.

Maak games boeiender met animatie

Het toevoegen van animaties aan je games kan de betrokkenheid en onderdompeling van spelers aanzienlijk vergroten. Animaties geven visuele feedback op acties van spelers, waardoor de gameplay intuïtiever en leuker wordt. Ze brengen spelwerelden tot leven en creëren een gevoel van realisme en opwinding.

Of het nu gaat om een ​​rennend personage, een exploderend object of een eenvoudig overgangseffect, animaties dragen bij aan een meer dynamische en meeslepende game-ervaring.