Hur man implementerar en dag-natt-cykel i Godot

En växling mellan dag och natt kan berika spelupplevelsen avsevärt, tillföra visuell variation och möjliggöra intressanta spelmekaniker. Spel som Minecraft, Animal Crossing och Don’t Starve utnyttjar denna teknik effektivt, och det är något du bör överväga för dina egna spel, särskilt om de innehåller realtidselement.

I Godot 4 är det nu enklare än någonsin att implementera en dynamisk dag- och nattcykel.

Förbereda Spelet i Godot

Innan du börjar implementera dag- och nattcykeln, är det viktigt att skapa grunden för ditt spel. Starta med ett nytt 2D-projekt i Godot 4 och ställ in alla nödvändiga projektinställningar.

Koden som används i denna guide finns tillgänglig på GitHub-förrådet, och du kan fritt använda den under MIT-licensen.

Skapa sedan en spelarkaraktär. Lägg till en CharacterBody2D-nod i scenen. Inuti denna, lägg till en CollisionShape2D med en rektangulär form och en Sprite2D. Detta utgör den visuella representationen av din karaktär.

För att ge spelaren möjlighet att röra sig, använd följande GDScript-kod. Fäst detta skript till din karaktärsnod:

 extends CharacterBody2D
var hastighet = 300
func _physics_process(delta):
    var riktning = Vector2.ZERO
    if Input.is_action_pressed("ui_left"):
        riktning.x -= 1
    if Input.is_action_pressed("ui_right"):
        riktning.x += 1
    if Input.is_action_pressed("ui_up"):
        riktning.y -= 1
    if Input.is_action_pressed("ui_down"):
        riktning.y += 1
    velocity = riktning.normalized() * hastighet
    move_and_collide(velocity * delta)
 

Denna kod låter spelaren förflytta sig åt vänster, höger, upp och ner med hjälp av piltangenterna. Du kan även lägga till fiender som spelaren behöver undvika. Använd StaticBody2D-noder för fienderna och anpassa deras former och placeringar.

Skapa En Timer För Dag- Och Nattcykeln

För att skapa en dag- och nattcykel krävs en timer som kontinuerligt växlar mellan dag- och nattfaserna. Denna timer kommer att styra tidens gång i spelet.

Lägg till en Timer-nod till din Godot-scen. Du kan göra detta genom att högerklicka i scenpanelen, välja ”Lägg till nod” och sedan söka efter Timer i nodbiblioteket.

Ge Timer-noden ett passande namn, som till exempel ”DagNattTimer” för tydlighetens skull. Konfigurera sedan timerns egenskaper i inspektörspanelen. Ange ”Väntetid” till 0 (för att inte ha någon initial fördröjning) och kryssa i ”En gång”-egenskapen så att timern upprepas.

Lägg till följande GDScript-kod som hanterar dag- och nattcykeln:

 extends Node2D
var dagens_längd = 30 
var nattens_längd = 30 
var är_dag = true
func _ready():
    $DagNattTimer.start()
func _on_DagNattTimer_timeout():
    if är_dag:
        $DagNattTimer.start(dagens_längd)
        är_dag = false
    else:
        $DagNattTimer.start(nattens_längd)
        är_dag = true
 

I funktionen `_ready` startas timern `DagNattTimer` när scenen laddas, för att initiera dag- och nattcykeln. Funktionen `_on_DagNattTimer_timeout` aktiveras varje gång timern når noll, vilket markerar tidpunkten för att växla mellan dag och natt.

Genom att följa dessa steg har du en fungerande dag- och nattimer som växlar mellan dag och natt, vilket ger dig möjlighet att lägga till dynamiska spelinslag och visuella förändringar i ditt Godot-spel beroende på tiden på dygnet.

Anpassa Bakgrunden För Dag Och Natt

För att fullborda din dag- och nattcykel behöver du ett sätt att visuellt representera övergången mellan dag och natt. Du kan använda en ColorRect-nod för att skapa en bakgrund som passar för både dag och natt. Detta ger jämnare övergångar och mer kontroll över det visuella.

Lägg till en ColorRect-nod i din Godot-scen. Denna nod kommer att fungera som din bakgrund och ändra färg för att representera dag och natt. Byt namn på ColorRect-noden till något passande, som ”BakgrundsRektangel”. Placera den som ett bakgrundslager och se till att den täcker hela visningsområdet.

I inspektörspanelen, ställ in ”Färg”-egenskapen till den färg du vill ha som standard, vilken ska representera dagtid. Till exempel kan du använda `Color(0.5, 0.5, 0.8)` för en ljusblå daghimmel.

Uppdatera nu din GDScript-kod för att hantera ColorRect-noden:

 func _on_day_night_timer_timeout():
    if är_dag:
        $DagNattTimer.start(dagens_längd)
        är_dag = false
        $BakgrundsRektangel.color = Color(0.5, 0.5, 0.8)
    else:
        $DagNattTimer.start(nattens_längd)
        är_dag = true
        $BakgrundsRektangel.color = Color(0, 0, 0) 
 

Uppdatera färgen på ”BakgrundsRektangel”-noden för att spegla tidpunkten på dygnet. Du kan till exempel ställa in den till svart när det blir natt, vilket skapar en mörk bakgrund. När det blir dag kan du ändra den till ljusblå.

Ljudeffekter För Dag- Och Nattcykeln

Ljudeffekter kan spela en viktig roll för att förstärka inlevelsen och realismen i din dag- och nattcykel i Godot. De ger spelare auditiva signaler och gör övergången mellan dag och natt mer engagerande. Du kan enkelt lägga till ljudeffekter i ditt spel.

Innan du börjar, se till att du har ljudfiler som representerar dag- och nattljud. Du kan till exempel ha fågelkvitter för dagen och syrsor eller ugglor för natten.

Lägg till två AudioStreamPlayer2D-noder i din Godot-scen och ge dem passande namn. Du kan namnge dem något som ”$Dagsljud” och ”$Nattljud”.

Uppdatera nu GDScript-koden för att hantera ljudövergångarna mellan dag och natt:

 func _on_day_night_timer_timeout():
    if är_dag:
        $DagNattTimer.start(dagens_längd)
        är_dag = false
        $Nattljud.stop() 
        $Dagsljud.play() 
    else:
        $DagNattTimer.start(nattens_längd)
        är_dag = true
        $Dagsljud.stop() 
        $Nattljud.play() 
 

När timern löper ut kontrollerar denna kod vilken fas spelet ska övergå till och spelar upp de lämpliga ljuden.

Anpassa gärna dina royaltyfria ljudeffekter för att matcha temat och atmosfären i ditt spel. Du kan också lägga flera ljudspår på varandra eller använda ljudeffekter som reverb och eko för att skapa en rikare ljudupplevelse.

Gör Dina Godot-spel Mer Engagerande Med En Dag-Och Nattcykel

Att implementera en dag- och nattcykel i ditt Godot-spel kan avsevärt öka spelarens inlevelse och engagemang. Det ger djup till spelvärlden, introducerar dynamiska spelinslag och möjliggör kreativa berättelser.

Kom ihåg att skräddarsy dag- och nattcykeln efter just ditt spels unika tema och mekanik. Tveka inte att experimentera med olika visuella effekter och spelrelaterade effekter för att skapa en verkligt fängslande spelupplevelse.