The main game scene¶

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

Utwórz nową scenę i dodaj a Node o nazwie Main. (Powodem, dla którego używamy Node zamiast Node2D jest to, że węzeł ten będzie kontenerem zajmującym się logiką gry. Sam nie wymaga funkcjonalności 2D.)

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

Następnie dodaj następujące węzły jako dzieci sceny Main i nazwij je tak, jak pokazano na rysunku (wartości są podane w sekundach):

Timer (o nazwie MobTimer) - czasomierz do kontroli częstotliwości tworzenia przeciwników
Timer (o nazwie ScoreTimer) - czasomierz mający co sekundę zwiększać liczbę zdobytych punktów
Timer (o nazwie StartTimer) - czasomierz służący podaniu opóźnienia przed rozpoczęciem
Position2D (o nazwie StartPosition) - wyznacznik pozycji startowej gracza

Ustawić właściwość Czas oczekiwania każdego z węzłów Timer w następujący sposób:

MobTimer: 0.5
ScoreTimer: 1
StartTimer: 2

Dodatkowo, ustawmy właściwość One Shot w StartTimer na "Włącz" i ustaw właściwość Position z węzła StartPosition na (240, 450) (znajduje się pod Transform w Inspektorze).

Tworzenie przeciwników¶

Węzeł główny Main odpowiadał będzie za tworzenie nowych przeciwników. Chcemy, aby pojawiali się oni w losowych miejscach na krawędzi ekranu. Dodajmy węzeł Path2D o nazwie MobPath jako dziecko Main. Po wybraniu Path2D na górze edytora pojawi się kilka nowych przycisków:

Wybierzmy środkowy z nich ("Dodaj Punkt") i narysujmy ścieżkę - kliknijmy w każdy z czterech rogów, aby dodawać w nich punkty. Aby punkty były wyrównane do siatki, zaznaczona musi być opcja "Użyj przyciągania do siatki". Opcję tę można znaleźć na lewo przycisku "Opcje przyciągania", którego ikonka to trzy pionowo ułożone kropki.

Ważne

Narysuj ścieżkę zgodnie z ruchem zegara, albo twoi przeciwnicy będą tworzyli się na zewnątrz zamiast do wewnątrz!

Po umieszczeniu punktu 4, kliknijmy przycisk "Zamknij krzywą", a krzywa zostanie ukończona.

Teraz, gdy ścieżka jest zdefiniowana, dodaj węzeł PathFollow2D <class_PathFollow2D>`jako dziecko ``MobPath` i nazwij go MobSpawnLocation. Węzeł ten będzie automatycznie obracał się i podążał ścieżką, tak abyśmy mogli go wykorzystać do wybrania losowego położenia i kierunku wzdłuż ścieżki.

Twoja scena powinna wyglądać tak:

Główny skrypt¶

Dodaj skrypt do Main. W górnej części skryptu używamy export (PackedScene), aby umożliwić nam wybór sceny Mob(Przeciwnika), którą chcemy wyświetlić.

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

Możesz przypisać wartość dla tej właściwości na dwa sposoby:

Drag Mob.tscn from the "FileSystem" dock and drop it in the Mob Scene property.
Naciśnij strzałkę w dół obok "[empty]" i wybierz "Wczytaj". Następnie wybierz Mob.tscn.

Następnie zaznacz węzeł Gracz na drzewie węzłów i wybierz kartę "Węzeł" na pasku bocznym. upewnij się, że wybrano opcję "Sygnały".

Powinieneś widzieć listę sygnałów dla węzła Player `` Znajdź i dwukrotnie kliknij (Lub kliknij prawym przyciskiem myszy i kliknij "Połącz...") sygnał``hit. To otworzy okno łączenia sygnału. Chcemy stworzyć nową funkcję o nazwie game_over, która będzie obsługiwać to, co musi się zdarzyć, gdy gra się skończy. Wpisz "game_over" w polu "Metoda odbiorcy" u dołu okna łączenia sygnału i kliknij "Połącz". Dodaj następujący kod do nowej funkcji, jak również funkcję new_game, która skonfiguruje wszystko do nowej gry:

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

Teraz podłącz sygnał timeout() do każdego z węzłów Timer (Czasomierz) (StartTimer,``ScoreTimer``, i MobTimer) do głównego skryptu StartTimer uruchomi dwa pozostałe timery. ScoreTimer zwiększy wynik o 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).

Nowa instancja musi być dodana do sceny za pomocą 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);
}

Ważne

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.

Testowanie sceny¶

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

Ustawmy również Main jako naszą główną scenę - czyli taką, która jest automatycznie uruchamiana jako pierwsza po starcie gry. Naciśnij przycisk "Uruchom" i w oknie dialogowym wybierz plik Main.tscn.

Wskazówka

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

Powinieneś móc poruszać postacią gracza, widzieć pojawiające się potwory i znikającą postać gracza, gdy zostanie uderzona przez potwora.

Jeśli jesteś pewien, że wszystko działa tak, jak powinno, usuń wywołanie metody new_game() z _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.