Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Creare il tuo primo script

In questa lezione, si creerà il primo script per far girare in cerchio l'icona di Godot Come abbiamo detto nell'introduzione, si presuppone che si abbiano le basi di programmazione.

Questo tutorial è scritto per GDSCript. Per comodità, il codice C# equivalente è incluso in un'altra scheda per ciascun blocco di codice.

../../_images/scripting_first_script_rotating_godot.gif

Vedi anche

Per saperne di più su GDScript, le sue parole chiave e la sua sintassi, consultare la sezione GDScript. Per saperne di più su C#, consultare la sezione C#/.NET.

Impostazione del progetto

Si prega di creare un nuovo progetto per partire da zero. Il progetto deve contenere un'immagine: l'icona di Godot, che usiamo spesso per creare prototipi nella comunità.

Abbiamo bisogno di creare un nodo Sprite2D per visualizzarlo nel gioco. Nel pannello Scene, clicca sul pulsante Other Node.

../../_images/scripting_first_script_click_other_node.webp

Scrivi "Sprite2D" nella barra di ricerca per filtrare i nodi e clicca due volte su Sprite2D per creare il nodo.

La scheda Scene dovrebbe ora contenere solo un nodo Sprite2D.

../../_images/scripting_first_script_scene_tree.webp

Un nodo Sprite2D ha bisogno di una texture da visualizzare. Nell'Inspector a destra, puoi vedere che la proprietà Texture dice <empty>. Per visualizzare l'icona di Godot, clicca e trascina il file icon.svg dal pannello FileSystem allo slot della Texture.

../../_images/scripting_first_script_setting_texture.webp

Nota

È possibile creare automaticamente nodi Sprite2D trascinando e rilasciando le immagini nella viewport.

Quindi, clicca e trascina l'icona nella viewport per centrarla nella visuale di gioco.

Creare un nuovo script

Per creare e allegare un nuovo script al nostro nodo, fai clic destro sullo Sprite2D nel pannello Scena e seleziona Attach Script.

../../_images/scripting_first_script_attach_script.webp

Appare la finestra Attach Node Script. Essa consente di selezionare il linguaggio e il percorso dello script, tra altre opzioni.

Cambia il campo Template da Node: Default a Object: Empty per partire da un file pulito. Lascia le altre opzioni impostate sui valori predefiniti e clicca sul pulsante Create per creare lo script.

../../_images/scripting_first_script_attach_node_script.webp

Nota

I nomi degli script in C# devono corrispondere al nome della classe. In questo caso, il nome del file dovrebbe essere MySprite2D.cs.

Dovrebbe apparire lo spazio di lavoro Script con il nuovo file sprite_2d.gd aperto e la seguente riga di codice:

extends Sprite2D

using Godot;
using System;

public partial class MySprite2D : Sprite2D
{
}

Ciascun file GDScript è implicitamente una classe. La parola chiave extends definisce la classe che questo script eredita o estende. In questo caso, è Sprite2D, il che significa che il nostro script potrà accedere a tutte le proprietà e le funzioni del nodo Sprite2D, incluse le classi che estende, come Node2D, CanvasItem e Node.

Nota

In GDScript, se ometti la riga con la parola chiave extends, la tua classe estenderà implicitamente RefCounted, che Godot usa per gestire la memoria della tua applicazione.

Le proprietà ereditate includono quelle che puoi vedere nel pannello Inspector, come la texture del nostro nodo.

Nota

Come predefinito, l'Inspector visualizza le proprietà di un nodo in "Title Case", usando parole con la maiuscola separate da uno spazio. Nel codice GDScript, queste proprietà sono in "snake_case", ovvero minuscolo con le parole separate da un trattino basso.

È possibile passare il cursore sul nome di una proprietà nell'Inspector per visualizzarne la descrizione e il relativo identificatore nel codice.

Hello, world!

Il nostro script al momento non fa nulla. Facciamogli stampare il testo "Hello, world" nel pannello inferiore del output per iniziare.

Aggiungi il seguente codice al tuo script:

func _init():
    print("Hello, world!")

public MySprite2D()
{
    GD.Print("Hello, world!");
}

Cerchiamo di semplificarlo. La parola chiave func definisce una nuova funzione chiamata _init. Questo è un nome speciale per il costruttore della nostra classe. Il motore chiama init() su ogni oggetto o nodo appena viene creato in memoria, se definisci questa funzione.

Nota

GDScript è un linguaggio basato sull'indentazione. La tabulazione all'inizio della riga che riporta print() è necessaria per far funzionare il codice. Se la si omette o non si indenta correttamente una riga, l'editor la evidenzierà in rosso e visualizzerà il seguente messaggio di errore: "Indented block expected".

Salva la scena come sprite_2d.tscn se non l'hai già fatto, poi premi F6 (Cmd + R su macOS) per eseguirla. Guarda il pannello inferiore Output che si espande. Dovrebbe mostrare "Hello, world!".

../../_images/scripting_first_script_print_hello_world.webp

Elimina la funzione _init(), in modo da avere solo la riga extends Sprite2D.

Girare intorno

È ora di far muovere e ruotare il nostro nodo. Per farlo, aggiungeremo due variabili membro al nostro script: la velocità di movimento, in pixel al secondo, e la velocità angolare, in radianti al secondo. Aggiungiamo quanto segue dopo la riga extends Sprite2D.

var speed = 400
var angular_speed = PI

private int _speed = 400;
private float _angularSpeed = Mathf.Pi;

Le variabili membro si trovano nella parte superiore dello script, dopo ogni riga "extends", ma prima delle funzioni. Ogni istanza di nodo a cui è allegato questo script avrà la propria copia delle proprietà speed e angular_speed.

Nota

Normalmente in Godot gli angoli sono calcolati in radianti, ma hai a disposizione funzioni e proprietà integrate, se preferisci calcolare gli angoli in gradi.

Per spostare la nostra icona, dobbiamo aggiornarne la posizione e la rotazione a ogni frame del ciclo di gioco. Possiamo utilizzare la funzione virtuale _process() della classe Node. Se la definisci in una qualsiasi classe che estende la classe Node, come Sprite2D, Godot chiamerà la funzione a ogni frame e le passerà un argomento denominato delta, che indica il tempo trascorso dall'ultimo frame.

Nota

I giochi funzionano renderizzando molte immagini al secondo, ognuna chiamata un frame, e lo fanno in un loop. Misuriamo la frequenza alla quale il gioco produce immagini in frame al secondo (FPS). La maggior parte dei videogiochi puntano a 60 FPS, anche se potresti trovare valori come 30 FPS su dispositivi più lenti, oppure tra 90 e 240 per i videogiochi in realtà virtuale.

Il motore e gli sviluppatori di gioco fanno del loro meglio per aggiornare il mondo di gioco e renderizzare le immagini a intervalli di tempo costanti, ma ci sono sempre piccole variazioni nei tempi di rendering dei frame. Ecco perché il motore ci fornisce questo valore di tempo delta, rendendo il nostro movimento indipendente dal frame rate.

In fondo allo script, definisci la funzione:

func _process(delta):
    rotation += angular_speed * delta

public override void _Process(double delta)
{
    Rotation += _angularSpeed * (float)delta;
}

La parola chiave func definisce una nuova funzione. Dopo di essa, dobbiamo scrivere il nome della funzione e gli argomenti che accetta tra parentesi. I due punti terminano la definizione e i blocchi indentati che seguono rappresentano il contenuto o le istruzioni della funzione.

Nota

Nota come _process(), così come _init(), cominci con un trattino basso. Per convenzione, le funzioni virtuali di Godot, ovvero le funzioni integrate che è possibile sovrascrivere per comunicare con il motore, cominciano con un trattino basso.

La riga all'interno della funzione, rotation += angular_speed * delta, incrementa la rotazione del nostro sprite a ogni frame. Qui, rotation è una proprietà ereditata dalla classe Node2D, che Sprite2D estende. Controlla la rotazione del nostro nodo e funziona con radianti.

Suggerimento

Nell'editor di codice, puoi premere Ctrl + Click (Cmd + Click su macOS) su qualsiasi proprietà o funzione integrata come position, rotation o _process per aprire la documentazione corrispondente in una nuova scheda.

Avvia la scena per vedere l'icona di Godot ruotare sul posto.

../../_images/scripting_first_script_godot_turning_in_place.gif

Nota

In C#, nota come l'argomento delta accettato da _Process() sia un double. Dobbiamo quindi convertirlo in float quando lo applichiamo alla rotazione.

Muovere in avanti

Ora facciamo muovere il nodo. Aggiungi le due righe seguenti dentro la funzione _process(), assicurandoti che le nuove righe abbiano la stessa indentazione della riga rotation += angular_speed * delta precedente.

var velocity = Vector2.UP.rotated(rotation) * speed

position += velocity * delta

var velocity = Vector2.Up.Rotated(Rotation) * _speed;

Position += velocity * (float)delta;

Come abbiamo già visto, la parola chiave var definisce una nuova variabile. Se inserita in cima allo script, definisce una proprietà della classe. Dentro una funzione, definisce una variabile locale: esiste solo dentro l'ambito della funzione.

Definiamo una variabile locale chiamata velocity, un vettore 2D che rappresenta sia la direzione sia la velocità. Per far muovere il nodo in avanti, partiamo dalla costante Vector2.UP della classe Vector2, un vettore che punta verso l'alto, e lo ruotiamo chiamando il metodo rotated() di Vector2. Questa espressione, Vector2.UP.rotated(rotation), è un vettore che punta in avanti rispetto alla nostra icona. Moltiplicata per la nostra proprietà speed, otteniamo la velocità che possiamo usare per muovere il nodo in avanti.

Aggiungiamo velocity * delta alla position del nodo per spostarlo. La posizione stessa è di tipo Vector2, un tipo integrato in Godot che rappresenta un vettore 2D.

Esegui la scena per vedere la testa di Godot girare in tondo.

Nota

Spostare un nodo in questo modo non tiene conto delle collisioni con muri o pavimento. In Il tuo primo gioco 2D, imparerai un altro approccio per spostare gli oggetti mentre si rilevano le collisioni.

Il nostro nodo al momento si muove da solo. Nella prossima parte, Ascoltare l'input del giocatore, useremo l'input del giocatore per controllarlo.

Script completo

Ecco il file sprite_2d.gd completo per riferimento.

extends Sprite2D

var speed = 400
var angular_speed = PI

func _process(delta):
    rotation += angular_speed * delta

    var velocity = Vector2.UP.rotated(rotation) * speed

    position += velocity * delta

using Godot;
using System;

public partial class MySprite2D : Sprite2D
{
    private int _speed = 400;
    private float _angularSpeed = Mathf.Pi;

    public override void _Process(double delta)
    {
        Rotation += _angularSpeed * (float)delta;
        var velocity = Vector2.Up.Rotated(Rotation) * _speed;

        Position += velocity * (float)delta;
    }
}