Creare il tuo primo script
In this lesson, you will code your first script to make the Godot icon turn in circles. As we mentioned in the introduction, we assume you have programming foundations.
This tutorial is written for GDScript, and the equivalent C# code is included in another tab of each codeblock for convenience.
Vedi anche
To learn more about GDScript, its keywords, and its syntax, head to the GDScript section. To learn more about C#, head to the C#/.NET section.
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à.
We need to create a Sprite2D node to display it in the game. In the Scene dock, click the Other Node button.
Scrivi "Sprite2D" nella barra di ricerca per filtrare i nodi e clicca due volte su Sprite2D per creare il nodo.
La scheda Scena dovrebbe ora contenere solo un nodo Sprite2D.
A Sprite2D node needs a texture to display. In the Inspector on the right, you
can see that the Texture property says <empty>. To display the Godot icon,
click and drag the file icon.svg from the FileSystem dock onto the Texture
slot.
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
To create and attach a new script to our node, right-click on Sprite2D in the Scene dock and select Attach Script.
The Attach Node Script window appears. It allows you to select the script's language and file path, among other options.
Change the Template field from Node: Default to Object: Empty to
start with a clean file. Leave the other options set to their default values and
click the Create button to create the script.
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
{
}
Every GDScript file is implicitly a class. The extends keyword defines the
class this script inherits or extends. In this case, it's Sprite2D, meaning
our script will get access to all the properties and functions of the Sprite2D
node, including classes it extends, like Node2D, CanvasItem, and
Node.
Nota
In GDScript, if you omit the line with the extends keyword, your
class will implicitly extend RefCounted, which
Godot uses to manage your application's memory.
Le proprietà ereditate includono quelle che puoi vedere nel pannello Ispettore, come la texture del nostro nodo.
Nota
Come predefinito, l'Ispettore visualizza le proprietà di un nodo in "Title Case", con le parole in maiuscolo 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'Ispettore 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!".
Elimina la funzione _init(), in modo da avere solo la riga extends Sprite2D.
Turning around
È 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
In the code editor, you can Ctrl + Click (Cmd + Click on
macOS) on any built-in property or function like position,
rotation, or _process to open the corresponding documentation
in a new tab.
Avvia la scena per vedere l'icona di Godot ruotare sul posto.
Nota
In C#, nota come l'argomento delta accettato da _Process() sia un double. Dobbiamo quindi convertirlo in float quando lo applichiamo alla rotazione.
Moving forward
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;
}
}