Hur man implementerar en dag-natt-cykel i Godot

En dag-natt-cykel kan ge dina spel ett uppslukande element, göra grafiken mer varierad och skapa intressanta mekanismer. Spel som Minecraft, Animal Crossing och Don’t Starve använder denna teknik effektivt, och det är en teknik som du kan överväga att lägga till i dina egna spel, särskilt de med ett realtidselement.

Faktum är att processen med att införliva en dag-natt-cykel i Godot 4 har effektiviserats och förenklats till en aldrig tidigare skådad grad.

Konfigurera Godot-spelet

För att kunna påbörja utvecklingen av dag-natt-cykeln inom ramen för vårt spel, är det klokt att vi först skapar en solid grund att bygga vidare på. Detta kan uppnås genom att initiera ett nytt tvådimensionellt projekt inom ramen för Godot, och se till att alla relevanta projektparametrar är korrekt konfigurerade.

Koden som används i denna publikation kan nås via ett GitHub-arkiv, som fungerar som en plattform med öppen källkod för delning och samarbete. Detta arkiv innehåller koden och ger tillstånd till användare att använda den utan kostnad, i enlighet med villkoren i MIT-licensen.

När man skapar en spelscen i Unity måste man först skapa ett Player Character-objekt genom att instansiera en

För att spelaren ska kunna navigera genom spelmiljön är det nödvändigt att införliva en specifik uppsättning programmeringsinstruktioner som kallas GDScript i det utsedda karaktärsobjektet. Denna process innebär att det medföljande kodavsnittet appliceras på karaktärens associerade nod, vilket möjliggör dess rörelsefunktioner.

 extends CharacterBody2D

var speed = 300

func _physics_process(delta):
    var input_dir = Vector2.ZERO

    if Input.is_action_pressed("ui_left"):
        input_dir.x -= 1

    if Input.is_action_pressed("ui_right"):
        input_dir.x \\+= 1

    if Input.is_action_pressed("ui_up"):
        input_dir.y -= 1

    if Input.is_action_pressed("ui_down"):
        input_dir.y \\+= 1

    velocity = input_dir.normalized() * speed
    move_and_collide(velocity * delta)

Den medföljande koden gör det möjligt för användaren att navigera i ett tecken med hjälp av piltangenterna. Dessutom är det möjligt att införliva motståndare som huvudpersonen måste undvika. För detta ändamål kan vi använda Utilize StaticBody2D-noder som motståndare och manipulera deras form och placering efter behov.

Lägg till en timer för dag- och nattcykeln

För att implementera en dag-nattcykel i ett videospel är det nödvändigt att införliva en kontinuerligt löpande timer som växlar mellan dag- och nattfaser och fungerar som en indikator för förfluten tid under hela spelupplevelsen.

Starta snabbmenyn i scenpanelen med höger musknapp; i listan över tillgängliga alternativ som visas när du väljer “Add Node” väljer du den specifika timernoden som hittades i nodbibliotekets sökresultat.

Ändra beteckningen på timernoden till en mer beskrivande etikett som “DayNightTimer” för att förbättra läsbarheten.Konfigurera sedan attributen för noden Timer genom att granska dess egenskaper i Inspector-panelen. Justera särskilt attributet “Väntetid” till noll sekunder, vilket representerar den preliminära pausen innan timern startas, och se till att funktionen “One Shot” är aktiverad, vilket gör att timern upprepas kontinuerligt.

Införliva en GDScript-implementering för att hantera dag-natt-cykeln genom att införliva lämplig logik och beräkningar i skriptet.

 extends Node2D

var day_duration = 30 # Duration of the day in seconds
var night_duration = 30 # Duration of the night in seconds

var is_day = true

func _ready():
    # Start the timer when the scene loads
    $DayNightTimer.start()

func _on_DayNightTimer_timeout():
    if is_day:
        # Transition from day to night
        $DayNightTimer.start(day_duration)
        is_day = false

        # Add your code here for night-specific actions or visual changes
    else:
        # Transition from night to day
        $DayNightTimer.start(night_duration)
        is_day = true

        # Add your code here for day-specific actions or visual changes 

I funktionen ready , starta DayNightTimer i början av scenen för att initiera dag-natt-cykeln. Funktionen _on_DayNightTimer_timeout exekveras varje gång timern slår noll, vilket innebär en nära förestående övergång från dag till natt eller vice versa.

Om du följer denna procedur får du en fullt fungerande dag-natt-timer som sömlöst växlar mellan dagtid och nattetid i ditt Godot-spel, vilket gör att du kan införliva olika spelaspekter och visuellt slående ändringar beroende på vilken timme på dygnet som råder.

Anpassa bakgrunden för dag och natt

För att förbättra den visuella representationen av dag-natt-cykeln i din scen är det viktigt att införliva en metod som visar övergången från dag till natt på ett smidigt sätt. En effektiv lösning är att använda en ColorRect-nod för att skapa en lämplig bakgrund för båda scenarierna. Genom att använda denna teknik får du större flexibilitet när det gäller att skapa mjuka övergångar och finare kontroll över scenens övergripande utseende.

För att skapa en dynamisk bakgrund i ditt Godot-motorprojekt bör du först introducera ett ColorRect -objekt i scenen. Detta element fungerar som en anpassningsbar grund för olika visuella effekter och övergångar mellan dagtid och kvällstid. Därefter är det lämpligt att byta namn på denna komponent till en mer beskrivande etikett som “BackgroundRect” för att förbättra läsbarheten. Slutligen ska du se till att “BackgroundRect” placeras som det översta lagret genom att lägga det över hela det synliga canvasområdet.

I panelen Inspektör konfigurerar du egenskapen Färg så att den återspeglar den önskade bakgrundsnyansen, som symboliserar dagsljuset. För att uppnå detta kan du använda ett värde som Color(0.5, 0.5, 0.8), vilket motsvarar en mjuk nyans av blått som framkallar bilder av en ljus och solig dagshimmel.

Uppdatera din GDScript-kodbas så att den integreras sömlöst med

 func _on_day_night_timer_timeout():
    if is_day:
        # Transition from day to night
        $DayNightTimer.start(day_duration)
        is_day = false

        # Add your code here for night-specific actions or visual changes

        # Update the background color to indicate day
        $BackgroundRect.color = Color(0.5, 0.5, 0.8) # Light blue for day
    else:
        # Transition from night to day
        $DayNightTimer.start(night_duration)
        is_day = true

        # Add your code here for day-specific actions or visual changes

        # Update the background color to indicate night
        $BackgroundRect.color = Color(0, 0, 0) # Black for night 

Ändra utseendet på BackgroundRect-elementet genom att justera dess nyans baserat på den aktuella tiden på dagen. Vid övergången från dag till natt kan du ändra bakgrundsfärgen till en djup svart nyans för att skapa en mörk atmosfär. Omvänt, under dagtid, välj en mjuk nyans av himmelsblå som bakgrundsfärg.

Ljudeffekter för dag-natt-cykeln

En effektiv ljuddesign är avgörande för att skapa en uppslukande upplevelse i Godots dag-natt-cykel. Genom att integrera lämpliga ljudsignaler kan man öka spelarens engagemang genom att ge meningsfull feedback om miljöförändringar. Lyckligtvis är det relativt enkelt att integrera ljudeffekter i sitt Godot-projekt.

Se till att du innan du börjar har ljudtillgångar som består av ljudinspelningar som visar både dagliga och nattliga hörselfenomen. Det är till exempel tänkbart att du kan ha fågelmelodier för det första och syrsornas läten eller ugglornas hoande för det andra.

För att kunna införliva ljudsignaler i ditt Godot-projekt är det nödvändigt att inkludera två AudioStreamPlayer2D-instanser i scenen. Dessa bör namnges i enlighet med detta, med lämpliga moniker som “DaytimeSounds” och “NighttimeSounds”.

Ändra GDScript-koden för att underlätta ljudövergången från dag till natt:

 func _on_day_night_timer_timeout():
    if is_day:
        # Transition from day to night
        $DayNightTimer.start(day_duration)
        is_day = false
     
        # Play daytime sounds
        $NighttimeSounds.stop() # Stop nighttime sounds
        $DaytimeSounds.play() # Start daytime sounds
         
    else:
        # Transition from night to day
        $DayNightTimer.start(night_duration)
        is_day = true

        # Play nighttime sounds
        $DaytimeSounds.stop() # Stop daytime sounds
        $NighttimeSounds.play() # Start nighttime sounds 

När dag-natt-timern har löpt ut utvärderar denna algoritm det aktuella tillståndet och aktiverar motsvarande ljudsignaler för att underlätta en sömlös övergång mellan faserna.

Känn dig fri att anpassa ditt urval av upphovsrättsfria ljudeffekter för att anpassa dig till den ton och atmosfär du önskar för ditt spel. Dessutom har du möjlighet att använda flera ljudspår eller olika ljudeffekter som reverb, eko med mera för att skapa en mer uppslukande ljudmiljö.

Gör dina Godot-spel mer engagerande med en dag-natt-cykel

Att integrera en dygnscykel i ditt Godot-spel kan avsevärt höja nivån av fördjupning och engagemang som upplevs av spelarna. Detta tillägg ger inte bara spelvärlden ett extra lager av realism utan möjliggör också införandet av olika och utvecklande spelmekaniker samt främjar fantasifulla berättelser.

Överväg att justera dag-natt-cykeln i enlighet med spelets specifika teman och mekanik, samtidigt som du utforskar olika visuella och interaktiva element som kan bidra till en uppslukande och fängslande spelupplevelse.