Preparação para itens

17 files changed, 197 insertions, 157 deletions

diff --git a/scripts/GUI/Details.cs b/scripts/GUI/Details.cs
index 0e342aa..814d2ac 100644
--- a/scripts/GUI/Details.cs
+++ b/scripts/GUI/Details.cs
@@ -6,7 +6,7 @@ public partial class Details : CanvasLayer
 	private static readonly LabelSettings lblSettings = GD.Load<LabelSettings>("res://assets/definitions/message_label_settings.tres");
 	private Map map;
 	private VBoxContainer entityNames;
-	private Godot.Collections.Array<Actor> actors = [];
+	private Godot.Collections.Array<Entity> entities = [];
 
 	private Godot.Collections.Array<Label> actorsLabel = [];
 
@@ -23,7 +23,7 @@ public partial class Details : CanvasLayer
 
 	public void OnInspectorWalk(Vector2I pos) {
 		MapData mapData = map.Map_Data;
-		actors = mapData.GetActorsAtPosition(pos);
+		entities = mapData.GetEntitiesAtPosition(pos);
 		UpdateLabels();
 	}
 
@@ -33,10 +33,10 @@ public partial class Details : CanvasLayer
 		}
 		actorsLabel.Clear();
 
-		foreach (Actor actor in actors) {
+		foreach (Entity entity in entities) {
 			Label label = new()
 			{
-				Text = actor.ActorName,
+				Text = entity.DisplayName,
 				LabelSettings = lblSettings
 			};
 
diff --git a/scripts/Time/TurnManager.cs b/scripts/Time/TurnManager.cs
index cbf1176..fd16f0f 100644
--- a/scripts/Time/TurnManager.cs
+++ b/scripts/Time/TurnManager.cs
@@ -78,8 +78,8 @@ public partial class TurnManager : RefCounted
 		TurnCount++;
 
 		// Recarregamos a energia de todos os atores.
-		foreach (Actor actor in Map_Data.Actors) {
-			if (actor.IsAlive) {
+		foreach (Entity entity in Map_Data.Entities) {
+			if (entity is Actor actor && actor.IsAlive) {
 				actor.RechargeEnergy();
 			}
 		}
@@ -89,11 +89,11 @@ public partial class TurnManager : RefCounted
 	/// Executa turnos para cada ator no mapa.
 	/// </summary>
 	private void HandleEnemyTurns() {
-		foreach (Actor actor in Map_Data.Actors) {
-			if (actor is Player) continue;
+		foreach (Entity entity in Map_Data.Entities) {
+			if (entity 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) {
+			if (entity is Enemy enemy && enemy.IsAlive) {
 				// O inimigo poderá fazer quantos turnos sua energia deixar.
 				while (enemy.Energy > 0) {
 					enemy.Soul.Perform();
diff --git a/scripts/entities/Entity.cs b/scripts/entities/Entity.cs
new file mode 100644
index 0000000..fb83f90
--- /dev/null
+++ b/scripts/entities/Entity.cs
@@ -0,0 +1,82 @@
+using Godot;
+
+public partial class Entity : Sprite2D {
+	/// <summary>
+	/// A definição da entidade possui caracterísitcas padrões que definem
+	/// a entidade em questão.
+	/// </summary>
+	private EntityDefinition definition;
+
+	/// <summary>
+    /// É conveniente ter acesso ao mapa dentro da entidade. Isto porque ela existe 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 da entidade 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;
+	}
+
+	private bool blocksMovement;
+	/// <summary>
+	/// Se a entidade bloqueia movimento (não pode oculpar a mesma célula de outra entidade.)
+	/// </summary>
+	public bool BlocksMovement {
+		get => blocksMovement;
+		protected set {
+			blocksMovement = value;
+		}
+	}
+
+	private string displayName;
+	/// <summary>
+    /// Nome da entidade.
+    /// </summary>
+	public string DisplayName {
+		get => displayName;
+		protected set {
+			displayName = value;
+		}
+	}
+
+	public override void _Ready()
+	{
+		base._Ready();
+		// Quando a entidade for carregada completamente, atualizamos sua posição para refletir
+		// sua posição real.
+		GridPosition = Grid.WorldToGrid(Position);
+	}
+
+	public Entity(Vector2I initialPosition, MapData map, EntityDefinition definition) {
+		GridPosition = initialPosition;
+		Map_Data = map;
+		Centered = false;
+
+		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(EntityDefinition definition) {
+		this.definition = definition;
+		BlocksMovement = definition.blocksMovement;
+		DisplayName = definition.name;
+		ZIndex = 1;
+		Texture = definition.texture;
+	}
+}
\ No newline at end of file
diff --git a/scripts/entities/Entity.cs.uid b/scripts/entities/Entity.cs.uid
new file mode 100644
index 0000000..f178d64
--- /dev/null
+++ b/scripts/entities/Entity.cs.uid
@@ -0,0 +1 @@
+uid://w1325qe64c6w
diff --git a/scripts/entities/EntityDefinition.cs b/scripts/entities/EntityDefinition.cs
new file mode 100644
index 0000000..19693db
--- /dev/null
+++ b/scripts/entities/EntityDefinition.cs
@@ -0,0 +1,17 @@
+using Godot;
+
+[GlobalClass]
+public partial class EntityDefinition : Resource{
+	[ExportCategory("Visuals")]
+	// Nome da entidade.
+	[Export]
+	public string name = "unnamed";
+	// Seu sprite.
+	[Export]
+	public Texture2D texture;
+
+	[ExportCategory("Mechanics")]
+	// Se a entidade bloqueia movimento.
+	[Export]
+	public bool blocksMovement = true;
+}
\ No newline at end of file
diff --git a/scripts/entities/EntityDefinition.cs.uid b/scripts/entities/EntityDefinition.cs.uid
new file mode 100644
index 0000000..0aed6ab
--- /dev/null
+++ b/scripts/entities/EntityDefinition.cs.uid
@@ -0,0 +1 @@
+uid://bp33ly3hnjwk0
diff --git a/scripts/entities/actors/AI/HostileEnemyAI.cs b/scripts/entities/actors/AI/HostileEnemyAI.cs
index 35d6d1a..e7efd26 100644
--- a/scripts/entities/actors/AI/HostileEnemyAI.cs
+++ b/scripts/entities/actors/AI/HostileEnemyAI.cs
@@ -53,8 +53,8 @@ public partial class HostileEnemyAI : BaseAI
 		if (path.Count > 0) {
 			// Pegamos o próximo passo para o destino.
 			Vector2I destination = (Vector2I) path[0];
-			// Se tiver um outro ator no caminho, paramos o nosso turno aqui.
-			if (body.Map_Data.GetBlockingActorAtPosition(destination) != null) {
+			// Se tiver o caminho estiver bloqueado, paramos o nosso turno aqui.
+			if (body.Map_Data.GetBlockingEntityAtPosition(destination) != null) {
 				action = new WaitAction(body);
 				action.Perform();
 				return;
diff --git a/scripts/entities/actors/Actor.cs b/scripts/entities/actors/Actor.cs
index c77122a..dc8ba53 100644
--- a/scripts/entities/actors/Actor.cs
+++ b/scripts/entities/actors/Actor.cs
@@ -4,7 +4,7 @@ using Godot;
 /// A classe de ator define um personagem no jogo.
 /// </summary>
 [GlobalClass]
-public partial class Actor : Sprite2D
+public partial class Actor : Entity
 {
 	/// <summary>
     /// Sinal emitido toda vez que o HP mudar.
@@ -25,12 +25,7 @@ public partial class Actor : Sprite2D
 	/// 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 ActorDefinition definition;
 
 	/// <summary>
     /// Se o ator está vivo.
@@ -66,37 +61,6 @@ public partial class Actor : Sprite2D
 		Energy += Speed;
 	}
 
-	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;
-	}
-
-	private bool blocksMovement;
-	/// <summary>
-	/// Se o ator bloqueia movimento (não pode oculpar a mesma célula de outro ator.)
-	/// </summary>
-	public bool BlocksMovement {
-		get => blocksMovement;
-	}
-
-	private string actorName;
-	/// <summary>
-    /// Nome do ator.
-    /// </summary>
-	public string ActorName {
-		get => actorName;
-	}
-
 	private int hp;
 	/// <summary>
     /// HP máximo do ator.
@@ -147,14 +111,6 @@ public partial class Actor : Sprite2D
     /// </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>
@@ -162,18 +118,15 @@ public partial class Actor : Sprite2D
 	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);
+		Map_Data.UnregisterBlockingEntity(this);
 		GridPosition += offset;
 		// E colocamos na próxima.
-		Map_Data.RegisterBlockingActor(this);
+		Map_Data.RegisterBlockingEntity(this);
 		// Este peso influencia o algoritmo de pathfinding.
 		// Atores evitam caminhos bloqueados. por outros atores.
 	}
 
-	public Actor(Vector2I initialPosition, MapData map, ActorDefinition definition) {
-		GridPosition = initialPosition;
-		Map_Data = map;
-		Centered = false;
+	public Actor(Vector2I initialPosition, MapData map, ActorDefinition definition) : base(initialPosition, map, definition) {
 
 		SetDefinition(definition);
 	}
@@ -200,11 +153,10 @@ public partial class Actor : Sprite2D
     /// </summary>
     /// <param name="definition">A definição do ator.</param>
 	public virtual void SetDefinition(ActorDefinition definition) {
+		base.SetDefinition(definition);
 		this.definition = definition;
-		blocksMovement = definition.blocksMovement;
-		actorName = definition.name;
+
 		ZIndex = 1;
-		Texture = definition.texture;
 
 		MaxHp = definition.Hp;
 		Hp = definition.Hp;
@@ -248,16 +200,16 @@ public partial class Actor : Sprite2D
 		if (Map_Data.Player == this) {
 			deathMessage = "Você morreu!";
 		} else {
-			deathMessage = $"{ActorName} morreu!";
+			deathMessage = $"{DisplayName} morreu!";
 		}
 
 		MessageLogData.Instance.AddMessage(deathMessage);
 
 		Texture = definition.deathTexture;
-		blocksMovement = false;
+		BlocksMovement = false;
 		ZIndex = 0;
-		actorName = $"Restos mortais de {actorName}";
-		Map_Data.UnregisterBlockingActor(this);
+		DisplayName= $"Restos mortais de {DisplayName}";
+		Map_Data.UnregisterBlockingEntity(this);
 		EmitSignal(SignalName.Died);
 	}
 }
\ No newline at end of file
diff --git a/scripts/entities/actors/ActorDefinition.cs b/scripts/entities/actors/ActorDefinition.cs
index ab0160b..540ede0 100644
--- a/scripts/entities/actors/ActorDefinition.cs
+++ b/scripts/entities/actors/ActorDefinition.cs
@@ -4,23 +4,14 @@ using Godot;
 /// Define de forma genérica as características de um ator.
 /// </summary>
 [GlobalClass]
-public partial class ActorDefinition : Resource
+public partial class ActorDefinition : EntityDefinition
 {
 	[ExportCategory("Visuals")]
-	// Nome do ator.
-	[Export]
-	public string name = "unnamed";
-	// Seu sprite.
-	[Export]
-	public Texture2D texture;
 	// Sprite de morto
 	[Export]
 	public Texture2D deathTexture;
 
 	[ExportCategory("Mechanics")]
-	// Se o ator bloqueia movimento.
-	[Export]
-	public bool blocksMovement = true;
 	[Export]
 	public int Speed { get; set;} = 10;
 
diff --git a/scripts/entities/actors/Enemy.cs b/scripts/entities/actors/Enemy.cs
index 19bcd2c..9c06417 100644
--- a/scripts/entities/actors/Enemy.cs
+++ b/scripts/entities/actors/Enemy.cs
@@ -16,13 +16,15 @@ public enum AIType
 /// </summary>
 public partial class Enemy : Actor
 {
+	private EnemyDefinition definition;
 	/// <summary>
-    /// A alma do ator. Gera ações que são executadas todo turno.
-    /// </summary>
+	/// A alma do ator. Gera ações que são executadas todo turno.
+	/// </summary>
 	public BaseAI Soul { get; private set; }
 
 	public Enemy(Vector2I initialPosition, MapData map, EnemyDefinition definition) : base(initialPosition, map, definition)
 	{
+		this.definition = definition;
 		SetDefinition(definition);
 	}
 
diff --git a/scripts/entities/actors/actions/BumpAction.cs b/scripts/entities/actors/actions/BumpAction.cs
index 805520c..bee202b 100644
--- a/scripts/entities/actors/actions/BumpAction.cs
+++ b/scripts/entities/actors/actions/BumpAction.cs
@@ -19,7 +19,7 @@ public partial class BumpAction : DirectionalAction
 		Action action;
 
 		// Se houver um ator no destino, crie uma ação de ataque.
-		if (GetTargetActor() != null) {
+		if (GetTarget() != null) {
 			action = new MeleeAction(actor, Offset);
 		} else {
 			// Mas se não houver, crie uma ação de movimento.
diff --git a/scripts/entities/actors/actions/DirectionalAction.cs b/scripts/entities/actors/actions/DirectionalAction.cs
index ca2ca95..9c7a915 100644
--- a/scripts/entities/actors/actions/DirectionalAction.cs
+++ b/scripts/entities/actors/actions/DirectionalAction.cs
@@ -24,7 +24,7 @@ public abstract partial class DirectionalAction : Action
     /// Função que obtém o alvo da ação, se houver.
     /// </summary>
     /// <returns>O ator alvo da ação, nulo se não houver.</returns>
-	protected Actor GetTargetActor() {
-		return Map_Data.GetBlockingActorAtPosition(Destination);
+	protected Entity GetTarget() {
+		return Map_Data.GetBlockingEntityAtPosition(Destination);
 	}
 }
diff --git a/scripts/entities/actors/actions/MeleeAction.cs b/scripts/entities/actors/actions/MeleeAction.cs
index b20430a..6dfeb78 100644
--- a/scripts/entities/actors/actions/MeleeAction.cs
+++ b/scripts/entities/actors/actions/MeleeAction.cs
@@ -15,7 +15,15 @@ public partial class MeleeAction : DirectionalAction
 	public override void Perform()
 	{
 		// Eu te disse que este método seria útil.
-		Actor target = GetTargetActor();
+		Entity potentialTarget = GetTarget();
+
+		// Só podemos atacar atores.
+		if (potentialTarget is not Actor) {
+			return;
+		}
+
+		Actor target = (Actor)potentialTarget;
+
 
 		// Se não houver um ator na direção, não podemos continuar.
 		// Isto é uma ação gratuita.
@@ -24,13 +32,13 @@ public partial class MeleeAction : DirectionalAction
 		// não podemos ter dano negativo.
 		int damage = actor.Atk - target.Def;
 
-		string attackDesc = $"{actor.ActorName} ataca {target.ActorName}";
+		string attackDesc = $"{actor.DisplayName} ataca {target.DisplayName}";
 
 		if (damage > 0) {
 			attackDesc += $" e remove {damage} de HP.";
 			target.Hp -= damage;
 		} else {
-			attackDesc += $" mas {target.ActorName} tem músculos de aço.";
+			attackDesc += $" mas {target.DisplayName} tem músculos de aço.";
 		}
 
 		MessageLogData.Instance.AddMessage(attackDesc);
diff --git a/scripts/entities/actors/actions/MovementAction.cs b/scripts/entities/actors/actions/MovementAction.cs
index 3608357..2c394fc 100644
--- a/scripts/entities/actors/actions/MovementAction.cs
+++ b/scripts/entities/actors/actions/MovementAction.cs
@@ -12,11 +12,11 @@ public partial class MovementAction : DirectionalAction
 	public override void Perform()
 	{
 		// Não anda se o destino for um tile sólido.
-		if (!Map_Data.IsTileWalkable(Destination)) return;
+		if (!Map_Data.GetTile(Destination).IsWalkable) return;
 
 		// Não anda se o destino for oculpado por um ator.
 		// Na maioria dos casos, essa condição nunca é verdadeira.
-		if (GetTargetActor() != null) return;
+		if (GetTarget() != null) return;
 
 		actor.Walk(Offset);
 		actor.Energy -= cost;
diff --git a/scripts/map/DungeonGenerator.cs b/scripts/map/DungeonGenerator.cs
index 6a159c9..f016dd2 100644
--- a/scripts/map/DungeonGenerator.cs
+++ b/scripts/map/DungeonGenerator.cs
@@ -159,8 +159,8 @@ public partial class DungeonGenerator : Node
 
 			// Só podemos colocar um ator por ponto no espaço.
 			bool canPlace = true;
-			foreach (Actor actor in data.Actors) {
-				if (actor.GridPosition == position) {
+			foreach (Entity entity in data.Entities) {
+				if (entity.GridPosition == position) {
 					canPlace = false;
 					break;
 				}
@@ -169,8 +169,8 @@ 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);
-				data.InsertActor(enemy);
+				Enemy enemy = new(position, data, definition);
+				data.InsertEntity(enemy);
 			}
 		}
 	}
@@ -211,7 +211,7 @@ public partial class DungeonGenerator : Node
     /// <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) {
+	private static void TunnelBetween(MapData data, Vector2I start, Vector2I end) {
 		HorizontalCorridor(data, start.Y, start.X, end.X);
 		VerticalCorridor(data, end.X, start.Y, end.Y);
 	}
@@ -221,7 +221,7 @@ public partial class DungeonGenerator : Node
     /// </summary>
     /// <param name="data">O mapa</param>
     /// <param name="root">Divisão mestre.</param>
-	private void TunnelDivisions(MapData data, MapDivision root) {
+	private static void TunnelDivisions(MapData data, MapDivision root) {
 		if (root.IsLeaf) {
 			return;
 		}
diff --git a/scripts/map/Map.cs b/scripts/map/Map.cs
index e62aa21..c14880a 100644
--- a/scripts/map/Map.cs
+++ b/scripts/map/Map.cs
@@ -24,7 +24,7 @@ public partial class Map : Node2D
 	FieldOfView fieldOfView;
 
 	private Node2D tilesNode;
-	private Node2D actorsNode;
+	private Node2D entitiesNode;
 
 	public override void _Ready()
 	{
@@ -33,7 +33,7 @@ public partial class Map : Node2D
 		generator = GetNode<DungeonGenerator>("Generator");
 		fieldOfView = GetNode<FieldOfView>("FieldOfView");
 		tilesNode = GetNode<Node2D>("Tiles");
-		actorsNode = GetNode<Node2D>("Actors");
+		entitiesNode = GetNode<Node2D>("Entities");
 	}
 
 	/// <summary>
@@ -48,9 +48,9 @@ public partial class Map : Node2D
 	/// <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);
+	private void PlaceEntities() {
+		foreach (Actor actor in Map_Data.Entities) {
+			entitiesNode.AddChild(actor);
 		}
 	}
 
@@ -63,7 +63,7 @@ public partial class Map : Node2D
 		Map_Data = generator.GenerateDungeon(player);
 
 		PlaceTiles();
-		PlaceActors();
+		PlaceEntities();
 	}
 
 	/// <summary>
@@ -73,7 +73,7 @@ public partial class Map : Node2D
 	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) {
+		foreach (Actor actor in Map_Data.Entities) {
 			actor.Visible = Map_Data.GetTile(actor.GridPosition).IsInView;
 		}
 	}
diff --git a/scripts/map/MapData.cs b/scripts/map/MapData.cs
index de0ddf0..08a144d 100644
--- a/scripts/map/MapData.cs
+++ b/scripts/map/MapData.cs
@@ -31,7 +31,7 @@ public partial class MapData : RefCounted
 	/// <summary>
     /// Lista de todos os atores dentro do mapa.
     /// </summary>
-	public Godot.Collections.Array<Actor> Actors { get; private set; } = [];
+	public Godot.Collections.Array<Entity> Entities { get; private set; } = [];
 
 	private AStarGrid2D pathfinder;
 	/// <summary>
@@ -43,7 +43,7 @@ public partial class MapData : RefCounted
     /// Peso do ator no pathfinder.
     /// A IA irá evitar de passar por espaços com peso alto.
     /// </summary>
-	private static float ActorWeight = 10.0f;
+	private static readonly float EntityWeight = 10.0f;
 
 	/// <summary>
     /// Inicializa o pathfinder;
@@ -69,31 +69,31 @@ public partial class MapData : RefCounted
 		}
 
 		// Registra todos os atores em cena.
-		foreach (Actor actor in Actors) {
-			if (actor.BlocksMovement) {
-				RegisterBlockingActor(actor);
+		foreach (Entity entity in Entities) {
+			if (entity.BlocksMovement) {
+				RegisterBlockingEntity(entity);
 			}
 		}
 
 	}
 
 	/// <summary>
-    /// Define um peso na posição de um ator para que a IA evite de passar por lá.
+    /// Define um peso na posição de uma entidade 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.
+    /// por uma entidade, 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);
+    /// <param name="entity">A entidade em questão.</param>
+	public void RegisterBlockingEntity(Entity entity) {
+		pathfinder.SetPointWeightScale(entity.GridPosition, EntityWeight);
 	}
 
 	/// <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.
+    /// Remove o peso na posição de uma entidade.
+    /// Quando uma entidade 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);
+    /// <param name="entity">A entidade em questão.</param>
+	public void UnregisterBlockingEntity(Entity entity) {
+		pathfinder.SetPointWeightScale(entity.GridPosition, 0);
 	}
 
 	public MapData(int width, int height, Player player) {
@@ -104,7 +104,7 @@ public partial class MapData : RefCounted
 		// Como o jogador é criado antes do mapa, precisamos
 		// atualizá-lo com o novo mapa.
 		player.Map_Data = this;
-		InsertActor(player);
+		InsertEntity(player);
 
 		SetupTiles();
 	}
@@ -125,12 +125,12 @@ 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.
+    /// Registra uma entidade no mapa. A existência de uma entidade não é considerada se ela não
+    /// estiver registrada no mapa.
     /// </summary>
-    /// <param name="actor">O ator em questão</param>
-	public void InsertActor(Actor actor) {
-		Actors.Add(actor);
+    /// <param name="entity">A entidade em questão</param>
+	public void InsertEntity(Entity entity) {
+		Entities.Add(entity);
 	}
 
 	/// <summary>
@@ -184,42 +184,42 @@ public partial class MapData : RefCounted
 	}
 
 	/// <summary>
-    /// Obtém o ator na posição especificada.
+    /// Obtém a entidade 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) {
-				return actor;
+    /// <returns>A entidade na posição especificada, nulo se não houver.</returns>
+	public Entity GetBlockingEntityAtPosition(Vector2I pos) {
+		foreach (Entity entity in Entities) {
+			if (entity.GridPosition == pos && entity.BlocksMovement) {
+				return entity;
 			}
 		}
 		return null;
 	}
 
 	/// <summary>
-    /// Obtém todos os atores na posição especificada.
-    /// É possível haver mais de um ator na mesma posição se um deles for morto.
+    /// Obtém todas as entidades na posição especificada.
+    /// É possível haver mais de uma entidade na mesma posição se uma delas não bloquear movimento.
     /// </summary>
     /// <param name="pos">Vetor posição</param>
-    /// <returns>Lista com todos os atores na posição especificada.</returns>
-	public Godot.Collections.Array<Actor> GetActorsAtPosition(Vector2I pos) {
-		Godot.Collections.Array<Actor> ZOfZero = [];
-		Godot.Collections.Array<Actor> ZOfOne = [];
-		Godot.Collections.Array<Actor> ZOfTwo = [];
+    /// <returns>Lista com todas as entidades na posição especificada.</returns>
+	public Godot.Collections.Array<Entity> GetEntitiesAtPosition(Vector2I pos) {
+		Godot.Collections.Array<Entity> ZOfZero = [];
+		Godot.Collections.Array<Entity> ZOfOne = [];
+		Godot.Collections.Array<Entity> ZOfTwo = [];
 		
 		// Pego todos os atores
-		foreach (Actor actor in Actors) {
-			if (actor.GridPosition == pos) {
-				switch (actor.ZIndex) {
+		foreach (Entity entity in Entities) {
+			if (entity.GridPosition == pos) {
+				switch (entity.ZIndex) {
 					case 0:
-						ZOfZero.Add(actor);
+						ZOfZero.Add(entity);
 						break;
 					case 1:
-						ZOfOne.Add(actor);
+						ZOfOne.Add(entity);
 						break;
 					case 2:
-						ZOfTwo.Add(actor);
+						ZOfTwo.Add(entity);
 						break;
 				}
 			}
@@ -228,18 +228,4 @@ public partial class MapData : RefCounted
 		// Retorno os atores ordenados por ZIndex.
 		return ZOfZero + ZOfOne + ZOfTwo;
 	}
-
-	/// <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);
-
-		if (tile == null) return false;
-
-		return tile.IsWalkable;
-	}
 }