## GDSCript och kodning i kursen Vi kommer att koda genom att skriva script-kod som läggs till objekt (kallas Noder i Godot). Som programmeringsspåk kommer vi då använda framförallt följande. 1. [Variabler](var.sv.shtml): 1. [Arrayer](arrayes.sv.shtml): 1. [for-loopar](for.sv.shtml): 1. [if-satser](if.sv.shtml): 1. [funktioner, med parametrar och retur](func.sv.shtml) 1. [`Inbygda_funktioner_i_Godot()`](builtin.sv.shtml) ## Grundläggande i scripten I GDScript används olika inbyggda funktioner, samt objekt/noder som redan finns i motorn. All kod vi skriver, förutom variabledeklarationer, måste ligga inne i funktioner. Det beror på att vi egenligen lägger till kod till ett objekt, därav startar att script med t.ex. `extend Node` eller `extend Control` eller `extend RigidiBody2D` osv... (I andra språk, som t.ex. python och JavaScript, kan kod skrivas direkt.) I Godot anropas egna script av spelmotorn på olika sätt beroende på hur de är kopplade till spelet. Här är några vanliga sätt: 1. **Node lifecycle callbacks**: - Om ditt script är kopplat till en nod i spelhierarkin, som en `Node2D` eller `Control`, kan spelmotorn automatiskt anropa vissa metoder i ditt script baserat på nodens livscykel. - Exempel på sådana metoder inkluderar `_ready()`, som anropas när noden har lagts till i scenen och är redo att användas, och `_process(delta)`, `_physics_process(delat)` anropas varje ram för att uppdatera nodens logik och fysik. 2. **Signalhantering**: - Om ditt script är kopplat till en nod som skickar signaler, kan du skapa och ansluta funktioner till dessa signaler för att utföra åtgärder när de utlöses. - Till exempel kan du ansluta en funktion i ditt script till en knapps `pressed`-signal för att utföra en handling när knappen trycks. 3. **Manuella anrop**: - Du kan också manuellt anropa funktioner i ditt script från andra delar av din kod. 4. **Autoloaded scripts**: - Om du har ett script som är laddat som ett autoloaded script, kommer det att finnas tillgängligt globalt i hela projektet och du kan anropa dess funktioner från var som helst i ditt spel. ## Arrayer och Dicts: 1. **Arrayer**: - Ett array är en ordnad samling av element där varje element har ett index. - I GDScript kan du skapa en array genom att använda hakparenteser `[]` och lägga till element med kommatecken mellan dem. - Exempel på en array i GDScript: ``` var my_array = [1, 2, 3, 4, 5] ``` - Du kan komma åt element i en array med dess index. Indexet börjar från 0 för det första elementet och ökar med 1 för varje efterföljande element. - Exempel på att komma åt element i en array: ``` var first_element = my_array[0] # första elementet, 1 var third_element = my_array[2] # tredje elementet, 3 ``` 2. **Dicts (Dictionary)**: - En dict, eller dictionary, är en samling av värden som är associerade med nycklar. Varje nyckel-värde-par representerar en post i dictionaryn. - I GDScript kan du skapa en dict genom att använda krullparenteser `{}` och ange nyckel-värde-par med kolon `:` mellan nyckeln och värdet, separerade med kommatecken. - Exempel på en dict i GDScript: ``` var my_dict = { "name": "John", "age": 30, "city": "New York" } ``` - Du kan komma åt värden i en dictionary genom att använda dess nycklar. - Exempel på att komma åt värden i en dictionary: ``` var person_name = my_dict["name"] # "John" var person_age = my_dict["age"] # 30 ``` Arrayer är lämpliga för att lagra en sekvens av element med indexerad åtkomst, medan dicts är användbara när du behöver lagra och hämta data med hjälp av nycklar. Båda dessa datatyper är värdefulla verktyg för att organisera och manipulera data i GDScript. ## Block och scope 1. **Block**: - Ett block i GDScript är en grupp av instruktioner som följer efter ett `:`och är inskjutet t.ex. med en TAB, tills koden skjuts tillbaka igen. Det kan vara en del av en funktion, en villkorssats (t.ex. `if`-sats, `for`-loop eller `while`-loop) eller en kodblock inom en klassdefinition. - Exempel på ett block i GDScript: ``` if condition: # Detta är ett kodblock print("Detta är inom if-satsen") ``` 2. **Scope**: - Scope, eller räckvidd, avser området där en variabel existerar, är synlig och åtkomlig i koden. Variabler kan vara globala (tillgängliga över hela koden), lokal för en funktion eller ett block. - Variabler som deklareras inom en funktion eller ett kodblock är lokala för det blocket och är inte tillgängliga utanför det. - Variabler som deklareras utanför något block är vanligtvis globala och är tillgängliga från vilket block som helst i koden. - Variabler är inte tillgägnliga mellan objeckt eller olika script men kan göras tillgägnliga 3. **Kopplade kontrolltecken**: - Kopplade kontrolltecken, som `:` efter villkorssatser och `TAB` osynligt tecken, leder till inskjutning av koden, definiera gränserna för ett block i GDScript. - De indikerar början och slutet av ett kodblock och styr hur kodens struktur och utvärdering fungerar. 4. **Variabler och scope**: - Variabler i GDScript är bundna till det kodblock där de är deklarerade. - Om en variabel deklareras inuti en funktion eller ett kodblock är den endast synlig inom det blocket. Det betyder att den inte är tillgänglig utanför blocket eller inom andra funktioner. - Om en variabel deklareras utanför något block är den global och är synlig över hela koden. ## Anropsordning I kursen kommer vi så långt som möjligt göra all kodning från spelaren script. DEtta förenklare för nybörjare och i kursen men är egenligen inte önskvärt då det försvårar kodning av större system. Om kod sprids över många olika noder uppstår dock problem med ordningen som script körs t.ex. `_ready()`-funktionen. I Godot körs skript i scen-trädet och dess inlänkade scener i en förutbestämd ordning, vilket påverkar när funktioner som `_ready` anropas. Här är en översikt över hur detta fungerar: 1. **Huvudscenen**: När huvudscenen laddas in, börjar Godot med att exekvera funktionen `_ready` för alla noder direkt i huvudscenen. Detta görs i en djup först-sökning, vilket innebär att först rot-noden exekveras, sedan dess barn, och så vidare, tills alla noder i scenen har körts igenom. 2. **Inlänkade scener**: Om huvudscenen innehåller inlänkade scener (instanser av andra scener), exekveras de inlänkade scenerna efter att alla noder i huvudscenen har körts igenom. På samma sätt utförs exekveringen av `_ready` för noder i de inlänkade scenerna också i en djup först-sökning, vilket innebär att Godot exekverar noder i inlänkade scener från rot-nivån nedåt. 3. **Externa resurser och instansiering**: Om någon nod i scenen eller dess inlänkade scener instansierar eller laddar externa resurser under exekveringen av `_ready`, kommer Godot att vänta på att de externa resurserna laddas klart innan `_ready` exekveras för dessa noder. Genom att förstå denna ordning kan du organisera dina skript och hantera funktioner som `_ready` på ett effektivt sätt för att uppfylla dina spelbehov. Det är viktigt att tänka på denna ordning när du utvecklar dina scener för att undvika problem med beroenden och förväntat beteende hos dina noder. ## Felsökning Att felsöka i programmering är en viktig och ibland utmanande process. Här är några steg som kan hjälpa dig att felsöka effektivt: 1. **Identifiera problemet**: Först och främst måste du klart förstå vad som inte fungerar. Läs felmeddelandet om det finns något och försök att förstå vad det säger. Om det inte finns något felmeddelande, försök att precisera problemet så tydligt som möjligt. 2. **Lägg till utskrifter**: Placera utskrifter i relevanta delar av din kod för att få insikt i vad som händer när koden körs. Du kan skriva ut värden på variabler, meddelanden vid specifika händelser eller andra relevanta uppgifter. 3. **Använd meningsfulla meddelanden**: Se till att de meddelanden du skriver ut är informativa och hjälper dig att förstå vad som händer i koden. Det kan inkludera namn på variabler, villkor som utvärderas eller händelser som inträffar. 4. **Kör koden och observera utskrifterna**: Kör din kod och observera de utskrifter som genereras. Titta efter mönster eller avvikelser som kan hjälpa dig att identifiera problemet. 5. **Använd flera utskrifter**: Ibland kan det vara nödvändigt att lägga till flera utskrifter för att förstå vad som händer i din kod. Prova att lägga till fler utskrifter om det behövs för att få en tydligare bild av vad som händer. 6. **Jämför förväntat och faktiskt beteende**: Jämför resultatet av dina utskrifter med det förväntade beteendet för att se om det finns avvikelser eller felaktigheter. 3. **Isolera problemet**: Försök att begränsa området där problemet kan uppstå. Det kan innebära att kommentera ut delar av koden eller skapa en minimal reproducerbar testfall som visar problemet. 4. **Testa antaganden**: Kontrollera att dina antaganden är korrekta genom att lägga till utskrifter (print statements) eller använda debuggerverktyg för att undersöka värden och variabler när koden körs. 6. **Sök efter liknande problem online**: Om du inte kan lösa problemet själv, sök efter liknande problem online. Det finns ofta forum, communities och frågesidor där andra programmerare kan ha stött på samma problem och kan erbjuda lösningar. 7. **Testa lösningar**: När du har identifierat en potentiell lösning, testa den noggrant för att se om den löser problemet. Se till att du förstår varför det fungerar, så att du kan undvika liknande problem i framtiden. 7. **Radera utskrifter när problemet är löst**: När du har identifierat och åtgärdat problemet, se till att ta bort eller kommentera ut de utskrifter som du har lagt till så att de inte längre påverkar prestanda eller läsbarhet i din kod. ### Videos Se följande videos om Programmering (inte alla riktigt GDScript för Godot 4.0 men tillräckligt nära för introduktion)