A cena principal do jogo¶
Agora é hora de juntar tudo que fizemos em uma cena jogável.
Crie uma nova cena e adicione um :ref: Node <class_Node> chamado Main
. (O motivo para usarmos um Node ao invés deum Node2D é que esse será um recipiente para lidar com a lógica do jogo, por si ele não necessita de funcionalidade 2D.)
Clique no botão Instância (representado por um ícone de elo de corrente) e selecione seu Player.tscn
salvo.
Agora adicione os seguintes nós como filhos de Principal
, e os nomeie como mostrado (os valores estão em segundos):
Timer (nomeado
MobTimer
) - para controlar a frequência com que a turba é geradaTimer (nomeado
ScoreTimer
) - para incrementar a pontuação a cada segundoTimer (nomeado
StartTimer
) - para dar um atraso antes de começarPosition2D (nomeado
StartPosition
) - para indicar a posição inicial do jogador
Defina a propriedade Wait Time
(tempo de espera) para cada um dos nós Timer
da seguinte forma:
MobTimer
:0.5
ScoreTimer
:1
StartTimer
:2
Além disso, configure a propriedade One Shot
("uma só vez") de StartTimer
para "Ativo" e Position
do nó StartPosition
para (240, 450)
.
Gerando monstros¶
O nó Principal ficará gerando novos inimigos, e nós queremos que eles apareçam em lugares aleatórios nos cantos da tela. Adicione um nó Path2D chamado CaminhoTurba
como filho de Principal
. Quando você selecionar Path2D
, aparecerão alguns botões novos na parte superior do editor:
Selecione o do meio ("Adicionar Ponto") e desenhe o caminho clicando para adicionar os pontos nos cantos mostrados. Para que os pontos fiquem alinhados à grade, verifique se a opção <b>Encaixar na Grade</b> está marcada. Essa opção pode ser encontrada à esquerda do botão "Travar", parecido como um ímã e ao lado de uma série de 3 pontos verticais.
Importante
Desenhe o caminho em sentido horário, ou sua turba vai surgir apontando para fora em vez de para dentro!
Depois de colocar o ponto 4
na imagem, clique no botão "Fechar Curva", e sua curva estará completa.
Agora que o caminho está definido, adicione um nó PathFollow2D como filho de CaminhoTurba
e dê o nome de LocalGeraçãoTurba
. Esse nó vai rotacionar automaticamente e seguir o caminho conforme ele se move, para que possamos usá-lo para selecionar uma posição e uma direção aleatória ao longo do caminho.
Sua cena deve se parecer com isso:
Script principal¶
Adicione um roteiro a Principal
. No começo do script, nós usamos export (PackedScene)
para permitir-nos escolher a cena Inimigo 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
Também adicionamos uma chamada para randomize()
aqui para que o gerador de números aleatórios gere diferentes números aleatórios cada vez que o jogo é executado:
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();
}
Clique no nó Principal``e você verá a propriedade ``Cena Mob
no inspetor, abaixo das Variáveis do Script
.
Você pode atribuir o valor dessa propriedade de duas formas:
Arraste
Mob.tscn
do painel "Sistema de Arquivos" e solte-o na propriedadeCena Mob
.Clique na seta para baixo ao lado de "[vazio]" e escolha "Carregar". Selecione
Mob.tscn
.
Em seguida, selecione o nó do Player
no painel Cena, e acesse o nó na barra lateral. Certifique-se de selecionar a aba Sinais no Painel de nós.
Você deve ver uma lista de sinais para o nó Player
. Em seguida, encontre e dê dois cliques no sinal hit
da lista (ou clique com o botão direito e selecione "Conectar..."). Isso abrirá a caixa de diálogo de conexão de sinal. Queremos criar uma função chamada game_over
, que lidará com tudo o que precisa acontecer quando um jogo acaba. Digite "game_over" na caixa "Método no Nó" na parte inferior da janela de conexão de sinal e clique em "Conectar". Adicione o código a seguir à nova função, assim como uma função new_game
(novo jogo) para definir tudo para um novo jogo:
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();
}
Agora, conecte o sinal timeout()
de cada um dos nós de Timer (StartTimer
, ScoreTimer
, e``MobTimer``) para o script principal. StartTimer
irá iniciar os outros dois temporizadores. ScoreTimer
irá incrementar a pontuação em 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);
}
Em _on_MobTimer_timeout()
, criaremos uma instância do mob, escolheremos um local inicial aleatório ao longo do Path2D
e colocaremos o inimigo em movimento. O nó PathFollow2D
irá girar automaticamente enquanto segue o caminho, então vamos usar isso para selecionar a direção do inimigo, bem como sua posição. Quando geramos um inimigo, vamos escolher um valor aleatório entre 150.0
e 250.0
para quão rápido cada inimigo irá se mover (seria chato se todos estivessem se movendo na mesma velocidade).
Note que uma nova instância deve ser adicionada à cena usando add_child()
(adicionar filho).
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
Por que PI
? Em funções que requerem ângulos, Godot usa radianos, não graus. Pi representa meia volta em radianos, cerca de 3.1415
(existe também TAU
que é igual a 2 * PI
). Se você estiver mais confortável trabalhando com graus, você precisará usar as funções deg2rad()
e rad2deg()
para converter entre os dois.
Testando a cena¶
Vamos testar a cena para garantir que tudo esta funcionando. Adicione essa chamada new_game{
ao _ready()
:
func _ready():
randomize()
new_game()
public override void _Ready()
{
NewGame();
}
// This code goes in `main.cpp`.
void Main::_ready() {
new_game();
}
Vamos também atribuir Main
como nossa "Cena Principal" - aquela que é executada automaticamente quando o jogo é iniciado. Pressione o botão "Reproduzir" e selecione `` Main.tscn`` quando solicitado.
Dica
Caso você já tenha configurado outra cena como a "Main Scene" (Cena Principal), você pode clicar com o botão direito em ``Main.tscn``no Gerenciador de Arquivos e selecionar "Atribuir como Cena Principal".
Você deve ser capaz de mover o jogador, ver os inimigos nascendo, e ver o jogador desaparecer quando atingido por um inimigo.
Quando tiver certeza que tudo esta funcionando, remova a chamada de new_game()
em _ready()
.
O que nos falta? Uma interface de usuário! Na próxima lição, nós adicionaremos uma tela de título e mostraremos a pontuação do jogador.