La escena principal del juego¶

Ahora es el momento de reunir todo lo que hicimos en una escena de juego jugable.

Create a new scene and add a Node named Main. (The reason we are using Node instead of Node2D is because this node will be a container for handling game logic. It does not require 2D functionality itself.)

Click the Instance button (represented by a chain link icon) and select your saved Player.tscn.

Ahora agrega los siguientes nodos como hijos de Main, y nómbralos como se muestra (los valores son en segundos):

Timer (llamado MobTimer) - para controlar cuán seguido aparecerán los enemigos
Timer (llamado ScoreTimer) - para incrementar el puntaje cada segundo
Timer (llamado StartTimer) - para crear una retardo antes de comenzar
Position2D (llamado StartPosition) - para indicar la posición inicial del jugador

Ajustar la propiedad Wait Time (tiempo de espera) de cada nodo Timer como se indica:

MobTimer: 0.5
ScoreTimer: 1
StartTimer: 2

Además, marca la propiedad One Shot (una vez) como "Activado" y ajusta la propiedad Position del nodo StartPosition en (250,450).

Agregando enemigos¶

El nodo Main generará los nuevos enemigos, y queremos que aparezcan en una ubicación al azar en el borde de la pantalla. Agregue un nodo Path2D llamado MobPath como hijo de Main. Cuando seleccione Path2D, verá que aparecen nuevos botones en la parte de arriba del editor:

Selecciona el botón del medio ("Añadir Punto") y dibuja el camino haciendo clic para agregar los puntos en las esquinas como se muestra. Para tener los puntos ajustados a la cuadrícula, asegúrate de tener marcado "Ajustar a cuadrícula". Esta opción se encuentra a la izquierda del botón "Bloquear", que aparece como un imán al lado de las líneas de intersección.

Importante

Dibuja la ruta en el sentido de las agujas del reloj ¡o tus enemigos apuntarán hacia afuera en lugar de hacia adentro!

Después de colocar el punto 4, haz clic en el botón "Cerrar Curva" y la curva se completará.

Ahora que el camino está definido, agrega un nodo PathFollow2D como hijo de MobPath y nómbralo MobSpawnLocation. Este nodo rotará automáticamente y seguirá el camino mientras se mueve, así podemos usarlo para seleccionar una posición al azar y una dirección a lo largo del camino.

Tu escena debería verse así:

Script Principal¶

Agrega un script a Main. Al principio del script usaremos export (PackedScene) para permitirnos elegir la escena de enemigos que queremos instanciar.

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

También agregamos una llamada a randomize() aquí para que el generador de números aleatorios genere diferentes números aleatorios cada vez que se ejecuta el juego:

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".

Puedes asignar el valor de esta propiedad de dos maneras:

Arrastra Mob.tscn``del panel "Sistema de Archivos" y suéltalo en la propiedad ``Mob.
Haga clic en la flecha hacia abajo junto a "[empty]" y elija "Load". Selecciona Mob.tscn.

A continuación selecciona el nodo Player en el panel de escenas y accede al panel Nodo en la barra lateral. Asegúrate de tener seleccionada la pestaña Señales.

Deberías ver una lista de señales para el nodo Player. Busca la señal hit en la lista y haz doble clic en esta (o clic derecho y selecciona "Conectar..."). Esto abrirá el diálogo de conexión. Haremos una nueva función llamada game_over, la que ejecutará lo que debe suceder cuando el juego termina. Escribe "game_over" en el campo "Método receptor" en la parte inferior de la ventana y haz clic en "Conectar". Agrega el siguiente código a la nueva función, así como una función new_game que configurará todo en un juego nuevo:

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();
}

Ahora conecta la señal timeout() de cada uno de los nodos Timer (StartTimer, ScoreTimer y MobTimer) al script de Main. StartTimer iniciará los otros dos temporizadores. ScoreTimer incrementará la puntuación en 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).

Observa que añadiremos la nueva instancia a la escena usando add_child().

func _on_MobTimer_timeout():
    # Create a new instance of the Mob scene.
    var mob = mob_scene.instance()

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

    # 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 for the mob.
    var velocity = Vector2(rand_range(150.0, 250.0), 0.0)
    mob.linear_velocity = velocity.rotated(direction)

    # Spawn the mob by adding it to the Main scene.
    add_child(mob)

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 Mob and PathFollow2D, since they appear later on the line.

    // Create a new instance of the Mob scene.
    var mob = (Mob)MobScene.Instance();

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

    // 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);

    // Spawn the mob by adding it to the Main scene.
    AddChild(mob);
}

// This code goes in `main.cpp`.
void Main::_on_MobTimer_timeout() {
    // Create a new instance of the Mob scene.
    godot::Node *mob = mob_scene->instance();

    // Choose a random location on Path2D.
    _mob_spawn_location->set_offset((real_t)_random->randi());

    // 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));

    // Spawn the mob by adding it to the Main scene.
    add_child(mob);
}

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.

Probando la escena¶

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();
}

También asignemos Principal como nuestra Escena Principal, la que se ejecuta automáticamente cuando se lanza el juego. Presiona el botón "Play" y selecciona Main.tscn cuando se te pida.

Truco

If you had already set another scene as the "Main Scene", you can right click Main.tscn in the FileSystem dock and select "Set As Main Scene".

Deberías poder mover al jugador alrededor, ver a los mobs creándose, y ver al jugador desaparecer cuando es golpeado por un mob.

Cuando estés seguro de que todo funciona, quita la llamada a new_game() de ready().

¿Qué le falta a nuestro juego? Alguna interfaz de usuario. En la siguiente lección, agregaremos una pantalla de título y mostraremos la puntuación del jugador.