summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--scripts/Game.cs30
-rw-r--r--scripts/InputHandler.cs4
-rw-r--r--scripts/Utils/Grid.cs6
-rw-r--r--scripts/actors/AI/BaseAI.cs19
-rw-r--r--scripts/actors/AI/HostileEnemyAI.cs26
-rw-r--r--scripts/actors/Actor.cs63
-rw-r--r--scripts/actors/ActorDefinition.cs9
-rw-r--r--scripts/actors/Enemy.cs20
-rw-r--r--scripts/actors/EnemyDefinition.cs3
-rw-r--r--scripts/actors/Player.cs3
-rw-r--r--scripts/actors/actions/Action.cs24
-rw-r--r--scripts/actors/actions/BumpAction.cs10
-rw-r--r--scripts/actors/actions/DirectionalAction.cs15
-rw-r--r--scripts/actors/actions/MeleeAction.cs12
-rw-r--r--scripts/actors/actions/MovementAction.cs9
-rw-r--r--scripts/map/DungeonGenerator.cs88
-rw-r--r--scripts/map/FieldOfView.cs2
-rw-r--r--scripts/map/Map.cs32
-rw-r--r--scripts/map/MapData.cs95
-rw-r--r--scripts/map/MapDivision.cs37
-rw-r--r--scripts/map/Tile.cs32
-rw-r--r--scripts/map/TileDefinition.cs4
22 files changed, 513 insertions, 30 deletions
diff --git a/scripts/Game.cs b/scripts/Game.cs
index 818b064..3a70e0c 100644
--- a/scripts/Game.cs
+++ b/scripts/Game.cs
@@ -1,9 +1,22 @@
using Godot;
-using System;
+
+/// <summary>
+/// Classe principal do jogo.
+/// Lar da lógica central do jogo.
+/// </summary>
public partial class Game : Node {
+ /// <summary>
+ /// Definição de um jogador.
+ /// </summary>
private static readonly ActorDefinition playerDefinition = GD.Load<ActorDefinition>("res://assets/definitions/actor/Player.tres");
+ /// <summary>
+ /// O jogo possui o mapa.
+ /// </summary>
private Map Map;
+ /// <summary>
+ /// Objeto para obter input do usuário.
+ /// </summary>
private InputHandler inputHandler;
public override void _Ready() {
@@ -13,6 +26,7 @@ public partial class Game : Node {
inputHandler = GetNode<InputHandler>("InputHandler");
+ // O jogador é criado pelo jogo.
Player player = new Player(Vector2I.Zero, null, playerDefinition);
Camera2D camera = GetNode<Camera2D>("Camera2D");
RemoveChild(camera);
@@ -24,26 +38,40 @@ public partial class Game : Node {
Map.UpdateFOV(player.GridPosition);
}
+ /// <summary>
+ /// Método executa aproximadamente 60 vezes por segundo.
+ /// </summary>
+ /// <param name="delta"></param>
public override void _PhysicsProcess(double delta) {
base._PhysicsProcess(delta);
Player player = Map.Map_Data.Player;
+ // Pegamos uma ação do usuário
Action action = inputHandler.GetAction(player);
+ // Se realmente houve uma ação, computamos um turno.
if (action != null) {
Vector2I previousPlayerPos = player.GridPosition;
+ // Primeiro executamos a ação do jogador
action.Perform();
+ // Depois computamos os turnos dos outros atores.
HandleEnemyTurns();
+ // Por fim, se o jogador mudou de lugar, atualizamos seu campo de visão.
if (player.GridPosition != previousPlayerPos) {
Map.UpdateFOV(player.GridPosition);
}
}
}
+ /// <summary>
+ /// Executa um turno para cada ator no mapa.
+ /// </summary>
private void HandleEnemyTurns() {
foreach (Actor actor in Map.Map_Data.Actors) {
if (actor is Player) continue;
+ // Se o ator for um inimigo e estiver vivo, deixamos
+ // que sua IA faça um turno.
if (actor is Enemy enemy && enemy.IsAlive) {
enemy.Soul.Perform();
}
diff --git a/scripts/InputHandler.cs b/scripts/InputHandler.cs
index 807ec83..b3c7018 100644
--- a/scripts/InputHandler.cs
+++ b/scripts/InputHandler.cs
@@ -1,6 +1,8 @@
using Godot;
-using System;
+/// <summary>
+/// Obtém input do usuário.
+/// </summary>
public partial class InputHandler : Node {
public Action GetAction(Player player) {
Action action = null;
diff --git a/scripts/Utils/Grid.cs b/scripts/Utils/Grid.cs
index cde01f6..271f559 100644
--- a/scripts/Utils/Grid.cs
+++ b/scripts/Utils/Grid.cs
@@ -1,6 +1,12 @@
using Godot;
using System;
+/// <summary>
+/// Classe utilitária para converter coordenadas da malha dos tiles
+/// em coordenadas em pixels.
+/// Esta classe é necessária porque o Godot trata posições em pixels,
+/// mas faz mais sentido tratarmos as posições em tiles.
+/// </summary>
public abstract partial class Grid : GodotObject {
public static readonly Vector2I tileSize = new(16, 16);
diff --git a/scripts/actors/AI/BaseAI.cs b/scripts/actors/AI/BaseAI.cs
index f9b5387..23cdcf6 100644
--- a/scripts/actors/AI/BaseAI.cs
+++ b/scripts/actors/AI/BaseAI.cs
@@ -1,17 +1,36 @@
using Godot;
+/// <summary>
+/// base para as IAs do jogo.
+/// </summary>
public abstract partial class BaseAI : Node {
+ /// <summary>
+ /// Corpo controlado pela IA.
+ /// O corpo é a marionete da alma.
+ /// </summary>
protected Actor body;
public override void _Ready()
{
base._Ready();
+ // Por padrão, a IA é filha do nó de seu corpo.
body = GetParent<Actor>();
}
+ /// <summary>
+ /// Computa um único turno para o ator controlado.
+ /// </summary>
public abstract void Perform();
+ /// <summary>
+ /// Utiliza o pathfinder do mapa para obter um caminho
+ /// da posição atual do ator para um destino qualquer.
+ /// </summary>
+ /// <param name="destination">Destino</param>
+ /// <returns>Vetor com vetores, passo a passo para chegar no destino.</returns>
public Godot.Collections.Array<Vector2> GetPathTo(Vector2I destination) {
+ // Arrays do Godot são muito mais confortáveis de manipular, então
+ // eu converto o Array do C# em um array do Godot antes de retornar o caminho.
Godot.Collections.Array<Vector2> list = [];
Vector2[] path = body.Map_Data.Pathfinder.GetPointPath(body.GridPosition, destination);
list.AddRange(path);
diff --git a/scripts/actors/AI/HostileEnemyAI.cs b/scripts/actors/AI/HostileEnemyAI.cs
index 061295f..3989004 100644
--- a/scripts/actors/AI/HostileEnemyAI.cs
+++ b/scripts/actors/AI/HostileEnemyAI.cs
@@ -1,37 +1,59 @@
using Godot;
+/// <summary>
+/// Uma IA simples. Sempre tentará atacar o jogador com ataques corpo a corpo.
+/// </summary>
public partial class HostileEnemyAI : BaseAI
{
+ /// <summary>
+ /// Caminho até a última posição conhecida do jogador.
+ /// </summary>
private Godot.Collections.Array<Vector2> path = [];
public override void Perform()
{
+ // O alvo da IA sempre é o jogador.
Player target = body.Map_Data.Player;
+ // Vetor que parte do inimigo até o jogador.
Vector2I offset = target.GridPosition - body.GridPosition;
+ // Distância entre o inimigo e o jogador. Leva em consideração somente
+ // um dos eixos.
int distance = int.Max(int.Abs(offset.X), int.Abs(offset.Y));
+ // A ação executada no turno pode ser de ataque ou de movimento.
Action action;
+ // Só faz sentido atacar o jogador se o inimigo estiver visível.
if (body.Map_Data.GetTile(body.GridPosition).IsInView) {
+ // Se estiver do lado do jogador, ataque.
if (distance <= 1) {
action = new MeleeAction(body, offset);
action.Perform();
+ // Executada a ação, acabamos nosso turno aqui.
return;
}
+
+ // Se o inimigo estiver visível para o jogador,
+ // consideramos que ele também consiga ver o jogador.
+ // Logo, atualizamos o caminho para a posição atual do jogador.
path = GetPathTo(target.GridPosition);
- GD.Print($"Arno Breker: {path}");
+ // O primeiro passo é a posição atual do inimigo, podemos remover.
path.RemoveAt(0);
}
+ // Se existir um caminho conhecido para o jogador.
if (path.Count > 0) {
+ // Pegamos o próximo passo para o destino.
Vector2I destination = (Vector2I) path[0];
- GD.Print(destination);
+ // Se tiver um outro ator no caminho, paramos o nosso turno aqui.
if (body.Map_Data.GetBlockingActorAtPosition(destination) != null) {
return;
}
+ // Caso o contrário, criamos uma nova ação de movimentação e a executamos.
action = new MovementAction(body, destination - body.GridPosition);
action.Perform();
+ // Podemos remover o passo do caminho.
path.RemoveAt(0);
}
}
diff --git a/scripts/actors/Actor.cs b/scripts/actors/Actor.cs
index 199c301..9257bdc 100644
--- a/scripts/actors/Actor.cs
+++ b/scripts/actors/Actor.cs
@@ -1,39 +1,76 @@
using Godot;
+/// <summary>
+/// A classe de ator define um personagem no jogo.
+/// </summary>
[GlobalClass]
public abstract partial class Actor : Sprite2D
{
+ /// <summary>
+ /// A definição do ator possui caracterísitcas padrões que definem
+ /// o ator em questão.
+ /// </summary>
protected ActorDefinition definition;
+ /// <summary>
+ /// É conveniente ter acesso ao mapa dentro do ator. Isto porque suas ações são feitas dentro
+ /// do mapa, então é necessário ter acesso à algumas informações.
+ /// </summary>
public MapData Map_Data { get; set; }
+
private Vector2I gridPosition = Vector2I.Zero;
+ /// <summary>
+ /// Posição do ator no mapa do jogo. Diferentemente de Position, GridPosition tem como formato
+ /// os tiles do mapa.
+ /// </summary>
public Vector2I GridPosition {
set {
gridPosition = value;
+ // O sistema de coordenadas do Godot é em pixels, mas faz mais sentido para o jogo utilizar coordenadas em tiles.
+ // Esta propriedade converte um sistema para o outro automaticamente.
Position = Grid.GridToWorld(value);
}
get => gridPosition;
}
+ /// <summary>
+ /// Se o ator bloqueia movimento (não pode oculpar a mesma célula de outro ator.)
+ /// </summary>
public bool BlocksMovement {
get => definition.blocksMovement;
}
+ /// <summary>
+ /// Nome do ator.
+ /// </summary>
public string ActorName {
get => definition.name;
}
private int hp;
+ /// <summary>
+ /// HP máximo do ator.
+ /// </summary>
public int MaxHp { get; private set; }
+ /// <summary>
+ /// HP atual do ator.
+ /// </summary>
public int Hp {
get => hp;
set {
+ // Esta propriedade impede que o HP seja maior que o máximo.
hp = int.Clamp(value, 0, MaxHp);
}
}
private int mp;
+ /// <summary>
+ /// Máximo de mana do ator.
+ /// </summary>
public int MaxMp { get; private set; }
+ /// <summary>
+ /// Mana atual do ator.
+ /// </summary>
public int Mp {
get => mp;
set {
@@ -41,22 +78,42 @@ public abstract partial class Actor : Sprite2D
}
}
+ /// <summary>
+ /// Estatística de ataque
+ /// </summary>
public int Atk { get; private set; }
+ /// <summary>
+ /// Estatística de defesa.
+ /// </summary>
public int Def { get; private set; }
+ /// <summary>
+ /// Estatística mental.
+ /// </summary>
public int Men { get; private set; }
public override void _Ready()
{
base._Ready();
+ // Quando o ator for carregado completamente, atualizamos sua posição para refletir
+ // sua posição real.
GridPosition = Grid.WorldToGrid(Position);
}
+ /// <summary>
+ /// Move o ator para uma localização. Veja MovementAction.
+ /// </summary>
+ /// <param name="offset">Vetor que parte da posição do ator até o seu destino.</param>
public void Walk(Vector2I offset) {
+ // Cada ator tem um peso no sistema de pathfinding.
+ // Sempre que ele se mover, removemos seu peso da posição antiga
Map_Data.UnregisterBlockingActor(this);
GridPosition += offset;
+ // E colocamos na próxima.
Map_Data.RegisterBlockingActor(this);
+ // Este peso influencia o algoritmo de pathfinding.
+ // Atores evitam caminhos bloqueados. por outros atores.
}
public Actor(Vector2I initialPosition, MapData map, ActorDefinition definition) {
@@ -67,6 +124,12 @@ public abstract partial class Actor : Sprite2D
SetDefinition(definition);
}
+ /// <summary>
+ /// Aplica uma definição de NPC para o ator.
+ /// Se o ator for um boneco de barro, este método é como um
+ /// sopro de vida.
+ /// </summary>
+ /// <param name="definition">A definição do ator.</param>
public virtual void SetDefinition(ActorDefinition definition) {
this.definition = definition;
Texture = definition.texture;
diff --git a/scripts/actors/ActorDefinition.cs b/scripts/actors/ActorDefinition.cs
index 5c0ece9..72eb745 100644
--- a/scripts/actors/ActorDefinition.cs
+++ b/scripts/actors/ActorDefinition.cs
@@ -1,19 +1,26 @@
using Godot;
-using System;
+
+/// <summary>
+/// Define de forma genérica as características de um ator.
+/// </summary>
[GlobalClass]
public partial class ActorDefinition : Resource
{
[ExportCategory("Visuals")]
+ // Nome do ator.
[Export]
public string name = "unnamed";
+ // Seu sprite.
[Export]
public Texture2D texture;
[ExportCategory("Mechanics")]
+ // Se o ator bloqueia movimento.
[Export]
public bool blocksMovement = true;
+ // Estatísticas padrão do ator.
[ExportCategory("Stats")]
[Export]
public int Hp;
diff --git a/scripts/actors/Enemy.cs b/scripts/actors/Enemy.cs
index 6c111b1..03fe309 100644
--- a/scripts/actors/Enemy.cs
+++ b/scripts/actors/Enemy.cs
@@ -1,16 +1,29 @@
using Godot;
using System;
+/// <summary>
+/// Enum das diferentes IAs disponíveis.
+/// </summary>
public enum AIType
{
None,
DefaultHostile
};
+/// <summary>
+/// Um inimigo é uma espécie de ator que é
+/// hostil ao jogador. Inimigos são controlados por IA.
+/// </summary>
public partial class Enemy : Actor
{
+ /// <summary>
+ /// A alma do ator. Gera ações que são executadas todo turno.
+ /// </summary>
public BaseAI Soul { get; private set; }
+ /// <summary>
+ /// Enquanto a alma controlar o corpo, o ser continua vivo.
+ /// </summary>
public bool IsAlive { get => Soul != null; }
public Enemy(Vector2I initialPosition, MapData map, EnemyDefinition definition) : base(initialPosition, map, definition)
@@ -18,10 +31,17 @@ public partial class Enemy : Actor
SetDefinition(definition);
}
+ /// <summary>
+ /// Além de definir as características gerais de um ator,
+ /// também define qual IA utilizar.
+ /// </summary>
+ /// <param name="definition">Definição do inimigo.</param>
public void SetDefinition(EnemyDefinition definition)
{
+ // Definimos as características do ator.
base.SetDefinition(definition);
+ // Definimos qual IA utilizar.
switch(definition.AI) {
case AIType.None:
break;
diff --git a/scripts/actors/EnemyDefinition.cs b/scripts/actors/EnemyDefinition.cs
index 21d4ca0..e372e3a 100644
--- a/scripts/actors/EnemyDefinition.cs
+++ b/scripts/actors/EnemyDefinition.cs
@@ -1,5 +1,8 @@
using Godot;
+/// <summary>
+/// Além das configurações do ator, também possui qual IA utilizar.
+/// </summary>
[GlobalClass]
public partial class EnemyDefinition : ActorDefinition {
[ExportCategory("AI")]
diff --git a/scripts/actors/Player.cs b/scripts/actors/Player.cs
index c15db21..324e67a 100644
--- a/scripts/actors/Player.cs
+++ b/scripts/actors/Player.cs
@@ -1,6 +1,9 @@
using Godot;
using System;
+/// <summary>
+/// Classe do jogador. Por enquanto não é diferente do Ator, mas isso pode mudar.
+/// </summary>
[GlobalClass]
public partial class Player : Actor
{
diff --git a/scripts/actors/actions/Action.cs b/scripts/actors/actions/Action.cs
index bb5f6f1..0320dd8 100644
--- a/scripts/actors/actions/Action.cs
+++ b/scripts/actors/actions/Action.cs
@@ -1,16 +1,36 @@
using Godot;
-using System;
-using System.Data;
+
+/// <summary>
+/// <c>Action</c> representa uma ação no jogo efetuada por um ator.
+/// Ações são geradas pelo jogador e pela IA, elas regem os atores do jogo.
+/// </summary>
public abstract partial class Action : RefCounted {
+ /// <summary>
+ /// O ator que realiza a ação.
+ /// </summary>
protected Actor actor;
public Action(Actor actor) {
this.actor = actor;
}
+ /// <summary>
+ /// Método que executa a ação. Subclasses da ação devem implementar este método.
+ /// <example>
+ /// Exemplo:
+ /// <code>
+ /// Action action = new Action(actor);
+ /// /* . . . */
+ /// action.Perform();
+ /// </code>
+ /// </example>
+ /// </summary>
public abstract void Perform();
+ /// <summary>
+ /// É conveniente ter acesso ao mapa dentro de uma ação.
+ /// </summary>
protected MapData Map_Data {
get => actor.Map_Data;
}
diff --git a/scripts/actors/actions/BumpAction.cs b/scripts/actors/actions/BumpAction.cs
index 5958b11..def721b 100644
--- a/scripts/actors/actions/BumpAction.cs
+++ b/scripts/actors/actions/BumpAction.cs
@@ -1,6 +1,10 @@
using Godot;
-using System;
+/// <summary>
+/// Ação de "Esbarramento", utilizada principalmente pelo jogador.
+/// Esta ação direcionada tentará andar para o destino, se houver um
+/// ator no caminho, uma ação de ataque é gerada no lugar.
+/// </summary>
public partial class BumpAction : DirectionalAction
{
public BumpAction(Actor actor, Vector2I offset) : base(actor, offset)
@@ -11,14 +15,18 @@ public partial class BumpAction : DirectionalAction
{
Vector2I destination = actor.GridPosition + Offset;
+ // Declaramos uma ação genérica.
Action action;
+ // Se houver um ator no destino, crie uma ação de ataque.
if (GetBlockingActorAtPosition(destination) != null) {
action = new MeleeAction(actor, Offset);
} else {
+ // Mas se não houver, crie uma ação de movimento.
action = new MovementAction(actor, Offset);
}
+ // Executa a ação.
action.Perform();
}
}
diff --git a/scripts/actors/actions/DirectionalAction.cs b/scripts/actors/actions/DirectionalAction.cs
index d5199f9..8c3c68f 100644
--- a/scripts/actors/actions/DirectionalAction.cs
+++ b/scripts/actors/actions/DirectionalAction.cs
@@ -1,14 +1,27 @@
using Godot;
-using System;
+/// <summary>
+/// Ação direcionada. Esta ação é acompanhada com um vetor que representa uma
+/// distância tendo como ponto de partida o ator.
+/// </summary>
public abstract partial class DirectionalAction : Action
{
+ /// <summary>
+ /// Direção/distância do ator da ação.
+ /// Seu significado depende da ação que implementará esta classe.
+ /// </summary>
public Vector2I Offset { get; private set; }
public DirectionalAction(Actor actor, Vector2I offset) : base(actor)
{
Offset = offset;
}
+ /// <summary>
+ /// É conveniente ter acesso à função para obter atores em uma determinada posição.
+ /// Este método expõe o método de mesmo nome do mapa.
+ /// </summary>
+ /// <param name="pos">Posição para verificar</param>
+ /// <returns>O ator naquela posição, nulo se não houver.</returns>
protected Actor GetBlockingActorAtPosition(Vector2I pos) {
return Map_Data.GetBlockingActorAtPosition(pos);
}
diff --git a/scripts/actors/actions/MeleeAction.cs b/scripts/actors/actions/MeleeAction.cs
index c6d0960..cf40f1d 100644
--- a/scripts/actors/actions/MeleeAction.cs
+++ b/scripts/actors/actions/MeleeAction.cs
@@ -1,21 +1,27 @@
using Godot;
-using System;
-using System.Net.NetworkInformation;
+/// <summary>
+/// Ação de ataque físico. Uma ação direcionada que ataca um alvo.
+/// </summary>
public partial class MeleeAction : DirectionalAction
{
public MeleeAction(Actor actor, Vector2I offset) : base(actor, offset)
{
}
+ /// <summary>
+ /// Ataca o ator na direção da ação.
+ /// </summary>
public override void Perform()
{
Vector2I destination = actor.GridPosition + Offset;
-
+ // Eu te disse que este método seria útil.
Actor target = GetBlockingActorAtPosition(destination);
+ // Se não houver um ator na direção, não podemos continuar.
if (target == null) return;
+ // TODO: Implementar ataque.
GD.Print($"Você tenta socar {target.ActorName}, mas como não sobra nada para o beta, você ainda não tem um método de ataque.");
}
}
diff --git a/scripts/actors/actions/MovementAction.cs b/scripts/actors/actions/MovementAction.cs
index 704dd4f..f86d542 100644
--- a/scripts/actors/actions/MovementAction.cs
+++ b/scripts/actors/actions/MovementAction.cs
@@ -1,6 +1,8 @@
using Godot;
-using System;
+/// <summary>
+/// Ação de movimento. Movimenta o ator para a direção de seu Offset.
+/// </summary>
public partial class MovementAction : DirectionalAction
{
public MovementAction(Actor actor, Vector2I offset) : base(actor, offset)
@@ -11,12 +13,13 @@ public partial class MovementAction : DirectionalAction
{
Vector2I finalDestination = actor.GridPosition + Offset;
+ // Não anda se o destino for um tile sólido.
if (!Map_Data.IsTileWalkable(finalDestination)) return;
+ // Não anda se o destino for oculpado por um ator.
+ // Na maioria dos casos, essa condição nunca é verdadeira.
if (GetBlockingActorAtPosition(finalDestination) != null) return;
- GD.Print("What?");
-
actor.Walk(Offset);
}
}
diff --git a/scripts/map/DungeonGenerator.cs b/scripts/map/DungeonGenerator.cs
index ebb7a3d..1da7e16 100644
--- a/scripts/map/DungeonGenerator.cs
+++ b/scripts/map/DungeonGenerator.cs
@@ -1,26 +1,51 @@
using Godot;
+/// <summary>
+/// A classe dungeonGenerator cria exatamente um andar da masmorra.
+/// Ela é chamada quando necessário.
+/// </summary>
public partial class DungeonGenerator : Node
{
+ /// <summary>
+ /// Coleção de todos os inimigos que o gerador tem acesso.
+ /// </summary>
private static readonly Godot.Collections.Array<EnemyDefinition> enemies = [
GD.Load<EnemyDefinition>("res://assets/definitions/actor/Skeleton.tres")
];
+ /// <summary>
+ /// Dimensões do mapa a ser criado.
+ /// </summary>
[ExportCategory("Dimension")]
[Export]
private int width = 80;
[Export]
private int height = 60;
+ /// <summary>
+ /// Gerador de números aleatórios
+ /// </summary>
[ExportCategory("RNG")]
private RandomNumberGenerator rng = new();
+ /// <summary>
+ /// Qual seed utilizar.
+ /// </summary>
[Export]
private ulong seed;
+ /// <summary>
+ /// Se será utilizada a nossa seed ou a seed padrão da classe RandomNumberGenerator.
+ /// </summary>
[Export]
private bool useSeed = true;
+ /// <summary>
+ /// Quantas iterações do algoritmo chamar.
+ /// </summary>
[Export]
private int iterations = 3;
+ /// <summary>
+ /// Quantidade máxima de inimigos por sala.
+ /// </summary>
[ExportCategory("Monster RNG")]
[Export]
private int maxMonsterPerRoom = 2;
@@ -33,6 +58,11 @@ public partial class DungeonGenerator : Node
}
}
+ /// <summary>
+ /// Transforma o tile da posição especificada em chão.
+ /// </summary>
+ /// <param name="data">o mapa</param>
+ /// <param name="pos">posição para colocar o chão.</param>
private static void CarveTile(MapData data, Vector2I pos)
{
Tile tile = data.GetTile(pos);
@@ -41,6 +71,11 @@ public partial class DungeonGenerator : Node
tile.SetDefinition(MapData.floorDefinition);
}
+ /// <summary>
+ /// Preenche uma área retangular com chão.
+ /// </summary>
+ /// <param name="data">O mapa</param>
+ /// <param name="room">Área para preencher com chão</param>
private static void CarveRoom(MapData data, Rect2I room)
{
for (int y = room.Position.Y; y < room.End.Y; y++)
@@ -52,25 +87,34 @@ public partial class DungeonGenerator : Node
}
}
+ /// <summary>
+ /// Gera um andar da masmorra.
+ /// Inimigos são colocados conforme configurações.
+ /// O jogador é colocado na primeira sala gerada.
+ /// </summary>
+ /// <param name="player">Jogador.</param>
+ /// <returns>O mapa gerado.</returns>
public MapData GenerateDungeon(Player player)
{
MapData data = new MapData(width, height, player);
- data.InsertActor(player);
- player.Map_Data = data;
-
+ // Divisão mestre que engloba o mapa inteiro.
MapDivision root = new MapDivision(0, 0, width, height);
+ // Chama o algoritmo para dividir o mapa.
root.Split(iterations, rng);
bool first = true;
+ // Coloca os corredores.
TunnelDivisions(data, root);
+ // Cria as salas com base nas divisões geradas.
foreach(MapDivision division in root.GetLeaves())
{
Rect2I room = new(division.Position, division.Size);
+ // A sala não pode oculpar a divisão inteira, senão não haveriam paredes.
room = room.GrowIndividual(
-rng.RandiRange(1, 2),
-rng.RandiRange(1, 2),
@@ -78,28 +122,40 @@ public partial class DungeonGenerator : Node
-rng.RandiRange(1, 2)
);
+ // De fato cria a sala.
CarveRoom(data, room);
+ // Colocamos o jogador na primeira sala.
if (first)
{
first = false;
player.GridPosition = room.GetCenter();
}
+ // Colocamos os inimigos na sala.
PlaceEntities(data, room);
}
+ // Feito o mapa, inicializamos o algoritmo de pathfinding.
data.SetupPathfinding();
return data;
}
+ /// <summary>
+ /// Popula uma sala com inimigos.
+ /// </summary>
+ /// <param name="data">O mapa</param>
+ /// <param name="room">A sala.</param>
private void PlaceEntities(MapData data, Rect2I room) {
+ // Define quantos monstros serão colocados na sala
int monsterAmount = rng.RandiRange(0, maxMonsterPerRoom);
for (int i = 0; i < monsterAmount; i++) {
+ // Escolhe um lugar aleatório na sala.
Vector2I position = new(
rng.RandiRange(room.Position.X, room.End.X - 1),
rng.RandiRange(room.Position.Y, room.End.Y - 1)
);
+ // Só podemos colocar um ator por ponto no espaço.
bool canPlace = true;
foreach (Actor actor in data.Actors) {
if (actor.GridPosition == position) {
@@ -108,6 +164,7 @@ public partial class DungeonGenerator : Node
}
}
+ // Se possível, criamos um inimigo aleatório na posição escolhida.
if (canPlace) {
EnemyDefinition definition = enemies.PickRandom();
Enemy enemy = new Enemy(position, data, definition);
@@ -116,6 +173,13 @@ public partial class DungeonGenerator : Node
}
}
+ /// <summary>
+ /// Preenche uma linha horizontal com chão.
+ /// </summary>
+ /// <param name="data">O mapa</param>
+ /// <param name="y">Eixo y do corredor.</param>
+ /// <param name="xBegin">Início do corredor</param>
+ /// <param name="xEnd">Final do corredor.</param>
private static void HorizontalCorridor(MapData data, int y, int xBegin, int xEnd) {
int begin = (xBegin < xEnd) ? xBegin : xEnd;
int end = (xEnd > xBegin) ? xEnd : xBegin;
@@ -124,6 +188,13 @@ public partial class DungeonGenerator : Node
}
}
+ /// <summary>
+ /// Preenche uma linha vertical com chão.
+ /// </summary>
+ /// <param name="data">O mapa.</param>
+ /// <param name="x">Eixo x do corredor.</param>
+ /// <param name="yBegin">Início do corredor</param>
+ /// <param name="yEnd">Final do corredor.</param>
private static void VerticalCorridor(MapData data, int x, int yBegin, int yEnd) {
int begin = (yBegin < yEnd) ? yBegin : yEnd;
int end = (yEnd > yBegin) ? yEnd : yBegin;
@@ -132,11 +203,22 @@ public partial class DungeonGenerator : Node
}
}
+ /// <summary>
+ /// Cria corredores vertical e horizontal para unir dois pontos no mapa.
+ /// </summary>
+ /// <param name="data">O mapa</param>
+ /// <param name="start">Ponto inicial</param>
+ /// <param name="end">Ponto final.</param>
private void TunnelBetween(MapData data, Vector2I start, Vector2I end) {
HorizontalCorridor(data, start.Y, start.X, end.X);
VerticalCorridor(data, end.X, start.Y, end.Y);
}
+ /// <summary>
+ /// Cria recursivamente corredores entre o centro de cada divisão do mapa.
+ /// </summary>
+ /// <param name="data">O mapa</param>
+ /// <param name="root">Divisão mestre.</param>
private void TunnelDivisions(MapData data, MapDivision root) {
if (root.IsLeaf) {
return;
diff --git a/scripts/map/FieldOfView.cs b/scripts/map/FieldOfView.cs
index eee1ae9..cadaf74 100644
--- a/scripts/map/FieldOfView.cs
+++ b/scripts/map/FieldOfView.cs
@@ -2,6 +2,8 @@ using Godot;
// Copiado e adaptado deste cara aqui: https://www.roguebasin.com/index.php?title=C%2B%2B_shadowcasting_implementation e deste também https://selinadev.github.io/08-rogueliketutorial-04/
+// Eu não vou mentir, li como o algoritmo funciona, mas mesmo assim não entendi.
+
public partial class FieldOfView : Node {
private Godot.Collections.Array<Tile> fov = [];
diff --git a/scripts/map/Map.cs b/scripts/map/Map.cs
index 29f5e62..e62aa21 100644
--- a/scripts/map/Map.cs
+++ b/scripts/map/Map.cs
@@ -1,13 +1,24 @@
using Godot;
-using System;
+/// <summary>
+/// A parte visual do mapa.
+/// </summary>
public partial class Map : Node2D
{
+ /// <summary>
+ /// Dados do mapa.
+ /// </summary>
public MapData Map_Data { get; private set; }
+ /// <summary>
+ /// raio de alcance da visão do jogador.
+ /// </summary>
[Export]
private int fovRadius = 12;
+ /// <summary>
+ /// Gerador de mapas.
+ /// </summary>
private DungeonGenerator generator;
FieldOfView fieldOfView;
@@ -18,37 +29,50 @@ public partial class Map : Node2D
public override void _Ready()
{
base._Ready();
-
+ // Começamos obtendo nós relevantes para o mapa.
generator = GetNode<DungeonGenerator>("Generator");
fieldOfView = GetNode<FieldOfView>("FieldOfView");
tilesNode = GetNode<Node2D>("Tiles");
actorsNode = GetNode<Node2D>("Actors");
}
+ /// <summary>
+ /// Coloca todos os tiles do mapa no mundo do jogo.
+ /// </summary>
private void PlaceTiles() {
foreach (Tile tile in Map_Data.Tiles) {
tilesNode.AddChild(tile);
}
}
+ /// <summary>
+ /// Coloca todos os tiles do mapa no mundo do jogo.
+ /// </summary>
private void PlaceActors() {
foreach (Actor actor in Map_Data.Actors) {
actorsNode.AddChild(actor);
}
}
+ /// <summary>
+ /// Cria um andar da masmorra utilizando o gerador de mapa.
+ /// </summary>
+ /// <param name="player">O gerador de mapas precisa do jogador.</param>
public void Generate(Player player)
{
Map_Data = generator.GenerateDungeon(player);
- player.Map_Data = Map_Data;
-
PlaceTiles();
PlaceActors();
}
+ /// <summary>
+ /// Atualiza o campo de visão do mapa com base em uma coordenada.
+ /// </summary>
+ /// <param name="pos">Centro de visão, normalmente é a posição do jogador.</param>
public void UpdateFOV(Vector2I pos) {
fieldOfView.UpdateFOV(Map_Data, pos, fovRadius);
+ // Esconde ou revela atores com base no campo de visão.
foreach (Actor actor in Map_Data.Actors) {
actor.Visible = Map_Data.GetTile(actor.GridPosition).IsInView;
}
diff --git a/scripts/map/MapData.cs b/scripts/map/MapData.cs
index be466ba..3b03de8 100644
--- a/scripts/map/MapData.cs
+++ b/scripts/map/MapData.cs
@@ -1,40 +1,74 @@
using Godot;
-using System;
-using System.Runtime.InteropServices;
+/// <summary>
+/// Classe que cuida dos dados e da parte lógica do mapa.
+/// O mapa é o cenário onde as ações do jogo ocorrem.
+/// Mais especificamente, o mapa é um único andar da masmorra.
+/// </summary>
public partial class MapData : RefCounted
{
public static readonly TileDefinition wallDefinition = GD.Load<TileDefinition>("res://assets/definitions/tiles/wall.tres");
public static readonly TileDefinition floorDefinition = GD.Load<TileDefinition>("res://assets/definitions/tiles/floor.tres");
+ /// <summary>
+ /// Largura do mapa.
+ /// </summary>
public int Width { get; private set; }
+ /// <summary>
+ /// Altura do mapa.
+ /// </summary>
public int Height { get; private set; }
+ /// <summary>
+ /// Os tiles que compõem o mapa.
+ /// </summary>
public Godot.Collections.Array<Tile> Tiles { get; private set; } = [];
+ /// <summary>
+ /// O jogador é especial e por isso o mapa faz questão de rastreá-lo.
+ /// </summary>
public Player Player { get; set; }
+ /// <summary>
+ /// Lista de todos os atores dentro do mapa.
+ /// </summary>
public Godot.Collections.Array<Actor> Actors { get; private set; } = [];
private AStarGrid2D pathfinder;
+ /// <summary>
+ /// Objeto do Godot que utiliza do algoritmo A* para calcular
+ /// caminhos e rotas.
+ /// </summary>
public AStarGrid2D Pathfinder { get => pathfinder; }
+ /// <summary>
+ /// Peso do ator no pathfinder.
+ /// A IA irá evitar de passar por espaços com peso alto.
+ /// </summary>
private static float ActorWeight = 10.0f;
+ /// <summary>
+ /// Inicializa o pathfinder;
+ /// </summary>
public void SetupPathfinding() {
pathfinder = new AStarGrid2D
{
+ //A região é o mapa inteiro.
Region = new Rect2I(0, 0, Width, Height)
};
+ // Atualiza o pathfinder para a região definida.
pathfinder.Update();
+ // Define quais pontos do mapa são passáveis ou não.
for (int y = 0; y < Height; y++) {
for (int x = 0; x < Width; x++) {
Vector2I pos = new Vector2I(x, y);
Tile tile = GetTile(pos);
+ // Pontos sólidos são impossíveis de passar.
pathfinder.SetPointSolid(pos, !tile.IsWalkable);
}
}
+ // Registra todos os atores em cena.
foreach (Actor actor in Actors) {
if (actor.BlocksMovement) {
RegisterBlockingActor(actor);
@@ -43,10 +77,21 @@ public partial class MapData : RefCounted
}
+ /// <summary>
+ /// Define um peso na posição de um ator para que a IA evite de passar por lá.
+ /// Ênfase em evitar. Se o único caminho para o destino estiver bloqueado
+ /// por um ator, o jogo tentará andar mesmo assim.
+ /// </summary>
+ /// <param name="actor">O ator em questão.</param>
public void RegisterBlockingActor(Actor actor) {
pathfinder.SetPointWeightScale(actor.GridPosition, ActorWeight);
}
+ /// <summary>
+ /// Remove o peso na posição de um ator.
+ /// Quando um ator move sua posição, devemos tirar o peso de sua posição anterior.
+ /// </summary>
+ /// <param name="actor">O ator em questão.</param>
public void UnregisterBlockingActor(Actor actor) {
pathfinder.SetPointWeightScale(actor.GridPosition, 0);
}
@@ -56,10 +101,19 @@ public partial class MapData : RefCounted
Height = height;
Player = player;
+ // Como o jogador é criado antes do mapa, precisamos
+ // atualizá-lo com o novo mapa.
+ player.Map_Data = this;
+ InsertActor(player);
SetupTiles();
}
+ /// <summary>
+ /// Cria novos Tiles até preencher as dimensões do mapa.
+ /// É importante que estes tiles sejam paredes, o gerador de mapas
+ /// não cria paredes por conta própria.
+ /// </summary>
private void SetupTiles() {
for (int i = 0; i < Height; i++)
{
@@ -70,16 +124,31 @@ public partial class MapData : RefCounted
}
}
+ /// <summary>
+ /// Registra um ator no mapa. A existência de um ator não é considerada se ele não
+ /// estiver registrado no mapa.
+ /// </summary>
+ /// <param name="actor">O ator em questão</param>
public void InsertActor(Actor actor) {
Actors.Add(actor);
}
+ /// <summary>
+ /// Converte uma coordenada em um índice para acessar a lista de tiles.
+ /// </summary>
+ /// <param name="pos">Vetor posição</param>
+ /// <returns>Índice na lista de tiles. -1 se estiver fora do mapa.</returns>
private int GridToIndex(Vector2I pos) {
if (!IsInBounds(pos)) return -1;
return pos.Y * Width + pos.X;
}
+ /// <summary>
+ /// Se uma coordenada está dentro da área do mapa.
+ /// </summary>
+ /// <param name="pos">Vetor posição</param>
+ /// <returns>Se o vetor está dentro do mapa.</returns>
private bool IsInBounds(Vector2I pos) {
if (pos.X < 0 || pos.Y < 0) {
return false;
@@ -91,6 +160,11 @@ public partial class MapData : RefCounted
return true;
}
+ /// <summary>
+ /// Obtém o tile na posição desejada.
+ /// </summary>
+ /// <param name="pos">Vetor posição</param>
+ /// <returns>O tile na posição, nulo se for fora do mapa.</returns>
public Tile GetTile(Vector2I pos) {
int index = GridToIndex(pos);
@@ -99,10 +173,21 @@ public partial class MapData : RefCounted
return Tiles[index];
}
+ /// <summary>
+ /// Obtém o tile na posição desejada.
+ /// </summary>
+ /// <param name="x">x da coordenada</param>
+ /// <param name="y">y da coordenada</param>
+ /// <returns>O tile na posição, nulo se for fora do mapa.</returns>
public Tile GetTile(int x, int y) {
return GetTile(new Vector2I(x, y));
}
+ /// <summary>
+ /// Obtém o ator na posição especificada.
+ /// </summary>
+ /// <param name="pos">Vetor posição</param>
+ /// <returns>O ator na posição especificada, nulo se não houver.</returns>
public Actor GetBlockingActorAtPosition(Vector2I pos) {
foreach (Actor actor in Actors) {
if (actor.GridPosition == pos && actor.BlocksMovement) {
@@ -112,6 +197,12 @@ public partial class MapData : RefCounted
return null;
}
+ /// <summary>
+ /// Verifica se é possível caminhar na coordenada especificada.
+ /// Este método será removido.
+ /// </summary>
+ /// <param name="pos">Vetor posição</param>
+ /// <returns>Se é possível caminhar nesta posição</returns>
public bool IsTileWalkable(Vector2I pos) {
Tile tile = GetTile(pos);
diff --git a/scripts/map/MapDivision.cs b/scripts/map/MapDivision.cs
index 15a6be8..3273775 100644
--- a/scripts/map/MapDivision.cs
+++ b/scripts/map/MapDivision.cs
@@ -1,21 +1,34 @@
-using System.Linq;
-using System.Numerics;
-using System.Xml.Schema;
using Godot;
+/// <summary>
+/// Classe utilizada pelo gerador de mapas.
+/// Uma divisão é uma região retangular de espaço que pode
+/// conter dentro de si duas regiões menores *ou* uma sala.
+/// Uma divisão é uma árvore binária que possui espaço para salas em suas folhas.
+/// </summary>
public partial class MapDivision : RefCounted {
+ /// <summary>
+ /// Região retangular da divisão.
+ /// </summary>
public Vector2I Position { get; set; }
public Vector2I Size { get; set; }
-
+
public Vector2I Center {
get => new(Position.X + Size.X/2, Position.Y + Size.Y/2);
}
+ /// <summary>
+ /// Filhos da árvore
+ /// </summary>
private MapDivision left;
public MapDivision Left { get => this.left; }
private MapDivision right;
public MapDivision Right { get => this.right; }
+ /// <summary>
+ /// Se a divisão atual for uma folha.
+ /// As folhas representam salas.
+ /// </summary>
public bool IsLeaf {
get => left == null && right == null;
}
@@ -35,6 +48,10 @@ public partial class MapDivision : RefCounted {
Size = new(width, height);
}
+ /// <summary>
+ /// É conveniente ter acesso à todas as folhas da árvore.
+ /// </summary>
+ /// <returns>Lista com todas as folhas da árvore.</returns>
public Godot.Collections.Array<MapDivision> GetLeaves() {
if (IsLeaf) {
Godot.Collections.Array<MapDivision> list = [];
@@ -44,10 +61,20 @@ public partial class MapDivision : RefCounted {
return left.GetLeaves() + right.GetLeaves();
}
+ /// <summary>
+ /// Algoritmo para gerar as divisões.
+ /// O mapa começa com uma única divisão que oculpa sua extensão completa.
+ /// Depois disso, ela se dividirá recursivamente n vezes.
+ /// As divisões nas folhas representam espaços onde pode gerar uma sala.
+ /// </summary>
+ /// <param name="iterations">Número de iterações</param>
+ /// <param name="rng">Gerador de números</param>
public void Split(int iterations, RandomNumberGenerator rng) {
float SplitRatio = rng.RandfRange(0.35f, 0.65f);
bool horizontalSplit = Size.X <= Size.Y;
-
+
+ // Eu defini um limite mínimo de 4 de altura e 4 de largura para divisões.
+
if (horizontalSplit) {
int leftHeight = (int) (Size.Y * SplitRatio);
if (leftHeight > 4 && Size.Y - leftHeight > 4) {
diff --git a/scripts/map/Tile.cs b/scripts/map/Tile.cs
index e050701..67b9be5 100644
--- a/scripts/map/Tile.cs
+++ b/scripts/map/Tile.cs
@@ -1,14 +1,33 @@
using Godot;
using System;
+/// <summary>
+/// O mundo do jogo é composto por Tiles.
+/// Um tile é um quadrado de 16x16 que representa uma
+/// unidade discreta do cenário. Tiles podem agir como
+/// parede, chão, ou outras funções.
+/// </summary>
public partial class Tile : Sprite2D
{
+ /// <summary>
+ /// A definição do tile carrega seus valores padrão.
+ /// </summary>
private TileDefinition definition;
+ /// <summary>
+ /// Determina se atores podem andar em cima do Tile.
+ /// </summary>
public bool IsWalkable { get; private set; }
+ /// <summary>
+ /// Determina se o tile bloqueia visão.
+ /// </summary>
public bool IsTransparent { get; private set; }
private bool isExplored = false;
+ /// <summary>
+ /// Se o jogador já viu este tile antes.
+ /// Tiles não descobertos são invisíveis.
+ /// </summary>
public bool IsExplored {
get => this.isExplored;
set {
@@ -20,6 +39,10 @@ public partial class Tile : Sprite2D
}
private bool isInView = false;
+ /// <summary>
+ /// Se o jogador vê o tile neste exato momento.
+ /// Elementos neste tile estão dentro do campo de visão do jogador.
+ /// </summary>
public bool IsInView {
get => this.isInView;
set {
@@ -32,12 +55,21 @@ public partial class Tile : Sprite2D
public Tile(Vector2I pos, TileDefinition definition)
{
+ // Tile herda da classe Sprite2D.
+ // Por padrão, a posição do Sprite2D é no centro de sua textura.
+ // Para o jogo, faz mais sentido que a posição seja no
+ // canto superior esquerdo.
Centered = false;
+ // Tiles começam invisíveis porque não foram vistos pelo jogador.
Visible = false;
Position = Grid.GridToWorld(pos);
SetDefinition(definition);
}
+ /// <summary>
+ /// Define as características do tile.
+ /// </summary>
+ /// <param name="definition">Definição do tile.</param>
public void SetDefinition(TileDefinition definition) {
this.definition = definition;
Texture = definition.Texture;
diff --git a/scripts/map/TileDefinition.cs b/scripts/map/TileDefinition.cs
index fbd14a1..235508a 100644
--- a/scripts/map/TileDefinition.cs
+++ b/scripts/map/TileDefinition.cs
@@ -1,6 +1,8 @@
using Godot;
-using System;
+/// <summary>
+/// Define as características de um tile.
+/// </summary>
[GlobalClass]
public partial class TileDefinition : Resource
{
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-30 20:55:23 +0000