changing peg disposition so that none = 0 and neutral = -2, will make it easier to sort peg actions later to divide them up by disposition type (will need to delay peg turns by disposition) so that it goes neutral to hostile to friendly. will need to account for this in other methods as well

Art/attack.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://m4wfj36twmqy"
+path="res://.godot/imported/attack.png-c625624f48e39eb3c9d0bdfb20bcabb8.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://Art/attack.png"
+dest_files=["res://.godot/imported/attack.png-c625624f48e39eb3c9d0bdfb20bcabb8.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

Art/star.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://c5jj7yhlnodxt"
+path="res://.godot/imported/star.png-7953868fbd7392e6e06ff69587708912.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://Art/star.png"
+dest_files=["res://.godot/imported/star.png-7953868fbd7392e6e06ff69587708912.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

Ball.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using Godot;
 
-public partial class Attack : RigidBody2D
+public partial class Ball : RigidBody2D
 {
     [Signal]
     public delegate void HitEventHandler(Node NODE);
@@ -9,7 +9,7 @@ public partial class Attack : RigidBody2D
     public delegate void BucketEnteredEventHandler();
 
     public bool _hovered = false;
-    public int _damage = 1;
+    public int _healthChange = -1, _hits = 0;
     public Vector2 _speed;
     public Path2D _predictionPath;
     public Commander _commanderOwner;
@@ -21,6 +21,16 @@ public partial class Attack : RigidBody2D
         _predictionPath = GetNode<Path2D>("PredictedPath");
     }
 
+    public void Act(Node BODY)
+    {
+        EmitSignal(SignalName.Hit, BODY);
+        if (BODY is Peg peg)
+        {
+            peg.ChangeHealth(_healthChange);
+            _hits++;
+        }
+    }
+
     public override void _PhysicsProcess(double delta)
     {
         base._PhysicsProcess(delta);
@@ -49,19 +59,5 @@ public partial class Attack : RigidBody2D
         GravityScale = 1;
     }
 
-    public void TakeAction(Node BODY)
-    {
-        EmitSignal(SignalName.Hit, BODY);
-        if (BODY is Enemy enemy)
-        {
-            enemy.TakeDamage(_damage, _commanderOwner);
-        }
-    }
     
-    public void OnMouseEntered(){
-        _hovered = true;
-    }
-    public void OnMouseExited(){
-        _hovered = true;
-    }
 }

Bucket.cs

@@ -5,7 +5,7 @@ public partial class Bucket : Node2D
 {
 	
 	[Signal]
-	public delegate void AttackEnteredEventHandler(Attack ATTACK);
+	public delegate void BallEnteredEventHandler(Ball BALL);
 	public int _minX = -500, _maxX = 500, _movementSign = 1, _movementSpeed = 3;
 	public Vector2 _startPoisition;
 
@@ -27,10 +27,10 @@ public partial class Bucket : Node2D
 	}
 	public void OnBodyEntered(Node2D BODY)
 	{
-		if (BODY is Attack attack)
+		if (BODY is Ball ball)
 		{
-			EmitSignal(SignalName.AttackEntered, attack);
+			EmitSignal(SignalName.BallEntered, ball);
-			attack.EnteredBucket();
+			ball.EnteredBucket();
 		}
 	}
 }

Commander.cs

@@ -6,18 +6,18 @@ public partial class Commander : Sprite2D
     [Signal]
     public delegate void ActionsUpEventHandler();
     public int _actionsMax = 1, _actions;
-    public PackedScene _attackScene = GD.Load<PackedScene>("res://Attack.tscn");
+    public PackedScene _ballScene = GD.Load<PackedScene>("res://Ball.tscn");
-    public Attack _attack;
+    public Ball _ball;
     public PlayerController _playerController;
 
     public override void _Process(double delta)
     {
         base._Process(delta);
-        if (_attack != null)
+        if (_ball != null)
         {
-            if (_attack.Position.Y > GetViewportRect().Size.Y + 50)
+            if (_ball.Position.Y > GetViewportRect().Size.Y + 50)
             {
-                UnloadAttack();
+                UnloadBall();
                 if (_actions <= 0)
                 {
                     EmitSignal(SignalName.ActionsUp);
@@ -26,34 +26,34 @@ public partial class Commander : Sprite2D
         }
     }
 
-    public void AttackEnteredBucket()
+    public void BallEnteredBucket()
     {
         _actions += (_actions + 1) > _actionsMax ? 0 : 1;
-        UnloadAttack();
+        UnloadBall();
     }
 
-    public void LoadAttack(Vector2 OFFSET)
+    public void LoadBall(Vector2 OFFSET)
     {
-        if (_attack == null)
+        if (_ball == null)
         {
-            _attack = _attackScene.Instantiate<Attack>();
+            _ball = _ballScene.Instantiate<Ball>();
-            _attack.Position = OFFSET;
+            _ball.Position = OFFSET;
-            _attack._commanderOwner = this;
+            _ball._commanderOwner = this;
-            _attack.GravityScale = 0;
+            _ball.GravityScale = 0;
-            _attack.BucketEntered += AttackEnteredBucket;
+            _ball.BucketEntered += BallEnteredBucket;
-            AddChild(_attack);
+            AddChild(_ball);
         }
     }
 
-    public void ShootCurrentAttack(Vector2 FORCE){
+    public void ShootCurrentBall(Vector2 FORCE){
 
-        _attack.Shoot(FORCE);
+        _ball.Shoot(FORCE);
         _actions--;
     }
 
-    public void UnloadAttack()
+    public void UnloadBall()
     {
-        _attack.QueueFree();
+        _ball.QueueFree();
-        _attack = null;
+        _ball = null;
     }
 }

Enemy.cs

@@ -1,117 +0,0 @@
-using Godot;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-public partial class Enemy : StaticBody2D
-{
-    [Signal]
-    public delegate void DeathEventHandler(Enemy THIS);
-    [Signal]
-    public delegate void ClickedEventHandler(Enemy THIS);
-    [Signal]
-    public delegate void RightClickedEventHandler(Enemy THIS);
-    public bool _hovered = false, _track = false, _warp = false;
-    public int _damage = 1, _health = 2, _stamina, _staminaRemaining, _visibilityRange = 4, _hitRange, _priority = 1;
-    public Vector2I _address = -Vector2I.One, _range = Vector2I.Up;
-    public List<Vector2I> _path = new(), _pathStored = new();
-    public float _movement = 0;
-    public EnemyController _enemyController;
-
-    public override void _Ready()
-    {
-        base._Ready();
-    }
-
-    public override void _Process(double delta)
-    {
-        base._Process(delta);
-        if (_hovered)
-        {
-            if (Input.IsActionJustPressed("leftClick"))
-            {
-                EmitSignal(SignalName.Clicked, this);
-            }
-            if (Input.IsActionJustPressed("rightClick"))
-            {
-                EmitSignal(SignalName.RightClicked, this);
-            }
-        }
-    } 
-    public override void _PhysicsProcess(double delta)
-    {
-        base._PhysicsProcess(delta);
-    }
-    
-    public void AnimateMovement(EnemyController CONTROLLER)
-    {
-        for (int i = 0; i < _path.Count; i++)
-        {
-            Tween subtween = CreateTween();
-            subtween.TweenProperty(this, "global_position", CONTROLLER._playArea._map.GetCellPositionFromAddress(_path[i]), 0.25f);
-            float key = _priority + i/1000;
-            if (!CONTROLLER._tweenStages.ContainsKey(key))
-            {
-                CONTROLLER._tweenStages[key] = new();
-            }
-            CONTROLLER._tweenStages[key].Add(subtween);
-        }
-        
-    }
-
-    public void Attack(PlayerController PLAYER)
-    {
-        PLAYER.ChangeHealth(-1, this);
-    }
-
-    public bool CanAttack()
-    {
-        return _address.Y <= _hitRange;
-    }
-
-    public void CounterAttack(Commander COMMANDER)
-    {
-        
-    }
-
-    public virtual List<Vector2I> GetGoals(Map MAP)
-    {
-        List<Vector2I> firstOpenRow = [.. MAP._cells.Where(c => c.Y == MAP.GetFirstOpenRow() && !MAP._astar.IsPointSolid(c))];
-        return firstOpenRow;
-    }
-
-    public virtual List<Vector2I> GetBestPath(Map MAP)
-    {
-        List<Vector2I> goals = GetGoals(MAP);
-        List<List<Vector2I>> paths = new();
-
-        for (int i = 0; i < goals.Count; i++)
-        {
-            paths.Add(MAP.GetPath(_address, goals[i]));
-        }
-        List<Vector2I> bestPath = paths.OrderBy(p => p.Count).ThenBy(p => p.Last().X % 2).ToList()[0];
-        return bestPath;
-    }
-
-    public void GetRemainingStamina(EnemyController CONTROLLER)
-    {
-        _staminaRemaining = _address.Y <= CONTROLLER._playArea._map.GetFirstOpenRow() ? 0 : _staminaRemaining;
-    }
-
-    public void TakeDamage(int DAMAGE, Commander ATTACKER)
-    {
-        _health -= DAMAGE;
-        CounterAttack(ATTACKER);
-        if (_health <= 0)
-        {
-            EmitSignal(SignalName.Death, this);
-        }
-    }
-
-    public void OnMouseEntered(){
-        _hovered = true;
-    }
-    public void OnMouseExited(){
-        _hovered = false;
-    }
-}

EnemyController.cs

@@ -1,212 +0,0 @@
-using Godot;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading.Tasks;
-
-public partial class EnemyController : TurnController
-{
-    
-    public PackedScene _enemyScene = GD.Load<PackedScene>("res://Enemy.tscn");
-    public List<Enemy> _enemies = new();
-    public PlayerController _playerController;
-    public Dictionary<float, List<Tween>> _tweenStages = new();
-    public Tween _tween;
-
-    public void AddEnemies(int ENEMY_COUNT = 1)
-    {
-        for (int i = 0; i < ENEMY_COUNT; i++)
-        {
-            Enemy newEnemy = _enemyScene.Instantiate<Enemy>();
-            newEnemy.Death += RemoveEnemy;
-            newEnemy.Clicked += HandleEnemyClick;
-            newEnemy.RightClicked += HandleEnemyRightClick;
-
-            newEnemy._stamina = Globals._rng.Next(2,4+1);
-            newEnemy.Modulate = new Color(newEnemy._stamina == 2 ? "#FF0000" : newEnemy._stamina == 3 ? "#00FF00" : "#0000FF");
-            newEnemy._enemyController = this;
-            List<Vector2I> unoccupied = [.. _playArea._map._bottomRow.Where(c => _enemies.All(e => e._address != c))];
-            Vector2I randomCell = unoccupied[Globals._rng.Next(unoccupied.Count)];
-            SetEnemy(newEnemy, randomCell);
-            _enemies.Add(newEnemy);
-            AddChild(newEnemy);
-        }
-    }
-    public void AddEnemies(List<Vector2I> POSITIONS)
-    {
-        for (int i = 0; i < POSITIONS.Count; i++)
-        {
-            Enemy newEnemy = _enemyScene.Instantiate<Enemy>();
-            newEnemy.Death += RemoveEnemy;
-            newEnemy.Clicked += HandleEnemyClick;
-            newEnemy.RightClicked += HandleEnemyRightClick;
-
-            newEnemy._stamina = Globals._rng.Next(2,4+1);
-            newEnemy._hitRange = Globals._rng.Next(1,2+1);
-            newEnemy.Modulate = new Color(newEnemy._stamina == 2 ? "#FF0000" : newEnemy._stamina == 3 ? "#00FF00" : "#0000FF");
-            newEnemy._enemyController = this;
-            
-            SetEnemy(newEnemy, POSITIONS[i]);
-            _enemies.Add(newEnemy);
-            AddChild(newEnemy);
-        }
-        
-    }
-
-    public void EnemyAttacks()
-    {
-        List<Enemy> attackingEnemies = [.. _enemies.Where(e => e.CanAttack())];
-        for (int i = 0; i < attackingEnemies.Count; i++)
-        {
-            Enemy enemy = attackingEnemies[i];
-            enemy.Attack(_playerController);
-            enemy._staminaRemaining = Math.Max(enemy._staminaRemaining - 2, 0);
-        }
-    }
-
-    public async Task BuildEnemyPaths()
-    {
-        Map map = _playArea._map;
-        
-        for (int i = 0; i < _enemies.Count; i++)
-        {
-            Enemy enemy = _enemies[i];
-            enemy.GetRemainingStamina(this);
-        }
-
-        _enemies.ForEach(e => e._path.Clear());
-
-        if (_enemies.All(e => e._staminaRemaining <= 0))
-        {
-            return;
-        }
-
-        while (_enemies.Any(e => e._staminaRemaining > 0))
-        {
-            for (int i = 0; i < _enemies.Count; i++)
-            {
-                Enemy enemy = _enemies[i];
-                if (enemy._staminaRemaining <= 0 || enemy._address.Y <= map.GetFirstOpenRow())
-                {
-                    enemy._path.Add(enemy._path.LastOrDefault(enemy._address));
-                    continue;
-                }
-
-                List<Vector2I> path = enemy.GetBestPath(map);
-
-                if (path.Count == 0)
-                {
-                    enemy._path.Add(enemy._path.LastOrDefault(enemy._address));
-                    continue;
-                }
-
-                Vector2I cell = path[0];
-
-                map.SetCellEnemy(cell, enemy);
-                enemy._path.Add(cell);
-                
-                enemy._staminaRemaining--;
-            }
-        }
-    }
-
-    public void HandleEnemyClick(Enemy ENEMY)
-    {
-        if (ENEMY._staminaRemaining <= 0){
-            return;
-        }
-        TileMapLayer pathLayer = _playArea.GetNode<TileMapLayer>("PathLayer");
-        List<Vector2I> newPath = ENEMY.GetBestPath(_playArea._map);
-
-
-        pathLayer.GetUsedCells().ToList().ForEach(c => pathLayer.SetCell(c,0,Vector2I.Down*4));
-        for (int i = 0; i < newPath.Count; i++)
-        {
-            pathLayer.SetCell(newPath[i],0,Vector2I.One);
-        }
-    }
-
-    public void HandleEnemyRightClick(Enemy ENEMY)
-    {
-        RemoveEnemy(ENEMY);
-    }
-
-    public void Initiate()
-    {
-        List<Vector2I> positions = [.. _playArea.GetNode<TileMapLayer>("InitialPositions").GetUsedCells()];
-
-        AddEnemies(positions);
-    }
-
-    public void ProcessTween()
-    {
-        if (_tween != null)
-        {
-            _tween.Kill();
-        }
-        _tween = CreateTween();
-        _tween.TweenInterval(0.5f);
-
-        List<float> tweenPriorities = [.. _tweenStages.Keys];
-        for (int i = 0; i < tweenPriorities.Count; i++)
-        {
-            float stage = tweenPriorities[i];
-            List<Tween> stageTweens = _tweenStages[stage];
-            _tween.Chain().TweenSubtween(stageTweens[0]);
-            for (int j = 1; j < stageTweens.Count; j++)
-            {
-                Tween step = stageTweens[j];
-                _tween.Parallel().TweenSubtween(step);
-            }
-        }
-        _tween.TweenCallback(Callable.From(() => EndTurn()));
-    }
-
-    public void StepEnemies(int STEP)
-    {
-        Map map = _playArea._map;
-
-        for (int i= 0; i < _enemies.Count; i++)
-        {
-            Enemy enemy = _enemies[i];
-            enemy.AnimateMovement(this);
-        }
-    }
-
-    public void RemoveEnemy(Enemy ENEMY_TO_REMOVE)
-    {
-        _enemies.Remove(ENEMY_TO_REMOVE);
-        _playArea._map.SetCellEnemy(ENEMY_TO_REMOVE._address, null);
-        ENEMY_TO_REMOVE.QueueFree();
-    }
-
-    public void SortEnemies()
-    {
-        _enemies = [.. _enemies.OrderByDescending(e => e._priority).ThenBy(e => e._address.Y).ThenBy(e => e._path.Count).ThenBy(e => Math.Abs(e._address.X - _playArea._map._maxX / 2))];
-    }
-
-    public override async Task StartTurn()
-    {
-        AddEnemies(1);
-
-        SortEnemies();
-        
-        EnemyAttacks();
-
-        await BuildEnemyPaths();
-        
-        StepEnemies(0);
-    }
-
-    public void SetEnemy(Enemy ENEMY, Vector2I CELL)
-    {
-        if (CELL == new Vector2I(16, 14))
-        {
-            ENEMY._track = true;
-        }
-        _playArea._map.SetCellEnemy(CELL, ENEMY);
-        ENEMY.GlobalPosition = _playArea._map.GetCellPositionFromAddress(CELL);
-    }
-
-}

Globals.cs

@@ -1,9 +1,16 @@
 using Godot;
 using System;
+using System.Collections.Generic;
 
-public partial class Globals : Node
+public partial class Globals : Node2D
 {
     public static Random _rng = new();
     public static float _gravity = (float)ProjectSettings.GetSetting("physics/2d/default_gravity"), _drag = (float)ProjectSettings.GetSetting("physics/2d/default_linear_damp");
+    public static MouseHandler _mouse;
     
+
+    public static T GetRandomFromList<T>(List<T> TYPED_LIST)
+    {
+        return TYPED_LIST[_rng.Next(0,TYPED_LIST.Count)];
+    }
 }

HoverableNode.cs

@@ -0,0 +1,52 @@
+using Godot;
+using System;
+
+public partial class HoverableNode : Node2D
+{
+    [Signal]
+    public delegate void HoverEventHandler(HoverableNode THIS, bool IS_HOVERED);
+    [Signal]
+    public delegate void ClickEventHandler(HoverableNode THIS, int CLICK_TYPE);
+
+    public bool _hovered;
+    public Area2D _bounds;
+
+    public override void _Ready()
+    {
+        base._Ready();
+        _bounds = GetNode<Area2D>("HoverBounds");
+        _bounds.MouseEntered += OnMouseEntered;
+        _bounds.MouseExited += OnMouseExited; 
+    }
+    public override void _Process(double delta)
+    {
+        base._Process(delta);
+        if (_hovered)
+        {
+            if (Input.IsActionJustPressed("leftClick"))
+            {
+                EmitSignal(SignalName.Click, this, 0);
+            }
+            if (Input.IsActionJustPressed("rightClick"))
+            {
+                EmitSignal(SignalName.Click, this, 2);
+            }
+            if (Input.IsActionJustPressed("middleClick"))
+            {
+                EmitSignal(SignalName.Click, this, 1);
+            }
+        }
+    }
+
+    public virtual void OnMouseEntered()
+    {
+        _hovered = true;
+        EmitSignal(SignalName.Hover, this,_hovered);
+    }
+
+    public virtual void OnMouseExited()
+    {
+        _hovered = false;
+        EmitSignal(SignalName.Hover, this, _hovered);
+    }
+}

HoverableNode.cs.uid

@@ -0,0 +1 @@
+uid://dqvysa2n208d3

Main.cs

@@ -7,27 +7,30 @@ public partial class Main : Node
 {
     public PlayArea _playArea;
     public PlayerController _playerController;
-    public EnemyController _enemyController;
+    public PegController _pegController;
     public TurnController _turnController;
     public Random _rng = new();
     public override void _Ready()
     {
         base._Ready();
+        Globals._mouse = GetNode<MouseHandler>("MouseHandler");
         _playArea = GetNode<PlayArea>("PlayArea");
         _playerController = GetNode<PlayerController>("PlayerController");
-        _enemyController = GetNode<EnemyController>("EnemyController");
+        _pegController = GetNode<PegController>("PegController");
 
-        _playerController._enemyController = _enemyController;
+        _playerController._pegController = _pegController;
-        _enemyController._playerController = _playerController;
+        _pegController._playerController = _playerController;
 
         _playerController._playArea = _playArea;
-        _enemyController._playArea = _playArea;
+        _pegController._playArea = _playArea;
+        _playerController._map = _playArea._map;
+        _pegController._map = _playArea._map;
 
         _playerController.TurnDone += ChangeTurn;
         _playerController.Death += EndGame;
-        _enemyController.TurnDone += ChangeTurn;
+        _pegController.TurnDone += ChangeTurn;
         
-        _enemyController.Initiate();
+        _pegController.Initiate();
         _playerController.SetUpTowers();
         ChangeTurn();
     }
@@ -43,24 +46,15 @@ public partial class Main : Node
         {
             if(_turnController == _playerController)
             {
-                ChangeTurn();
+                _playerController.EndTurn();
             }
         }
     }
 
-    public async void ChangeTurn()
+    public void ChangeTurn()
     {
-
+        _turnController = _turnController == _playerController ? _pegController : _playerController;
-        if (_turnController != _playerController)
+        _turnController.StartTurn();
-        {
-            _turnController = _playerController;
-            await _playerController.StartTurn();
-        }
-        else
-        {
-            _turnController = _enemyController;
-            await _enemyController.StartTurn();
-        }
     }
 
     public void EndGame(PlayerController PLAYER)

Map.cs

@@ -3,31 +3,97 @@ using System;
 using System.Collections.Generic;
 using System.Dynamic;
 using System.Linq;
+using System.Reflection.Metadata.Ecma335;
 
 public partial class Map : TileMapLayer
 {
+    public PackedScene _mapCellScene = GD.Load<PackedScene>("res://map_cell.tscn");
     public int _minX, _maxX, _minY, _maxY, _mainSource = 0;
-    public string _isSolidString = "is_solid";
+    public string _isSolidString = "is_solid", _dispositionString = "disposition";
     public Vector2 _cellSize, _sizeInPixels, _sizeInCells;
-    public Vector2I _pathTakenAtlasCoordinates = new Vector2I(4, 0);
-    public List<Vector2I> _cells = new(), _leftmostColumn = new(), _rightmostColumn = new(), _topRow = new(), _bottomRow = new();
     public AStarGrid2D _astar = new();
-    public Dictionary<Vector2I, Enemy> _addressOccupants = new();
+    public Dictionary<Vector2I, MapCell> _cells = new(), _leftmostColumn = new(), _rightmostColumn = new(), _topRow = new(), _bottomRow = new();
-
+    public int _firstOpenRow
+    {
+        get
+        {
+            for (int i = 0; i < _maxY; i++)
+            {
+                if (!IsRowFull(i))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+    public int _lastOpenRow
+    {
+        get
+        {
+            for (int i = _maxY; i > _minY; i--)
+            {
+                if (!IsRowFull(i))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+    public int _firstOpenColumn
+    {
+        get
+        {
+            for (int i = 0; i < _maxX; i++)
+            {
+                if (!IsColumnnFull(i))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+    public int _lastOpenColumn
+    {
+        get
+        {
+            for (int i = _maxX; i > _minX; i--)
+            {
+                if (!IsColumnnFull(i))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
     public override void _Ready()
     {
         base._Ready();
+        // GD.Print(GlobalPosition);
+        List<Vector2I> usedCells = [.. GetUsedCells()];
         _cellSize = TileSet.TileSize;
-        _cells = [.. GetUsedCells()];
+        for (int i = 0; i < usedCells.Count; i++)
-        _cells.ForEach(c => _addressOccupants[c] = null);
+        {
-        _minX = _cells.Min(c => c.X);
+            MapCell newMapCell = _mapCellScene.Instantiate<MapCell>();
-        _maxX = _cells.Max(c => c.X);
+            Vector2I usedCell = usedCells[i];
-        _minY = _cells.Min(c => c.Y);
+            newMapCell._address = usedCell;
-        _maxY = _cells.Max(c => c.Y);
+            newMapCell.GlobalPosition = newMapCell._address * _cellSize + _cellSize / 2;
-        _leftmostColumn = [.. _cells.Where(c => c.X == _minX)];
+            // GD.Print(GlobalPosition, newMapCell.GlobalPosition);
-        _rightmostColumn = [.. _cells.Where(c => c.X == _maxX)];
+            newMapCell._occupant = null;
-        _topRow = [.. _cells.Where(c => c.Y == _minY)];
+            _cells[usedCell] = newMapCell;
-        _bottomRow = [.. _cells.Where(c => c.Y == _maxY)];
+            AddChild(newMapCell);
+        }
+        _minX = _cells.Min(c => c.Value._address.X);
+        _maxX = _cells.Max(c => c.Value._address.X);
+        _minY = _cells.Min(c => c.Value._address.Y);
+        _maxY = _cells.Max(c => c.Value._address.Y);
+        _leftmostColumn = _cells.Where(c => c.Value._address.X == _minX).ToDictionary();
+        _rightmostColumn = _cells.Where(c => c.Value._address.X == _maxX).ToDictionary();
+        _topRow = _cells.Where(c => c.Value._address.Y == _minY).ToDictionary();
+        _bottomRow = _cells.Where(c => c.Value._address.Y == _maxY).ToDictionary();
         _sizeInCells = new Vector2(_topRow.Count, _leftmostColumn.Count);
         _sizeInPixels = _sizeInCells * _cellSize;
 
@@ -46,26 +112,15 @@ public partial class Map : TileMapLayer
         }
         return new Vector2I((int)Math.Floor(POSITION.X / _cellSize.X), (int)Math.Floor(POSITION.Y / _cellSize.Y));
     }
-    public Vector2 GetCellPositionFromAddress(Vector2I CELL_ADDRESS)
+
+    public int GetCellDisposition(Vector2I ADDRESS)
     {
-        return GlobalPosition + CELL_ADDRESS * _cellSize + _cellSize / 2;
+        return (int)GetCellTileData(ADDRESS).GetCustomData(_dispositionString);
     }
 
-    public int GetFirstOpenRow()
+    public MapCellOccupant GetOccupant(Vector2I CELL_TO_CHECK)
     {
-        for (int i = 0; i < _maxY; i++)
+        return _cells[CELL_TO_CHECK]._occupant;
-        {
-            if (!IsRowFull(i))
-            {
-                return i;
-            }
-        }
-        return 1;
-    }
-
-    public Enemy GetOccupant(Vector2I CELL_TO_CHECK)
-    {
-        return _addressOccupants[CELL_TO_CHECK];
     }
 
     public bool HasOccupant(Vector2I CELL_TO_CHECK)
@@ -82,33 +137,39 @@ public partial class Map : TileMapLayer
         return hasOccupant || isSolid;
     }
 
+    public bool IsColumnnFull(int COLUMN_TO_CHECK)
+    {
+        List<Vector2I> rowCells = [.. _cells.Where(c => c.Value._address.X == COLUMN_TO_CHECK).ToDictionary().Keys];
+        
+        return rowCells.All(_astar.IsPointSolid);
+    }
+
     public bool IsRowFull(int ROW_TO_CHECK)
     {
-        List<Vector2I> rowCells = [.. _cells.Where(c => c.Y == ROW_TO_CHECK)];
+        List<Vector2I> rowCells = [.. _cells.Where(c => c.Value._address.Y == ROW_TO_CHECK).ToDictionary().Keys];
         
-        return rowCells.All(c => _astar.IsPointSolid(c));
+        return rowCells.All(_astar.IsPointSolid);
     }
 
-    public void SetCellEnemy(Vector2I ADDRESS, Enemy ENEMY)
+    public void SetCellPeg(MapCell CELL, Peg PEG)
     {
-        if (ENEMY != null)
+        if (PEG != null)
         {
-            if (ENEMY._address != -Vector2I.One)
+            if (PEG._cell != null)
             {
-                _addressOccupants[ENEMY._address] = null;
+                PEG._cell._occupant = null;
-                SetCellSolid(ENEMY._address);
+                SetCellSolid(_cells[PEG._address]);
             }
-            ENEMY._address = ADDRESS;
+            PEG._cell = CELL;
+            PEG._address = CELL._address;
         }
-        
+        CELL._occupant = PEG;
-
+        SetCellSolid(CELL);
-        _addressOccupants[ADDRESS] = ENEMY;
-        SetCellSolid(ADDRESS);
     }
 
-    public void SetCellSolid(Vector2I ADDRESS)
+    public void SetCellSolid(MapCell CELL)
     {
-        _astar.SetPointSolid(ADDRESS, IsCellSolid(ADDRESS));
+        _astar.SetPointSolid(CELL._address, IsCellSolid(CELL._address));
         // _astar.SetPointWeightScale(ADDRESS, IsCellSolid(ADDRESS) ? 1000 : 1);
     }
 
@@ -121,16 +182,16 @@ public partial class Map : TileMapLayer
         _astar.Update();
         for (int i = 0; i < _cells.Count; i++)
         {
-            _astar.SetPointWeightScale(_cells[i], _cells[i].Y * 2);
+            _astar.SetPointWeightScale(_cells.ElementAt(i).Value._address, Math.Abs(_cells.ElementAt(i).Value._address.Y * 2));
         }
         EvaluateSolidCells();
     }
 
-    public List<Vector2I> GetPath(Vector2I FROM, Vector2I TO, bool INCLUDE_FROM = false)
+    public List<Vector2I> GetPath(Vector2I FROM, Vector2I TO, bool INCLUDE_FROM = false, bool PARTIAL = false)
     {
         _astar.SetPointSolid(FROM, false);
         
-        List<Vector2I> pathTaken = [.. _astar.GetIdPath(FROM, TO, true)];
+        List<Vector2I> pathTaken = [.. _astar.GetIdPath(FROM, TO, PARTIAL)];
         _astar.SetPointSolid(FROM, true);
 
         if (!INCLUDE_FROM)
@@ -144,7 +205,7 @@ public partial class Map : TileMapLayer
     {   
         for (int i = 0; i < _cells.Count; i++)
         {
-            SetCellSolid(_cells[i]);
+            SetCellSolid(_cells.ElementAt(i).Value);
         }
     }
 

Map.tscn

@@ -1,4 +1,4 @@
-[gd_scene format=3 uid="uid://mjinvqj25wha"]
+[gd_scene format=3 uid="uid://dqknim3lldrmv"]
 
 [ext_resource type="Texture2D" uid="uid://cf554xlykq1o4" path="res://Art/tile_set.png" id="1_gfjgm"]
 [ext_resource type="Script" uid="uid://d2ri1sa0jwtqm" path="res://Map.cs" id="2_3vi7k"]
@@ -11,7 +11,9 @@ texture = ExtResource("1_gfjgm")
 texture_region_size = Vector2i(40, 40)
 0:0/0 = 0
 1:0/0 = 0
+1:0/0/custom_data_1 = -1
 2:0/0 = 0
+2:0/0/custom_data_1 = 1
 3:0/0 = 0
 3:0/0/custom_data_0 = true
 4:0/0 = 0
@@ -26,6 +28,8 @@ texture_region_size = Vector2i(40, 40)
 tile_size = Vector2i(40, 40)
 custom_data_layer_0/name = "is_solid"
 custom_data_layer_0/type = 1
+custom_data_layer_1/name = "disposition"
+custom_data_layer_1/type = 2
 sources/1 = SubResource("TileSetAtlasSource_trj13")
 pattern_0 = SubResource("TileMapPattern_fjt81")
 

MapCell.cs

@@ -0,0 +1,15 @@
+using Godot;
+using System;
+
+public partial class MapCell : Node2D
+{
+    public Vector2I _address;
+    public MapCellOccupant _occupant;
+
+    public override void _Ready()
+    {
+        base._Ready();
+    }
+
+}
+

MapCell.cs.uid

@@ -0,0 +1 @@
+uid://b8fx1wwyj30bg

MapCellOccupant.cs

@@ -0,0 +1,16 @@
+using Godot;
+using System;
+
+public partial class MapCellOccupant : HoverableNode
+{
+    public Vector2I _address;
+    public MapCell _cell;
+    public Disposition _disposition = Disposition.NONE;
+    public enum Disposition
+    {
+        NONE = 0,
+        FRIENDLY = 1,
+        HOSTILE = -1,
+        NEUTRAL = -2
+    }
+}

MapCellOccupant.cs.uid

@@ -0,0 +1 @@
+uid://b3dlktsgeteuw

MouseHandler.cs

@@ -0,0 +1,18 @@
+using Godot;
+using System;
+
+public partial class MouseHandler : Node
+{
+    public enum ClickType
+    {
+        LEFT_CLICK,
+        MIDDLE_CLICK,
+        RIGHT_CLICK,
+        LEFT_HOLD,
+        MIDDLE_HOLD,
+        RIGHT_HOLD,
+        LEFT_DOUBLE,
+        MIDDLE_DOUBLE,
+        RIGHT_DOUBLE
+    }
+}

MouseHandler.cs.uid

@@ -0,0 +1 @@
+uid://dewxuppyw2gtp

Peg.cs

@@ -0,0 +1,91 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+public partial class Peg : MapCellOccupant
+{
+    [Signal]
+    public delegate void DeathEventHandler(Peg THIS);
+    public int _id, _health = 2, _healthMax = 2, _stamina, _staminaRemaining, _movement = 0, _visibility;
+    public List<MapCell> _path = new();
+    public PegController _pegController;
+    public Map _map;
+    public List<PegAction> _actions;
+    public int _distanceToGoal
+    {
+        get
+        {
+            return GetBestPath().Count;
+        }
+    }
+
+    public override void _Ready()
+    {
+        base._Ready();
+        _actions = [.. GetNode<Node2D>("Actions").GetChildren().Cast<PegAction>()];
+        _map = _pegController._playArea._map;
+    }
+    public virtual PegAction SelectAction()
+    {
+        return _actions.FirstOrDefault(a => a.MeetsCriteria(this), null);
+    }
+
+    public virtual void CounterAct(Commander COMMANDER)
+    {
+        
+    }
+
+    public virtual List<MapCell> GetBestPath(bool PARTIAL = false)
+    {
+        MapCell goal = Goal();
+        return [.. _map.GetPath(_address, goal._address, false, PARTIAL).Select(a => _map._cells[a])];
+    }
+
+    public virtual Dictionary<Vector2I, MapCell> GetEnemies()
+    {
+        return _map._cells.Where(c => (int)(c.Value._occupant?._disposition ?? Disposition.NONE) == -(int)_disposition).ToDictionary();
+    }
+
+    public virtual Dictionary<Vector2I, MapCell> GetVisibleCells()
+    {
+        Map map = _pegController._playArea._map;
+        return map._cells.Where(c => (c.Value._address - _address).Length() <= _visibility).ToDictionary();
+    }
+
+    public virtual Dictionary<Vector2I, MapCell> GetVisibleEnemies()
+    {
+        Dictionary<Vector2I, MapCell> visible  = GetVisibleCells();
+        Dictionary<Vector2I, MapCell> enemies  = GetEnemies();
+        
+        return enemies.Keys.Intersect(visible.Keys).ToDictionary(e => e, e => enemies[e]);
+    }
+
+    public virtual MapCell Goal()
+    {
+        Dictionary<Vector2I, MapCell> enemyTerritory = _map._cells.Where(c => _map.GetCellDisposition(c.Value._address) == (_disposition == Disposition.FRIENDLY ? -1 : 1)).ToDictionary();
+        Dictionary<Vector2I, MapCell> closest = enemyTerritory.OrderByDescending(c => c.Value._address.Y).ThenBy(c => Math.Abs(c.Value._address.X - _address.X)).ToDictionary();
+        return closest.ElementAt(0).Value;
+    }
+
+    public virtual void StartTurn()
+    {
+        _staminaRemaining = _stamina;
+        _actions.ForEach(a => a.Reset());
+    }
+
+    public virtual void ChangeHealth(int DELTA)
+    {
+        _health += DELTA;
+        if (_health <= 0)
+        {
+            EmitSignal(SignalName.Death, this);
+        }
+        else if (_health > _healthMax)
+        {
+            _health = _healthMax;
+        }
+    }
+
+}

Peg.cs.uid

@@ -0,0 +1 @@
+uid://g2ucwg3k342p

PegController.cs

@@ -0,0 +1,267 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml;
+
+public partial class PegController : TurnController
+{
+    public int _pegsCreated = 0, _pegsDestroyed = 0;
+    public List<PackedScene> _hostilePegScenes, _friendlyPegScenes, _neutralPegScenes;
+    public List<Peg> _pegs = new();
+    public PlayerController _playerController;
+    public Dictionary<string, List<Tuple<Peg, PegAction>>> _tweenStages = new();
+    public Tween _tween;
+    public XmlDocument _pegProbabilities = new();
+
+    public override void _Ready()
+    {
+        base._Ready();
+        _hostilePegScenes = [.. Directory.GetFiles("Pegs/HostilePegs/", "*.tscn").Select(f => GD.Load<PackedScene>(f))];
+        _friendlyPegScenes = [.. Directory.GetFiles("Pegs/FriendlyPegs/", "*.tscn").Select(f => GD.Load<PackedScene>(f))];
+        // _neutralPegScenes = [.. Directory.GetFiles("Pegs/NeutralPegs/", "*.tscn").Select(f => GD.Load<PackedScene>(f))];
+
+        // _pegProbabilities.Load("res://PegProbabilities.xml");
+    }
+
+    public void AddFriendlyPegs(int PEG_COUNT = 1)
+    {
+        for (int i = 0; i < PEG_COUNT; i++)
+        {
+            FriendlyPeg newFriendlyPeg = Globals.GetRandomFromList(_friendlyPegScenes).Instantiate<FriendlyPeg>();
+            newFriendlyPeg._id = _pegsCreated;
+            newFriendlyPeg.Death += HandlePegRemoval;
+            newFriendlyPeg.Click += HandlePegClick;
+
+            newFriendlyPeg._pegController = this;
+
+            Dictionary<Vector2I, MapCell> unoccupied = _playArea._map._bottomRow.Where(c => c.Value._occupant == null).ToDictionary();
+            MapCell randomCell = unoccupied.ElementAt(Globals._rng.Next(unoccupied.Keys.Count)).Value;
+
+            SetPeg(newFriendlyPeg, randomCell);
+            _pegs.Add(newFriendlyPeg);
+            AddChild(newFriendlyPeg);
+            _pegsCreated++;
+        }
+    }
+    public void AddFriendlyPegs(List<Vector2I> POSITIONS)
+    {
+        for (int i = 0; i < POSITIONS.Count; i++)
+        {
+            FriendlyPeg newFriendlyPeg = Globals.GetRandomFromList(_friendlyPegScenes).Instantiate<FriendlyPeg>();
+            newFriendlyPeg._id = _pegsCreated;
+            newFriendlyPeg.Scale *= _pegsCreated == 4 ? 1.5f : 1f;
+            newFriendlyPeg.Death += HandlePegRemoval;
+            newFriendlyPeg.Click += HandlePegClick;
+
+            newFriendlyPeg._pegController = this;
+            
+            SetPeg(newFriendlyPeg, _map._cells[POSITIONS[i]]);
+            _pegs.Add(newFriendlyPeg);
+            AddChild(newFriendlyPeg);
+            _pegsCreated++;
+        }
+    }
+
+    public void AddHostilePegs(int PEG_COUNT = 1)
+    {
+        for (int i = 0; i < PEG_COUNT; i++)
+        {
+            HostilePeg newHostilePeg = Globals.GetRandomFromList(_hostilePegScenes).Instantiate<HostilePeg>();
+            newHostilePeg._id = _pegsCreated;
+            newHostilePeg.Death += HandlePegRemoval;
+            newHostilePeg.Click += HandlePegClick;
+
+            newHostilePeg._pegController = this;
+
+            Dictionary<Vector2I, MapCell> unoccupied = _map._bottomRow.Where(c => c.Value._occupant == null).ToDictionary();
+            MapCell randomCell = unoccupied.ElementAt(Globals._rng.Next(unoccupied.Count)).Value;
+
+            SetPeg(newHostilePeg, randomCell);
+            _pegs.Add(newHostilePeg);
+            AddChild(newHostilePeg);
+            _pegsCreated++;
+        }
+    }
+    public void AddHostilePegs(List<Vector2I> POSITIONS)
+    {
+        for (int i = 0; i < POSITIONS.Count; i++)
+        {
+            HostilePeg newHostilePeg = Globals.GetRandomFromList(_hostilePegScenes).Instantiate<HostilePeg>();
+            newHostilePeg._id = _pegsCreated;
+            newHostilePeg.Scale *= _pegsCreated == 4 ? 1.5f : 1f;
+            newHostilePeg.Death += HandlePegRemoval;
+            newHostilePeg.Click += HandlePegClick;
+
+            newHostilePeg._pegController = this;
+            newHostilePeg._map = _playArea._map;
+            
+            SetPeg(newHostilePeg, _map._cells[POSITIONS[i]]);
+            _pegs.Add(newHostilePeg);
+            AddChild(newHostilePeg);
+            _pegsCreated++;
+        }
+    }
+    
+    public void HandlePegTurn()
+    {
+        _tweenStages.Clear();
+
+        int loop = 0;
+        bool anyPegsActed = true;
+        while (anyPegsActed)
+        {
+            anyPegsActed = false;
+            for (int i = 0; i < _pegs.Count; i++)
+            {
+                Peg peg = _pegs[i];
+                PegAction action = peg.SelectAction();
+                
+                if (action != null)
+                {
+                    action.DoImmediately(peg);
+                    string key = action._priority + ":" + loop;
+                    
+                    if (!_tweenStages.ContainsKey(key))
+                    {
+                        _tweenStages[key] = new();
+                    }
+                    _tweenStages[key].Add(new(peg, action));
+                    if (!anyPegsActed)
+                    {
+                        anyPegsActed = true;
+                    }
+                    peg._staminaRemaining -= action._cost;
+                }
+            }
+            loop++;
+        }
+        ProcessTween();
+    }
+
+    public void HandlePegClick(Node CLICKED_NODE, int CLICK_TYPE)
+    {
+        if (CLICKED_NODE is not Peg peg)
+        {
+            return;
+        }
+        if (CLICK_TYPE == 0)
+        {
+            
+            Map map = _playArea._map;
+            TileMapLayer pathLayer = _playArea.GetNode<TileMapLayer>("PathLayer");
+            List<Vector2I> pl = [.. pathLayer.GetUsedCells()];
+            Dictionary<Vector2I, MapCell> visible = peg.GetVisibleCells();
+
+            for (int i = 0; i < pl.Count; i++)
+            {
+                Vector2I cell = pl[i];
+                pathLayer.GetUsedCells().ToList().ForEach(c => pathLayer.SetCell(cell,0,Vector2I.Down + Vector2I.Right*(visible.ContainsKey(cell) ? 1 : 4)));
+                
+            }
+        }
+        else if (CLICK_TYPE == 1)
+        {
+            TileMapLayer pathLayer = _playArea.GetNode<TileMapLayer>("PathLayer");
+            List<MapCell> newPath = peg.GetBestPath(true);
+
+            pathLayer.GetUsedCells().ToList().ForEach(c => pathLayer.SetCell(c,0,Vector2I.Down + Vector2I.Right*4));
+            for (int i = 0; i < newPath.Count; i++)
+            {
+                pathLayer.SetCell(newPath[i]._address,0,Vector2I.One);
+            }
+        }
+        else if (CLICK_TYPE == 2)
+        {
+            HandlePegRemoval(peg);
+        }
+        
+    }
+
+    public void HandlePegRemoval(Peg PEG_TO_REMOVE)
+    {
+        _pegs.Remove(PEG_TO_REMOVE);
+        _playArea._map.SetCellPeg(_map._cells[PEG_TO_REMOVE._address], null);
+        PEG_TO_REMOVE.QueueFree();
+        _pegsDestroyed++;
+    }
+
+    public void HandlePegSort()
+    {
+        _pegs = [.. _pegs.OrderBy(p => p._address.Y).ThenBy(p => p._distanceToGoal).ThenBy(p => Math.Abs(p._address.X - _playArea._map._maxX / 2))];
+    }
+
+
+    public void Initiate()
+    {
+        TileMapLayer init = _playArea.GetNode<TileMapLayer>("InitialPositions");
+        List<Vector2I> initPos = [.. init.GetUsedCells()];
+        List<Vector2I> positions = [.. initPos.OrderBy(c => c.Y).ThenBy(c => c.X)];
+        List<Vector2I> hPositions = [.. positions.Where(c => (int)init.GetCellTileData(c).GetCustomData("disposition") == -1)];
+        List<Vector2I> fPositions = [.. positions.Where(c => (int)init.GetCellTileData(c).GetCustomData("disposition") == 1)];
+        AddHostilePegs(hPositions);
+        AddFriendlyPegs(fPositions);
+        _playArea.HighlightCells();
+    }
+
+    public void ProcessTween()
+    {
+        _tweenStages = _tweenStages.OrderBy(s => int.Parse(s.Key.Split(":")[0])).ThenBy(s => int.Parse(s.Key.Split(":")[1])).ToDictionary();
+        
+        if (_tweenStages.Count <= 0)
+        {
+            EndTurn();
+            return;
+        }
+
+        _tween?.Kill();
+
+        _tween = CreateTween();
+
+        for (int i = 0; i < _tweenStages.Count; i++)
+        {
+            _tween.Chain().TweenInterval(0.5f);
+            List<Tuple<Peg, PegAction>> tweenSteps = _tweenStages.Values.ElementAt(i);
+            for (int j = 0; j < tweenSteps.Count; j++)
+            {
+                Tuple<Peg, PegAction> step = tweenSteps[j];
+                Peg peg = step.Item1;
+                PegAction action = step.Item2;
+                Tween tween = action.CreateAnimation(peg);
+                if (tween != null)
+                {
+                    _tween.Parallel().TweenSubtween(tween);
+                }
+            }
+        }
+        _tween.TweenCallback(Callable.From(EndTurn));
+        
+    }
+
+    public override void StartTurn()
+    {
+        AddHostilePegs(4);
+
+        for (int i = 0; i < _pegs.Count; i++)
+        {
+            _pegs[i].StartTurn();
+        }
+        HandlePegSort();
+        
+        HandlePegTurn();
+        _playArea.HighlightCells();
+    }
+
+    public void SetPeg(Peg PEG, MapCell CELL)
+    {
+        _map.SetCellPeg(CELL, PEG);
+        PEG.GlobalPosition = CELL.GlobalPosition;
+    }
+
+}

PegProbabilities.html

@@ -0,0 +1,3 @@
+<xml>
+    
+</xml>

Pegs/Actions/BasicMovement.cs

@@ -0,0 +1,58 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public partial class BasicMovement : PegAction
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _category = "movement";
+        _priority = 0;
+        _cost = 1;
+        _range = 2^32;
+        _usesMax = 2^32;
+        _usesRemaining = _usesMax;
+    }
+
+    public override Tween CreateAnimation(Peg PEG)
+    {
+        PegController pegController = PEG._pegController;
+        Map map = pegController._playArea._map;
+        MapCell cell = PEG._path[0];
+
+        Tween subtween = CreateTween();
+        Vector2 target = cell.GlobalPosition;
+
+        subtween.TweenProperty(PEG, "global_position", target, 0.25f);
+        PEG._path.RemoveAt(0);
+        return subtween;
+    }
+
+    public override void DoImmediately(Peg PEG)
+    {
+        List<MapCell> path = PEG.GetBestPath(true);
+        PegController pegController = PEG._pegController;
+        Map map = pegController._playArea._map;
+        if (path?.Count == 0)
+        {
+            return;
+        }
+        MapCell cell = path[0];
+        
+        map.SetCellPeg(cell, PEG);
+        PEG._path.Add(cell);
+    }
+
+    public override bool MeetsCriteria(Peg PEG)
+    {
+        List<MapCell> bestPath = PEG.GetBestPath(true);
+        return base.MeetsCriteria(PEG) 
+               && bestPath.Count > 0
+               && PEG._map.GetCellDisposition(bestPath[0]._address) != -(int)PEG._disposition;
+    }
+
+
+
+}

Pegs/Actions/BasicMovement.cs.uid

@@ -0,0 +1 @@
+uid://hp5iucbq5brg

Pegs/Actions/ShootShortbow.cs

@@ -0,0 +1,35 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public partial class ShootShortbow : PegAction
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _category = "attack";
+        _priority = 1;
+        _cost = 2;
+        _range = 2;
+        _usesMax = 1;
+        _usesRemaining = _usesMax;
+    }
+    
+    public override Tween CreateAnimation(Peg PEG)
+    {
+        MapCell target = Target(PEG);
+        Tween subtween = CreateTween();
+        subtween.TweenProperty(_image, "visible", true, 0.0f);
+        subtween.TweenProperty(_image, "rotation", PEG.GetAngleTo(target.GlobalPosition), 0.0f);
+        subtween.TweenProperty(_image, "global_position", target.GlobalPosition, 0.5f);
+        subtween.TweenCallback(Callable.From(() =>
+        {
+            PEG._pegController._playerController.ChangeHealth(-2, this);
+            Position = Vector2.Zero;
+            Visible = false;
+        }));
+        return subtween;
+    }
+    
+}

Pegs/Actions/ShootShortbow.cs.uid

@@ -0,0 +1 @@
+uid://dt7qbvowj1sm4

Pegs/Actions/SwingShortsword.cs

@@ -0,0 +1,35 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public partial class SwingShortsword : PegAction
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _category = "attack";
+        _priority = 1;
+        _cost = 2;
+        _range = 1;
+        _usesMax = 1;
+        _usesRemaining = _usesMax;
+    }
+
+    public override Tween CreateAnimation(Peg PEG)
+    {
+        MapCell target = Target(PEG);
+        // GD.Print(target);
+        Tween subtween = CreateTween();
+        subtween.TweenProperty(_image, "visible", true, 0.0f);
+        subtween.TweenProperty(_image, "rotation", PEG.GetAngleTo(target.GlobalPosition), 0.0f);
+        subtween.TweenProperty(_image, "global_position", target.GlobalPosition, 0.5f);
+        subtween.TweenCallback(Callable.From(() =>
+        {
+            PEG._pegController._playerController.ChangeHealth(-2, this);
+            _image.Position = Vector2.Zero;
+            _image.Visible = false;
+        }));
+        return subtween;
+    }
+}

Pegs/Actions/SwingShortsword.cs.uid

@@ -0,0 +1 @@
+uid://td6dv1t4y5os

Pegs/Actions/ThrustSpear.cs

@@ -0,0 +1,43 @@
+using Godot;
+using System;
+
+public partial class ThrustSpear : PegAction
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _category = "attack";
+        _priority = 1;
+        _cost = 1;
+        _range = 1;
+        _usesMax = 1;
+        _usesRemaining = _usesMax;
+    }
+
+    public override Tween CreateAnimation(Peg PEG)
+    {
+        MapCell target = Target(PEG);
+        if (target == PEG._cell)
+        {
+            return null;
+        }
+        Tween subtween = CreateTween();
+        
+        subtween.TweenProperty(_image, "visible", true, 0.0f);
+        subtween.TweenProperty(_image, "rotation", PEG.GetAngleTo(target.GlobalPosition), 0.0f);
+        subtween.TweenProperty(_image, "global_position", target.GlobalPosition, 0.5f);
+        subtween.TweenCallback(Callable.From(() =>
+        {
+            ((Peg)target?._occupant)?.ChangeHealth(-1);
+            _image.Position = Vector2.Zero;
+            _image.Visible = false;
+        }));
+        return subtween;
+    }
+
+    public override MapCell Target(Peg PEG)
+    {
+        return PEG.Goal();
+    }
+
+}

Pegs/Actions/ThrustSpear.cs.uid

@@ -0,0 +1 @@
+uid://bj2lg1voxioq7

Pegs/Actions/basic_movement.tscn

@@ -0,0 +1,9 @@
+[gd_scene format=3 uid="uid://bup5oli00p3lg"]
+
+[ext_resource type="Script" uid="uid://hp5iucbq5brg" path="res://Pegs/Actions/BasicMovement.cs" id="1_u1rld"]
+
+[node name="BasicMovement" type="Node2D" unique_id=460007250]
+script = ExtResource("1_u1rld")
+
+[node name="Image" type="Sprite2D" parent="." unique_id=1133735272]
+visible = false

Pegs/Actions/shoot_shortbow.tscn

@@ -0,0 +1,12 @@
+[gd_scene format=3 uid="uid://duspilwelsiy3"]
+
+[ext_resource type="Script" uid="uid://dt7qbvowj1sm4" path="res://Pegs/Actions/ShootShortbow.cs" id="1_yhiab"]
+[ext_resource type="Texture2D" uid="uid://32m5teus1cjj" path="res://Art/tower.png" id="2_uaien"]
+
+[node name="ShootShortbow" type="Node2D" unique_id=518048625]
+script = ExtResource("1_yhiab")
+
+[node name="Image" type="Sprite2D" parent="." unique_id=944294157]
+visible = false
+scale = Vector2(0.1, 0.1)
+texture = ExtResource("2_uaien")

Pegs/Actions/swing_shortsword.tscn

@@ -0,0 +1,12 @@
+[gd_scene format=3 uid="uid://c6df6ib0qan5g"]
+
+[ext_resource type="Script" uid="uid://td6dv1t4y5os" path="res://Pegs/Actions/SwingShortsword.cs" id="1_rflgk"]
+[ext_resource type="Texture2D" uid="uid://32m5teus1cjj" path="res://Art/tower.png" id="2_fs74r"]
+
+[node name="Shortsword" type="Node2D" unique_id=518048625]
+script = ExtResource("1_rflgk")
+
+[node name="Image" type="Sprite2D" parent="." unique_id=906537972]
+visible = false
+scale = Vector2(0.1, 0.1)
+texture = ExtResource("2_fs74r")

Pegs/Actions/thrust_spear.tscn

@@ -0,0 +1,13 @@
+[gd_scene format=3 uid="uid://xx4n81m8hbxv"]
+
+[ext_resource type="Script" uid="uid://bj2lg1voxioq7" path="res://Pegs/Actions/ThrustSpear.cs" id="1_revbx"]
+[ext_resource type="Texture2D" uid="uid://32m5teus1cjj" path="res://Art/tower.png" id="2_nwcvh"]
+
+[node name="ThrustSpear" type="Node2D" unique_id=460007250]
+script = ExtResource("1_revbx")
+
+[node name="Image" type="Sprite2D" parent="." unique_id=1133735272]
+visible = false
+position = Vector2(0, -4.999999)
+scale = Vector2(0.1, 0.1)
+texture = ExtResource("2_nwcvh")

Pegs/FriendlyPeg.cs

@@ -0,0 +1,13 @@
+using Godot;
+using System;
+
+public partial class FriendlyPeg : Peg
+{
+
+    public override void _Ready()
+    {
+        base._Ready();
+        _disposition = Disposition.FRIENDLY;
+    }
+
+}

Pegs/FriendlyPeg.cs.uid

@@ -0,0 +1 @@
+uid://fxx1mrrxxqip

Pegs/FriendlyPegs/Spearman.cs

@@ -0,0 +1,25 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public partial class Spearman : FriendlyPeg
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _stamina = 2;
+        _visibility = 4;
+    }
+
+    public override MapCell Goal()
+    {
+        Dictionary<Vector2I, MapCell> enemies = GetVisibleEnemies();
+        if (enemies.Count == 0)
+        {
+            return _cell;
+        }
+        Dictionary<Vector2I, MapCell> closest = enemies.OrderBy(e => (e.Value._occupant._address - _address).Length()).ToDictionary();
+        return closest.ElementAt(0).Value;
+    }
+}

Pegs/FriendlyPegs/Spearman.cs.uid

@@ -0,0 +1 @@
+uid://dd4k8egcg3r2v

Pegs/FriendlyPegs/spearman.tscn

@@ -0,0 +1,43 @@
+[gd_scene format=3 uid="uid://b5rrpaj7up7w3"]
+
+[ext_resource type="Script" uid="uid://dd4k8egcg3r2v" path="res://Pegs/FriendlyPegs/Spearman.cs" id="1_rd6ui"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_v2nt8"]
+[ext_resource type="PackedScene" uid="uid://xx4n81m8hbxv" path="res://Pegs/Actions/thrust_spear.tscn" id="3_ig48t"]
+[ext_resource type="PackedScene" uid="uid://bup5oli00p3lg" path="res://Pegs/Actions/basic_movement.tscn" id="4_gi7y5"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="Spearman" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_rd6ui")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+modulate = Color(1, 1, 0, 1)
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("2_v2nt8")
+
+[node name="Actions" type="Node2D" parent="." unique_id=2023031702]
+
+[node name="ThrustSpear" parent="Actions" unique_id=460007250 instance=ExtResource("3_ig48t")]
+
+[node name="BasicMovement" parent="Actions" unique_id=791425339 instance=ExtResource("4_gi7y5")]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/HostilePeg.cs

@@ -0,0 +1,17 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+public partial class HostilePeg : Peg
+{
+
+    public override void _Ready()
+    {
+        base._Ready();
+        
+        _disposition = Disposition.HOSTILE;
+    }
+
+}

Pegs/HostilePegs/Archer.cs

@@ -0,0 +1,12 @@
+using Godot;
+using System;
+
+public partial class Archer : HostilePeg
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _stamina = 2;
+        _visibility = 4;
+    }
+}

Pegs/HostilePegs/Archer.cs.uid

@@ -0,0 +1 @@
+uid://b3a0x3r3yx861

Pegs/HostilePegs/Infantry.cs

@@ -0,0 +1,12 @@
+using Godot;
+using System;
+
+public partial class Infantry : HostilePeg
+{
+    public override void _Ready()
+    {
+        base._Ready();
+        _stamina = 3;
+        _visibility = 3;
+    }
+}

Pegs/HostilePegs/Infantry.cs.uid

@@ -0,0 +1 @@
+uid://xlg4cblo1vf1

Pegs/HostilePegs/archer.tscn

@@ -0,0 +1,43 @@
+[gd_scene format=3 uid="uid://dwqhme11j5ihb"]
+
+[ext_resource type="Script" uid="uid://b3a0x3r3yx861" path="res://Pegs/HostilePegs/Archer.cs" id="1_ij48w"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_j7but"]
+[ext_resource type="PackedScene" uid="uid://duspilwelsiy3" path="res://Pegs/Actions/shoot_shortbow.tscn" id="3_c81uf"]
+[ext_resource type="PackedScene" uid="uid://bup5oli00p3lg" path="res://Pegs/Actions/basic_movement.tscn" id="3_j7but"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="Archer" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_ij48w")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+self_modulate = Color(0, 0, 1, 1)
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("2_j7but")
+
+[node name="Actions" type="Node2D" parent="." unique_id=96111050]
+
+[node name="ShootShortbow" parent="Actions" unique_id=518048625 instance=ExtResource("3_c81uf")]
+
+[node name="BasicMovement" parent="Actions" unique_id=460007250 instance=ExtResource("3_j7but")]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/HostilePegs/infantry.tscn

@@ -0,0 +1,43 @@
+[gd_scene format=3 uid="uid://d55ut168gh3k"]
+
+[ext_resource type="Script" uid="uid://xlg4cblo1vf1" path="res://Pegs/HostilePegs/Infantry.cs" id="1_wlksp"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_b77ka"]
+[ext_resource type="PackedScene" uid="uid://c6df6ib0qan5g" path="res://Pegs/Actions/swing_shortsword.tscn" id="3_b77ka"]
+[ext_resource type="PackedScene" uid="uid://bup5oli00p3lg" path="res://Pegs/Actions/basic_movement.tscn" id="4_b77ka"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="Infantry" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_wlksp")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+self_modulate = Color(1, 0, 0, 1)
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("2_b77ka")
+
+[node name="Actions" type="Node2D" parent="." unique_id=1442443799]
+
+[node name="Shortsword" parent="Actions" unique_id=518048625 instance=ExtResource("3_b77ka")]
+
+[node name="BasicMovement" parent="Actions" unique_id=460007250 instance=ExtResource("4_b77ka")]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/NeutralPeg.cs

@@ -0,0 +1,14 @@
+using Godot;
+using System;
+
+public partial class NeutralPeg : Peg
+{
+
+    public override void _Ready()
+    {
+        base._Ready();
+        
+        _disposition = Disposition.NEUTRAL;
+    }
+
+}

Pegs/NeutralPeg.cs.uid

@@ -0,0 +1 @@
+uid://hcna8x41gtkq

Pegs/PegAction.cs

@@ -0,0 +1,43 @@
+using Godot;
+using System;
+
+public partial class PegAction : Node2D
+{
+    public string _category;
+    public int _priority, _cost, _range, _usesMax, _usesRemaining, _triggers = 0;
+    public Sprite2D _image;
+
+    public override void _Ready()
+    {
+        base._Ready();
+        _image = GetNode<Sprite2D>("Image");
+    }
+
+    public virtual Tween CreateAnimation(Peg PEG)
+    {
+        return null;
+    }
+
+    public virtual void DoImmediately(Peg PEG)
+    {
+
+    }
+
+    public virtual bool MeetsCriteria(Peg PEG)
+    {
+        MapCell target = Target(PEG);
+        return PEG._staminaRemaining >= _cost
+            && _usesRemaining > 0
+            && (PEG._address - target._address).Length() <= _range;
+    }
+
+    public virtual void Reset()
+    {
+        _usesRemaining = _usesMax;
+    }
+
+    public virtual MapCell Target(Peg PEG)
+    {
+        return PEG.Goal();
+    }
+}

Pegs/PegAction.cs.uid

@@ -0,0 +1 @@
+uid://dpa15pxib2qyr

Pegs/friendly_peg.tscn

@@ -0,0 +1,36 @@
+[gd_scene format=3 uid="uid://tym3gfecxnhf"]
+
+[ext_resource type="Script" uid="uid://fxx1mrrxxqip" path="res://Pegs/FriendlyPeg.cs" id="1_d26yj"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="1_q81kk"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="FriendlyPeg" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_d26yj")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("1_q81kk")
+
+[node name="Actions" type="Node2D" parent="." unique_id=2023031702]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/hostile_peg.tscn

@@ -1,7 +1,7 @@
-[gd_scene format=3 uid="uid://drt7w0eqp13tu"]
+[gd_scene format=3 uid="uid://43ty0uit6ylb"]
 
-[ext_resource type="Script" uid="uid://dfba4vq6jv0a6" path="res://Enemy.cs" id="1_4gyqm"]
+[ext_resource type="Script" uid="uid://dfba4vq6jv0a6" path="res://Pegs/HostilePeg.cs" id="1_nc8fp"]
-[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="1_7k104"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_0icqg"]
 
 [sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
 bounce = 0.5
@@ -9,17 +9,28 @@ bounce = 0.5
 [sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
 radius = 12.5
 
-[node name="Enemy" type="StaticBody2D" unique_id=1417697759]
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="HostilePeg" type="StaticBody2D" unique_id=1417697759]
 input_pickable = true
 physics_material_override = SubResource("PhysicsMaterial_7k104")
-script = ExtResource("1_4gyqm")
+script = ExtResource("1_nc8fp")
 
 [node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
 shape = SubResource("CircleShape2D_4gyqm")
 
 [node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+texture_filter = 1
 scale = Vector2(0.5, 0.5)
-texture = ExtResource("1_7k104")
+texture = ExtResource("2_0icqg")
+
+[node name="Actions" type="Node2D" parent="." unique_id=2023031702]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
 
 [connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
 [connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/neutral_peg.tscn

@@ -0,0 +1,36 @@
+[gd_scene format=3 uid="uid://d3jw2bvkr8ahq"]
+
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="1_bdrbe"]
+[ext_resource type="Script" uid="uid://hcna8x41gtkq" path="res://Pegs/NeutralPeg.cs" id="1_vrgbl"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_6w6fg"]
+radius = 12.5
+
+[node name="NeutralPeg" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_vrgbl")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("1_bdrbe")
+
+[node name="Actions" type="Node2D" parent="." unique_id=2023031702]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=937525982]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=2142666816]
+shape = SubResource("CircleShape2D_6w6fg")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

Pegs/peg_action.tscn

@@ -0,0 +1,9 @@
+[gd_scene format=3 uid="uid://bj2qrn0l01us1"]
+
+[ext_resource type="Script" uid="uid://dpa15pxib2qyr" path="res://Pegs/PegAction.cs" id="1_8o8tf"]
+
+[node name="PegAction" type="Node2D" unique_id=460007250]
+script = ExtResource("1_8o8tf")
+
+[node name="Image" type="Sprite2D" parent="." unique_id=1133735272]
+visible = false

PlayArea.cs

@@ -8,12 +8,10 @@ public partial class PlayArea : Node2D
     public Node2D _leftEdge, _rightEdge;
     public Area2D _region;
     public Map _map;
-    public Bucket _bucket;
 
     public override void _Ready()
     {
         base._Ready();
-        _bucket = GetNode<Bucket>("Bucket");
         _region = GetNode<Area2D>("Region");
 
         _leftEdge = GetNode<Node2D>("LeftEdge");
@@ -23,33 +21,32 @@ public partial class PlayArea : Node2D
 
         _map = GetNode<Map>("Map");
         TileMapLayer occupiedSpaces = GetNode<TileMapLayer>("OccupiedSpaces");
-        occupiedSpaces.SetCell(Vector2I.Zero, 0,  new Vector2I(4,0));
     }
     
     public override void _Process(double delta)
     {
         base._Process(delta);
-        _bucket.Move();
     }
 
     public void HighlightCells()
     {
         TileMapLayer occupiedSpaces = GetNode<TileMapLayer>("OccupiedSpaces");
-        _map._cells.ForEach(c =>
+        for (int i = 0; i < _map._cells.Count; i++)
         {
-            if (_map.HasOccupant(c))
+            MapCell c = _map._cells.ElementAt(i).Value;
+            if (c._occupant != null)
             {
-                occupiedSpaces.SetCell(c, 0,  new Vector2I(4,0));
+                occupiedSpaces.SetCell(c._address, 0,  new Vector2I(4,0));
             }
-            else if (_map._astar.IsPointSolid(c))
+            else if (_map._astar.IsPointSolid(c._address))
             {
-                
+                occupiedSpaces.SetCell(c._address, 0,  new Vector2I(3,1));
             }
             else
             {
-                occupiedSpaces.SetCell(c, 0,  Vector2I.Down*4);
+                occupiedSpaces.SetCell(c._address, 0,  new Vector2I(4,1));
             } 
-        });
+        }
     }
 
 }

PlayerController.cs

@@ -9,17 +9,26 @@ public partial class PlayerController : TurnController
     [Signal]
     public delegate void DeathEventHandler(PlayerController THIS);
     public bool _dead = false;
-    public int _health, _healthMax = 100;
+    public int _health, _healthMax = 100, _gold = 0;
-    public EnemyController _enemyController;
+    public PegController _pegController;
     public PackedScene _commanderScene = GD.Load<PackedScene>("res://Commander.tscn");
     public List<Tower> _towers = new();
+    public Bucket _bucket;
 
     public override void _Ready()
     {
         _health = _healthMax;
         base._Ready();
+        _bucket = GetNode<Bucket>("Bucket");
     }
 
+    public override void _Process(double delta)
+    {
+        base._Process(delta);
+        _bucket.Move();
+    }
+
+
     public void ChangeHealth(int DAMAGE, Node IMPETUS = null)
     {
         _health += DAMAGE;
@@ -63,7 +72,7 @@ public partial class PlayerController : TurnController
         _towers[3].AddChild(newCommander);
     }
 
-    public override async Task StartTurn()
+    public override void StartTurn()
     {
         _towers.ForEach(t => t.StartTurn());
     }

Tower.cs

@@ -3,22 +3,22 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
-public partial class Tower : Sprite2D
+public partial class Tower : HoverableNode
 {
-    public bool _hovered, _aiming;
+    public bool _aiming;
     public int _launchSpeed = 1000, _arcIterations = 50;
     public Vector2 _aimOffset, _arcEnd;
     public List<Vector2> _arc = new();
-    public Marker2D _offset, _attackSpawn;
+    public Marker2D _offset, _ballSpawn;
     public Area2D _area;
     public Commander _commander;
     public override void _Ready()
     {
         base._Ready();
 
-        _area = GetNode<Area2D>("Area");
         _offset = GetNode<Marker2D>("Offset");
-        _attackSpawn = GetNode<Marker2D>("AttackSpawn");
+        _ballSpawn = GetNode<Marker2D>("BallSpawn");
+        // Click += HandleClick;
     }
     public override void _Process(double delta)
     {
@@ -29,19 +29,19 @@ public partial class Tower : Sprite2D
             {
                 if (_arcEnd != GetGlobalMousePosition())
                 {
-                    DrawArc(_attackSpawn.GlobalPosition, GetGlobalMousePosition());
+                    DrawArc(_ballSpawn.GlobalPosition, GetGlobalMousePosition());
                 }
                 if (Input.IsActionJustPressed("rightClick"))
                 {
-                    _commander.UnloadAttack();
+                    _commander.UnloadBall();
                     _aiming = false;
                 }
                 else if (Input.IsActionJustPressed("leftClick"))
                 {
 
-                    _aimOffset = ToLaunchVector(CalculateLaunchAngle(_attackSpawn.GlobalPosition, GetGlobalMousePosition()));
+                    _aimOffset = ToLaunchVector(CalculateLaunchAngle(_ballSpawn.GlobalPosition, GetGlobalMousePosition()));
 
-                    _commander.ShootCurrentAttack(_aimOffset);
+                    _commander.ShootCurrentBall(_aimOffset);
 
                     ClearArc();
                     _aiming = false;
@@ -52,10 +52,11 @@ public partial class Tower : Sprite2D
                 if (Input.IsActionJustPressed("leftClick"))
                 {
                     _aiming = true;
-                    _commander.LoadAttack(_attackSpawn.Position);
+                    _commander.LoadBall(_ballSpawn.Position);
                 }
             }
         }
+        
     }
 
     public float CalculateLaunchAngle(Vector2 START, Vector2 END, int MAX_ITERATIONS = 20)
@@ -111,7 +112,7 @@ public partial class Tower : Sprite2D
 
     public void ClearArc()
     {
-        Path2D path = _commander._attack.GetNode<Path2D>("PredictedPath");
+        Path2D path = _commander._ball.GetNode<Path2D>("PredictedPath");
         path.Curve.ClearPoints();
     }
 
@@ -143,7 +144,7 @@ public partial class Tower : Sprite2D
             }
         }
 
-        Path2D path = _commander._attack.GetNode<Path2D>("PredictedPath");
+        Path2D path = _commander._ball.GetNode<Path2D>("PredictedPath");
         path.Curve.ClearPoints();
 
         for (int i = 0; i < arc.Count; i++)
@@ -192,11 +193,4 @@ public partial class Tower : Sprite2D
         return Vector2.FromAngle(ANGLE) * _launchSpeed;
     }
 
-    public void OnMouseEntered(){
-        _hovered = true;
-    }
-    public void OnMouseExited(){
-        _hovered = true;
-    }
-
 }

TurnController.cs

@@ -7,8 +7,8 @@ public partial class TurnController : Node2D
     [Signal]
     public delegate void TurnDoneEventHandler();
     public PlayArea _playArea;
-
+    public Map _map;
-    public virtual async Task StartTurn()
+    public virtual void StartTurn()
     {
         
     }

ball.tscn

@@ -1,7 +1,7 @@
 [gd_scene format=3 uid="uid://cevk7yax5tvej"]
 
-[ext_resource type="Script" uid="uid://dm2gyxmgwbmg8" path="res://Attack.cs" id="1_63pi1"]
+[ext_resource type="Script" uid="uid://dm2gyxmgwbmg8" path="res://Ball.cs" id="1_41u45"]
-[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_hqc8w"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_ktgx5"]
 
 [sub_resource type="PhysicsMaterial" id="PhysicsMaterial_63pi1"]
 bounce = 0.25
@@ -11,19 +11,21 @@ radius = 12.5
 
 [sub_resource type="Curve2D" id="Curve2D_63pi1"]
 
-[node name="Attack" type="RigidBody2D" unique_id=1225359241]
+[node name="Ball" type="RigidBody2D" unique_id=1225359241]
 input_pickable = true
 physics_material_override = SubResource("PhysicsMaterial_63pi1")
 contact_monitor = true
 max_contacts_reported = 100
-script = ExtResource("1_63pi1")
+script = ExtResource("1_41u45")
 
 [node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1448070524]
 shape = SubResource("CircleShape2D_7yfhp")
 
 [node name="Sprite2D" type="Sprite2D" parent="." unique_id=1583277900]
 scale = Vector2(0.5, 0.5)
-texture = ExtResource("2_hqc8w")
+texture = ExtResource("2_ktgx5")
+
+[node name="Ray" type="RayCast2D" parent="." unique_id=113171676]
 
 [node name="PredictedPath" type="Path2D" parent="." unique_id=1505290715]
 modulate = Color(1, 0, 1, 1)

enemy_controller.tscn

@@ -1,6 +0,0 @@
-[gd_scene format=3 uid="uid://c6b188d2a20eq"]
-
-[ext_resource type="Script" uid="uid://brsi76xcgx3et" path="res://EnemyController.cs" id="1_tkpyo"]
-
-[node name="EnemyController" type="Node2D" unique_id=197453707]
-script = ExtResource("1_tkpyo")

hoverable_node.tscn

@@ -0,0 +1,10 @@
+[gd_scene format=3 uid="uid://dse0sugndsrs"]
+
+[ext_resource type="Script" uid="uid://dqvysa2n208d3" path="res://HoverableNode.cs" id="1_14v3m"]
+
+[node name="HoverableNode" type="Node2D" unique_id=946672764]
+script = ExtResource("1_14v3m")
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=783465962]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=585114419]

main.tscn

@@ -2,8 +2,9 @@
 
 [ext_resource type="Script" uid="uid://cg1m762ed04kv" path="res://Main.cs" id="1_ig7tw"]
 [ext_resource type="PackedScene" uid="uid://dumcridek4xy3" path="res://play_area.tscn" id="2_1bvp3"]
-[ext_resource type="PackedScene" uid="uid://c6b188d2a20eq" path="res://enemy_controller.tscn" id="4_1bvp3"]
+[ext_resource type="PackedScene" uid="uid://bxlt2ap0dym1x" path="res://peg_controller.tscn" id="3_lquwl"]
 [ext_resource type="PackedScene" uid="uid://b7kvx7p0b2086" path="res://player_controller.tscn" id="4_lquwl"]
+[ext_resource type="PackedScene" path="res://mouse_handler.tscn" id="5_lquwl"]
 
 [node name="Main" type="Node" unique_id=535208469]
 script = ExtResource("1_ig7tw")
@@ -11,6 +12,8 @@ script = ExtResource("1_ig7tw")
 [node name="PlayArea" parent="." unique_id=1123610167 instance=ExtResource("2_1bvp3")]
 position = Vector2(360, 180)
 
-[node name="EnemyController" parent="." unique_id=1894449838 instance=ExtResource("4_1bvp3")]
+[node name="PegController" parent="." unique_id=197453707 instance=ExtResource("3_lquwl")]
 
 [node name="PlayerController" parent="." unique_id=364781168 instance=ExtResource("4_lquwl")]
+
+[node name="MouseHandler" parent="." unique_id=1823071759 instance=ExtResource("5_lquwl")]

map_cell.tscn

@@ -0,0 +1,11 @@
+[gd_scene format=3 uid="uid://cqwi2kesqh5wt"]
+
+[ext_resource type="Script" uid="uid://b8fx1wwyj30bg" path="res://MapCell.cs" id="1_jkeij"]
+[ext_resource type="Texture2D" uid="uid://c5jj7yhlnodxt" path="res://Art/star.png" id="2_ugbl7"]
+
+[node name="MapCell" type="Node2D" unique_id=953237004]
+script = ExtResource("1_jkeij")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=733491629]
+scale = Vector2(0.025, 0.025)
+texture = ExtResource("2_ugbl7")

map_cell_occupant.tscn

@@ -0,0 +1,10 @@
+[gd_scene format=3 uid="uid://d4nyjj5740ww5"]
+
+[ext_resource type="Script" uid="uid://b3dlktsgeteuw" path="res://MapCellOccupant.cs" id="1_2wshj"]
+
+[node name="MapCellOccupant" type="Node2D" unique_id=946672764]
+script = ExtResource("1_2wshj")
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=783465962]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=585114419]

mouse_handler.tscn

@@ -0,0 +1,6 @@
+[gd_scene format=3 uid="uid://by0a5f2ft0u03"]
+
+[ext_resource type="Script" uid="uid://dewxuppyw2gtp" path="res://MouseHandler.cs" id="1_r4hv2"]
+
+[node name="MouseHandler" type="Node2D" unique_id=215972463]
+script = ExtResource("1_r4hv2")

peg.tscn

@@ -0,0 +1,34 @@
+[gd_scene format=3 uid="uid://01m32xxk1ryh"]
+
+[ext_resource type="Script" uid="uid://g2ucwg3k342p" path="res://Peg.cs" id="1_cavuh"]
+[ext_resource type="Texture2D" uid="uid://nwj4n7if8kqd" path="res://Art/circle25r.png" id="2_cut4e"]
+[ext_resource type="PackedScene" uid="uid://bj2qrn0l01us1" path="res://Pegs/peg_action.tscn" id="3_cavuh"]
+
+[sub_resource type="PhysicsMaterial" id="PhysicsMaterial_7k104"]
+bounce = 0.5
+
+[sub_resource type="CircleShape2D" id="CircleShape2D_4gyqm"]
+radius = 12.5
+
+[node name="Peg" type="StaticBody2D" unique_id=1417697759]
+input_pickable = true
+physics_material_override = SubResource("PhysicsMaterial_7k104")
+script = ExtResource("1_cavuh")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="." unique_id=1762191899]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[node name="Sprite2D" type="Sprite2D" parent="." unique_id=1941012605]
+texture_filter = 1
+scale = Vector2(0.5, 0.5)
+texture = ExtResource("2_cut4e")
+
+[node name="PegAction" parent="." unique_id=637569115 instance=ExtResource("3_cavuh")]
+
+[node name="HoverBounds" type="Area2D" parent="." unique_id=2086452813]
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=252175102]
+shape = SubResource("CircleShape2D_4gyqm")
+
+[connection signal="mouse_entered" from="." to="." method="OnMouseEntered"]
+[connection signal="mouse_exited" from="." to="." method="OnMouseExited"]

peg_controller.tscn

@@ -0,0 +1,6 @@
+[gd_scene format=3 uid="uid://bxlt2ap0dym1x"]
+
+[ext_resource type="Script" path="res://PegController.cs" id="1_31br5"]
+
+[node name="PegController" type="Node2D" unique_id=197453707]
+script = ExtResource("1_31br5")

player_controller.tscn

@@ -2,8 +2,12 @@
 
 [ext_resource type="Script" uid="uid://cfohujgs5dygx" path="res://PlayerController.cs" id="1_lvefo"]
 [ext_resource type="PackedScene" uid="uid://d06n7p75u130s" path="res://tower.tscn" id="2_f0yg5"]
+[ext_resource type="PackedScene" uid="uid://b2mb7mimdu5ad" path="res://bucket.tscn" id="3_va7e3"]
 
 [node name="PlayerController" type="Node2D" unique_id=317732890]
 script = ExtResource("1_lvefo")
 
 [node name="Tower1" parent="." unique_id=1315831332 instance=ExtResource("2_f0yg5")]
+
+[node name="Bucket" parent="." unique_id=1168722558 instance=ExtResource("3_va7e3")]
+position = Vector2(960, 1040)

project.godot

@@ -51,6 +51,11 @@ changeTurn={
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":true,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":84,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ]
 }
+middleClick={
+"deadzone": 0.2,
+"events": [Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"button_mask":4,"position":Vector2(222, 10),"global_position":Vector2(231, 58),"factor":1.0,"button_index":3,"canceled":false,"pressed":true,"double_click":false,"script":null)
+]
+}
 
 [physics]
 

tower.tscn

@@ -11,9 +11,9 @@ self_modulate = Color(0, 0, 0, 1)
 texture = ExtResource("1_vedim")
 script = ExtResource("1_k1sas")
 
-[node name="Area" type="Area2D" parent="." unique_id=620986087]
+[node name="HoverBounds" type="Area2D" parent="." unique_id=620986087]
 
-[node name="Bounds" type="CollisionShape2D" parent="Area" unique_id=1639875880]
+[node name="CollisionShape2D" type="CollisionShape2D" parent="HoverBounds" unique_id=1639875880]
 position = Vector2(0, 0.5)
 shape = SubResource("RectangleShape2D_vedim")
 debug_color = Color(0.6411928, 0.52469516, 0, 0.41960785)
@@ -21,8 +21,8 @@ debug_color = Color(0.6411928, 0.52469516, 0, 0.41960785)
 [node name="Offset" type="Marker2D" parent="." unique_id=2053853274]
 position = Vector2(25, -50)
 
-[node name="AttackSpawn" type="Marker2D" parent="." unique_id=715904909]
+[node name="BallSpawn" type="Marker2D" parent="." unique_id=715904909]
 position = Vector2(0, -24)
 
-[connection signal="mouse_entered" from="Area" to="." method="OnMouseEntered"]
+[connection signal="mouse_entered" from="HoverBounds" to="." method="OnMouseEntered"]
-[connection signal="mouse_exited" from="Area" to="." method="OnMouseExited"]
+[connection signal="mouse_exited" from="HoverBounds" to="." method="OnMouseExited"]