Hur man skapar 2D-animering i Godot med AnimatedSprite

I spelutveckling spelar animationer en avgörande roll för att skapa en engagerande och uppslukande upplevelse för spelare. Genom att lägga till 2D-animationer i ditt Godot-spel kan dina karaktärer och miljöer levandegöras, vilket gör dem mer visuellt tilltalande och interaktiva.

Lyckligtvis tillhandahåller Godot kraftfulla verktyg och funktioner för att enkelt skapa och kontrollera 2D-animationer.

Konfigurera Godot-spelet

För att börja, ställ in en grundläggande 2D-spelscen i spelmotorn Godot. Skapa en ny scen och lägg till en KinematicBody2D nod som spelarkaraktär. Inuti KinematicBody2D, Lägg till en CollisionShape2D med en rektangelform som representerar spelarens kollisionsgränser.

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.

Lägg dessutom till en AnimatedSprite nod för att hantera spelarens animationer. Se dessutom till att du kartlägger följande inmatningsåtgärder i din Inmatningskarta:

Skriv sedan GDScript-koden för att kontrollera spelarens rörelse. Bifoga följande skript till KinematicBody2D nod:

 utökar 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 (hastighet)

Detta skript ställer in en konstant hastighet för spelaren och låter dem flytta vänster, höger, upp och ner med piltangenterna eller WASD.

Lägger till SpriteSheet i AnimatedSprite

Konfigurera nu AnimatedSprite att använda ett sprite-ark för animationer. Välj AnimatedSprite nod och navigera till Ramar avsnitt i nodens egenskaper flik. Här, klicka på Nya SpriteFrames knapp.

Byt till SpriteFrames fliken som finns längst ned i Godot-redigeraren. I den SpriteFrames fliken, klicka på Ny animering knapp. Skapa animationer som t.ex gå och på tomgång genom att lägga till lämpliga ramar till varje animation.

Dessutom har du möjlighet att skapa andra animationer, som att skjuta, hoppa och klättra för ett plattformsspel. Efter det klickar du på Lägg till ramar från SpriteSheet knappen för att automatiskt extrahera individuella ramar från spritearket.

Styra animationer med GDScript

Nu när du har konfigurerat dina animationer kan du styra dem programmatiskt med GDScript.

Spela och stoppa animeringen

Det är viktigt att kontrollera uppspelningen av animationer för att ge dynamiska och interaktiva upplevelser i ditt spel. De AnimatedSprite node i Godot erbjuder metoder för att spela och stoppa animationer enligt din spellogik.

Utöka KinematicBody2D nod och hantera animeringskontrollen inom _fysikprocess fungera. Du kan använda play_animation och stop_animation ingångar för att utlösa motsvarande animeringsåtgärder.

 utökar KinematicBody2Dfunc _physics_process (delta): # Spela animationen om Input.is_action_just_pressed("play_animation"): $AnimatedSprite.play() # Stoppa animeringen och återställ till den första bildrutan om Input.is_action_just_pressed("stop_animation"): $AnimatedSprite.stop() $AnimatedSprite.frame = 0

Genom att kartlägga lämpliga inmatningsåtgärder kan du ge spelare kontroll över animeringsuppspelningen i ditt spel.

Till exempel kan du binda play_animation åtgärd till en knapptryckning eller en specifik händelse i ditt spel, vilket gör att spelaren kan utlösa en animationssekvens vid ett önskat ögonblick. Dessutom kan du hitta upphovsrättsfri musik att spela medan animeringen körs.

På samma sätt kan du trigga stop_animation åtgärder för att helt stoppa animeringen.

Genom att införliva dessa animationskontrollmekanismer kan du lägga till djup och interaktivitet till ditt spels animationer, vilket skapar mer engagerande och uppslukande upplevelser för dina spelare.

Rotera animationen

Att rotera animeringen kan lägga till visuellt intresse och variation till ditt spel. Du kan programmässigt rotera AnimatedSprite nod för att ändra orienteringen för animeringen. Du kan tillämpa rotationen i grader med hjälp av rotera() metod.

 utökar KinematicBody2Dfunc _physics_process (delta): if Input.is_action_just_pressed("rotate_animation"): # Rotera animationen 45 grader medurs $AnimatedSprite.rotate (deg2rad (45))

När du trycker på knapparna som hör till rotate_animation (du kan definiera denna åtgärd i din inmatningskarta), den rotera() metod kallas på AnimatedSprite nod. Den roterar noden 45 grader i medurs riktning med hjälp av deg2rad() för att omvandla graderna till radianer.

Tänk på att det kommer att tillämpa rotation på hela AnimatedSprite nod, inklusive alla bildrutor i animationen. Därför, om du bara vill rotera specifika ramar, kan du behöva dela upp dem i separata AnimatedSprite noder eller använda andra tekniker som att vända individuella bildrutor.

Vänd på animationen

Att vända animationen horisontellt eller vertikalt kan vara användbart för att återspegla förändringar i karaktärens riktning. I Godot, den AnimatedSprite noden tillhandahåller egenskaper för att styra vändning.

För att vända animeringen horisontellt, ställ in flip_h egendom av AnimatedSprite till Sann. Detta kommer att spegla animeringen längs den horisontella axeln. På samma sätt ställer du in flip_v egendom till Sann kommer att spegla animeringen längs den vertikala axeln.

 utökar KinematicBody2Dfunc _physics_process (delta): om Input.is_action_just_pressed("flip_animation"): $AnimatedSprite.flip_h = true # eller $AnimatedSprite.flip_v = true för vertikal flipping

Om spelaren trycker på flip_animation ingångsåtgärd ställ sedan in flip_h egendom av AnimatedSprite till Sann. Detta kommer att vända animationen horisontellt.

Använda signaler i AnimatedSprite

Förutom att styra animationer programmatiskt tillhandahåller Godot ett kraftfullt händelsesystem som kallas signaler. Signaler låter dig svara på specifika händelser eller förändringar som inträffar under körningen av ditt spel.

I fallet med AnimatedSprite, det finns två viktiga signaler som du kan använda: animation_finished() och frame_changed().

1. animation_finished() Signal

De animation_finished() signal sänds ut när animeringen når den sista bildrutan, antingen under en enda uppspelning eller när den loopar. Denna signal är användbar när du vill utföra åtgärder eller utlösa händelser när en animering slutförs.

 utökar KinematicBody2Dfunc _ready(): $AnimatedSprite.connect("animation_finished", self, "_on_animation_finished")func _on_animation_finished(): # Utför åtgärder eller utlösa händelser print("Animation färdig!") # Ytterligare kod här...

Anslut animation_finished() signal från AnimatedSprite till _on_animation_finished() metod i samma skript med hjälp av ansluta() fungera.

När animationen är klar kan du köra anpassad logik eller utlösa andra funktioner med hjälp av _on_animation_finished() metod.

2. frame_changed() Signal

De frame_changed() signal sänds ut när den aktuella bildrutan i animationen ändras. Detta kan inträffa när animeringen spelas upp eller när du programmässigt modifierar ramen. Du kan använda denna signal för att upptäcka ramändringar och reagera därefter.

 utökar KinematicBody2Dfunc _ready(): $AnimatedSprite.connect("frame_changed", self, "_on_frame_changed")func _on_frame_changed(): # Utför åtgärder baserat på den aktuella ramen var currentFrame = $AnimatedSprite.frame print("Current frame: ", currentFrame) # Ytterligare kod här...

Anslut frame_changed() signal från AnimatedSprite till _on_frame_changed() metod i samma skript. När ramen ändras kan du komma åt den aktuella ramen med hjälp av _on_frame_changed() metod och utföra åtgärder eller logik baserat på ramens värde.

Genom att använda signaler kan du svara på animationshändelser som slutförande eller ramändringar och införliva dynamiska beteenden eller utlösa specifika åtgärder i ditt spel.

Gör Godot-spel mer engagerande med animationer

Att lägga till 2D-animationer till dina Godot-spel kan avsevärt förbättra den övergripande spelarupplevelsen. Animationer ger karaktärer liv och gör deras rörelser och handlingar mer visuellt tilltalande. Genom att inkludera animationer för olika aktiviteter som att gå, springa, attackera och hoppa kan du skapa en dynamisk och uppslukande spelmiljö.

Dessutom kan du också använda animationer för att ge visuell feedback till spelaren. Denna feedback hjälper till att göra spelet mer engagerande och lyhört, vilket ökar spelarens känsla av kontroll och engagemang.