2D-animatie maken in Godot met behulp van AnimatedSprite

Bij de ontwikkeling van games spelen animaties een cruciale rol bij het creëren van een boeiende en meeslepende ervaring voor spelers. Door 2D-animaties aan je Godot-game toe te voegen, kunnen je personages en omgevingen tot leven komen, waardoor ze visueel aantrekkelijker en interactiever worden.

Gelukkig biedt Godot krachtige tools en functies om eenvoudig 2D-animaties te maken en te besturen.

Het Godot-spel opzetten

Stel om te beginnen een eenvoudige 2D-spelscène in de Godot-game-engine. Maak een nieuwe scène en voeg een KinematicBody2D node als het personage van de speler. Binnen in de KinematicBody2D, Voeg een... toe BotsingVorm2D met een rechthoekige vorm die de botsingsgrenzen van de speler vertegenwoordigt.

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.

Voeg bovendien een GeanimeerdeSprite node om de animaties van de speler te verwerken. Zorg er verder voor dat u de volgende invoeracties in kaart brengt in uw

Invoer kaart:

Schrijf vervolgens de GDScript-code om de beweging van de speler te besturen. Voeg het volgende script toe aan het KinematicBody2D knooppunt:

 verlengt KinematicBody2Dconst SPEED = 200func _physics_process (delta): var velocity = Vector2.ZERO if Input.is_action_pressed("move_left"): velocity.x -= SPEED if Input.is_action_pressed("move_right"): velocity.x += SPEED if Input.is_action_pressed("move_up"): velocity.y -= SPEED if Input.is_action_pressed("move_down"): velocity.y += SPEED velocity = move_and_slide (snelheid)

Dit script zorgt voor een constante snelheid voor de speler en stelt hem in staat om naar links, rechts, omhoog en omlaag te bewegen met behulp van de pijltjestoetsen of WASD.

SpriteSheet toevoegen in AnimatedSprite

Configureer nu de GeanimeerdeSprite om een ​​sprite-sheet te gebruiken voor animaties. Selecteer de GeanimeerdeSprite knooppunt en navigeer naar de Kaders sectie op het eigenschappentabblad van het knooppunt. Klik hier op de Nieuwe SpriteFrames knop.

Schakel over naar de SpriteFrames tabblad onderaan de Godot-editor. In de SpriteFrames tabblad, klik op de Nieuwe animatie knop. Maak animaties zoals wandeling En inactief door geschikte frames aan elke animatie toe te voegen.

Daarnaast heb je de mogelijkheid om andere animaties te maken, zoals schieten, springen en klimmen voor een platformgame. Klik daarna op de Frames toevoegen vanuit SpriteSheet knop om automatisch individuele frames uit het sprite-blad te extraheren.

Animaties besturen met GDScript

Nu je je animaties hebt ingesteld, kun je ze programmatisch besturen met GDScript.

De animatie afspelen en stoppen

Het regelen van het afspelen van animaties is essentieel om dynamische en interactieve ervaringen in je game te bieden. De GeanimeerdeSprite node in Godot biedt methoden om animaties af te spelen en te stoppen volgens uw spellogica.

Verleng de KinematicBody2D node en beheert u de animatiecontrole binnen het _fysica_proces functie. U kunt de speel_animatie En stop_animation invoer om de bijbehorende animatieacties te activeren.

 breidt KinematicBody2Dfunc _physics_process (delta) uit: # Speel de animatie af als Input.is_action_just_pressed("play_animation"): $AnimatedSprite.play() # Stop de animatie en reset naar het eerste frame als Input.is_action_just_pressed("stop_animation"): $AnimatedSprite.stop() $AnimatedSprite.frame = 0

Door de juiste invoeracties in kaart te brengen, kunt u spelers controle geven over het afspelen van animaties in uw game.

U kunt bijvoorbeeld de speel_animatie actie op een druk op een knop of een specifieke gebeurtenis in je spel, waardoor de speler op een gewenst moment een animatiereeks kan activeren. Bovendien kan dat auteursrechtvrije muziek vinden afspelen terwijl de animatie wordt uitgevoerd.

Op dezelfde manier kunt u de stop_animation acties om de animatie volledig te stoppen.

Door deze animatiebesturingsmechanismen op te nemen, kunt u diepte en interactiviteit toevoegen aan de animaties van uw game, waardoor uw spelers meer boeiende en meeslepende ervaringen krijgen.

De animatie roteren

Het roteren van de animatie kan visuele interesse en afwisseling aan uw spel toevoegen. U kunt de GeanimeerdeSprite node om de oriëntatie van de animatie te wijzigen. U kunt de rotatie in graden toepassen met behulp van de draaien() methode.

 breidt KinematicBody2Dfunc _physics_process (delta) uit: if Input.is_action_just_pressed("rotate_animation"): # Draai de animatie 45 graden met de klok mee $AnimatedSprite.rotate (deg2rad (45))

Wanneer u op de knoppen drukt die zijn gekoppeld aan de roteren_animatie (u kunt deze actie definiëren in uw invoerkaart), de draaien() methode wordt aangeroepen op de GeanimeerdeSprite knooppunt. Het roteert het knooppunt met 45 graden met de klok mee met behulp van deg2rad() om de graden om te zetten in radialen.

Houd er rekening mee dat het rotatie op het geheel zal toepassen GeanimeerdeSprite node, inclusief alle frames van de animatie. Als u daarom alleen specifieke frames wilt roteren, moet u ze mogelijk in afzonderlijke frames splitsen GeanimeerdeSprite nodes of gebruik andere technieken zoals het omdraaien van individuele frames.

De animatie omdraaien

Het horizontaal of verticaal spiegelen van de animatie kan handig zijn om veranderingen in de tekenrichting weer te geven. In Godot, de GeanimeerdeSprite node biedt eigenschappen om het omdraaien te regelen.

Om de animatie horizontaal te spiegelen, stelt u de flip_h eigendom van de GeanimeerdeSprite naar WAAR. Hierdoor wordt de animatie langs de horizontale as gespiegeld. Evenzo het instellen van de flip_v eigendom aan WAAR spiegelt de animatie langs de verticale as.

 breidt KinematicBody2Dfunc _physics_process (delta) uit: if Input.is_action_just_pressed("flip_animation"): $AnimatedSprite.flip_h = true # of $AnimatedSprite.flip_v = true voor verticaal spiegelen

Als de speler op de flip_animation voer actie in en stel vervolgens de flip_h eigendom van de GeanimeerdeSprite naar WAAR. Hierdoor wordt de animatie horizontaal gespiegeld.

Signalen gebruiken in AnimatedSprite

Naast het programmatisch besturen van animaties, biedt Godot een krachtig gebeurtenissysteem dat signalen wordt genoemd. Met signalen kun je reageren op specifieke gebeurtenissen of veranderingen die plaatsvinden tijdens de uitvoering van je game.

In het geval van GeanimeerdeSprite, zijn er twee belangrijke signalen die u kunt gebruiken: animatie_finished() En frame_gewijzigd().

1. animatie_finished() Signaal

De animatie_finished() signaal wordt uitgezonden wanneer de animatie het laatste frame bereikt, tijdens een enkele weergave of wanneer deze in een lus wordt afgespeeld. Dit signaal is handig wanneer u acties wilt uitvoeren of gebeurtenissen wilt activeren wanneer een animatie is voltooid.

 breidt KinematicBody2Dfunc _ready() uit: $AnimatedSprite.connect("animation_finished", self, "_on_animation_finished")func _on_animation_finished(): # Voer acties uit of activeer gebeurtenissen print("Animation klaar!") # Extra code hier...

Verbind de animatie_finished() signaal van de GeanimeerdeSprite naar de _on_animation_finished() methode in hetzelfde script met behulp van de aansluiten() functie.

Wanneer de animatie is afgespeeld, kunt u aangepaste logica uitvoeren of andere functies activeren met behulp van de _on_animation_finished() methode.

2. frame_changed() Signaal

De frame_gewijzigd() signaal wordt uitgezonden wanneer het huidige frame van de animatie verandert. Dit kan gebeuren wanneer de animatie wordt afgespeeld of wanneer u het frame programmatisch wijzigt. U kunt dit signaal gebruiken om frameveranderingen te detecteren en dienovereenkomstig te reageren.

 breidt KinematicBody2Dfunc _ready(): $AnimatedSprite.connect("frame_changed", self, "_on_frame_changed")func _on_frame_changed(): # Acties uitvoeren op basis van het huidige frame var currentFrame = $AnimatedSprite.frame print("Current frame: ", currentFrame) # Aanvullende code hier...

Verbind de frame_gewijzigd() signaal van de GeanimeerdeSprite naar de _op_frame_gewijzigd() methode in hetzelfde script. Wanneer het kader verandert, kunt u het huidige kader openen met behulp van de _op_frame_gewijzigd() methode en voer acties of logica uit op basis van de waarde van het frame.

Door signalen te gebruiken, kunt u reageren op animatiegebeurtenissen zoals voltooiing of frameveranderingen en dynamisch gedrag opnemen of specifieke acties in uw game activeren.

Maak Godot-spellen boeiender met behulp van animaties

Het toevoegen van 2D-animaties aan je Godot-spellen kan de algehele spelerservaring aanzienlijk verbeteren. Animaties brengen personages tot leven, waardoor hun bewegingen en acties visueel aantrekkelijker worden. Door animaties op te nemen voor verschillende acties, zoals lopen, rennen, aanvallen en springen, kun je een dynamische en meeslepende gameplay-omgeving creëren.

Bovendien kun je ook animaties gebruiken om de speler visuele feedback te geven. Deze feedback helpt om het spel boeiender en responsiever te maken, waardoor het gevoel van controle en betrokkenheid van de speler wordt vergroot.