The main game scene¶

Now it's time to bring everything we did together into a playable game scene.

Create a new scene and add a Node named Main. Ensure you create a Node, not a Node2D. Click the "Instance" button and select your saved Player.tscn.

Ora, aggiungi i seguenti nodi come figli di Main, e rinominali come mostrato (i valori sono in secondi):

Timer (chiamato MobTimer) - per controllare la frequenza con cui i mob si generano
Timer (chiamato ScoreTimer) - per incrementare il punteggio ogni secondo
Timer (chiamato StartTimer) - per dare un ritardo prima di iniziare
Position2D (chiamato``StartPosition``) - per indicare la posizione di partenza del giocatore

Imposta la proprietà Wait Time di ciascuno dei nodi Timer come segue:

MobTimer: 0.5
ScoreTimer: 1
StartTimer: 2

In addition, set the One Shot property of StartTimer to "On" and set Position of the StartPosition node to (240, 450).

Generazione dei Mostri¶

Il nodo Main genererà nuovi mob, e vogliamo che appaiano in una posizione casuale sul bordo dello schermo. Aggiungi un nodo Path2D chiamato MobPath come figlio di Main. Quando selezioni Path2D, vedrai alcuni nuovi pulsanti nella parte superiore dell'editor:

Seleziona quello centrale ("Add Point") e disegna il percorso cliccando per aggiungere i punti agli angoli mostrati. Per fare in modo che i punti si aggancino alla griglia, assicurati che "Use Grid Snap" e "Use Snap" siano entrambi selezionati. Queste opzioni si trovano a sinistra del pulsante "Blocca", che appare come un magnete accanto ad alcuni punti e linee che si intersecano, rispettivamente.

Importante

Disegna il percorso in ordine orario, o i tuoi nemici verranno generati verso l'esterno invece che verso l'interno!

Dopo aver posizionato il punto 4 nell'immagine, fare clic sul pulsante "Chiudi curva" e la curva sarà completa.

Ora che il percorso è definito, aggiungere un nodo :ref:'PathFollow2D <class_PathFollow2D>' come figlio di ''MobPath'' e denominarlo ''MobSpawnLocation''. Questo nodo ruoterà automaticamente e seguirà il percorso mentre si muove, quindi possiamo usarlo per selezionare una posizione e una direzione casuali lungo il percorso.

La tua scena dovrebbe assomigliare a questa:

Script principale¶

Aggiungi uno script a `` Main``. Nella parte superiore, utilizziamo export (PackedScene) per permetterci di scegliere la scena Mob che vogliamo istanziare.

extends Node

export(PackedScene) var mob_scene
var score

public class Main : Node
{
    // Don't forget to rebuild the project so the editor knows about the new export variable.

#pragma warning disable 649
    // We assign this in the editor, so we don't need the warning about not being assigned.
    [Export]
    public PackedScene MobScene;
#pragma warning restore 649

    public int Score;
}

// Copy `player.gdns` to `main.gdns` and replace `Player` with `Main`.
// Attach the `main.gdns` file to the Main node.

// Create two files `main.cpp` and `main.hpp` next to `entry.cpp` in `src`.
// This code goes in `main.hpp`. We also define the methods we'll be using here.
#ifndef MAIN_H
#define MAIN_H

#include <AudioStreamPlayer.hpp>
#include <CanvasLayer.hpp>
#include <Godot.hpp>
#include <Node.hpp>
#include <PackedScene.hpp>
#include <PathFollow2D.hpp>
#include <RandomNumberGenerator.hpp>
#include <Timer.hpp>

#include "hud.hpp"
#include "player.hpp"

class Main : public godot::Node {
    GODOT_CLASS(Main, godot::Node)

    int score;
    HUD *_hud;
    Player *_player;
    godot::Node2D *_start_position;
    godot::PathFollow2D *_mob_spawn_location;
    godot::Timer *_mob_timer;
    godot::Timer *_score_timer;
    godot::Timer *_start_timer;
    godot::AudioStreamPlayer *_music;
    godot::AudioStreamPlayer *_death_sound;
    godot::Ref<godot::RandomNumberGenerator> _random;

public:
    godot::Ref<godot::PackedScene> mob_scene;

    void _init() {}
    void _ready();
    void game_over();
    void new_game();
    void _on_MobTimer_timeout();
    void _on_ScoreTimer_timeout();
    void _on_StartTimer_timeout();

    static void _register_methods();
};

#endif // MAIN_H

We also add a call to randomize() here so that the random number generator generates different random numbers each time the game is run:

func _ready():
    randomize()

public override void _Ready()
{
    GD.Randomize();
}

// This code goes in `main.cpp`.
#include "main.hpp"

#include <SceneTree.hpp>

#include "mob.hpp"

void Main::_ready() {
    _hud = get_node<HUD>("HUD");
    _player = get_node<Player>("Player");
    _start_position = get_node<godot::Node2D>("StartPosition");
    _mob_spawn_location = get_node<godot::PathFollow2D>("MobPath/MobSpawnLocation");
    _mob_timer = get_node<godot::Timer>("MobTimer");
    _score_timer = get_node<godot::Timer>("ScoreTimer");
    _start_timer = get_node<godot::Timer>("StartTimer");
    // Uncomment these after adding the nodes in the "Sound effects" section of "Finishing up".
    //_music = get_node<godot::AudioStreamPlayer>("Music");
    //_death_sound = get_node<godot::AudioStreamPlayer>("DeathSound");
    _random = (godot::Ref<godot::RandomNumberGenerator>)godot::RandomNumberGenerator::_new();
    _random->randomize();
}

Click the Main node and you will see the Mob Scene property in the Inspector under "Script Variables".

Puoi assegnare il valore di questa proprietà in due modi:

Trascina Mob.tscn dal pannello "FileSystem" e lasciatelo nella proprietà Mob .
Clicca la freccia rivolta verso il basso accanto a "[empty]" e scegli "Load". Seleziona Mob.tscn.

Quindi, seleziona il nodo Player nel dock Scene e accedi al dock Nodo sulla barra laterale. Assicurati di avere la scheda Segnali selezionata nel dock Nodo.

You should see a list of the signals for the Player node. Find and double-click the hit signal in the list (or right-click it and select "Connect..."). This will open the signal connection dialog. We want to make a new function named game_over, which will handle what needs to happen when a game ends. Type "game_over" in the "Receiver Method" box at the bottom of the signal connection dialog and click "Connect". Add the following code to the new function, as well as a new_game function that will set everything up for a new game:

func game_over():
    $ScoreTimer.stop()
    $MobTimer.stop()

func new_game():
    score = 0
    $Player.start($StartPosition.position)
    $StartTimer.start()

public void GameOver()
{
    GetNode<Timer>("MobTimer").Stop();
    GetNode<Timer>("ScoreTimer").Stop();
}

public void NewGame()
{
    Score = 0;

    var player = GetNode<Player>("Player");
    var startPosition = GetNode<Position2D>("StartPosition");
    player.Start(startPosition.Position);

    GetNode<Timer>("StartTimer").Start();
}

// This code goes in `main.cpp`.
void Main::game_over() {
    _score_timer->stop();
    _mob_timer->stop();
}

void Main::new_game() {
    score = 0;
    _player->start(_start_position->get_position());
    _start_timer->start();
}

Collega ora il segnale timeout() di ciascuno dei nodi Timer (StartTimer, ScoreTimer e MobTimer) allo script principale. StartTimer avvierà gli altri due timer. ScoreTimer incrementerà il punteggio di 1.

func _on_ScoreTimer_timeout():
    score += 1

func _on_StartTimer_timeout():
    $MobTimer.start()
    $ScoreTimer.start()

public void OnScoreTimerTimeout()
{
    Score++;
}

public void OnStartTimerTimeout()
{
    GetNode<Timer>("MobTimer").Start();
    GetNode<Timer>("ScoreTimer").Start();
}

// This code goes in `main.cpp`.
void Main::_on_ScoreTimer_timeout() {
    score += 1;
}

void Main::_on_StartTimer_timeout() {
    _mob_timer->start();
    _score_timer->start();
}

// Also add this to register all methods and the mob scene property.
void Main::_register_methods() {
    godot::register_method("_ready", &Main::_ready);
    godot::register_method("game_over", &Main::game_over);
    godot::register_method("new_game", &Main::new_game);
    godot::register_method("_on_MobTimer_timeout", &Main::_on_MobTimer_timeout);
    godot::register_method("_on_ScoreTimer_timeout", &Main::_on_ScoreTimer_timeout);
    godot::register_method("_on_StartTimer_timeout", &Main::_on_StartTimer_timeout);
    godot::register_property("mob_scene", &Main::mob_scene, (godot::Ref<godot::PackedScene>)nullptr);
}

In _on_MobTimer_timeout(), we will create a mob instance, pick a random starting location along the Path2D, and set the mob in motion. The PathFollow2D node will automatically rotate as it follows the path, so we will use that to select the mob's direction as well as its position. When we spawn a mob, we'll pick a random value between 150.0 and 250.0 for how fast each mob will move (it would be boring if they were all moving at the same speed).

Nota che una nuova istanza deve essere aggiunta alla scena usando add_child().

func _on_MobTimer_timeout():
    # Choose a random location on Path2D.
    var mob_spawn_location = get_node("MobPath/MobSpawnLocation");
    mob_spawn_location.offset = randi()

    # Create a Mob instance and add it to the scene.
    var mob = mob_scene.instance()
    add_child(mob)

    # Set the mob's direction perpendicular to the path direction.
    var direction = mob_spawn_location.rotation + PI / 2

    # Set the mob's position to a random location.
    mob.position = mob_spawn_location.position

    # Add some randomness to the direction.
    direction += rand_range(-PI / 4, PI / 4)
    mob.rotation = direction

    # Choose the velocity.
    var velocity = Vector2(rand_range(150.0, 250.0), 0.0)
    mob.linear_velocity = velocity.rotated(direction)

public void OnMobTimerTimeout()
{
    // Note: Normally it is best to use explicit types rather than the `var`
    // keyword. However, var is acceptable to use here because the types are
    // obviously PathFollow2D and Mob, since they appear later on the line.

    // Choose a random location on Path2D.
    var mobSpawnLocation = GetNode<PathFollow2D>("MobPath/MobSpawnLocation");
    mobSpawnLocation.Offset = GD.Randi();

    // Create a Mob instance and add it to the scene.
    var mob = (Mob)MobScene.Instance();
    AddChild(mob);

    // Set the mob's direction perpendicular to the path direction.
    float direction = mobSpawnLocation.Rotation + Mathf.Pi / 2;

    // Set the mob's position to a random location.
    mob.Position = mobSpawnLocation.Position;

    // Add some randomness to the direction.
    direction += (float)GD.RandRange(-Mathf.Pi / 4, Mathf.Pi / 4);
    mob.Rotation = direction;

    // Choose the velocity.
    var velocity = new Vector2((float)GD.RandRange(150.0, 250.0), 0);
    mob.LinearVelocity = velocity.Rotated(direction);
}

// This code goes in `main.cpp`.
void Main::_on_MobTimer_timeout() {
    // Choose a random location on Path2D.
    _mob_spawn_location->set_offset((real_t)_random->randi());

    // Create a Mob instance and add it to the scene.
    godot::Node *mob = mob_scene->instance();
    add_child(mob);

    // Set the mob's direction perpendicular to the path direction.
    real_t direction = _mob_spawn_location->get_rotation() + (real_t)Math_PI / 2;

    // Set the mob's position to a random location.
    mob->set("position", _mob_spawn_location->get_position());

    // Add some randomness to the direction.
    direction += _random->randf_range((real_t)-Math_PI / 4, (real_t)Math_PI / 4);
    mob->set("rotation", direction);

    // Choose the velocity for the mob.
    godot::Vector2 velocity = godot::Vector2(_random->randf_range(150.0, 250.0), 0.0);
    mob->set("linear_velocity", velocity.rotated(direction));
}

Importante

Why PI? In functions requiring angles, Godot uses radians, not degrees. Pi represents a half turn in radians, about 3.1415 (there is also TAU which is equal to 2 * PI). If you're more comfortable working with degrees, you'll need to use the deg2rad() and rad2deg() functions to convert between the two.

Testare la scena¶

Let's test the scene to make sure everything is working. Add this new_game call to _ready():

func _ready():
    randomize()
    new_game()

public override void _Ready()
{
    NewGame();
}

// This code goes in `main.cpp`.
void Main::_ready() {
    new_game();
}

Assegniamo anche Main come nostra "Scena principale" - quella che viene eseguita automaticamente al lancio del gioco. Premi il pulsante "Play" e seleziona Main.tscn quando richiesto.

Dovresti essere in grado di muovere il giocatore, vedere i nemici che vengono generati e vedere il giocatore scomparire quando viene colpito da uno di essi.

Quando sei sicuro che tutto funzioni, rimuovi la chiamata a new_game() da _ready().

What's our game lacking? Some user interface. In the next lesson, we'll add a title screen and display the player's score.