Fight system up and running with movement

.claude/settings.local.json

@@ -2,7 +2,8 @@
   "permissions": {
     "allow": [
       "Bash(mkdir -p \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/Maze/Core\" \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/Maze/Generation\" \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/Maze/Agent\" \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/Maze/Visualization\")",
-      "Bash(rm -f \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/MainGenerator.cs\" \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/MainGenerator.cs.meta\")"
+      "Bash(rm -f \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/MainGenerator.cs\" \"c:/Users/Axel-PC/MazeGenerator/Assets/Scripts/MainGenerator.cs.meta\")",
+      "Bash(xargs grep -l \"class.*MazeAgent\\\\b\")"
     ]
   }
 }

Assets/Resources/Characters/Monsters/Goblin.asset

@@ -20,7 +20,13 @@ MonoBehaviour:
     _attack: 3
     _defense: 3
     _magic: 0
+  _size: 0
   _startingWeapon: {fileID: 0}
   _startingArmor: {fileID: 0}
-  _possibleLoot:
-  - {fileID: 11400000, guid: 8f28b5b035a97134d976d952b65c75d2, type: 2}
+  _lootTable:
+  - Item: {fileID: 11400000, guid: 8f28b5b035a97134d976d952b65c75d2, type: 2}
+    MinCount: 0
+    MaxCount: 3
+  _includeStartingWeaponAsLoot: 0
+  _includeStartingArmorAsLoot: 0
+  _lootDropChance: 1

Assets/Scenes/SampleScene.unity

@@ -414,6 +414,8 @@ GameObject:
   - component: {fileID: 569980086}
   - component: {fileID: 569980085}
   - component: {fileID: 569980088}
+  - component: {fileID: 569980090}
+  - component: {fileID: 569980089}
   m_Layer: 0
   m_Name: MazeSystem
   m_TagString: Untagged
@@ -438,6 +440,7 @@ MonoBehaviour:
   initialDecisionDelayRange: {x: 0.5, y: 2}
   decisionInterval: 1.5
   exploreChance: 0.85
+  retreatThreshold: 1.5
   targetFinishedAgentCount: 20
   timeLimitSeconds: 150
 --- !u!114 &569980086
@@ -484,6 +487,43 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: Assembly-CSharp::MazeGen.MonsterSpawner
   mazeGenerator: {fileID: 569980086}
+--- !u!114 &569980089
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 569980084}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a100ae72bde13ac48bd767bf2cfadda3, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MazeGen.BattleArenaView
+  gridSize: {x: 11, y: 7}
+  cellSize: 1
+  arenaWorldOrigin: {x: 0, y: 10000}
+  secondsPerEvent: 0.4
+  playbackSpeed: 1
+  autoReturnSeconds: 4
+--- !u!114 &569980090
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 569980084}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 9fd6a64c71db20745968a20255a753ac, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MazeGen.CombatDirector
+  joinWindowSeconds: 5
+  pauseOnFightDeclared: 1
+  timeoutResolution: 0
+  maxRounds: 40
+  sneakBaseChance: 0.55
+  sneakSpeedWeight: 0.02
+  sneakPenaltyPerMonster: 0.08
 --- !u!1 &832575517
 GameObject:
   m_ObjectHideFlags: 0

Assets/Scripts/Maze/Agent/AutonomousAgentBrain.cs

@@ -1,43 +1,39 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using UnityEngine;
 
 namespace MazeGen
 {
     /// <summary>
-    /// Drives one agent's autonomous exploration: waits out a (randomized) initial delay so
-    /// many agents don't all decide in lockstep, then ticks a steady decision interval -
-    /// each time it fires, the agent deals with whatever is in its current room (fight it,
-    /// join a fight already forming, or sneak past) and otherwise picks an exit and moves.
-    /// Stops deciding once the agent reaches an exit room, dies, or the level ends.
+    /// Autonomous agent decision-making system based on a prioritized decision tree.
     ///
-    /// Agents can "peek" into adjacent rooms before entering to see if there are monsters.
-    /// Based on the perceived threat level, they may choose a different exit rather than fight.
+    /// Each decision encapsulates:
+    /// - A precondition (CanExecute)
+    /// - An action (Execute)
+    /// - Narration (Think)
     ///
-    /// Every decision this class makes is narrated into the agent's <see cref="AgentThoughtLog"/>,
-    /// which is what the HUD shows while an agent is being followed. Adding a decision here
-    /// without a matching Think() call makes the agent's behaviour unexplainable to the observer,
-    /// so keep them together.
+    /// The decision tree evaluates decisions in priority order and returns the first
+    /// one that can execute. This keeps behavior and narration synchronized and makes
+    /// the agent's decisions easy to understand and extend.
     ///
-    /// All timing runs off <see cref="SimulationClock"/>, never Time.deltaTime directly, so a
-    /// paused simulation genuinely freezes every agent.
+    /// To extend agent behavior, simply create a new AgentDecision subclass and add
+    /// it to BuildDecisionTree(). No need to modify the Update loop or narration logic.
+    ///
+    /// All timing runs off SimulationClock, not Time.deltaTime, so paused simulation
+    /// genuinely freezes every agent.
     /// </summary>
     public class AutonomousAgentBrain : MonoBehaviour
     {
-        /// <summary>Peek observations about the same room are only narrated this many times, to keep the thought log readable.</summary>
-        private const int MaxNarratedPeeksPerRoom = 2;
-
         private MazeAgentController _controller;
         private MazeGenerator _generator;
         private CombatDirector _director;
         private float _decisionInterval;
         private float _exploreChance;
-        private float _retreatThreshold = 1.5f;     // CR above this = don't pick that fight
+        private float _retreatThreshold = 1.5f;
         private Func<bool> _isLevelEnded;
 
         private float _timer;
-        private readonly Dictionary<int, int> _peekCount = new Dictionary<int, int>(); // narration throttle, per room id
+        private AgentDecisionTree _decisionTree;
 
         public void Initialize(MazeAgentController controller, MazeGenerator generator, CombatDirector director, float initialDelay, float decisionInterval, float exploreChance, float retreatThreshold, Func<bool> isLevelEnded)
         {
@@ -49,366 +45,54 @@ namespace MazeGen
             _retreatThreshold = Mathf.Max(0, retreatThreshold);
             _isLevelEnded = isLevelEnded;
             _timer = Mathf.Max(0f, initialDelay);
-        }
-
-        private void Update()
-        {
-            MazeAgent agent = _controller?.Agent;
-            if (agent == null || agent.IsFinished || agent.IsDead) return;
-            if (_isLevelEnded != null && _isLevelEnded()) return;
-
-            // Committed to a fight: the CombatDirector owns this agent until it resolves.
-            if (agent.IsEngaged) return;
-
-            _timer -= SimulationClock.DeltaTime;
-            if (_timer > 0f) return;
-            _timer = _decisionInterval;
 
-            if (HandleRoomHostiles(agent)) return;
-            MoveOn(agent);
+            // Build the decision tree in priority order
+            BuildDecisionTree();
         }
 
-        private void Think(ThoughtKind kind, string text) => _controller?.Agent?.Thoughts.Add(kind, text);
-
-        // ---------------------------------------------------------------- fighting & sneaking
-
         /// <summary>
-        /// Deals with hostiles in the room the agent is standing in. Returns true if this took
-        /// the agent's turn (it committed to a fight, or spent the tick slipping away).
-        /// </summary>
-        private bool HandleRoomHostiles(MazeAgent agent)
-        {
-            if (_director == null) return false;
-
-            Room room = agent.CurrentRoom;
-            if (room == null) return false;
-
-            // A fight is already mustering here - pile in for better odds, or try to slip past.
-            PendingFight mustering = _director.FindMusteringFight(room);
-            if (mustering != null && !mustering.Contains(agent))
-                return HandleArrivalAtFight(agent, mustering);
-
-            if (room.Encounter == null || !room.Encounter.HasLivingMonsters) return false;
-
-            int hostiles = room.Encounter.AliveMonsterCount;
-            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
-
-            // Already tried and failed to finish these off once - don't loop on it.
-            if (agent.HasFledFrom(room.Id))
-            {
-                Think(ThoughtKind.Avoid, $"Still {hostiles} hostile(s) here and I've already failed to beat them - leaving.");
-                return false; // fall through to MoveOn so it actually walks out this tick
-            }
-
-            if (threat <= _retreatThreshold)
-            {
-                Think(ThoughtKind.Fight,
-                    $"Peeked: {hostiles} hostile(s), threat {threat:0.00} vs my limit {_retreatThreshold:0.00} - engaging. Fight starts in {_director.JoinWindowSeconds:0.0}s, hopefully someone joins.");
-                _director.DeclareFight(room, agent, $"sized up {hostiles} hostile(s) at threat {threat:0.00} and attacked");
-                return true;
-            }
-
-            // Too dangerous to pick - try to get out without a brawl.
-            Think(ThoughtKind.Avoid, $"Peeked: {hostiles} hostile(s) at threat {threat:0.00}, over my limit {_retreatThreshold:0.00} - trying to slip out instead of fighting.");
-
-            if (_director.TrySneakOut(agent, out float odds))
-            {
-                Think(ThoughtKind.Sneak, $"Slipped away unnoticed ({odds:P0} odds).");
-                return false; // MoveOn carries it out of the room this same tick
-            }
-
-            Think(ThoughtKind.Sneak, $"Botched the sneak ({odds:P0} odds) - they've seen me, no choice but to fight.");
-            _director.DeclareFight(room, agent, $"was caught trying to sneak out past {hostiles} hostile(s)");
-            return true;
-        }
-
-        /// <summary>
-        /// The agent walked into a room where a fight is already forming. It can join (raising
-        /// the odds for everyone) or try to sneak by - and a botched sneak forces it in anyway.
-        /// </summary>
-        private bool HandleArrivalAtFight(MazeAgent agent, PendingFight fight)
-        {
-            float threat = fight.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
-
-            // The threat is shared: joining N-1 allies makes the same monsters worth risking.
-            float sharedThreat = threat / (fight.Agents.Count + 1);
-            bool wantsToSneak = sharedThreat > _retreatThreshold || agent.HasFledFrom(fight.Room.Id);
-
-            if (!wantsToSneak)
-                Think(ThoughtKind.Fight, $"Walked into fight #{fight.Id} - {fight.Agents.Count} ally(s) already in, shared threat {sharedThreat:0.00}. Joining.");
-            else
-                Think(ThoughtKind.Sneak, $"Walked into fight #{fight.Id} - shared threat {sharedThreat:0.00} still over my limit. Trying to sneak past it.");
-
-            switch (_director.ResolveArrival(agent, wantsToSneak))
-            {
-                case CombatDirector.ArrivalDecision.Joined:
-                case CombatDirector.ArrivalDecision.SneakFailedAndJoined:
-                    return true; // engaged now; the director takes it from here
-
-                case CombatDirector.ArrivalDecision.SneakedPast:
-                    // Made it past - keep going straight through into the next room.
-                    Think(ThoughtKind.Sneak, "Made it past them - pressing on into the next room.");
-                    return false;
-
-                default:
-                    return false;
-            }
-        }
-
-        // ---------------------------------------------------------------- movement
-
-        private void MoveOn(MazeAgent agent)
-        {
-            Exit choice = ChooseExit(agent, agent.CurrentRoom);
-            if (choice == null)
-            {
-                Think(ThoughtKind.Move, $"No usable door out of room {agent.CurrentRoom.Id} - waiting.");
-                return;
-            }
-
-            string heading = CompassName(choice.DirectionDegrees);
-            Room known = choice.ConnectedRoomId.HasValue ? _generator.Graph.Get(choice.ConnectedRoomId.Value) : null;
-            string destination = known != null
-                ? $"room {known.Id}{(agent.HasVisited(known.Id) ? " (been there)" : " (new to me)")}"
-                : "whatever is behind it (never opened)";
-
-            if (_controller.TryUseExit(choice))
-                Think(ThoughtKind.Move, $"Taking the {heading} door into {destination}.");
-            else
-                Think(ThoughtKind.Move, $"The {heading} door out of room {agent.CurrentRoom.Id} went nowhere - picking again next tick.");
-        }
-
-        /// <summary>
-        /// Picks the next exit to take. Strongly prefers an unused exit (fresh, unexplored
-        /// territory); failing that, prefers a used exit into a room this agent personally
-        /// hasn't visited yet (following where another agent has already been); only
-        /// backtracks into a room it's already visited as a last resort. `exploreChance`
-        /// adds some randomness so a "follow" opportunity is occasionally taken even when
-        /// exploring is available, rather than being 100% deterministic.
-        ///
-        /// A few anti-stuck rules keep this from looping forever around a small ring of
-        /// already-explored rooms (e.g. a square formed by a loop-closing connection):
-        /// - The door leading straight back to the room the agent just came from is excluded
-        ///   from consideration unless it's the only door available at all, so agents don't
-        ///   ping-pong between two rooms.
-        /// - When forced to backtrack, exits that "peek" into a room with its own unexplored
-        ///   option beyond it (an unused exit, or one leading somewhere this agent hasn't
-        ///   personally seen) are preferred over ones that only lead deeper into fully-picked-
-        ///   over territory - this steers the agent back out of a dead loop instead of just
-        ///   circling it.
-        /// - Ties are broken toward whichever room this agent has personally visited the
-        ///   fewest times, so a small loop gets cycled through rather than bounced around.
+        /// Constructs the decision tree with all available decisions in priority order.
+        /// Add new decisions here to extend agent behavior without modifying Update().
         ///
-        /// Also evaluates monster threats in adjacent rooms - if a room looks too dangerous,
-        /// the agent will retreat (choose a different exit) if possible.
-        /// </summary>
-        private Exit ChooseExit(MazeAgent agent, Room room)
-        {
-            Exit reverseExit = FindReverseExit(agent, room);
-
-            var explore = new List<Exit>();
-            var follow = new List<Exit>();
-            var backtrack = new List<Exit>();
-
-            foreach (var exit in room.Exits)
-            {
-                if (exit == reverseExit) continue;
-                if (exit.IsBlocked) continue; // Skip exits that are permanently unusable
-
-                if (!exit.IsUsed)
-                {
-                    explore.Add(exit);
-                    continue;
-                }
-
-                bool leadsToVisited = exit.ConnectedRoomId.HasValue && agent.HasVisited(exit.ConnectedRoomId.Value);
-                (leadsToVisited ? backtrack : follow).Add(exit);
-            }
-
-            // Filter exits by threat level - remove dangerous ones if safer options exist
-            explore = FilterByThreat(explore, agent);
-            follow = FilterByThreat(follow, agent);
-            backtrack = FilterByThreat(backtrack, agent);
-
-            if (explore.Count > 0 && UnityEngine.Random.value < _exploreChance)
-                return RandomPick(explore);
-
-            if (follow.Count > 0)
-                return LeastVisitedPick(agent, follow);
-
-            if (explore.Count > 0)
-                return RandomPick(explore);
-
-            if (backtrack.Count > 0)
-                return ChooseBacktrack(agent, backtrack);
-
-            // Excluding the reverse door left nothing - it's genuinely the only way out
-            // (e.g. a single-exit dead end), so take it (even if dangerous).
-            return reverseExit;
-        }
-
-        /// <summary>The door in `room` that leads straight back to wherever the agent's last move came from, if any.</summary>
-        private static Exit FindReverseExit(MazeAgent agent, Room room)
-        {
-            int? reverseExitId = agent.LastUsedExit?.ConnectedExitId;
-            if (!reverseExitId.HasValue) return null;
-            return room.Exits.Find(e => e.Id == reverseExitId.Value);
-        }
-
-        private Exit ChooseBacktrack(MazeAgent agent, List<Exit> backtrack)
-        {
-            var promising = backtrack.Where(e => LeadsTowardUnexploredOptions(agent, e)).ToList();
-            return LeastVisitedPick(agent, promising.Count > 0 ? promising : backtrack);
-        }
-
-        /// <summary>
-        /// One-step lookahead: does the room beyond `exit` itself have any door (other than
-        /// the one leading straight back here) that's still unused or leads somewhere this
-        /// agent hasn't personally been? If so, backtracking this way still has somewhere
-        /// useful to go; if not, it just leads deeper into already-picked-over territory.
+        /// Example of adding a custom decision:
+        ///   _decisionTree.Add(new MyCustomDecision(...));
         /// </summary>
-        private bool LeadsTowardUnexploredOptions(MazeAgent agent, Exit exit)
+        private void BuildDecisionTree()
         {
-            if (!exit.ConnectedRoomId.HasValue) return false;
-
-            Room target = _generator.Graph.Get(exit.ConnectedRoomId.Value);
-            if (target == null) return false;
-
-            int reverseExitId = exit.ConnectedExitId ?? -1;
-            foreach (var candidate in target.Exits)
-            {
-                if (candidate.Id == reverseExitId) continue;
-                if (!candidate.IsUsed) return true;
-                if (candidate.ConnectedRoomId.HasValue && !agent.HasVisited(candidate.ConnectedRoomId.Value)) return true;
-            }
-            return false;
-        }
-
-        private static Exit LeastVisitedPick(MazeAgent agent, List<Exit> exits)
-        {
-            int bestVisits = int.MaxValue;
-            var bestExits = new List<Exit>();
-
-            foreach (var exit in exits)
-            {
-                int visits = exit.ConnectedRoomId.HasValue ? agent.VisitCount(exit.ConnectedRoomId.Value) : 0;
-                if (visits < bestVisits)
-                {
-                    bestVisits = visits;
-                    bestExits.Clear();
-                    bestExits.Add(exit);
-                }
-                else if (visits == bestVisits)
-                {
-                    bestExits.Add(exit);
-                }
-            }
+            _decisionTree = new AgentDecisionTree();
 
-            return RandomPick(bestExits);
-        }
+            // Priority order:
+            // 1. Heal if needed (health is more important than combat)
+            _decisionTree.Add(new UseHealthPotionDecision());
 
-        private static Exit RandomPick(List<Exit> exits) => exits[UnityEngine.Random.Range(0, exits.Count)];
+            // 2. Handle existing fights (join or sneak past)
+            _decisionTree.Add(new HandleExistingFightDecision(_director, _retreatThreshold));
 
-        // ---------------------------------------------------------------- peeking
+            // 3. Declare new fights if appropriate
+            _decisionTree.Add(new DeclareFightDecision(_director, _retreatThreshold));
 
-        /// <summary>
-        /// Peek into a room (via an exit) to see if there are monsters and how many.
-        /// Returns the perceived challenge rating, or 0 if no monsters/already explored.
-        /// Agent sees incomplete info (60-100% of actual monsters, doesn't know about hidden ones).
-        /// </summary>
-        public float PeekThroughExit(Exit exit, MazeAgent agent)
-        {
-            if (!exit.ConnectedRoomId.HasValue)
-                return 0; // Unresolved exit - can't peek yet
+            // 4. Sneak away if threatened
+            _decisionTree.Add(new SneakAwayDecision(_director, _retreatThreshold));
 
-            Room nextRoom = _generator.Graph.Get(exit.ConnectedRoomId.Value);
-            if (nextRoom == null || nextRoom.Encounter == null)
-                return 0; // No encounter in this room
-
-            return nextRoom.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            // 5. Catch-all: move to next room (always succeeds)
+            _decisionTree.Add(new MoveOnDecision(_generator, _controller, _exploreChance, _retreatThreshold));
         }
 
-        /// <summary>
-        /// Decide if an exit is worth taking based on threat level inside.
-        /// Returns true if the exit is relatively safe or if the agent has no choice,
-        /// false if the agent decides to retreat from this exit.
-        /// </summary>
-        private bool ShouldTakeExit(Exit exit, MazeAgent agent)
-        {
-            if (!exit.ConnectedRoomId.HasValue)
-                return true; // Unresolved exit - proceed cautiously
-
-            Room nextRoom = _generator.Graph.Get(exit.ConnectedRoomId.Value);
-            if (nextRoom == null || nextRoom.Encounter == null || !nextRoom.Encounter.HasLivingMonsters)
-                return true; // No encounter, safe to enter
-
-            // Peek and evaluate threat
-            float perceivedCR = nextRoom.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
-
-            // If threat is below threshold, take it. If above, retreat with some randomness.
-            if (perceivedCR <= _retreatThreshold)
-            {
-                NarratePeek(agent, exit, nextRoom, perceivedCR, false);
-                return true; // Manageable threat
-            }
-
-            // Higher difficulty = more likely to retreat, but add randomness for personality
-            float retreatChance = Mathf.Clamp01((perceivedCR - _retreatThreshold) / 2.0f);
-            bool avoiding = UnityEngine.Random.value <= retreatChance;
-            NarratePeek(agent, exit, nextRoom, perceivedCR, avoiding);
-            return !avoiding;
-        }
-
-        /// <summary>
-        /// Narrates a peek, throttled per room so an agent standing next to a dangerous room
-        /// doesn't spam the same observation every decision tick.
-        /// </summary>
-        private void NarratePeek(MazeAgent agent, Exit exit, Room peeked, float threat, bool avoiding)
-        {
-            int narrated = _peekCount.TryGetValue(peeked.Id, out int count) ? count : 0;
-            if (narrated >= MaxNarratedPeeksPerRoom) return;
-            _peekCount[peeked.Id] = narrated + 1;
-
-            // VisibleMonsterCount is fixed at spawn time and isn't reduced as monsters die, so
-            // clamp it or a half-cleared room reads as busier than it is.
-            int hostiles = Mathf.Min(peeked.Encounter.VisibleMonsterCount, peeked.Encounter.AliveMonsterCount);
-            string heading = CompassName(exit.DirectionDegrees);
-
-            if (avoiding)
-                Think(ThoughtKind.Avoid, $"Peeked {heading} into room {peeked.Id}: ~{hostiles} hostile(s), threat {threat:0.00} - too rich for me, looking for another door.");
-            else
-                Think(ThoughtKind.Peek, $"Peeked {heading} into room {peeked.Id}: ~{hostiles} hostile(s), threat {threat:0.00} - that's manageable.");
-        }
-
-        /// <summary>
-        /// Filter exits: remove those the agent wants to retreat from due to high threat.
-        /// This is called during exit selection so dangerous rooms are avoided when possible.
-        /// </summary>
-        private List<Exit> FilterByThreat(List<Exit> exits, MazeAgent agent)
+        private void Update()
         {
-            var safeExits = new List<Exit>();
+            MazeAgent agent = _controller?.Agent;
+            if (agent == null || agent.IsFinished || agent.IsDead) return;
+            if (_isLevelEnded != null && _isLevelEnded()) return;
 
-            foreach (var exit in exits)
-            {
-                if (ShouldTakeExit(exit, agent))
-                    safeExits.Add(exit);
-            }
+            // Committed to a fight: the CombatDirector owns this agent until it resolves.
+            if (agent.IsEngaged) return;
 
-            // If all exits are dangerous, agent must take one anyway (don't get stuck)
-            return safeExits.Count > 0 ? safeExits : exits;
-        }
+            _timer -= SimulationClock.DeltaTime;
+            if (_timer > 0f) return;
+            _timer = _decisionInterval;
 
-        /// <summary>Exits are cardinal-only, so a direction always has an exact compass name.</summary>
-        private static string CompassName(float directionDegrees)
-        {
-            int normalized = Mathf.RoundToInt(Mathf.Repeat(directionDegrees, 360f) / 90f) % 4;
-            switch (normalized)
-            {
-                case 0: return "east";
-                case 1: return "north";
-                case 2: return "west";
-                default: return "south";
-            }
+            // Evaluate decision tree: returns true if a decision executed and was narrated
+            _decisionTree?.TryDecide(agent);
         }
     }
 }

Assets/Scripts/Maze/Agent/Decisions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f63b29cae97e4ed438c5e3c1b049e8d8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Maze/Agent/Decisions/AgentDecision.cs

@@ -0,0 +1,47 @@
+namespace MazeGen
+{
+    /// <summary>
+    /// Abstract base class for all agent decisions. Each decision encapsulates:
+    /// - A precondition check (CanExecute)
+    /// - An action to perform (Execute)
+    /// - A narration of the decision (Think)
+    ///
+    /// The key insight: keeping CanExecute, Execute, and Think together ensures that
+    /// every action the agent takes is explained to the observer. Adding a new decision
+    /// without narration makes the agent's behavior unexplainable.
+    ///
+    /// Decisions are evaluated in order by AgentDecisionTree, which returns the first
+    /// one whose CanExecute() returns true.
+    /// </summary>
+    public abstract class AgentDecision
+    {
+        /// <summary>
+        /// Check if this decision can be executed given the agent's current state.
+        /// Return true if this decision should be considered.
+        /// </summary>
+        public abstract bool CanExecute(MazeAgent agent);
+
+        /// <summary>
+        /// Execute the decision. This modifies the agent's state or the world.
+        /// Returns true if the decision consumed the agent's decision this tick,
+        /// false if the agent should continue to the next decision in the tree.
+        /// </summary>
+        public abstract bool Execute(MazeAgent agent);
+
+        /// <summary>
+        /// Narrate this decision to the agent's thought log.
+        /// Called after Execute() if Execute() returned true.
+        /// This is what the HUD's "Agent thoughts" panel shows.
+        ///
+        /// Keep this synchronized with Execute(): if Execute() does something,
+        /// Think() must explain it. Otherwise the observer sees an agent doing
+        /// things for no explained reason.
+        /// </summary>
+        public abstract void Think(MazeAgent agent);
+
+        /// <summary>
+        /// Human-readable name for debugging/logging.
+        /// </summary>
+        public abstract string DecisionName { get; }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/AgentDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b33105d69a6acc640997524747661f29

Assets/Scripts/Maze/Agent/Decisions/AgentDecisionTree.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Manages a prioritized list of agent decisions. On each call, iterates through decisions
+    /// in order, finds the first one that CanExecute(), and calls both Execute() and Think()
+    /// in lockstep so behavior and narration stay synchronized.
+    ///
+    /// Usage pattern:
+    ///   var tree = new AgentDecisionTree();
+    ///   tree.Add(new HandleExistingFightDecision(director));
+    ///   tree.Add(new DeclareFightDecision(director));
+    ///   tree.Add(new SneakAwayDecision(director));
+    ///   tree.Add(new MoveOnDecision(generator));
+    ///
+    ///   // In your update loop:
+    ///   if (!tree.TryDecide(agent)) {
+    ///       // No decision could execute (shouldn't happen if the last decision is a catch-all)
+    ///   }
+    /// </summary>
+    public class AgentDecisionTree
+    {
+        private List<AgentDecision> _decisions = new List<AgentDecision>();
+
+        public void Add(AgentDecision decision)
+        {
+            if (decision == null)
+                throw new ArgumentNullException(nameof(decision));
+            _decisions.Add(decision);
+        }
+
+        public void Insert(int index, AgentDecision decision)
+        {
+            if (decision == null)
+                throw new ArgumentNullException(nameof(decision));
+            _decisions.Insert(index, decision);
+        }
+
+        public void Remove(AgentDecision decision) => _decisions.Remove(decision);
+        public void RemoveAt(int index) => _decisions.RemoveAt(index);
+        public int Count => _decisions.Count;
+
+        /// <summary>
+        /// Evaluate the decision tree: find the first decision that can execute, then Execute it.
+        /// If Execute returns true, call Think to narrate it.
+        /// Returns true if a decision was executed, false if none could execute.
+        /// </summary>
+        public bool TryDecide(MazeAgent agent)
+        {
+            if (agent == null) return false;
+
+            foreach (var decision in _decisions)
+            {
+                if (!decision.CanExecute(agent))
+                    continue;
+
+                // This decision can execute - do it
+                bool consumed = decision.Execute(agent);
+                if (consumed)
+                {
+                    // Narrate the decision
+                    decision.Think(agent);
+                    return true;
+                }
+            }
+
+            // No decision could execute
+            return false;
+        }
+
+        /// <summary>
+        /// Evaluate just the preconditions without executing or thinking.
+        /// Useful for debugging or logging what decisions are available.
+        /// </summary>
+        public AgentDecision FindApplicableDecision(MazeAgent agent)
+        {
+            foreach (var decision in _decisions)
+            {
+                if (decision.CanExecute(agent))
+                    return decision;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the list of all decisions that could currently execute.
+        /// </summary>
+        public List<AgentDecision> GetAvailableDecisions(MazeAgent agent)
+        {
+            var available = new List<AgentDecision>();
+            foreach (var decision in _decisions)
+            {
+                if (decision.CanExecute(agent))
+                    available.Add(decision);
+            }
+            return available;
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/AgentDecisionTree.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e8f2693bcab70ba4583902824521bc27

Assets/Scripts/Maze/Agent/Decisions/DeclareFightDecision.cs

@@ -0,0 +1,79 @@
+namespace MazeGen
+{
+    /// <summary>
+    /// Declares a fight with monsters in the current room if the threat level is acceptable.
+    /// Uses a health-aware retreat threshold: lower health = more defensive.
+    /// </summary>
+    public class DeclareFightDecision : AgentDecision
+    {
+        private CombatDirector _director;
+        private float _retreatThreshold;
+
+        public override string DecisionName => "Declare Fight";
+
+        public DeclareFightDecision(CombatDirector director, float retreatThreshold)
+        {
+            _director = director;
+            _retreatThreshold = retreatThreshold;
+        }
+
+        public override bool CanExecute(MazeAgent agent)
+        {
+            if (agent == null || _director == null) return false;
+            if (agent.IsEngaged) return false;
+
+            Room room = agent.CurrentRoom;
+            if (room == null || room.Encounter == null || !room.Encounter.HasLivingMonsters)
+                return false;
+
+            // Already failed here before
+            if (agent.HasFledFrom(room.Id))
+                return false;
+
+            // Would we accept this threat level?
+            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            return threat <= effectiveThreshold;
+        }
+
+        public override bool Execute(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            int hostiles = room.Encounter.AliveMonsterCount;
+
+            _director.DeclareFight(room, agent, $"sized up {hostiles} hostile(s) at threat {threat:0.00} and attacked");
+            return true;
+        }
+
+        public override void Think(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            int hostiles = room.Encounter.AliveMonsterCount;
+
+            agent.Thoughts.Add(ThoughtKind.Fight,
+                $"Peeked: {hostiles} hostile(s), threat {threat:0.00} vs my limit {effectiveThreshold:0.00} - engaging. Fight starts in {_director.JoinWindowSeconds:0.0}s, hopefully someone joins.");
+        }
+
+        private float GetEffectiveReteatThreshold(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            float maxHealth = sheet.Stats.MaxHealth;
+            if (maxHealth <= 0) return _retreatThreshold;
+
+            float healthPercent = sheet.Stats.CurrentHealth / maxHealth;
+
+            if (healthPercent < 0.3f)
+                return _retreatThreshold * 0.5f;
+            else if (healthPercent < 0.5f)
+            {
+                float t = (healthPercent - 0.3f) / 0.2f;
+                return UnityEngine.Mathf.Lerp(_retreatThreshold * 0.5f, _retreatThreshold, t);
+            }
+
+            return _retreatThreshold;
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/DeclareFightDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e2a6cd9372df97845baeb73eb9f978e3

Assets/Scripts/Maze/Agent/Decisions/HandleExistingFightDecision.cs

@@ -0,0 +1,98 @@
+namespace MazeGen
+{
+    /// <summary>
+    /// Handles arrival at a room where a fight is already forming.
+    /// Agent can join (raising odds) or try to sneak past, with failed sneak forcing entry.
+    /// </summary>
+    public class HandleExistingFightDecision : AgentDecision
+    {
+        private CombatDirector _director;
+        private float _retreatThreshold;
+
+        public override string DecisionName => "Handle Existing Fight";
+
+        public HandleExistingFightDecision(CombatDirector director, float retreatThreshold)
+        {
+            _director = director;
+            _retreatThreshold = retreatThreshold;
+        }
+
+        public override bool CanExecute(MazeAgent agent)
+        {
+            if (agent == null || _director == null) return false;
+            if (agent.IsEngaged) return false; // Already committed
+
+            Room room = agent.CurrentRoom;
+            if (room == null) return false;
+
+            // Is there a fight already mustering here that we're not in?
+            PendingFight mustering = _director.FindMusteringFight(room);
+            return mustering != null && !mustering.Contains(agent);
+        }
+
+        public override bool Execute(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            PendingFight fight = _director.FindMusteringFight(room);
+            if (fight == null) return false;
+
+            float threat = fight.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            float sharedThreat = threat / (fight.Agents.Count + 1);
+
+            bool wantsToSneak = sharedThreat > effectiveThreshold || agent.HasFledFrom(fight.Room.Id);
+
+            if (!wantsToSneak)
+            {
+                // Join the fight
+                var result = _director.ResolveArrival(agent, false);
+                return result == CombatDirector.ArrivalDecision.Joined;
+            }
+            else
+            {
+                // Try to sneak, which might fail and force a join
+                var result = _director.ResolveArrival(agent, true);
+                return result == CombatDirector.ArrivalDecision.Joined ||
+                       result == CombatDirector.ArrivalDecision.SneakFailedAndJoined;
+            }
+        }
+
+        public override void Think(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            PendingFight fight = _director.FindMusteringFight(room);
+            if (fight == null) return;
+
+            float threat = fight.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            float sharedThreat = threat / (fight.Agents.Count + 1);
+            bool wantsToSneak = sharedThreat > effectiveThreshold || agent.HasFledFrom(fight.Room.Id);
+
+            if (!wantsToSneak)
+                agent.Thoughts.Add(ThoughtKind.Fight,
+                    $"Walked into fight #{fight.Id} - {fight.Agents.Count} ally(s) already in, shared threat {sharedThreat:0.00}. Joining.");
+            else
+                agent.Thoughts.Add(ThoughtKind.Sneak,
+                    $"Walked into fight #{fight.Id} - shared threat {sharedThreat:0.00} still over my limit. Trying to sneak past it.");
+        }
+
+        private float GetEffectiveReteatThreshold(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            float maxHealth = sheet.Stats.MaxHealth;
+            if (maxHealth <= 0) return _retreatThreshold;
+
+            float healthPercent = sheet.Stats.CurrentHealth / maxHealth;
+
+            if (healthPercent < 0.3f)
+                return _retreatThreshold * 0.5f;
+            else if (healthPercent < 0.5f)
+            {
+                float t = (healthPercent - 0.3f) / 0.2f;
+                return UnityEngine.Mathf.Lerp(_retreatThreshold * 0.5f, _retreatThreshold, t);
+            }
+
+            return _retreatThreshold;
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/HandleExistingFightDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f0f2e45eb6f33d2449213373d6c5522a

Assets/Scripts/Maze/Agent/Decisions/MoveOnDecision.cs

@@ -0,0 +1,234 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Picks an exit and moves through it. This is the catch-all decision that always
+    /// executes if no other decision takes precedence. It handles:
+    /// - Choosing between explore/follow/backtrack exits
+    /// - Filtering by threat level
+    /// - Moving through the chosen exit
+    /// </summary>
+    public class MoveOnDecision : AgentDecision
+    {
+        private MazeGenerator _generator;
+        private MazeAgentController _controller;
+        private float _exploreChance;
+        private float _retreatThreshold;
+
+        public override string DecisionName => "Move On";
+
+        public MoveOnDecision(MazeGenerator generator, MazeAgentController controller, float exploreChance, float retreatThreshold)
+        {
+            _generator = generator;
+            _controller = controller;
+            _exploreChance = exploreChance;
+            _retreatThreshold = retreatThreshold;
+        }
+
+        public override bool CanExecute(MazeAgent agent)
+        {
+            // Always can execute, but only if no other decision consumed the turn
+            return agent != null && agent.CurrentRoom != null;
+        }
+
+        public override bool Execute(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            Exit choice = ChooseExit(agent, room);
+
+            if (choice == null)
+            {
+                // No usable door - waiting
+                return false;
+            }
+
+            // Try to use the exit (generates room if needed)
+            _controller.TryUseExit(choice);
+            return true;
+        }
+
+        public override void Think(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            Exit choice = ChooseExit(agent, room);
+
+            if (choice == null)
+            {
+                agent.Thoughts.Add(ThoughtKind.Move, $"No usable door out of room {room.Id} - waiting.");
+                return;
+            }
+
+            string heading = CompassName(choice.DirectionDegrees);
+            Room known = choice.ConnectedRoomId.HasValue ? _generator.Graph.Get(choice.ConnectedRoomId.Value) : null;
+            string destination = known != null
+                ? $"room {known.Id}{(agent.HasVisited(known.Id) ? " (been there)" : " (new to me)")}"
+                : "whatever is behind it (never opened)";
+
+            agent.Thoughts.Add(ThoughtKind.Move, $"Taking the {heading} door into {destination}.");
+        }
+
+        private Exit ChooseExit(MazeAgent agent, Room room)
+        {
+            Exit reverseExit = FindReverseExit(agent, room);
+
+            var explore = new List<Exit>();
+            var follow = new List<Exit>();
+            var backtrack = new List<Exit>();
+
+            foreach (var exit in room.Exits)
+            {
+                if (exit == reverseExit) continue;
+                if (exit.IsBlocked) continue;
+
+                if (!exit.IsUsed)
+                {
+                    explore.Add(exit);
+                    continue;
+                }
+
+                bool leadsToVisited = exit.ConnectedRoomId.HasValue && agent.HasVisited(exit.ConnectedRoomId.Value);
+                (leadsToVisited ? backtrack : follow).Add(exit);
+            }
+
+            // Filter by threat
+            explore = FilterByThreat(agent, explore);
+            follow = FilterByThreat(agent, follow);
+            backtrack = FilterByThreat(agent, backtrack);
+
+            if (explore.Count > 0 && UnityEngine.Random.value < _exploreChance)
+                return RandomPick(explore);
+
+            if (follow.Count > 0)
+                return LeastVisitedPick(agent, follow);
+
+            if (explore.Count > 0)
+                return RandomPick(explore);
+
+            if (backtrack.Count > 0)
+                return ChooseBacktrack(agent, backtrack);
+
+            return reverseExit;
+        }
+
+        private static Exit FindReverseExit(MazeAgent agent, Room room)
+        {
+            int? reverseExitId = agent.LastUsedExit?.ConnectedExitId;
+            if (!reverseExitId.HasValue) return null;
+            return room.Exits.Find(e => e.Id == reverseExitId.Value);
+        }
+
+        private Exit ChooseBacktrack(MazeAgent agent, System.Collections.Generic.List<Exit> backtrack)
+        {
+            var promising = backtrack.Where(e => LeadsTowardUnexploredOptions(agent, e)).ToList();
+            return LeastVisitedPick(agent, promising.Count > 0 ? promising : backtrack);
+        }
+
+        private bool LeadsTowardUnexploredOptions(MazeAgent agent, Exit exit)
+        {
+            if (!exit.ConnectedRoomId.HasValue) return false;
+
+            Room target = _generator.Graph.Get(exit.ConnectedRoomId.Value);
+            if (target == null) return false;
+
+            int reverseExitId = exit.ConnectedExitId ?? -1;
+            foreach (var candidate in target.Exits)
+            {
+                if (candidate.Id == reverseExitId) continue;
+                if (!candidate.IsUsed) return true;
+                if (candidate.ConnectedRoomId.HasValue && !agent.HasVisited(candidate.ConnectedRoomId.Value)) return true;
+            }
+            return false;
+        }
+
+        private static Exit LeastVisitedPick(MazeAgent agent, System.Collections.Generic.List<Exit> exits)
+        {
+            int bestVisits = int.MaxValue;
+            var bestExits = new System.Collections.Generic.List<Exit>();
+
+            foreach (var exit in exits)
+            {
+                int visits = exit.ConnectedRoomId.HasValue ? agent.VisitCount(exit.ConnectedRoomId.Value) : 0;
+                if (visits < bestVisits)
+                {
+                    bestVisits = visits;
+                    bestExits.Clear();
+                    bestExits.Add(exit);
+                }
+                else if (visits == bestVisits)
+                {
+                    bestExits.Add(exit);
+                }
+            }
+
+            return RandomPick(bestExits);
+        }
+
+        private System.Collections.Generic.List<Exit> FilterByThreat(MazeAgent agent, System.Collections.Generic.List<Exit> exits)
+        {
+            var safeExits = new System.Collections.Generic.List<Exit>();
+
+            foreach (var exit in exits)
+            {
+                if (ShouldTakeExit(agent, exit))
+                    safeExits.Add(exit);
+            }
+
+            return safeExits.Count > 0 ? safeExits : exits;
+        }
+
+        private bool ShouldTakeExit(MazeAgent agent, Exit exit)
+        {
+            if (!exit.ConnectedRoomId.HasValue)
+                return true;
+
+            Room nextRoom = _generator.Graph.Get(exit.ConnectedRoomId.Value);
+            if (nextRoom == null || nextRoom.Encounter == null || !nextRoom.Encounter.HasLivingMonsters)
+                return true;
+
+            float perceivedCR = nextRoom.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+
+            if (perceivedCR <= effectiveThreshold)
+                return true;
+
+            float retreatChance = UnityEngine.Mathf.Clamp01((perceivedCR - effectiveThreshold) / 2.0f);
+            return UnityEngine.Random.value > retreatChance;
+        }
+
+        private static Exit RandomPick(System.Collections.Generic.List<Exit> exits)
+            => exits[UnityEngine.Random.Range(0, exits.Count)];
+
+        private static string CompassName(float directionDegrees)
+        {
+            int normalized = UnityEngine.Mathf.RoundToInt(UnityEngine.Mathf.Repeat(directionDegrees, 360f) / 90f) % 4;
+            switch (normalized)
+            {
+                case 0: return "east";
+                case 1: return "north";
+                case 2: return "west";
+                default: return "south";
+            }
+        }
+
+        private float GetEffectiveReteatThreshold(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            float maxHealth = sheet.Stats.MaxHealth;
+            if (maxHealth <= 0) return _retreatThreshold;
+
+            float healthPercent = sheet.Stats.CurrentHealth / maxHealth;
+
+            if (healthPercent < 0.3f)
+                return _retreatThreshold * 0.5f;
+            else if (healthPercent < 0.5f)
+            {
+                float t = (healthPercent - 0.3f) / 0.2f;
+                return UnityEngine.Mathf.Lerp(_retreatThreshold * 0.5f, _retreatThreshold, t);
+            }
+
+            return _retreatThreshold;
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/MoveOnDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9f0fd59525634ca48b2376b6a29d6e29

Assets/Scripts/Maze/Agent/Decisions/SneakAwayDecision.cs

@@ -0,0 +1,92 @@
+namespace MazeGen
+{
+    /// <summary>
+    /// When the threat is too high to fight, tries to sneak out of the room.
+    /// If the sneak fails, declares a forced fight instead.
+    /// </summary>
+    public class SneakAwayDecision : AgentDecision
+    {
+        private CombatDirector _director;
+        private float _retreatThreshold;
+
+        public override string DecisionName => "Sneak Away";
+
+        public SneakAwayDecision(CombatDirector director, float retreatThreshold)
+        {
+            _director = director;
+            _retreatThreshold = retreatThreshold;
+        }
+
+        public override bool CanExecute(MazeAgent agent)
+        {
+            if (agent == null || _director == null) return false;
+            if (agent.IsEngaged) return false;
+
+            Room room = agent.CurrentRoom;
+            if (room == null || room.Encounter == null || !room.Encounter.HasLivingMonsters)
+                return false;
+
+            // Already failed here before
+            if (agent.HasFledFrom(room.Id))
+                return false;
+
+            // Would we reject this threat level?
+            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            return threat > effectiveThreshold;
+        }
+
+        public override bool Execute(MazeAgent agent)
+        {
+            // Try to sneak
+            if (_director.TrySneakOut(agent, out float odds))
+            {
+                // Successfully sneaked away
+                return false; // Return false so MoveOn can proceed this same tick
+            }
+            else
+            {
+                // Sneak failed - now forced to fight
+                Room room = agent.CurrentRoom;
+                int hostiles = room.Encounter.AliveMonsterCount;
+                _director.DeclareFight(room, agent, $"was caught trying to sneak out past {hostiles} hostile(s)");
+                return true; // Consumed the turn
+            }
+        }
+
+        public override void Think(MazeAgent agent)
+        {
+            Room room = agent.CurrentRoom;
+            float threat = room.Encounter.GetPerceivedChallengeRating(agent.CharacterSheet);
+            float effectiveThreshold = GetEffectiveReteatThreshold(agent);
+            int hostiles = room.Encounter.AliveMonsterCount;
+
+            agent.Thoughts.Add(ThoughtKind.Avoid,
+                $"Peeked: {hostiles} hostile(s) at threat {threat:0.00}, over my limit {effectiveThreshold:0.00} - trying to slip out instead of fighting.");
+
+            if (_director.TrySneakOut(agent, out float odds))
+                agent.Thoughts.Add(ThoughtKind.Sneak, $"Slipped away unnoticed ({odds:P0} odds).");
+            else
+                agent.Thoughts.Add(ThoughtKind.Sneak, $"Botched the sneak ({odds:P0} odds) - they've seen me, no choice but to fight.");
+        }
+
+        private float GetEffectiveReteatThreshold(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            float maxHealth = sheet.Stats.MaxHealth;
+            if (maxHealth <= 0) return _retreatThreshold;
+
+            float healthPercent = sheet.Stats.CurrentHealth / maxHealth;
+
+            if (healthPercent < 0.3f)
+                return _retreatThreshold * 0.5f;
+            else if (healthPercent < 0.5f)
+            {
+                float t = (healthPercent - 0.3f) / 0.2f;
+                return UnityEngine.Mathf.Lerp(_retreatThreshold * 0.5f, _retreatThreshold, t);
+            }
+
+            return _retreatThreshold;
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/SneakAwayDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cc0fd00ad6809674ea112b54fbb462a9

Assets/Scripts/Maze/Agent/Decisions/UseHealthPotionDecision.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Decides to use a health potion if the agent's health is low.
+    /// Only executes when outside of combat and health is below 50%.
+    /// </summary>
+    public class UseHealthPotionDecision : AgentDecision
+    {
+        private const float LowHealthThreshold = 0.5f;
+
+        public override string DecisionName => "Use Health Potion";
+
+        public override bool CanExecute(MazeAgent agent)
+        {
+            if (agent == null || agent.IsEngaged) return false; // Can't use potions while fighting
+
+            CharacterSheet sheet = agent.CharacterSheet;
+            float healthPercent = sheet.Stats.MaxHealth > 0 ? sheet.Stats.CurrentHealth / sheet.Stats.MaxHealth : 1f;
+
+            if (healthPercent >= LowHealthThreshold) return false; // Health is fine
+
+            // Check if we have a potion available (peek without consuming)
+            return sheet.Inventory.Any(i => i is Consumable c && c.HealthBonus > 0);
+        }
+
+        public override bool Execute(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            Consumable potion = sheet.GetHealthPotionFromInventory();
+            if (potion != null && potion.HealthBonus > 0)
+            {
+                sheet.Stats.Heal(potion.HealthBonus);
+                return true;
+            }
+            return false;
+        }
+
+        public override void Think(MazeAgent agent)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+            // The potion was consumed in Execute, so we narrate the result
+            agent.Thoughts.Add(ThoughtKind.Peek,
+                $"Used health potion, recovered HP (now {sheet.Stats.CurrentHealth:0.#}/{sheet.Stats.MaxHealth:0.#})");
+        }
+    }
+}

Assets/Scripts/Maze/Agent/Decisions/UseHealthPotionDecision.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9d9248c4bd518ef4a869b1320a8a4d30

Assets/Scripts/Maze/Combat/CharacterSheet.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 
 namespace MazeGen
@@ -123,6 +124,20 @@ namespace MazeGen
                 _inventory.Add(item);
         }
 
+        // Needs a better way to handle this, but for now just remove the first item that matches the name. Returns null if not found.
+        public Consumable GetHealthPotionFromInventory()
+        {
+            List<Consumable> consumables = _inventory.FindAll(i => i is Consumable && ((Consumable)i).HealthBonus > 0).Cast<Consumable>().ToList();
+            Consumable consumable = consumables.Find(c => c.HealthBonus > 0);
+            if (consumable != null)
+            {
+                _inventory.Remove(consumable);
+                return consumable;
+            }
+
+            return null;
+        }
+
         /// <summary>Apply a temporary stat bonus (e.g., from a weapon, buff, or potion).</summary>
         public void ApplyTemporaryBonus(string key, float attackBonus = 0, float defenseBonus = 0, float magicBonus = 0, float speedBonus = 0, float healthBonus = 0)
         {

Assets/Scripts/Maze/Combat/CharacterStats.cs

@@ -8,7 +8,7 @@ namespace MazeGen
     /// are used in combat resolution).
     /// </summary>
     [System.Serializable]
-    public class CharacterStats
+    public class CharacterStats : ISerializationCallbackReceiver
     {
         [SerializeField] private float _maxHealth = 100f;
         [SerializeField] private float _speed = 10f;           // Initiative and movement speed
@@ -36,18 +36,44 @@ namespace MazeGen
             _currentHealth = _maxHealth;
         }
 
+        /// <summary>
+        /// Unity deserializes nested [Serializable] classes by running the default constructor
+        /// first (which sets _currentHealth from _maxHealth's *default field value*, 100), and
+        /// only afterwards overwrites the serialized fields (like _maxHealth) with the saved
+        /// asset data. That leaves _currentHealth stale (e.g. 100/20) for any template asset whose
+        /// real MaxHealth differs from the field default. _currentHealth isn't [SerializeField],
+        /// so nothing else corrects it - fix it up here now that _maxHealth holds its real value.
+        /// </summary>
+        public void OnAfterDeserialize()
+        {
+            _currentHealth = _maxHealth;
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        /// <summary>
+        /// Calculate how many grid squares this character can move per turn during combat.
+        /// Movement range is based on Speed: faster characters move further.
+        /// Formula: Speed / 2, minimum 1 square per turn.
+        /// </summary>
+        public int GetMovementRange()
+        {
+            return Mathf.Max(1, Mathf.FloorToInt(_speed / 2f));
+        }
+
         /// <summary>Create a copy of this stat block (useful for monster instances).</summary>
         public CharacterStats Clone()
         {
-            var clone = new CharacterStats
-            {
-                _maxHealth = _maxHealth,
-                _speed = _speed,
-                _attack = _attack,
-                _defense = _defense,
-                _magic = _magic,
-                _currentHealth = _currentHealth
-            };
+            var clone = new CharacterStats();
+            // Manually copy all fields (can't use object initializer for private fields)
+            clone._maxHealth = _maxHealth;
+            clone._speed = _speed;
+            clone._attack = _attack;
+            clone._defense = _defense;
+            clone._magic = _magic;
+            clone._currentHealth = _currentHealth;
             return clone;
         }
 
@@ -63,6 +89,11 @@ namespace MazeGen
             CurrentHealth -= Mathf.Max(0, damage);
         }
 
+        public void Heal(float amount)
+        {
+            CurrentHealth += Mathf.Max(0, amount);
+        }
+
         /// <summary>Calculate effective damage taken after defense reduction.</summary>
         public float CalculateDamageReduction(float incomingDamage)
         {

Assets/Scripts/Maze/Combat/CombatAction.cs

@@ -0,0 +1,87 @@
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Types of actions a combatant can take during their turn.
+    /// </summary>
+    public enum ActionType
+    {
+        Move,       // Move towards/away from target or selected position
+        Attack,     // Attack a target (if in range)
+        UseItem,    // Use a consumable item (health potion, etc.)
+        Defend,     // Brace for impact (future: reduce damage taken)
+        Pass        // Do nothing this turn
+    }
+
+    /// <summary>
+    /// Represents a single action a combatant can take during their turn in combat.
+    /// This is decided by the AI (or eventually player input) and then executed by CombatResolver.
+    /// </summary>
+    public class CombatAction
+    {
+        /// <summary>ID of the combatant taking this action.</summary>
+        public int ActorId { get; set; }
+
+        /// <summary>Type of action being taken.</summary>
+        public ActionType ActionType { get; set; }
+
+        /// <summary>Target combatant (for Attack, Defend). Null for Move/UseItem/Pass.</summary>
+        public Combatant TargetCombatant { get; set; }
+
+        /// <summary>Target grid position (for Move actions). Zero for other action types.</summary>
+        public Vector2Int TargetPosition { get; set; }
+
+        /// <summary>Item to use (for UseItem actions). Null for other action types.</summary>
+        public Consumable TargetItem { get; set; }
+
+        public CombatAction()
+        {
+            ActorId = -1;
+            ActionType = ActionType.Pass;
+            TargetCombatant = null;
+            TargetPosition = Vector2Int.zero;
+            TargetItem = null;
+        }
+
+        public CombatAction(int actorId, ActionType actionType)
+        {
+            ActorId = actorId;
+            ActionType = actionType;
+            TargetCombatant = null;
+            TargetPosition = Vector2Int.zero;
+            TargetItem = null;
+        }
+
+        public CombatAction(int actorId, Combatant targetCombatant)
+        {
+            ActorId = actorId;
+            ActionType = ActionType.Attack;
+            TargetCombatant = targetCombatant;
+            TargetPosition = Vector2Int.zero;
+            TargetItem = null;
+        }
+
+        public CombatAction(int actorId, Vector2Int targetPosition)
+        {
+            ActorId = actorId;
+            ActionType = ActionType.Move;
+            TargetCombatant = null;
+            TargetPosition = targetPosition;
+            TargetItem = null;
+        }
+
+        public override string ToString()
+        {
+            return ActionType switch
+            {
+                ActionType.Move => $"Move to {TargetPosition}",
+                ActionType.Attack => $"Attack {TargetCombatant?.Name ?? "null"}",
+                ActionType.UseItem => $"Use {TargetItem?.ItemName ?? "null"}",
+                ActionType.Defend => "Defend",
+                ActionType.Pass => "Pass",
+                _ => "Unknown action"
+            };
+        }
+    }
+}

Assets/Scripts/Maze/Combat/CombatAction.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8e542c555eab51a43ba222f823fe29a5

Assets/Scripts/Maze/Combat/CombatEvent.cs

@@ -6,10 +6,16 @@ namespace MazeGen
     {
         FightStart,
         RoundStart,
+        MovementStart,         // Actor begins moving
+        MovementComplete,      // Actor completes movement
+        OutOfRange,            // Attack failed: target out of weapon range
+        TooFarForMelee,        // Attack failed: not adjacent for melee
+        TargetUnreachable,     // Movement failed: destination unreachable
         Hit,
         Miss,
         Death,
-        FightEnd
+        FightEnd,
+        HealthPotionUsed
     }
 
     /// <summary>
@@ -37,6 +43,15 @@ namespace MazeGen
 
         /// <summary>Pre-rendered log line, so the log/thought/feed surfaces don't each re-describe it.</summary>
         public string Text;
+
+        /// <summary>Starting position for movement events (grid coordinates).</summary>
+        public UnityEngine.Vector2Int SourcePosition = UnityEngine.Vector2Int.zero;
+
+        /// <summary>Destination position for movement events, or target position for attacks (grid coordinates).</summary>
+        public UnityEngine.Vector2Int TargetPosition = UnityEngine.Vector2Int.zero;
+
+        /// <summary>Distance moved in squares (for MovementComplete events).</summary>
+        public int MovementDistance = 0;
     }
 
     public enum BattleOutcome

Assets/Scripts/Maze/Combat/CombatGrid.cs

@@ -0,0 +1,328 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Manages the combat grid where combatants are positioned during a fight.
+    /// Handles placement, collision detection, occupancy tracking, and pathfinding.
+    /// Grid cells are based on maze room spacing for consistency.
+    /// </summary>
+    public class CombatGrid
+    {
+        /// <summary>Grid dimensions in squares.</summary>
+        private Vector2Int _gridSize;
+
+        /// <summary>Grid cell size in world units (matches maze room spacing).</summary>
+        private float _cellSize;
+
+        /// <summary>Tracks which combatants occupy each grid position.</summary>
+        private Dictionary<Vector2Int, List<Combatant>> _occupancy;
+
+        /// <summary>All combatants on this grid.</summary>
+        private List<Combatant> _allCombatants;
+
+        /// <summary>
+        /// Initialize the grid with specified dimensions.
+        /// Default size is 11x7 squares (standard arena size).
+        /// </summary>
+        public CombatGrid(Vector2Int gridSize, float cellSize = 1f)
+        {
+            _gridSize = gridSize;
+            _cellSize = cellSize;
+            _occupancy = new Dictionary<Vector2Int, List<Combatant>>();
+            _allCombatants = new List<Combatant>();
+
+            // Pre-allocate all cells
+            for (int x = 0; x < _gridSize.x; x++)
+            {
+                for (int y = 0; y < _gridSize.y; y++)
+                {
+                    Vector2Int pos = new Vector2Int(x, y);
+                    _occupancy[pos] = new List<Combatant>();
+                }
+            }
+        }
+
+        public Vector2Int GridSize => _gridSize;
+        public float CellSize => _cellSize;
+
+        /// <summary>
+        /// Place all combatants on the grid. Agents on left side, monsters on right side.
+        /// </summary>
+        public void PlaceAllCombatants(IReadOnlyList<Combatant> combatants)
+        {
+            _allCombatants.Clear();
+            _occupancy.Clear();
+
+            // Re-initialize occupancy
+            for (int x = 0; x < _gridSize.x; x++)
+            {
+                for (int y = 0; y < _gridSize.y; y++)
+                {
+                    Vector2Int pos = new Vector2Int(x, y);
+                    _occupancy[pos] = new List<Combatant>();
+                }
+            }
+
+            // Separate agents and monsters
+            var agents = new List<Combatant>();
+            var monsters = new List<Combatant>();
+
+            foreach (var c in combatants)
+            {
+                if (c.IsAgent)
+                    agents.Add(c);
+                else
+                    monsters.Add(c);
+            }
+
+            // Place agents on the left side
+            PlaceTeam(agents, isAgents: true);
+
+            // Place monsters on the right side
+            PlaceTeam(monsters, isAgents: false);
+        }
+
+        /// <summary>
+        /// Place a team (agents or monsters) on their respective side of the grid.
+        /// </summary>
+        private void PlaceTeam(List<Combatant> team, bool isAgents)
+        {
+            if (team.Count == 0) return;
+
+            // Calculate starting column and direction
+            int startColumn = isAgents ? 1 : _gridSize.x - 2;
+            int columnDirection = isAgents ? 1 : -1;
+
+            int combatantsPlaced = 0;
+            int currentColumn = startColumn;
+
+            while (combatantsPlaced < team.Count && currentColumn >= 0 && currentColumn < _gridSize.x)
+            {
+                // Try to fill this column from top to bottom
+                for (int row = 0; row < _gridSize.y && combatantsPlaced < team.Count; row++)
+                {
+                    Vector2Int position = new Vector2Int(currentColumn, row);
+
+                    if (IsPositionValid(position, team[combatantsPlaced]))
+                    {
+                        PlaceCombatant(team[combatantsPlaced], position);
+                        combatantsPlaced++;
+                    }
+                }
+
+                currentColumn += columnDirection;
+            }
+
+            // Fallback: if not all placed, fill remaining positions
+            if (combatantsPlaced < team.Count)
+            {
+                for (int x = 0; x < _gridSize.x && combatantsPlaced < team.Count; x++)
+                {
+                    for (int y = 0; y < _gridSize.y && combatantsPlaced < team.Count; y++)
+                    {
+                        Vector2Int position = new Vector2Int(x, y);
+                        if (_occupancy[position].Count == 0 && IsPositionValid(position, team[combatantsPlaced]))
+                        {
+                            PlaceCombatant(team[combatantsPlaced], position);
+                            combatantsPlaced++;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Place a single combatant at the specified grid position.
+        /// Only call after validating with IsPositionValid().
+        /// </summary>
+        public void PlaceCombatant(Combatant combatant, Vector2Int position)
+        {
+            if (combatant == null) return;
+
+            // Remove from old position if already placed
+            if (_allCombatants.Contains(combatant))
+            {
+                foreach (var cellCombatants in _occupancy.Values)
+                {
+                    cellCombatants.Remove(combatant);
+                }
+            }
+
+            // Add to new position
+            combatant.GridPosition = position;
+            if (!_allCombatants.Contains(combatant))
+                _allCombatants.Add(combatant);
+
+            if (_occupancy.ContainsKey(position))
+            {
+                if (!_occupancy[position].Contains(combatant))
+                    _occupancy[position].Add(combatant);
+            }
+        }
+
+        /// <summary>
+        /// Check if a position is valid for a combatant to occupy.
+        /// Considers grid boundaries, size, and occupancy rules.
+        /// </summary>
+        public bool IsPositionValid(Vector2Int position, Combatant combatant)
+        {
+            if (combatant == null) return false;
+
+            // Check grid bounds
+            if (position.x < 0 || position.x >= _gridSize.x ||
+                position.y < 0 || position.y >= _gridSize.y)
+                return false;
+
+            // Get the footprint this combatant would occupy
+            Vector2Int footprint = combatant.GetFootprintSize();
+
+            // Check if entire footprint fits in grid
+            if (position.x + footprint.x > _gridSize.x ||
+                position.y + footprint.y > _gridSize.y)
+                return false;
+
+            // Check occupancy based on size
+            if (combatant.Size == MonsterSize.Large)
+            {
+                // Large creatures can't share a grid with anything
+                for (int x = position.x; x < position.x + footprint.x; x++)
+                {
+                    for (int y = position.y; y < position.y + footprint.y; y++)
+                    {
+                        if (x < 0 || x >= _gridSize.x || y < 0 || y >= _gridSize.y)
+                            return false;
+                        if (_occupancy.ContainsKey(new Vector2Int(x, y)) && _occupancy[new Vector2Int(x, y)].Count > 0)
+                            return false;
+                    }
+                }
+            }
+            else if (combatant.Size == MonsterSize.Medium)
+            {
+                // Medium creatures need empty space
+                if (_occupancy.ContainsKey(position) && _occupancy[position].Count > 0)
+                    return false;
+            }
+            else if (combatant.Size == MonsterSize.Small)
+            {
+                // Small creatures can stack (up to 4 per square)
+                if (_occupancy.ContainsKey(position))
+                {
+                    int creaturesInSquare = 0;
+                    foreach (var c in _occupancy[position])
+                    {
+                        creaturesInSquare += c.Size == MonsterSize.Small ? 1 : 4;
+                    }
+                    if (creaturesInSquare >= 4) return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Try to move a combatant to a new position atomically.
+        /// Returns true if successful, false if invalid move.
+        /// </summary>
+        public bool TryMoveCombatant(Combatant combatant, Vector2Int newPosition)
+        {
+            if (!IsPositionValid(newPosition, combatant))
+                return false;
+
+            PlaceCombatant(combatant, newPosition);
+            return true;
+        }
+
+        /// <summary>
+        /// Remove a combatant from the grid (e.g., when they die).
+        /// </summary>
+        public void RemoveCombatant(Combatant combatant)
+        {
+            if (combatant == null) return;
+
+            _allCombatants.Remove(combatant);
+            foreach (var cellCombatants in _occupancy.Values)
+            {
+                cellCombatants.Remove(combatant);
+            }
+        }
+
+        /// <summary>
+        /// Get all combatants currently on the grid.
+        /// </summary>
+        public IReadOnlyList<Combatant> GetAllCombatants() => _allCombatants.AsReadOnly();
+
+        /// <summary>
+        /// Get combatants at a specific grid position.
+        /// </summary>
+        public IReadOnlyList<Combatant> GetCombatantsAt(Vector2Int position)
+        {
+            if (_occupancy.ContainsKey(position))
+                return _occupancy[position].AsReadOnly();
+            return new List<Combatant>().AsReadOnly();
+        }
+
+        /// <summary>
+        /// Get all reachable positions from a starting position within movement range.
+        /// Uses BFS (Breadth-First Search) for pathfinding.
+        /// </summary>
+        public HashSet<Vector2Int> GetReachablePositions(Combatant actor, int maxMovement)
+        {
+            var reachable = new HashSet<Vector2Int>();
+            var queue = new Queue<(Vector2Int pos, int distance)>();
+
+            queue.Enqueue((actor.GridPosition, 0));
+            reachable.Add(actor.GridPosition);
+
+            while (queue.Count > 0)
+            {
+                var (currentPos, currentDistance) = queue.Dequeue();
+
+                if (currentDistance >= maxMovement)
+                    continue;
+
+                // Check all 4 cardinal directions
+                Vector2Int[] directions = new Vector2Int[]
+                {
+                    new Vector2Int(1, 0),   // Right
+                    new Vector2Int(-1, 0), // Left
+                    new Vector2Int(0, 1),  // Up
+                    new Vector2Int(0, -1)  // Down
+                };
+
+                foreach (var direction in directions)
+                {
+                    Vector2Int nextPos = currentPos + direction;
+
+                    if (!reachable.Contains(nextPos) && IsPositionValid(nextPos, actor))
+                    {
+                        reachable.Add(nextPos);
+                        queue.Enqueue((nextPos, currentDistance + 1));
+                    }
+                }
+            }
+
+            return reachable;
+        }
+
+        /// <summary>
+        /// Convert a grid position to world coordinates (for visualization).
+        /// </summary>
+        public Vector2 GridToWorldPosition(Vector2Int gridPos)
+        {
+            return new Vector2(gridPos.x * _cellSize, gridPos.y * _cellSize);
+        }
+
+        /// <summary>
+        /// Convert world coordinates to grid position.
+        /// </summary>
+        public Vector2Int WorldToGridPosition(Vector2 worldPos)
+        {
+            return new Vector2Int(
+                Mathf.RoundToInt(worldPos.x / _cellSize),
+                Mathf.RoundToInt(worldPos.y / _cellSize)
+            );
+        }
+    }
+}

Assets/Scripts/Maze/Combat/CombatGrid.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 91e8fb72dc98a854e97f98e8c5da4a8a

Assets/Scripts/Maze/Combat/CombatResolver.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 
 namespace MazeGen
@@ -6,6 +7,9 @@ namespace MazeGen
     /// <summary>
     /// Resolves a battle between a group of agents and a group of monsters, all in one room.
     ///
+    /// Now includes grid-based positioning and movement. Combatants must move into range
+    /// before they can attack. Movement is determined by Speed stat (Speed/2 = squares per turn).
+    ///
     /// Runs to completion synchronously and returns the whole thing as an ordered
     /// <see cref="CombatEvent"/> list (see <see cref="BattleResult"/>). Nothing about this is
     /// frame-based or animated - "watching" a fight is purely a replay of the list this produces,
@@ -26,6 +30,8 @@ namespace MazeGen
         private const float DamageVariance = 0.15f;
         private const float DefenseMitigationPerPoint = 0.1f;
         private const float MaxMitigation = 0.9f;
+        private const int CombatGridWidth = 11;
+        private const int CombatGridHeight = 7;
 
         /// <summary>
         /// Fights it out until one side is wiped or <paramref name="maxRounds"/> is exhausted
@@ -41,6 +47,9 @@ namespace MazeGen
             Emit(result, CombatEventKind.FightStart, 0, -1, -1, 0f,
                 $"Fight begins: {agentCount} agent(s) vs {monsterCount} monster(s).");
 
+            // Initialize combat grid and place combatants
+            CombatGrid grid = InitializeGrid(combatants);
+
             // Initiative is rolled once for the whole battle (classic fixed turn order) so the
             // arena can lay combatants out in a stable order that matches the log.
             var order = BuildTurnOrder(combatants);
@@ -51,18 +60,14 @@ namespace MazeGen
                 round++;
                 Emit(result, CombatEventKind.RoundStart, round, -1, -1, 0f, $"-- Round {round} --");
 
-                foreach (var actor in order)
-                {
-                    if (!actor.IsAlive) continue;
-
-                    Combatant target = PickTarget(combatants, actor);
-                    if (target == null) break; // no enemies left
+                // Select actions for all combatants this round
+                var actions = SelectActions(order, combatants, grid);
 
-                    TakeSwing(result, round, actor, target);
+                // Execute actions in order (movements first, then attacks)
+                ExecuteActions(actions, order, grid, result, round, combatants);
 
-                    if (!HasAlive(combatants, Combatant.TeamAgents) || !HasAlive(combatants, Combatant.TeamMonsters))
-                        break;
-                }
+                if (!HasAlive(combatants, Combatant.TeamAgents) || !HasAlive(combatants, Combatant.TeamMonsters))
+                    break;
             }
 
             result.Rounds = round;
@@ -74,11 +79,302 @@ namespace MazeGen
                 : !agentsLeft && monstersLeft ? BattleOutcome.MonstersVictory
                 : !agentsLeft && !monstersLeft ? BattleOutcome.MonstersVictory // mutual wipe counts as a loss for the agents
                 : BattleOutcome.Stalemate;
-
+            if (result.Outcome == BattleOutcome.AgentsVictory)
+            {
+                LootMonsters(combatants);
+            }
             Emit(result, CombatEventKind.FightEnd, round, -1, -1, 0f, result.Summary);
             return result;
         }
 
+        /// <summary>
+        /// Initialize the combat grid and place all combatants on it.
+        /// Monsters start fresh (full health each room), but agents retain damage between fights.
+        /// Resets grid positions to ensure clean placement each fight.
+        /// </summary>
+        private static CombatGrid InitializeGrid(IReadOnlyList<Combatant> combatants)
+        {
+            // Reset grid positions for all combatants (they persist between fights)
+            foreach (var combatant in combatants)
+            {
+                combatant.GridPosition = Vector2Int.zero;
+            }
+
+            // Monsters always start at full health (they're spawned per-room)
+            // Agents keep their damage from previous fights (only healed by potions)
+            foreach (var combatant in combatants)
+            {
+                if (!combatant.IsAgent)  // Only monsters start fresh
+                {
+                    combatant.Sheet.Stats.RestoreHealth();
+                }
+            }
+
+            var grid = new CombatGrid(new Vector2Int(CombatGridWidth, CombatGridHeight), 1f);
+            grid.PlaceAllCombatants(combatants);
+
+            // Snapshot the starting position for playback - GridPosition keeps changing as the
+            // fight resolves, so this is what BattleArenaView uses to place sprites correctly
+            // from the first frame instead of wherever the fight ended up.
+            foreach (var combatant in combatants)
+            {
+                combatant.StartGridPosition = combatant.GridPosition;
+            }
+
+            return grid;
+        }
+
+        /// <summary>
+        /// Select actions for all alive combatants this turn.
+        /// Agents try health potions first if low on health, then decide between movement and attack.
+        /// Monsters always attack or move closer.
+        /// </summary>
+        private static List<CombatAction> SelectActions(
+            List<Combatant> order,
+            IReadOnlyList<Combatant> allCombatants,
+            CombatGrid grid)
+        {
+            var actions = new List<CombatAction>();
+
+            foreach (var actor in order)
+            {
+                if (!actor.IsAlive) continue;
+
+                CombatAction action = null;
+
+                // Agent health potion logic
+                if (actor.IsAgent && actor.Agent.CharacterSheet.Stats.CurrentHealth <
+                    actor.Agent.CharacterSheet.Stats.MaxHealth * 0.2f)
+                {
+                    Consumable healthPotion = actor.Agent.CharacterSheet.GetHealthPotionFromInventory();
+                    if (healthPotion != null)
+                    {
+                        action = new CombatAction(actor.Id, ActionType.UseItem);
+                        action.TargetItem = healthPotion;
+                        actions.Add(action);
+                        continue;
+                    }
+                }
+
+                // Pick a target
+                Combatant target = PickTarget(allCombatants, actor);
+                if (target == null)
+                {
+                    action = new CombatAction(actor.Id, ActionType.Pass);
+                    actions.Add(action);
+                    continue;
+                }
+
+                // Get equipped weapon (or default to unarmed melee range 1)
+                Weapon weapon = actor.Sheet.EquippedWeapon;
+                int attackRange = weapon != null ? weapon.Range : 1; // Fists = range 1, adjacent only
+
+                // Check if in attack range
+                bool inRange = false;
+                if (weapon != null)
+                {
+                    inRange = MovementValidator.CanAttack(actor, target, weapon);
+                }
+                else
+                {
+                    // Unarmed: must be adjacent (distance = 1)
+                    inRange = actor.IsAdjacentTo(target);
+                }
+
+                if (inRange)
+                {
+                    action = new CombatAction(actor.Id, target);
+                    actions.Add(action);
+                }
+                else
+                {
+                    // Out of range, try to move closer
+                    Vector2Int nextPos = MovementValidator.GetNextPositionTowards(
+                        actor.GridPosition, target.GridPosition);
+
+                    if (MovementValidator.CanMoveTo(actor, nextPos, grid))
+                    {
+                        action = new CombatAction(actor.Id, nextPos);
+                        actions.Add(action);
+                    }
+                    else
+                    {
+                        // Can't move, just pass
+                        action = new CombatAction(actor.Id, ActionType.Pass);
+                        actions.Add(action);
+                    }
+                }
+            }
+
+            return actions;
+        }
+
+        /// <summary>
+        /// Execute all actions for this round in order.
+        /// </summary>
+        private static void ExecuteActions(
+            List<CombatAction> actions,
+            List<Combatant> turnOrder,
+            CombatGrid grid,
+            BattleResult result,
+            int round,
+            IReadOnlyList<Combatant> allCombatants)
+        {
+            foreach (var action in actions)
+            {
+                // Find the actor
+                Combatant actor = null;
+                foreach (var c in turnOrder)
+                {
+                    if (c.Id == action.ActorId)
+                    {
+                        actor = c;
+                        break;
+                    }
+                }
+
+                if (actor == null || !actor.IsAlive) continue;
+
+                switch (action.ActionType)
+                {
+                    case ActionType.Move:
+                        ExecuteMovement(actor, action.TargetPosition, grid, result, round);
+                        break;
+
+                    case ActionType.Attack:
+                        ExecuteAttack(actor, action.TargetCombatant, grid, result, round);
+                        break;
+
+                    case ActionType.UseItem:
+                        ExecuteUseItem(actor, action.TargetItem, result, round);
+                        break;
+
+                    case ActionType.Defend:
+                        // TODO: Implement defend action (damage reduction this turn)
+                        break;
+
+                    case ActionType.Pass:
+                    default:
+                        // Do nothing
+                        break;
+                }
+
+                // Check if fight is over after each action
+                if (!HasAlive(allCombatants, Combatant.TeamAgents) ||
+                    !HasAlive(allCombatants, Combatant.TeamMonsters))
+                {
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Execute a movement action for an actor.
+        /// </summary>
+        private static void ExecuteMovement(
+            Combatant actor,
+            Vector2Int destination,
+            CombatGrid grid,
+            BattleResult result,
+            int round)
+        {
+            Vector2Int startPos = actor.GridPosition;
+
+            if (!grid.TryMoveCombatant(actor, destination))
+            {
+                Emit(result, CombatEventKind.TargetUnreachable, round, actor.Id, -1, 0f,
+                    $"{actor.Name} could not reach {destination}.");
+                return;
+            }
+
+            int distance = MovementValidator.ManhattanDistance(startPos, destination);
+
+            Emit(result, CombatEventKind.MovementStart, round, actor.Id, -1, 0f,
+                $"{actor.Name} moves from {startPos} to {destination}.");
+
+            Emit(result, CombatEventKind.MovementComplete, round, actor.Id, -1, distance,
+                $"{actor.Name} has moved {distance} square(s).");
+
+            var moveEvent = result.Events[result.Events.Count - 1];
+            moveEvent.SourcePosition = startPos;
+            moveEvent.TargetPosition = destination;
+            moveEvent.MovementDistance = distance;
+        }
+
+        /// <summary>
+        /// Execute an attack action, with range validation.
+        /// Supports both armed and unarmed (fist) attacks.
+        /// </summary>
+        private static void ExecuteAttack(
+            Combatant actor,
+            Combatant target,
+            CombatGrid grid,
+            BattleResult result,
+            int round)
+        {
+            if (target == null || !target.IsAlive)
+                return;
+
+            Weapon weapon = actor.Sheet.EquippedWeapon;
+            bool isUnarmed = weapon == null;
+
+            // Validate range
+            bool canAttack = false;
+            if (isUnarmed)
+            {
+                // Unarmed: must be adjacent
+                canAttack = actor.IsAdjacentTo(target);
+                if (!canAttack)
+                {
+                    Emit(result, CombatEventKind.TooFarForMelee, round, actor.Id, target.Id, 0f,
+                        $"{actor.Name} is not adjacent to {target.Name} and cannot use fists.");
+                    return;
+                }
+            }
+            else
+            {
+                // Armed: use weapon's range
+                canAttack = MovementValidator.CanAttack(actor, target, weapon);
+                if (!canAttack)
+                {
+                    if (weapon.WeaponType == WeaponType.Melee)
+                    {
+                        Emit(result, CombatEventKind.TooFarForMelee, round, actor.Id, target.Id, 0f,
+                            $"{actor.Name} is not adjacent to {target.Name} and cannot use {weapon.ItemName}.");
+                    }
+                    else
+                    {
+                        Emit(result, CombatEventKind.OutOfRange, round, actor.Id, target.Id, 0f,
+                            $"{actor.Name}'s {weapon.ItemName} cannot reach {target.Name} (range: {weapon.Range}, distance: {actor.DistanceTo(target)}).");
+                    }
+                    return;
+                }
+            }
+
+            // Attack is valid, execute it
+            TakeSwing(result, round, actor, target);
+        }
+
+        /// <summary>
+        /// Execute using a consumable item.
+        /// </summary>
+        private static void ExecuteUseItem(
+            Combatant actor,
+            Consumable item,
+            BattleResult result,
+            int round)
+        {
+            if (item == null) return;
+
+            if (item is Consumable consumable)
+            {
+                actor.Sheet.Stats.Heal(consumable.HealthBonus);
+                Emit(result, CombatEventKind.HealthPotionUsed, round, actor.Id, -1,
+                    consumable.HealthBonus,
+                    $"{actor.Name} used {item.ItemName} to heal {consumable.HealthBonus} health.");
+            }
+        }
+
         /// <summary>
         /// Single attack: roll to hit, then damage attacker's effective attack against the
         /// target's effective defense.
@@ -175,5 +471,24 @@ namespace MazeGen
         }
 
         private static bool HasAlive(IReadOnlyList<Combatant> combatants, int team) => CountAlive(combatants, team) > 0;
+
+        private static void LootMonsters(IReadOnlyList<Combatant> combatants)
+        {
+            List<Combatant> aliveAgentCombatants = combatants.Where(c => c.IsAgent && c.IsAlive).ToList();
+            List<Combatant> deadMonsters = combatants.Where(c => !c.IsAgent && !c.IsAlive).ToList();
+            aliveAgentCombatants = aliveAgentCombatants.OrderBy(x => Random.value).ToList(); // Randomize the order of agents to distribute loot fairly
+
+            for (int i = 0; i < deadMonsters.Count; i++)
+            {
+                Combatant deadMonster = deadMonsters[i];
+                Combatant lootingAgent = aliveAgentCombatants[i % aliveAgentCombatants.Count];
+                Item loot = deadMonster.Monster.GetRandomLoot(); // Now uses the monster instance's remaining loot pool
+                if (loot != null)
+                {
+                    lootingAgent.Agent.CharacterSheet.AddToInventory(loot);
+                    Debug.Log($"{lootingAgent.Name} looted {loot.ItemName} from {deadMonster.Name}.");
+                }
+            }
+        }
     }
 }

Assets/Scripts/Maze/Combat/Combatant.cs

@@ -33,6 +33,12 @@ namespace MazeGen
         /// <summary>Health at the moment the battle was resolved, for playback purposes.</summary>
         public readonly float StartHealth;
 
+        /// <summary>Grid position during combat. Set by CombatGrid during Initialize.</summary>
+        private Vector2Int _gridPosition = Vector2Int.zero;
+
+        /// <summary>Size category for grid footprint (determines how many squares this combatant occupies).</summary>
+        private MonsterSize _size = MonsterSize.Medium;
+
         public bool IsAgent => Agent != null;
         public bool IsAlive => Sheet.Stats.IsAlive;
 
@@ -43,6 +49,29 @@ namespace MazeGen
         /// </summary>
         public float MaxHealth => Mathf.Max(1f, Sheet.Stats.MaxHealth);
 
+        /// <summary>Current position on the combat grid.</summary>
+        public Vector2Int GridPosition
+        {
+            get => _gridPosition;
+            set => _gridPosition = value;
+        }
+
+        /// <summary>Size category of this combatant (affects grid footprint).</summary>
+        public MonsterSize Size
+        {
+            get => _size;
+            set => _size = value;
+        }
+
+        /// <summary>
+        /// Grid position at the moment combatants were first placed on the grid, before any
+        /// movement happened. CombatResolver.Resolve() runs the whole fight synchronously and
+        /// mutates GridPosition throughout, so by the time playback starts, GridPosition already
+        /// holds the *final* position - this snapshot is what BattleArenaView uses to place the
+        /// combatant's sprite where it actually started, exactly like StartHealth does for health.
+        /// </summary>
+        public Vector2Int StartGridPosition { get; set; } = Vector2Int.zero;
+
         private Combatant(int id, int team, string name, Color color, MazeAgent agent, MonsterEncounter.MonsterInstance monster, CharacterSheet sheet)
         {
             Id = id;
@@ -59,6 +88,78 @@ namespace MazeGen
             => new Combatant(id, TeamAgents, agent.CharacterSheet.Name, color, agent, null, agent.CharacterSheet);
 
         public static Combatant ForMonster(int id, MonsterEncounter.MonsterInstance monster)
-            => new Combatant(id, TeamMonsters, monster.Template.MonsterName, monster.Template.Color, null, monster, monster.CharacterSheet);
+        {
+            var combatant = new Combatant(id, TeamMonsters, monster.Template.MonsterName, monster.Template.Color, null, monster, monster.CharacterSheet);
+            // Set size from monster template
+            combatant.Size = monster.Template.Size;
+            return combatant;
+        }
+
+        /// <summary>
+        /// Calculate grid distance to another combatant using Manhattan distance.
+        /// This represents how many squares apart they are.
+        /// </summary>
+        public int DistanceTo(Combatant other)
+        {
+            return Mathf.Abs(GridPosition.x - other.GridPosition.x) +
+                   Mathf.Abs(GridPosition.y - other.GridPosition.y);
+        }
+
+        /// <summary>
+        /// Get the footprint size (in grid squares) for this combatant based on its Size category.
+        /// </summary>
+        public Vector2Int GetFootprintSize()
+        {
+            return Size switch
+            {
+                MonsterSize.Small => Vector2Int.one,      // Small: 1x1, but multiple fit per square
+                MonsterSize.Medium => Vector2Int.one,     // Medium: 1x1
+                MonsterSize.Large => new Vector2Int(4, 4), // Large: 4x4
+                _ => Vector2Int.one
+            };
+        }
+
+        /// <summary>
+        /// Get the maximum number of this-sized creatures that can occupy a single grid square.
+        /// </summary>
+        public int GetCreaturesPerSquare()
+        {
+            return Size switch
+            {
+                MonsterSize.Small => 4,     // Small: 4 per square
+                MonsterSize.Medium => 1,    // Medium: 1 per square
+                MonsterSize.Large => 0,     // Large: occupies multiple squares, not stackable
+                _ => 1
+            };
+        }
+
+        /// <summary>
+        /// Check if this combatant is in melee range (adjacent) to a target.
+        /// </summary>
+        public bool IsAdjacentTo(Combatant target)
+        {
+            int distance = DistanceTo(target);
+            return distance == 1;
+        }
+
+        /// <summary>
+        /// Check if this combatant can reach a target with the given weapon.
+        /// Returns true if target is within the weapon's range.
+        /// </summary>
+        public bool CanReachTarget(Combatant target, Weapon weapon)
+        {
+            if (weapon == null) return false;
+
+            int distance = DistanceTo(target);
+
+            // For melee weapons, must be adjacent
+            if (weapon.WeaponType == WeaponType.Melee)
+            {
+                return IsAdjacentTo(target);
+            }
+
+            // For ranged/magic weapons, check against range attribute
+            return distance <= weapon.Range;
+        }
     }
 }

Assets/Scripts/Maze/Combat/Items/Item.cs

@@ -34,5 +34,10 @@ namespace MazeGen
 
         /// <summary>Short label for UI - override if needed.</summary>
         public virtual string GetLabel() => _itemName;
+
+        public virtual void Use(CharacterSheet character)
+        {
+            Debug.LogWarning($"Item {ItemName} has no Use() implementation.");
+        }
     }
 }

Assets/Scripts/Maze/Combat/Items/Weapon.cs

@@ -2,6 +2,16 @@ using UnityEngine;
 
 namespace MazeGen
 {
+    /// <summary>
+    /// Weapon classification for combat range and mechanics.
+    /// </summary>
+    public enum WeaponType
+    {
+        Melee,      // Must be adjacent to target (1 square)
+        Ranged,     // Physical projectile with variable range
+        Magic       // Spell-based with variable range
+    }
+
     /// <summary>
     /// A weapon that can be equipped to boost attack power. Can also provide
     /// secondary effects (e.g., magic boost, defense buff).
@@ -12,11 +22,15 @@ namespace MazeGen
         [SerializeField] private float _magicBonus = 0f;       // Some weapons add spell power
         [SerializeField] private float _defenseBonus = 0f;      // Some weapons grant parry/shield bonuses
         [SerializeField] private float _speedBonus = 0f;        // Heavy weapons might slow you down
+        [SerializeField] private WeaponType _weaponType = WeaponType.Melee;
+        [SerializeField] private int _range = 1;              // Range in grid squares (1 = melee/adjacent, 2+ = ranged/magic)
 
         public float AttackBonus => _attackBonus;
         public float MagicBonus => _magicBonus;
         public float DefenseBonus => _defenseBonus;
         public float SpeedBonus => _speedBonus;
+        public WeaponType WeaponType => _weaponType;
+        public int Range => _range;
 
         public override bool OnEquip(CharacterSheet character)
         {

Assets/Scripts/Maze/Combat/Monsters/Monster.cs

@@ -1,8 +1,44 @@
+using System.Collections.Generic;
 using Unity.VisualScripting;
 using UnityEngine;
 
 namespace MazeGen
 {
+    /// <summary>
+    /// Monster size for combat positioning. Determines grid footprint and spatial presence.
+    /// Small: 4 creatures fit in 1 grid square (fractionally tracked)
+    /// Medium: 1 creature = 1 grid square
+    /// Large: 1 creature = 4x4 grid squares
+    /// </summary>
+    public enum MonsterSize
+    {
+        Small,      // 4 per square
+        Medium,     // 1 per square (1x1)
+        Large       // 4x4 squares per creature
+    }
+
+    /// <summary>
+    /// Defines a loot entry with an item and its min/max drop count.
+    /// E.g., a Goblin might drop 0-2 Health Potions.
+    /// </summary>
+    [System.Serializable]
+    public class LootEntry
+    {
+        public Item Item;
+        [Tooltip("Minimum number of this item to drop (0 means it might not drop at all)")]
+        public int MinCount = 0;
+        [Tooltip("Maximum number of this item to drop")]
+        public int MaxCount = 1;
+
+        public LootEntry() { }
+        public LootEntry(Item item, int minCount, int maxCount)
+        {
+            Item = item;
+            MinCount = minCount;
+            MaxCount = maxCount;
+        }
+    }
+
     /// <summary>
     /// A ScriptableObject that defines a monster template (stats, appearance, loot).
     /// Monsters are instantiated from this template when they spawn in a room.
@@ -12,20 +48,67 @@ namespace MazeGen
         [SerializeField] private string _monsterName = "Goblin";
         [SerializeField] private Color _color = Color.green;
         [SerializeField] private CharacterStats _baseStats = new CharacterStats();
+        [SerializeField] private MonsterSize _size = MonsterSize.Medium;
 
         // Optional starting equipment
         [SerializeField] private Weapon _startingWeapon;
         [SerializeField] private Armor _startingArmor;
 
-        // Loot: what items might this monster drop when defeated (rough probabilities)
-        [SerializeField] private Item[] _possibleLoot;
+        // Loot table: what items might this monster drop with min/max counts
+        [SerializeField] private LootEntry[] _lootTable;
+
+        // Loot options
+        [SerializeField] private bool _includeStartingWeaponAsLoot = false;
+        [SerializeField] private bool _includeStartingArmorAsLoot = false;
+        [SerializeField] [Range(0f, 1f)] private float _lootDropChance = 1.0f; // Chance to drop any loot at all
 
         public string MonsterName => _monsterName;
         public Color Color => _color;
         public CharacterStats BaseStats => _baseStats;
+        public MonsterSize Size => _size;
         public Weapon StartingWeapon => _startingWeapon;
         public Armor StartingArmor => _startingArmor;
-        public Item[] PossibleLoot => _possibleLoot;
+        public LootEntry[] LootTable => _lootTable;
+        public bool IncludeStartingWeaponAsLoot => _includeStartingWeaponAsLoot;
+        public bool IncludeStartingArmorAsLoot => _includeStartingArmorAsLoot;
+        public float LootDropChance => _lootDropChance;
+
+        /// <summary>Build the final loot pool for this monster instance based on min/max ranges.</summary>
+        public List<Item> GenerateLootPool()
+        {
+            var pool = new List<Item>();
+
+            // Determine if this monster drops any loot at all
+            if (Random.value > _lootDropChance)
+                return pool; // Return empty pool (no loot)
+
+            // Add items from the loot table based on min/max rolls
+            if (_lootTable != null)
+            {
+                foreach (var entry in _lootTable)
+                {
+                    if (entry?.Item == null) continue;
+
+                    int count = Random.Range(entry.MinCount, entry.MaxCount + 1);
+                    for (int i = 0; i < count; i++)
+                    {
+                        pool.Add(entry.Item);
+                    }
+                }
+            }
+
+            // Optionally add starting equipment
+            if (_includeStartingWeaponAsLoot && _startingWeapon != null)
+            {
+                pool.Add(_startingWeapon);
+            }
+            if (_includeStartingArmorAsLoot && _startingArmor != null)
+            {
+                pool.Add(_startingArmor);
+            }
+
+            return pool;
+        }
 
         /// <summary>Create a fresh character sheet for a monster instance (with a copy of stats).</summary>
         public CharacterSheet CreateCharacterSheet()
@@ -45,17 +128,6 @@ namespace MazeGen
             return sheet;
         }
 
-        /// <summary>
-        /// Get a random loot item from this monster's loot table (null if no loot).
-        /// You can extend this with probability tiers or rarity weighting later.
-        /// </summary>
-        public Item GetRandomLoot()
-        {
-            if (_possibleLoot == null || _possibleLoot.Length == 0)
-                return null;
-
-            return _possibleLoot[Random.Range(0, _possibleLoot.Length)];
-        }
 
 #if UNITY_EDITOR
         private void OnValidate()

Assets/Scripts/Maze/Combat/Monsters/MonsterEncounter.cs

@@ -15,10 +15,31 @@ namespace MazeGen
             public CharacterSheet CharacterSheet;
             public bool IsDefeated => !CharacterSheet.Stats.IsAlive;
 
+            private List<Item> _remainingLoot; // Track which loot items haven't been claimed yet
+
             public MonsterInstance(Monster template)
             {
                 Template = template;
                 CharacterSheet = template.CreateCharacterSheet();
+
+                // Generate the loot pool based on the template's loot table and min/max counts
+                _remainingLoot = template.GenerateLootPool();
+            }
+
+            /// <summary>
+            /// Get a random loot item from this monster instance's remaining loot pool.
+            /// The selected item is removed so it won't be looted again.
+            /// Returns null if no loot remains.
+            /// </summary>
+            public Item GetRandomLoot()
+            {
+                if (_remainingLoot == null || _remainingLoot.Count == 0)
+                    return null;
+
+                int lootIndex = Random.Range(0, _remainingLoot.Count);
+                Item loot = _remainingLoot[lootIndex];
+                _remainingLoot.RemoveAt(lootIndex); // Remove so it can't be looted again
+                return loot;
             }
         }
 

Assets/Scripts/Maze/Combat/MovementValidator.cs

@@ -0,0 +1,129 @@
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Handles all validation logic for movement and attack ranges in combat.
+    /// Centralizes rules for what's allowed vs. what's not.
+    /// </summary>
+    public static class MovementValidator
+    {
+        /// <summary>
+        /// Determine the effective attack range for a weapon.
+        /// Melee weapons have range 1 (adjacent), ranged/magic respect their Range attribute.
+        /// </summary>
+        public static int GetAttackRange(Weapon weapon)
+        {
+            if (weapon == null) return 1;
+            return weapon.Range;
+        }
+
+        /// <summary>
+        /// Check if an actor can attack a target with their equipped weapon.
+        /// Melee: must be adjacent (1 square away)
+        /// Ranged/Magic: must be within weapon range
+        /// </summary>
+        public static bool CanAttack(Combatant actor, Combatant target, Weapon weapon)
+        {
+            if (actor == null || target == null || weapon == null)
+                return false;
+
+            if (actor == target)
+                return false; // Can't attack self
+
+            if (!actor.IsAlive || !target.IsAlive)
+                return false; // Only alive combatants can attack
+
+            if (actor.Team == target.Team)
+                return false; // Can't attack teammates
+
+            return actor.CanReachTarget(target, weapon);
+        }
+
+        /// <summary>
+        /// Check if an actor can move to a destination on the grid.
+        /// Basic validation: not already there, not moving more than movement range,
+        /// destination must be valid per the grid.
+        /// </summary>
+        public static bool CanMoveTo(Combatant actor, Vector2Int destination, CombatGrid grid)
+        {
+            if (actor == null || grid == null)
+                return false;
+
+            // Already at destination
+            if (actor.GridPosition == destination)
+                return false;
+
+            // Calculate movement distance
+            int movementDistance = actor.GridPosition.x != destination.x ?
+                Mathf.Abs(actor.GridPosition.x - destination.x) :
+                Mathf.Abs(actor.GridPosition.y - destination.y);
+
+            // Check if within movement budget
+            int maxMovement = actor.Sheet.Stats.GetMovementRange();
+            if (movementDistance > maxMovement)
+                return false;
+
+            // Check if destination is valid on grid
+            return grid.IsPositionValid(destination, actor);
+        }
+
+        /// <summary>
+        /// Check if two positions are adjacent (1 square apart, horizontally or vertically).
+        /// Used for melee range validation.
+        /// </summary>
+        public static bool IsAdjacentTo(Vector2Int pos1, Vector2Int pos2)
+        {
+            int distX = Mathf.Abs(pos1.x - pos2.x);
+            int distY = Mathf.Abs(pos1.y - pos2.y);
+
+            // Adjacent means 1 square away (Manhattan distance = 1)
+            return (distX == 1 && distY == 0) || (distX == 0 && distY == 1);
+        }
+
+        /// <summary>
+        /// Calculate Manhattan distance between two grid positions.
+        /// Used for range calculations and pathfinding.
+        /// </summary>
+        public static int ManhattanDistance(Vector2Int pos1, Vector2Int pos2)
+        {
+            return Mathf.Abs(pos1.x - pos2.x) + Mathf.Abs(pos1.y - pos2.y);
+        }
+
+        /// <summary>
+        /// Get the direction from one position to another (returns normalized direction vector).
+        /// Used for pathfinding towards targets.
+        /// </summary>
+        public static Vector2Int GetDirectionTowards(Vector2Int from, Vector2Int to)
+        {
+            Vector2Int direction = Vector2Int.zero;
+
+            if (from.x < to.x) direction.x = 1;
+            else if (from.x > to.x) direction.x = -1;
+
+            if (from.y < to.y) direction.y = 1;
+            else if (from.y > to.y) direction.y = -1;
+
+            return direction;
+        }
+
+        /// <summary>
+        /// Get a position one step closer to the target using Manhattan distance pathfinding.
+        /// Used to move towards enemies during combat.
+        /// </summary>
+        public static Vector2Int GetNextPositionTowards(Vector2Int from, Vector2Int to)
+        {
+            if (from == to) return from;
+
+            Vector2Int direction = GetDirectionTowards(from, to);
+
+            // Prefer moving horizontally/vertically to get closer
+            if (direction.x != 0)
+                return from + new Vector2Int(direction.x, 0);
+            else if (direction.y != 0)
+                return from + new Vector2Int(0, direction.y);
+
+            return from;
+        }
+    }
+}

Assets/Scripts/Maze/Combat/MovementValidator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0b0379f0a8cc75c4d8a8505c8ef85e34

Assets/Scripts/Maze/Visualization/BattleArenaView.cs

@@ -45,6 +45,7 @@ namespace MazeGen
             public Transform Transform;
             public SpriteRenderer Sprite;
             public Vector3 Home;
+            public Vector3 CurrentGridPos;  // Current position on the grid
             public float DisplayHealth;
             public bool Felled;
         }
@@ -174,34 +175,20 @@ namespace MazeGen
             }
         }
 
-        /// <summary>Agents line up on the left of the grid, monsters on the right, facing off.</summary>
+        /// <summary>
+        /// Place combatants at their starting grid positions. Uses StartGridPosition, not the
+        /// live GridPosition - by the time playback starts, CombatResolver has already resolved
+        /// the whole fight synchronously, so GridPosition holds the *final* position, not where
+        /// the combatant actually started.
+        /// </summary>
         private void PlaceCombatants(IReadOnlyList<Combatant> combatants)
         {
             _slots.Clear();
 
-            var agents = new List<Combatant>();
-            var monsters = new List<Combatant>();
-            foreach (var c in combatants)
-                (c.Team == Combatant.TeamAgents ? agents : monsters).Add(c);
-
-            LayoutTeam(agents, true);
-            LayoutTeam(monsters, false);
-        }
-
-        private void LayoutTeam(List<Combatant> team, bool leftSide)
-        {
-            int rows = Mathf.Max(1, gridSize.y);
-
-            for (int i = 0; i < team.Count; i++)
+            foreach (var combatant in combatants)
             {
-                int column = i / rows;
-                int indexInColumn = i % rows;
-                int countInColumn = Mathf.Min(rows, team.Count - column * rows);
-
-                int x = leftSide ? Mathf.Min(column, gridSize.x - 1) : Mathf.Max(0, gridSize.x - 1 - column);
-                int y = (rows - countInColumn) / 2 + indexInColumn;
-
-                _slots[team[i].Id] = CreateSlot(team[i], CellToWorld(x, y));
+                Vector3 worldPos = CellToWorld(combatant.StartGridPosition.x, combatant.StartGridPosition.y);
+                _slots[combatant.Id] = CreateSlot(combatant, worldPos);
             }
         }
 
@@ -210,7 +197,17 @@ namespace MazeGen
             var go = new GameObject($"{(combatant.IsAgent ? "Agent" : "Monster")}_{combatant.Name}");
             go.transform.SetParent(_root.transform, false);
             go.transform.position = position;
-            go.transform.localScale = Vector3.one * (cellSize * (combatant.IsAgent ? 0.58f : 0.5f));
+
+            // Scale based on size: Large > Medium > Small
+            float sizeScale = combatant.Size switch
+            {
+                MonsterSize.Small => 0.4f,     // Smaller creatures
+                MonsterSize.Medium => 0.58f,   // Standard size (was the default for agents)
+                MonsterSize.Large => 1.2f,     // Large creatures take up more space
+                _ => 0.58f
+            };
+
+            go.transform.localScale = Vector3.one * (cellSize * sizeScale);
 
             var sr = go.AddComponent<SpriteRenderer>();
             sr.sprite = RoomView.SharedSquareSprite;
@@ -223,6 +220,7 @@ namespace MazeGen
                 Transform = go.transform,
                 Sprite = sr,
                 Home = position,
+                CurrentGridPos = position,  // Initialize to the actual starting position from the grid
                 DisplayHealth = combatant.StartHealth
             };
         }
@@ -258,19 +256,42 @@ namespace MazeGen
 
                 switch (e.Kind)
                 {
+                    case CombatEventKind.MovementStart:
+                        // Movement is handled in MovementComplete, this is just flavor text
+                        yield return Hold(0.2f);
+                        break;
+
+                    case CombatEventKind.MovementComplete:
+                        yield return Movement(e);
+                        break;
+
                     case CombatEventKind.Hit:
                     case CombatEventKind.Miss:
                         yield return Strike(e);
                         break;
+
                     case CombatEventKind.Death:
                         yield return Fell(e.TargetId);
                         break;
+
+                    case CombatEventKind.OutOfRange:
+                    case CombatEventKind.TooFarForMelee:
+                    case CombatEventKind.TargetUnreachable:
+                        // Visual feedback for failure: brief shake or pulse
+                        yield return RangeFailure(e.ActorId);
+                        break;
+
                     case CombatEventKind.RoundStart:
                         _round = e.Round;
                         yield return Hold(0.6f);
                         break;
+
+                    case CombatEventKind.HealthPotionUsed:
+                        yield return HealPotion(e);
+                        break;
+
                     default:
-                        yield return Hold(1.2f);
+                        yield return Hold(0.3f);
                         break;
                 }
             }
@@ -284,8 +305,13 @@ namespace MazeGen
                 yield break;
             }
 
-            Vector3 lunge = Vector3.Lerp(actor.Home, target.Home, 0.5f);
-            yield return Glide(actor, actor.Home, lunge, 0.45f);
+            // Use actual grid positions from the event
+            Vector3 actorPos = actor.CurrentGridPos;
+            Vector3 targetPos = target.CurrentGridPos;
+
+            // Lunge toward target (halfway)
+            Vector3 lunge = Vector3.Lerp(actorPos, targetPos, 0.4f);
+            yield return Glide(actor, actorPos, lunge, 0.35f);
 
             if (e.Kind == CombatEventKind.Hit)
             {
@@ -299,7 +325,86 @@ namespace MazeGen
                 yield return Flash(target, Color.white);
             }
 
-            yield return Glide(actor, lunge, actor.Home, 0.3f);
+            // Return to grid position
+            yield return Glide(actor, lunge, actorPos, 0.25f);
+        }
+
+        /// <summary>
+        /// Animate a combatant moving across the grid to a new position.
+        /// </summary>
+        private IEnumerator Movement(CombatEvent e)
+        {
+            if (!_slots.TryGetValue(e.ActorId, out Slot actor))
+            {
+                yield return Hold(0.3f);
+                yield break;
+            }
+
+            // Convert grid positions to world positions
+            Vector3 fromWorld = CellToWorld(e.SourcePosition.x, e.SourcePosition.y);
+            Vector3 toWorld = CellToWorld(e.TargetPosition.x, e.TargetPosition.y);
+
+            // Update the slot's current grid position
+            actor.CurrentGridPos = toWorld;
+
+            // Animate movement
+            yield return Glide(actor, fromWorld, toWorld, 0.6f);
+        }
+
+        /// <summary>
+        /// Visual feedback when an attack fails due to range.
+        /// Brief shake/pulse effect.
+        /// </summary>
+        private IEnumerator RangeFailure(int combatantId)
+        {
+            if (!_slots.TryGetValue(combatantId, out Slot actor))
+            {
+                yield return Hold(0.3f);
+                yield break;
+            }
+
+            Vector3 startPos = actor.Transform.position;
+            Color startColor = actor.Sprite.color;
+
+            // Brief shake
+            for (int i = 0; i < 3; i++)
+            {
+                actor.Transform.position = startPos + Vector3.right * (cellSize * 0.15f);
+                yield return Hold(0.15f);
+                actor.Transform.position = startPos - Vector3.right * (cellSize * 0.15f);
+                yield return Hold(0.15f);
+            }
+
+            actor.Transform.position = startPos;
+            actor.Sprite.color = startColor;
+            yield return Hold(0.2f);
+        }
+
+        /// <summary>
+        /// Animate a combatant using a health potion.
+        /// </summary>
+        private IEnumerator HealPotion(CombatEvent e)
+        {
+            if (!_slots.TryGetValue(e.ActorId, out Slot actor))
+            {
+                yield return Hold(0.4f);
+                yield break;
+            }
+
+            // Update displayed health
+            actor.DisplayHealth = Mathf.Min(actor.Combatant.Sheet.Stats.MaxHealth,
+                actor.DisplayHealth + e.Amount);
+
+            // Green flash for healing
+            Color original = actor.Sprite.color;
+            actor.Sprite.color = new Color(0.5f, 1f, 0.5f);
+
+            // Green floating text
+            AddFloater(actor, $"+{e.Amount:0.#}", new Color(0.5f, 1f, 0.5f));
+
+            yield return Hold(0.35f);
+            actor.Sprite.color = original;
+            yield return Hold(0.25f);
         }
 
         private IEnumerator Fell(int combatantId)
@@ -367,7 +472,8 @@ namespace MazeGen
             foreach (var slot in _slots.Values)
             {
                 slot.DisplayHealth = slot.Combatant.Sheet.Stats.CurrentHealth;
-                slot.Transform.position = slot.Home;
+                // Use final grid position from the combatant
+                slot.Transform.position = CellToWorld(slot.Combatant.GridPosition.x, slot.Combatant.GridPosition.y);
 
                 if (!slot.Combatant.IsAlive && !slot.Felled)
                 {
@@ -412,7 +518,7 @@ namespace MazeGen
         {
             _floaters.Add(new Floater
             {
-                WorldPosition = slot.Home + Vector3.up * (cellSize * 0.5f),
+                WorldPosition = slot.Transform.position + Vector3.up * (cellSize * 0.5f),
                 Text = text,
                 Color = color,
                 BornAt = Time.time
@@ -442,10 +548,10 @@ namespace MazeGen
 
             foreach (var slot in _slots.Values)
             {
-                Vector3 screen = _camera.WorldToScreenPoint(slot.Home);
+                Vector3 screen = _camera.WorldToScreenPoint(slot.Transform.position);
                 if (screen.z < 0f) continue;
 
-                float max = slot.Combatant.MaxHealth;
+                float max = slot.Combatant.Sheet.Stats.MaxHealth;
                 float fraction = Mathf.Clamp01(max > 0f ? slot.DisplayHealth / max : 0f);
                 var rect = new Rect(screen.x - 55f, Screen.height - screen.y - 44f, 110f, 30f);
 

Assets/Scripts/Maze/Visualization/HUD.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c138346615e385a458293b45a51c562a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Maze/Visualization/HUD/AgentPanelUI.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Displays a clickable list of all agents with their status. Allows the player to follow
+    /// an agent's perspective. Narrates status as dead, reached exit, fighting, or exploring with HP.
+    /// </summary>
+    public class AgentPanelUI
+    {
+        private Vector2 scrollPosition;
+
+        public AgentPanelUI()
+        {
+        }
+
+        /// <summary>
+        /// Draw the agent list panel. Returns the clicked agent (if any) or null.
+        /// </summary>
+        public MazeAgent Draw(List<MazeAgent> agents, MazeAgent currentlyFollowed, bool hasFollowedAgent, Action onStopFollowing)
+        {
+            GUILayout.BeginArea(new Rect(10, 360, 280, Screen.height - 380), GUI.skin.box);
+
+            if (hasFollowedAgent && GUILayout.Button("Stop following"))
+                onStopFollowing?.Invoke();
+
+            GUILayout.Space(6);
+            GUILayout.Label("Agents (click to follow):");
+            scrollPosition = GUILayout.BeginScrollView(scrollPosition);
+
+            MazeAgent clickedAgent = null;
+            foreach (var agent in agents)
+            {
+                bool isFollowed = agent == currentlyFollowed;
+                string status = DescribeStatus(agent);
+
+                GUI.color = agent.IsDead ? new Color(0.55f, 0.55f, 0.55f) : Color.white;
+                if (GUILayout.Button($"{(isFollowed ? "> " : "")}{agent.DisplayName} - {status}"))
+                    clickedAgent = agent;
+            }
+            GUI.color = Color.white;
+            GUILayout.EndScrollView();
+
+            GUILayout.EndArea();
+            return clickedAgent;
+        }
+
+        private string DescribeStatus(MazeAgent agent)
+        {
+            if (agent.IsDead) return "dead";
+            if (agent.IsFinished) return "reached exit";
+            if (agent.IsEngaged) return "fighting";
+            return $"exploring ({agent.CharacterSheet.Stats.CurrentHealth:0}hp)";
+        }
+    }
+}

Assets/Scripts/Maze/Visualization/HUD/AgentPanelUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f1956060d84958c498b63b606cbde4de

Assets/Scripts/Maze/Visualization/HUD/FightPanelUI.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Displays live fights: join-window countdown timer, participant list, and controls
+    /// to watch or simulate each fight. Drawn centre-top so a paused fight is impossible to miss.
+    /// </summary>
+    public class FightPanelUI
+    {
+        private Vector2 scrollPosition;
+        private CombatDirector director;
+        private MazeCameraController cameraController;
+
+        public FightPanelUI(CombatDirector combatDirector, MazeCameraController camera)
+        {
+            director = combatDirector;
+            cameraController = camera;
+        }
+
+        public void Draw()
+        {
+            var fights = director.ActiveFights;
+            if (fights.Count == 0) return;
+
+            float width = Mathf.Min(460f, Mathf.Max(280f, Screen.width - 720f));
+            GUILayout.BeginArea(new Rect(300f, 10f, width, Screen.height - 20f), GUI.skin.box);
+
+            GUILayout.Label($"FIGHTS BREAKING OUT ({fights.Count})", GUI.skin.box);
+
+            // The "resume" button stays outside the scroll view so it's always reachable even
+            // when there are more fights than fit on screen at once.
+            scrollPosition = GUILayout.BeginScrollView(scrollPosition);
+
+            // Snapshot: resuming from this panel can resolve/cancel a fight, mutating the live list.
+            foreach (var fight in fights.ToArray())
+            {
+                GUILayout.BeginVertical(GUI.skin.box);
+                GUILayout.Label($"#{fight.Id} in room {fight.Room.Id} - {fight.Agents.Count} agent(s) vs {fight.Encounter.AliveMonsterCount} monster(s)");
+                GUILayout.Label($"Starts in {Mathf.Max(0f, fight.JoinTimeRemaining):0.0}s - {(SimulationClock.IsPaused ? "frozen; resume to let the timer run out" : "others can still join")}");
+                GUILayout.Label($"In: {string.Join(", ", fight.Agents.Select(a => a.DisplayName))}");
+
+                // These only set a preference for when the join window naturally expires - they
+                // never skip the timer, so late arrivals always get their full chance to join.
+                CombatViewMode preferred = fight.PreferredResolution ?? director.TimeoutResolution;
+                GUILayout.Label($"When it starts: {(preferred == CombatViewMode.Watch ? "watch it" : "log only")}");
+
+                GUILayout.BeginHorizontal();
+                GUI.enabled = preferred != CombatViewMode.Watch;
+                if (GUILayout.Button("Watch it"))
+                    director.PreferWatch(fight);
+                GUI.enabled = preferred != CombatViewMode.Simulate;
+                if (GUILayout.Button("Log only"))
+                    director.PreferSimulate(fight);
+                GUI.enabled = true;
+                if (GUILayout.Button("Go to"))
+                    cameraController?.FocusOn(fight.Room.Position);
+                GUILayout.EndHorizontal();
+                GUILayout.EndVertical();
+            }
+
+            GUILayout.EndScrollView();
+
+            if (SimulationClock.IsPaused && GUILayout.Button("Resume - let the join window run"))
+            {
+                director.ResumeAllMusters();
+                SimulationClock.UserPaused = false;
+            }
+
+            GUILayout.EndArea();
+        }
+    }
+}

Assets/Scripts/Maze/Visualization/HUD/FightPanelUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 900d715d637aa644dbe613c1e2967a60

Assets/Scripts/Maze/Visualization/HUD/InfoPanelUI.cs

@@ -0,0 +1,133 @@
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Right-side panel showing detailed info about the followed agent:
+    /// - Vitals (room, HP, stats, equipment)
+    /// - Inventory listing (equipped + unequipped items)
+    /// - Decision narration (newest first)
+    /// - Global combat log
+    /// </summary>
+    public class InfoPanelUI
+    {
+        private Vector2 thoughtScroll;
+        private Vector2 combatLogScroll;
+        private CombatDirector director;
+
+        public InfoPanelUI(CombatDirector combatDirector)
+        {
+            director = combatDirector;
+        }
+
+        public void Draw(MazeAgent followedAgent)
+        {
+            float width = 400f;
+            float x = Screen.width - width - 10f;
+            float height = Screen.height - 20f;
+
+            GUILayout.BeginArea(new Rect(x, 10f, width, height), GUI.skin.box);
+
+            if (followedAgent == null)
+            {
+                GUILayout.Label("AGENT THOUGHTS AND INFO", GUI.skin.box);
+                GUILayout.Label("Click an agent on the left to follow it and read what it's thinking.");
+            }
+            else
+            {
+                DrawAgentInfo(followedAgent, height, Color.white);
+            }
+
+            GUILayout.EndArea();
+        }
+
+        private void DrawAgentInfo(MazeAgent agent, float panelHeight, Color agentColor)
+        {
+            CharacterSheet sheet = agent.CharacterSheet;
+
+            GUI.color = agentColor;
+            GUILayout.Label($"{agent.DisplayName.ToUpperInvariant()} - {DescribeStatus(agent)}", GUI.skin.box);
+            GUI.color = Color.white;
+
+            // Vitals
+            GUILayout.Label($"Room {agent.CurrentRoom?.Id.ToString() ?? "?"}   New rooms seen: {agent.NewRoomsVisited}   Path: {agent.PathHistory.Count} hop(s)");
+            GUILayout.Label($"HP {sheet.Stats.CurrentHealth:0.#}/{sheet.Stats.MaxHealth:0.#}   ATK {sheet.GetEffectiveAttack():0.#}   DEF {sheet.GetEffectiveDefense():0.#}   SPD {sheet.GetEffectiveSpeed():0.#}");
+            GUILayout.Label($"Weapon: {sheet.EquippedWeapon?.ItemName ?? "none"}   Armor: {sheet.EquippedArmor?.ItemName ?? "none"}");
+
+            // Threat assessment for current room
+            Room room = agent.CurrentRoom;
+            int hostiles = room?.Encounter != null ? room.Encounter.AliveMonsterCount : 0;
+            GUILayout.Label(hostiles > 0
+                ? $"This room: {hostiles} living hostile(s), threat {room.Encounter.GetPerceivedChallengeRating(sheet):0.00}"
+                : "This room: clear");
+
+            // Inventory listing
+            GUILayout.Space(4);
+            DrawInventory(sheet);
+
+            GUILayout.Space(4);
+            GUILayout.Label("Thoughts (newest first):");
+            thoughtScroll = GUILayout.BeginScrollView(thoughtScroll, GUILayout.Height(Mathf.Max(80f, panelHeight * 0.30f)));
+            var thoughts = agent.Thoughts.Entries;
+            for (int i = thoughts.Count - 1; i >= 0; i--)
+            {
+                Thought thought = thoughts[i];
+                GUI.color = AgentThoughtLog.ColorFor(thought.Kind);
+                GUILayout.Label($"[{thought.Time:0.0}s] {thought.Text}");
+            }
+            GUI.color = Color.white;
+            GUILayout.EndScrollView();
+
+            GUILayout.Space(4);
+            GUILayout.Label("Combat log (all fights):");
+            combatLogScroll = GUILayout.BeginScrollView(combatLogScroll, GUILayout.Height(Mathf.Max(100f, panelHeight * 0.25f)));
+            var log = director.CombatLog;
+            for (int i = log.Count - 1; i >= 0; i--)
+                GUILayout.Label(log[i]);
+            GUILayout.EndScrollView();
+        }
+
+        private void DrawInventory(CharacterSheet sheet)
+        {
+            GUILayout.Label("Inventory:", GUI.skin.box);
+
+            if (sheet.Inventory.Count == 0)
+            {
+                GUILayout.Label("(Empty)");
+                return;
+            }
+
+            foreach (var item in sheet.Inventory)
+            {
+                string itemType = item is Consumable ? "[Consumable]" : item is Weapon ? "[Weapon]" : "[Item]";
+                string details = "";
+
+                if (item is Consumable cons)
+                {
+                    if (cons.HealthBonus > 0)
+                        details = $" +{cons.HealthBonus:0.#} HP";
+                }
+                else if (item is Weapon weap)
+                {
+                    details = $" (ATK +{weap.AttackBonus:0.#})";
+                }
+                else if (item is Armor armor)
+                {
+                    details = $" (DEF +{armor.DefenseBonus:0.#})";
+                }
+
+                GUI.color = new Color(0.7f, 0.85f, 1f);
+                GUILayout.Label($"  {itemType} {item.ItemName}{details}");
+            }
+            GUI.color = Color.white;
+        }
+
+        private string DescribeStatus(MazeAgent agent)
+        {
+            if (agent.IsDead) return "dead";
+            if (agent.IsFinished) return "reached exit";
+            if (agent.IsEngaged) return "fighting";
+            return $"exploring ({agent.CharacterSheet.Stats.CurrentHealth:0}hp)";
+        }
+    }
+}

Assets/Scripts/Maze/Visualization/HUD/InfoPanelUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7c1e87abd8e96984ca826a8d4ef0d452

Assets/Scripts/Maze/Visualization/HUD/StatusPanelUI.cs

@@ -0,0 +1,75 @@
+using UnityEngine;
+
+namespace MazeGen
+{
+    /// <summary>
+    /// Displays simulation status: elapsed time, agents finished/dead count, level completion state.
+    /// Also owns the simulation controls (pause/resume, speed adjust, fight pause toggle, watch/log mode).
+    /// </summary>
+    public class StatusPanelUI
+    {
+        private float targetFinishedAgentCount;
+        private float timeLimitSeconds;
+        private CombatDirector director;
+        private MazeCameraController cameraController;
+        private Bounds mazeBounds;
+
+        public StatusPanelUI(float targetFinished, float timeLimit, CombatDirector combatDirector, MazeCameraController camera, Bounds bounds)
+        {
+            targetFinishedAgentCount = targetFinished;
+            timeLimitSeconds = timeLimit;
+            director = combatDirector;
+            cameraController = camera;
+            mazeBounds = bounds;
+        }
+
+        public void Draw(float elapsedTime, int totalAgents, int finishedCount, int deadCount, bool levelEnded, System.Action onZoomToFit)
+        {
+            GUILayout.BeginArea(new Rect(10, 10, 280, Screen.height - 20), GUI.skin.box);
+
+            // Elapsed time display
+            string timeLabel = timeLimitSeconds > 0f ? $"{elapsedTime:0.0}s / {timeLimitSeconds:0.0}s" : $"{elapsedTime:0.0}s";
+            GUILayout.Label($"Elapsed: {timeLabel}");
+
+            // Finished/dead count
+            string finishLabel = targetFinishedAgentCount > 0 ? $"{finishedCount} / {(int)targetFinishedAgentCount}" : $"{finishedCount}";
+            GUILayout.Label($"Finished: {finishLabel}    Dead: {deadCount}");
+
+            // Level completion status
+            if (levelEnded)
+                GUILayout.Label("LEVEL COMPLETE", GUI.skin.box);
+
+            GUILayout.Space(4);
+            DrawSimulationControls();
+
+            GUILayout.Space(4);
+            if (GUILayout.Button("Zoom to fit maze"))
+                onZoomToFit?.Invoke();
+
+            GUILayout.EndArea();
+        }
+
+        private void DrawSimulationControls()
+        {
+            bool paused = SimulationClock.IsPaused;
+            GUILayout.Label(paused ? $"PAUSED ({SimulationClock.HoldSummary ?? "manual"})" : $"Running at {SimulationClock.TimeScale:0.0}x", GUI.skin.box);
+
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(SimulationClock.UserPaused ? "Resume (space)" : "Pause (space)"))
+                SimulationClock.UserPaused = !SimulationClock.UserPaused;
+            if (GUILayout.Button("0.5x")) SimulationClock.TimeScale = 0.5f;
+            if (GUILayout.Button("1x")) SimulationClock.TimeScale = 1f;
+            if (GUILayout.Button("4x")) SimulationClock.TimeScale = 4f;
+            GUILayout.EndHorizontal();
+
+            director.PauseOnFightDeclared = GUILayout.Toggle(director.PauseOnFightDeclared, " Pause when a fight is declared");
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("On join window end:", GUILayout.Width(120f));
+            bool watch = director.TimeoutResolution == CombatViewMode.Watch;
+            if (GUILayout.Button(watch ? "Watch fight" : "Log only"))
+                director.TimeoutResolution = watch ? CombatViewMode.Simulate : CombatViewMode.Watch;
+            GUILayout.EndHorizontal();
+        }
+    }
+}

Assets/Scripts/Maze/Visualization/HUD/StatusPanelUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4e4bee8ace812784aad2b02ddd169361

Assets/Scripts/Maze/Visualization/MazeSceneBuilder.cs

@@ -61,10 +61,13 @@ namespace MazeGen
 
         private bool _levelEnded;
         private float _elapsedTime;
-        private Vector2 _hudScroll;
-        private Vector2 _thoughtScroll;
-        private Vector2 _combatLogScroll;
-        private Vector2 _fightScroll;
+
+
+        // UI Panels
+        private StatusPanelUI _statusPanel;
+        private FightPanelUI _fightPanel;
+        private AgentPanelUI _agentPanel;
+        private InfoPanelUI _infoPanel;
 
         private void Awake()
         {
@@ -92,6 +95,13 @@ namespace MazeGen
                     _cameraController = cam.gameObject.AddComponent<MazeCameraController>();
             }
 
+            // Initialize UI panels
+            // Note: pass empty bounds to StatusPanelUI; ComputeMazeBounds() is called in the zoom callback
+            _statusPanel = new StatusPanelUI(targetFinishedAgentCount, timeLimitSeconds, _director, _cameraController, new Bounds(Vector3.zero, Vector3.one));
+            _fightPanel = new FightPanelUI(_director, _cameraController);
+            _agentPanel = new AgentPanelUI();
+            _infoPanel = new InfoPanelUI(_director);
+
             if (targetFinishedAgentCount <= 0 && timeLimitSeconds <= 0f)
             {
                 Debug.LogWarning("[MazeGen] No end condition configured (targetFinishedAgentCount and timeLimitSeconds are both 0) - defaulting targetFinishedAgentCount to agentCount so the level can still end.");
@@ -331,199 +341,36 @@ namespace MazeGen
             // The arena draws its own HUD and owns the screen while a fight is being watched.
             if (_director != null && _director.IsWatching) return;
 
-            DrawStatusPanel();
-            DrawFightPanel();
-            DrawFollowedAgentPanel();
-        }
-
-        private void DrawStatusPanel()
-        {
-            GUILayout.BeginArea(new Rect(10, 10, 280, Screen.height - 20), GUI.skin.box);
-
-            string timeLabel = timeLimitSeconds > 0f ? $"{_elapsedTime:0.0}s / {timeLimitSeconds:0.0}s" : $"{_elapsedTime:0.0}s";
-            GUILayout.Label($"Elapsed: {timeLabel}");
-
-            int finishedCount = _agents.Count(a => a.Controller.Agent.IsFinished);
-            string finishLabel = targetFinishedAgentCount > 0 ? $"{finishedCount} / {targetFinishedAgentCount}" : $"{finishedCount}";
-            GUILayout.Label($"Finished: {finishLabel}    Dead: {_agents.Count(a => a.Controller.Agent.IsDead)}");
-
-            if (_levelEnded)
-                GUILayout.Label("LEVEL COMPLETE", GUI.skin.box);
-
-            GUILayout.Space(4);
-            DrawSimulationControls();
-
-            GUILayout.Space(4);
-            if (GUILayout.Button("Zoom to fit maze"))
-                _cameraController?.FrameBounds(ComputeMazeBounds());
-
-            if (_followedAgent != null && GUILayout.Button("Stop following"))
-                StopFollowing();
-
-            GUILayout.Space(6);
-            GUILayout.Label("Agents (click to follow):");
-            _hudScroll = GUILayout.BeginScrollView(_hudScroll);
-            foreach (var entry in _agents)
+            // Draw status panel (top-left)
+            _statusPanel?.Draw(
+                _elapsedTime,
+                _agents.Count,
+                _agents.Count(a => a.Controller.Agent.IsFinished),
+                _agents.Count(a => a.Controller.Agent.IsDead),
+                _levelEnded,
+                () => _cameraController?.FrameBounds(ComputeMazeBounds())
+            );
+
+            // Draw fight panel (center-top)
+            _fightPanel?.Draw();
+
+            // Draw agent list (left, below status)
+            var clickedAgent = _agentPanel?.Draw(
+                _agents.Select(a => a.Controller.Agent).ToList(),
+                _followedAgent?.Controller.Agent,
+                _followedAgent != null,
+                StopFollowing
+            );
+            if (clickedAgent != null)
             {
-                MazeAgent agent = entry.Controller.Agent;
-                bool isFollowed = entry == _followedAgent;
-
-                GUI.color = agent.IsDead ? new Color(0.55f, 0.55f, 0.55f) : entry.Color;
-                if (GUILayout.Button($"{(isFollowed ? "> " : "")}{agent.DisplayName} - {DescribeStatus(agent)}"))
+                var entry = _agents.FirstOrDefault(a => a.Controller.Agent == clickedAgent);
+                if (entry != null)
                     FollowAgent(entry);
             }
-            GUI.color = Color.white;
-            GUILayout.EndScrollView();
-
-            GUILayout.EndArea();
-        }
-
-        private void DrawSimulationControls()
-        {
-            bool paused = SimulationClock.IsPaused;
-            GUILayout.Label(paused ? $"PAUSED ({SimulationClock.HoldSummary ?? "manual"})" : $"Running at {SimulationClock.TimeScale:0.0}x", GUI.skin.box);
-
-            GUILayout.BeginHorizontal();
-            if (GUILayout.Button(SimulationClock.UserPaused ? "Resume (space)" : "Pause (space)"))
-                SimulationClock.UserPaused = !SimulationClock.UserPaused;
-            if (GUILayout.Button("0.5x")) SimulationClock.TimeScale = 0.5f;
-            if (GUILayout.Button("1x")) SimulationClock.TimeScale = 1f;
-            if (GUILayout.Button("4x")) SimulationClock.TimeScale = 4f;
-            GUILayout.EndHorizontal();
-
-            _director.PauseOnFightDeclared = GUILayout.Toggle(_director.PauseOnFightDeclared, " Pause when a fight is declared");
-
-            GUILayout.BeginHorizontal();
-            GUILayout.Label("On join window end:", GUILayout.Width(120f));
-            bool watch = _director.TimeoutResolution == CombatViewMode.Watch;
-            if (GUILayout.Button(watch ? "Watch fight" : "Log only"))
-                _director.TimeoutResolution = watch ? CombatViewMode.Simulate : CombatViewMode.Watch;
-            GUILayout.EndHorizontal();
-        }
-
-        /// <summary>
-        /// Live fights: the join-window countdown plus the controls to watch or fast-resolve.
-        /// Drawn centre-top so a paused fight is impossible to miss.
-        /// </summary>
-        private void DrawFightPanel()
-        {
-            var fights = _director.ActiveFights;
-            if (fights.Count == 0) return;
-
-            float width = Mathf.Min(460f, Mathf.Max(280f, Screen.width - 720f));
-            GUILayout.BeginArea(new Rect(300f, 10f, width, Screen.height - 20f), GUI.skin.box);
-
-            GUILayout.Label($"FIGHTS BREAKING OUT ({fights.Count})", GUI.skin.box);
-
-            // The "resume" button stays outside the scroll view so it's always reachable even
-            // when there are more fights than fit on screen at once.
-            _fightScroll = GUILayout.BeginScrollView(_fightScroll);
-
-            // Snapshot: resuming from this panel can resolve/cancel a fight, mutating the live list.
-            foreach (var fight in fights.ToArray())
-            {
-                GUILayout.BeginVertical(GUI.skin.box);
-                GUILayout.Label($"#{fight.Id} in room {fight.Room.Id} - {fight.Agents.Count} agent(s) vs {fight.Encounter.AliveMonsterCount} monster(s)");
-                GUILayout.Label($"Starts in {Mathf.Max(0f, fight.JoinTimeRemaining):0.0}s - {(SimulationClock.IsPaused ? "frozen; resume to let the timer run out" : "others can still join")}");
-                GUILayout.Label($"In: {string.Join(", ", fight.Agents.Select(a => a.DisplayName))}");
-
-                // These only set a preference for when the join window naturally expires - they
-                // never skip the timer, so late arrivals always get their full chance to join.
-                CombatViewMode preferred = fight.PreferredResolution ?? _director.TimeoutResolution;
-                GUILayout.Label($"When it starts: {(preferred == CombatViewMode.Watch ? "watch it" : "log only")}");
-
-                GUILayout.BeginHorizontal();
-                GUI.enabled = preferred != CombatViewMode.Watch;
-                if (GUILayout.Button("Watch it"))
-                    _director.PreferWatch(fight);
-                GUI.enabled = preferred != CombatViewMode.Simulate;
-                if (GUILayout.Button("Log only"))
-                    _director.PreferSimulate(fight);
-                GUI.enabled = true;
-                if (GUILayout.Button("Go to"))
-                    _cameraController?.FocusOn(fight.Room.Position);
-                GUILayout.EndHorizontal();
-                GUILayout.EndVertical();
-            }
-
-            GUILayout.EndScrollView();
-
-            if (SimulationClock.IsPaused && GUILayout.Button("Resume - let the join window run"))
-            {
-                _director.ResumeAllMusters();
-                SimulationClock.UserPaused = false;
-            }
-
-            GUILayout.EndArea();
-        }
-
-        /// <summary>
-        /// "Agent thoughts and info" for the followed agent: its vitals plus its decision
-        /// narration, newest first, and the shared combat log underneath.
-        /// </summary>
-        private void DrawFollowedAgentPanel()
-        {
-            float width = 400f;
-            float x = Screen.width - width - 10f;
-            float height = Screen.height - 20f;
-
-            GUILayout.BeginArea(new Rect(x, 10f, width, height), GUI.skin.box);
-
-            if (_followedAgent == null)
-            {
-                GUILayout.Label("AGENT THOUGHTS AND INFO", GUI.skin.box);
-                GUILayout.Label("Click an agent on the left to follow it and read what it's thinking.");
-            }
-            else
-            {
-                MazeAgent agent = _followedAgent.Controller.Agent;
-                CharacterSheet sheet = agent.CharacterSheet;
-
-                GUI.color = _followedAgent.Color;
-                GUILayout.Label($"{agent.DisplayName.ToUpperInvariant()} - {DescribeStatus(agent)}", GUI.skin.box);
-                GUI.color = Color.white;
-
-                GUILayout.Label($"Room {agent.CurrentRoom?.Id.ToString() ?? "?"}   New rooms seen: {agent.NewRoomsVisited}   Path: {agent.PathHistory.Count} hop(s)");
-                GUILayout.Label($"HP {sheet.Stats.CurrentHealth:0.#}/{sheet.Stats.MaxHealth:0.#}   ATK {sheet.GetEffectiveAttack():0.#}   DEF {sheet.GetEffectiveDefense():0.#}   SPD {sheet.GetEffectiveSpeed():0.#}");
-                GUILayout.Label($"Weapon: {sheet.EquippedWeapon?.ItemName ?? "none"}   Armor: {sheet.EquippedArmor?.ItemName ?? "none"}");
-
-                Room room = agent.CurrentRoom;
-                int hostiles = room?.Encounter != null ? room.Encounter.AliveMonsterCount : 0;
-                GUILayout.Label(hostiles > 0
-                    ? $"This room: {hostiles} living hostile(s), threat {room.Encounter.GetPerceivedChallengeRating(sheet):0.00}"
-                    : "This room: clear");
-
-                GUILayout.Space(4);
-                GUILayout.Label("Thoughts (newest first):");
-                _thoughtScroll = GUILayout.BeginScrollView(_thoughtScroll, GUILayout.Height(Mathf.Max(120f, height * 0.42f)));
-                var thoughts = agent.Thoughts.Entries;
-                for (int i = thoughts.Count - 1; i >= 0; i--)
-                {
-                    Thought thought = thoughts[i];
-                    GUI.color = AgentThoughtLog.ColorFor(thought.Kind);
-                    GUILayout.Label($"[{thought.Time:0.0}s] {thought.Text}");
-                }
-                GUI.color = Color.white;
-                GUILayout.EndScrollView();
-            }
 
-            GUILayout.Space(4);
-            GUILayout.Label("Combat log (all fights):");
-            _combatLogScroll = GUILayout.BeginScrollView(_combatLogScroll);
-            var log = _director.CombatLog;
-            for (int i = log.Count - 1; i >= 0; i--)
-                GUILayout.Label(log[i]);
-            GUILayout.EndScrollView();
-
-            GUILayout.EndArea();
+            // Draw info panel (right side)
+            _infoPanel?.Draw(_followedAgent?.Controller.Agent);
         }
 
-        private string DescribeStatus(MazeAgent agent)
-        {
-            if (agent.IsDead) return "dead";
-            if (agent.IsFinished) return "reached exit";
-            if (agent.IsEngaged) return "fighting";
-            return $"exploring ({agent.CharacterSheet.Stats.CurrentHealth:0}hp)";
-        }
     }
 }

IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,258 @@
+# Implementation Summary - Agent Intelligence & UI Refactor
+
+**Date:** 2026-09-09  
+**Cost:** ~$0.90 USD (well under budget)
+
+## What Was Implemented
+
+### 1. ✅ Monster Health Display Fix
+- **File:** `BattleArenaView.cs:448`
+- **Issue:** Monster health bars displayed "100" as max health even when stats differed
+- **Fix:** Changed `slot.Combatant.MaxHealth` → `slot.Combatant.Sheet.Stats.MaxHealth`
+- **Impact:** Fight visualization now shows accurate health percentages
+
+### 2. ✅ Inventory Display for Agents
+- **Files:** `HUD/InfoPanelUI.cs` (new file)
+- **Location:** Right-side info panel when following an agent
+- **Features:**
+  - Lists all items in agent's inventory
+  - Shows item type (Weapon/Armor/Consumable)
+  - Displays stat bonuses (ATK, DEF, HP)
+  - Color-coded for clarity
+- **Access:** Click an agent in the left panel to follow and see inventory
+
+### 3. ✅ GUI Refactoring
+- **Created 4 new UI panel classes** (extracted from MazeSceneBuilder):
+  - `HUD/StatusPanelUI.cs` — Elapsed time, agent counts, simulation controls
+  - `HUD/FightPanelUI.cs` — Live fights with join-window countdown
+  - `HUD/AgentPanelUI.cs` — Agent list, click-to-follow
+  - `HUD/InfoPanelUI.cs` — Detailed agent info, thoughts, inventory, combat log
+
+- **Benefits:**
+  - Reduced MazeSceneBuilder by ~300 lines
+  - Each panel owns its own scroll state and drawing logic
+  - Easy to customize UI without touching scene logic
+  - Reusable components
+
+### 4. ✅ Health-Aware Retreat System
+- **Implementation:** Encapsulated in decision classes
+- **Behavior:**
+  - **Below 30% health:** Retreat threshold cut in half (very defensive)
+  - **30-50% health:** Gradually more cautious (linear lerp)
+  - **Above 50% health:** Normal threshold applies
+  
+- **Impact:** 
+  - Low-health agents actively avoid dangerous fights
+  - Encourages tactical retreat when wounded
+  - Reduces suicide charges by wounded agents
+
+### 5. ✅ Automatic Health Potion Usage
+- **Class:** `UseHealthPotionDecision`
+- **Trigger:** When health falls below 50% (outside combat)
+- **Behavior:**
+  - Checks inventory for health potions
+  - Uses the first potion found
+  - Narrates the action to thought log
+  - Only executes outside of active fights
+
+- **Extensibility:** Can modify `LowHealthThreshold` constant to adjust trigger point
+
+### 6. ✅ Decision Tree System (Major Architecture Change)
+
+#### Core Classes:
+- **`AgentDecision.cs`** — Abstract base class
+  - `CanExecute(agent)` — Precondition check
+  - `Execute(agent)` — Perform action, return if consumed
+  - `Think(agent)` — Narrate to thought log
+  - `DecisionName` — Human-readable label
+
+- **`AgentDecisionTree.cs`** — Priority-ordered decision manager
+  - `Add(decision)` — Register a decision
+  - `TryDecide(agent)` — Evaluate tree, execute first valid decision
+  - `FindApplicableDecision()` — Debug helper to see available choices
+  - `GetAvailableDecisions()` — List all executable decisions
+
+#### Concrete Decision Classes:
+1. **`UseHealthPotionDecision`**
+   - Uses health potions when HP < 50%
+   
+2. **`HandleExistingFightDecision`**
+   - Joins or sneaks past fights already mustering
+   
+3. **`DeclareFightDecision`**
+   - Starts a new fight if threat is acceptable
+   
+4. **`SneakAwayDecision`**
+   - Attempts to sneak past overwhelming forces
+   - Falls into forced fight if sneak fails
+   
+5. **`MoveOnDecision`**
+   - Explores/follows/backtracks based on exit type
+   - Filters by threat level
+   - Catch-all that always succeeds
+
+#### Execution Flow:
+```
+Update() 
+  → _decisionTree.TryDecide(agent)
+    → For each decision in priority order:
+      → If CanExecute():
+         → Execute()  (modifies state)
+         → Think()    (narrates to thought log)
+         → Return true (decision consumed this turn)
+    → Return false if no decision could execute
+```
+
+## How to Extend Agent Behavior
+
+### Adding a New Decision Type
+1. Create a new class inheriting from `AgentDecision`
+2. Implement `CanExecute()`, `Execute()`, `Think()`, `DecisionName`
+3. Add it to `BuildDecisionTree()` in the priority order you want
+4. That's it! No need to modify Update() or narration logic
+
+### Example: Custom Decision
+```csharp
+public class FleeFromMassiveHorde : AgentDecision
+{
+    public override string DecisionName => "Flee Horde";
+    
+    public override bool CanExecute(MazeAgent agent)
+    {
+        Room room = agent.CurrentRoom;
+        if (room?.Encounter == null) return false;
+        return room.Encounter.AliveMonsterCount > 8; // Flee if > 8 monsters
+    }
+    
+    public override bool Execute(MazeAgent agent)
+    {
+        // Attempt panic flee to nearest already-visited room
+        // ... implementation ...
+        return true; // Consumed this turn
+    }
+    
+    public override void Think(MazeAgent agent)
+    {
+        agent.Thoughts.Add(ThoughtKind.Avoid, "WAY too many hostiles - RUN!");
+    }
+}
+
+// Then in BuildDecisionTree():
+_decisionTree.Insert(3, new FleeFromMassiveHorde()); // Higher priority than sneaking
+```
+
+### Modifying Existing Behavior
+- Want to change when potions are used? Edit `UseHealthPotionDecision.LowHealthThreshold`
+- Want to change retreat logic? Modify the `GetEffectiveReteatThreshold()` methods in decision classes
+- Want to weight exploration differently? Edit `MoveOnDecision` / `_exploreChance`
+
+## Key Design Principles
+
+### 1. Behavior + Narration = Synchronized Pair
+- Every action that Execute() performs gets a Think() explanation
+- Observer can always understand why the agent did something
+- Adding action without narration is a compile-time contract violation (abstract method)
+
+### 2. Preconditions are Explicit
+- `CanExecute()` makes it clear when a decision applies
+- Easier to debug ("why didn't it do X?") → check if CanExecute() is true
+- Prevents logic buried in Execute() that nobody can see
+
+### 3. Priority Order is Visible
+- `BuildDecisionTree()` reads top-to-bottom as priority
+- First applicable decision wins
+- Overriding behavior is easy: Insert a higher-priority decision
+
+### 4. No Global State Pollution
+- Each decision is standalone
+- Decisions don't depend on magic fields or class-level flags
+- Easy to test, compose, and reuse
+
+## Files Changed/Created
+
+### New Files (8)
+```
+Assets/Scripts/Maze/Visualization/HUD/
+├── StatusPanelUI.cs          (165 lines)
+├── FightPanelUI.cs           (75 lines)
+├── AgentPanelUI.cs           (65 lines)
+└── InfoPanelUI.cs            (130 lines) ← Includes inventory display
+
+Assets/Scripts/Maze/Agent/Decisions/
+├── AgentDecision.cs          (45 lines)
+├── AgentDecisionTree.cs      (120 lines)
+├── UseHealthPotionDecision.cs (35 lines)
+├── HandleExistingFightDecision.cs (65 lines)
+├── DeclareFightDecision.cs   (65 lines)
+├── SneakAwayDecision.cs      (80 lines)
+└── MoveOnDecision.cs         (230 lines)
+```
+
+### Modified Files (3)
+```
+Assets/Scripts/Maze/Visualization/MazeSceneBuilder.cs
+  - Removed: 300+ lines of GUI code
+  - Added: UI panel instantiation & delegation
+  - Net: -280 lines
+
+Assets/Scripts/Maze/Visualization/BattleArenaView.cs
+  - Fixed: Line 448, monster max health display
+
+Assets/Scripts/Maze/Agent/AutonomousAgentBrain.cs
+  - Refactored: Entire class to use decision tree
+  - Reduced: 470 lines → 95 lines
+  - Removed: All decision logic (now in decision classes)
+```
+
+## Testing Recommendations
+
+1. **Inventory Display**
+   - Follow an agent
+   - Verify inventory items display in right panel
+   - Confirm equipped/unequipped items both show
+
+2. **Health-Aware Retreat**
+   - Damage agent in combat
+   - Observe thought log: "threat {X:0.00}, over my limit {Y:0.00}"
+   - Verify Y shrinks as health drops (should be ~75% of Y when at 30% health)
+
+3. **Potion Usage**
+   - Give agent a health potion
+   - Damage agent below 50% health
+   - Wait for next decision cycle
+   - Verify thought log: "Used health potion..."
+   - Confirm HP increased
+
+4. **Monster Health Bar**
+   - Trigger a fight
+   - Watch the arena
+   - Verify monster max health displays correctly (not always 100)
+
+5. **Decision Tree Extension**
+   - Create a simple test decision
+   - Add to tree in BuildDecisionTree()
+   - Verify it executes at the right time
+   - Verify thought log shows the narration
+
+## Notes for Future Developers
+
+- The decision tree is intentionally simple to keep overhead minimal
+- Agent decisions run every `_decisionInterval` seconds on SimulationClock time
+- Decisions can't run multi-frame (coroutines would require restructure)
+- Thought log limits itself to ~200 entries, so very old thoughts are pruned
+- Health threshold calculations appear in multiple decision classes (consider DRY refactor if > 3 uses)
+
+## Cost Analysis
+
+**Estimate:** ~$0.90 USD  
+**Budget:** $10 USD  
+**Status:** ✅ **Well Under Budget**
+
+Token breakdown:
+- Input: ~50K tokens (reading files, understanding code)
+- Output: ~180K tokens (writing classes, comments, documentation)
+- **Total: ~230K tokens** at Haiku 4.5 rates = ~$0.90
+
+---
+
+**Ready to test! All features are in place and synchronized.**

MOVEMENT_COMBAT_SUMMARY.md

@@ -0,0 +1,359 @@
+# Movement-Based Combat System Implementation
+
+## Overview
+Implemented a complete grid-based combat system with movement, positioning, and range-based attacks. The system transforms static combat into dynamic spatial warfare where agents must move into range before attacking.
+
+---
+
+## Phase 1: Data Model Extensions ✅
+
+### 1.1 Weapon.cs
+- **Added**: `WeaponType` enum (Melee, Ranged, Magic)
+- **Added**: `_range` field (int, default 1 for melee)
+- **Impact**: Weapons now declare their combat class and effective range
+
+### 1.2 Monster.cs
+- **Added**: `MonsterSize` enum (Small, Medium, Large)
+- **Added**: `_size` field (default Medium)
+- **Mapping**:
+  - Small: 4 creatures per square
+  - Medium: 1 creature per square (1x1)
+  - Large: 1 creature in 4x4 squares
+- **Impact**: Monsters occupy different amounts of grid space
+
+### 1.3 CharacterStats.cs
+- **Added**: `GetMovementRange()` method
+- **Formula**: Speed / 2 (minimum 1 square per turn)
+- **Impact**: Speed stat now determines both initiative and movement capability
+
+### 1.4 Combatant.cs
+- **Added**: `GridPosition` property (Vector2Int)
+- **Added**: `Size` property (MonsterSize)
+- **Added Methods**:
+  - `DistanceTo(Combatant)` - Manhattan distance
+  - `IsAdjacentTo(Combatant)` - 1 square away check
+  - `CanReachTarget(Combatant, Weapon)` - Range validation
+  - `GetFootprintSize()` - Grid size based on monster size
+  - `GetCreaturesPerSquare()` - Stacking limit
+
+---
+
+## Phase 2: Combat Infrastructure ✅
+
+### 2.1 CombatAction.cs (NEW)
+```csharp
+public enum ActionType { Move, Attack, UseItem, Defend, Pass }
+public class CombatAction
+```
+- Represents turn decisions
+- Holds actor, action type, targets (combatant/position/item)
+- Flexible constructors for different action types
+- Used by CombatResolver to make combat determinate
+
+### 2.2 MovementValidator.cs (NEW)
+Static utility class for all combat rules:
+- `CanAttack()` - Range validation (melee adjacency, ranged within range)
+- `CanMoveTo()` - Movement validation (in bounds, speed limit, grid valid)
+- `IsAdjacentTo()` - Melee range check (1 square away)
+- `ManhattanDistance()` - Distance calculation
+- `GetDirectionTowards()` - Direction for pathfinding
+- `GetNextPositionTowards()` - Single step toward target
+
+### 2.3 CombatGrid.cs (NEW)
+Core spatial management system:
+
+**Constructor**: `CombatGrid(Vector2Int gridSize, float cellSize)`
+- Default: 11x7 grid
+- Tracks all occupancy per cell
+
+**Key Methods**:
+- `PlaceAllCombatants()` - Agents left side, monsters right side
+- `IsPositionValid()` - Respects grid bounds and size rules
+- `TryMoveCombatant()` - Atomic move with validation
+- `GetReachablePositions()` - BFS pathfinding within movement range
+- `PlaceCombatant()` - Place individual combatant
+- `RemoveCombatant()` - Remove from grid (on death)
+- `GridToWorldPosition()` / `WorldToGridPosition()` - Coordinate conversion
+
+**Occupancy Rules**:
+- Large (4x4): Cannot share any space
+- Medium (1x1): Needs empty cell
+- Small: Up to 4 per square (stacking)
+
+---
+
+## Phase 3: Event System Extensions ✅
+
+### 3.1 CombatEvent.cs
+**New Event Kinds**:
+- `MovementStart` - Actor begins moving
+- `MovementComplete` - Actor finishes moving
+- `OutOfRange` - Attack failed (ranged/magic out of range)
+- `TooFarForMelee` - Attack failed (not adjacent)
+- `TargetUnreachable` - Movement failed
+
+**New Event Fields**:
+- `SourcePosition` (Vector2Int) - Where movement started
+- `TargetPosition` (Vector2Int) - Destination or target location
+- `MovementDistance` (int) - Squares moved
+
+---
+
+## Phase 4: Combat Resolver Refactor ✅
+
+### 4.1 Core Flow Changes
+**Old**: Pick target → Attack every turn
+**New**:
+1. **InitializeGrid()** - Create 11x7 grid, place all combatants
+2. **SelectActions()** - Each combatant decides Move/Attack/UseItem
+3. **ExecuteActions()** - Process decisions in order
+
+### 4.2 New Methods
+
+#### `InitializeGrid()`
+- Creates CombatGrid with 11x7 cells
+- Places combatants (agents left, monsters right)
+
+#### `SelectActions()`
+- Agents check health, use potions if <20% HP
+- Pick random enemy target
+- **Decision logic**:
+  - If target in weapon range → Attack action
+  - If out of range → Move action (toward target)
+  - If no weapon or can't move → Pass action
+
+#### `ExecuteActions()`
+- Processes all actions in turn order
+- Dispatches to specific executors
+
+#### `ExecuteMovement()`
+- Updates grid position
+- Emits MovementStart, MovementComplete events
+- Records source, destination, distance in events
+
+#### `ExecuteAttack()`
+- **Validates range BEFORE attacking**
+- Melee: Must be adjacent (distance = 1)
+- Ranged/Magic: Must be ≤ weapon.Range
+- Emits OutOfRange/TooFarForMelee if validation fails
+- Only calls TakeSwing() if valid
+
+#### `ExecuteUseItem()`
+- Agents can use consumables during their turn
+- Immediate health restoration
+
+### 4.3 Combat Flow
+```
+Round starts
+├─ SelectActions (all actors decide)
+│  └─ Pick target
+│     ├─ In range? → Attack
+│     └─ Out of range? → Move
+├─ ExecuteActions (process decisions)
+│  ├─ Movement (all moves for round)
+│  ├─ Attacks (validated against actual positions)
+│  └─ Items (consumables used)
+└─ Check win conditions
+```
+
+---
+
+## Phase 5: BattleArenaView Animation ✅
+
+### 5.1 Slot Class Enhancement
+- **Added**: `CurrentGridPos` - Tracks position on grid
+
+### 5.2 PlaceCombatants() Refactor
+- **Old**: Hard-coded team layout
+- **New**: Uses grid positions from Combatant objects
+- Respects actual CombatGrid placement
+
+### 5.3 CreateSlot() Size Scaling
+```csharp
+Small:  0.4f scale  (smaller creatures)
+Medium: 0.58f scale (default, human-sized)
+Large:  1.2f scale  (larger creatures)
+```
+
+### 5.4 Replay() Event Handling
+**New Event Handlers**:
+- `MovementStart` - Brief pause (0.2s)
+- `MovementComplete` → `Movement()` animation
+- `OutOfRange` / `TooFarForMelee` → `RangeFailure()` animation
+- `HealthPotionUsed` → `HealPotion()` animation
+
+### 5.5 New Animation Methods
+
+#### `Movement(CombatEvent e)`
+- Animates combatant from source to target position
+- Updates CurrentGridPos
+- Smooth glide over 0.6 beats
+
+#### `RangeFailure(int combatantId)`
+- Visual feedback: brief shake effect
+- 3 cycles of left-right motion
+- Indicates attack couldn't connect
+
+#### `HealPotion(CombatEvent e)`
+- Green color flash
+- Green floating text (+amount)
+- Updates displayed health
+- 0.6s total animation
+
+### 5.6 Position Tracking Updates
+- **Strike()**: Uses actual grid positions from events
+- **ApplyFinalState()**: Uses final combatant GridPosition
+- **DrawNameplates()**: Uses Transform.position (dynamic)
+- **AddFloater()**: Uses Transform.position (dynamic)
+
+---
+
+## Architecture Integration 🔗
+
+```
+BattleArenaView (Animation)
+    ↑
+    │ replays events with positions
+    │
+CombatResolver (Logic)
+    ├─ InitializeGrid() → CombatGrid
+    ├─ SelectActions() → CombatAction[]
+    ├─ ExecuteActions()
+    │   ├─ ExecuteMovement() → uses MovementValidator
+    │   ├─ ExecuteAttack() → uses MovementValidator
+    │   └─ ExecuteUseItem()
+    │
+    └─ Emits CombatEvent[] (with positions)
+        ├─ MovementStart
+        ├─ MovementComplete
+        ├─ OutOfRange
+        ├─ TooFarForMelee
+        ├─ TargetUnreachable
+        ├─ Hit/Miss
+        └─ Death
+        
+CombatGrid (Spatial State)
+    ├─ PlaceAllCombatants()
+    ├─ IsPositionValid()
+    ├─ TryMoveCombatant()
+    └─ GetReachablePositions()
+        
+MovementValidator (Rules)
+    ├─ CanAttack()
+    ├─ CanMoveTo()
+    ├─ IsAdjacentTo()
+    └─ ManhattanDistance()
+        
+Weapon (Type/Range)
+    ├─ WeaponType enum
+    └─ Range property
+
+Monster (Size)
+    └─ MonsterSize enum
+    
+Combatant (Positioning)
+    ├─ GridPosition
+    ├─ Size
+    ├─ DistanceTo()
+    ├─ CanReachTarget()
+    └─ GetFootprintSize()
+```
+
+---
+
+## What This Enables ✨
+
+✅ **Spatial Combat** - No more "attack from anywhere"
+✅ **Melee vs Ranged** - Different weapons have different reach
+✅ **Speed-Based Movement** - Faster = more squares per turn
+✅ **Smart AI** - Agents automatically move into range
+✅ **Monster Sizes** - Large/Medium/Small occupy different space
+✅ **Grid Stacking** - Small creatures can stack (4 per square)
+✅ **Replayable Events** - All movement recorded for animation
+✅ **Extensible** - Easy to add Defend, Flee, abilities, etc.
+
+---
+
+## Compatibility Notes ⚠️
+
+### Backwards Compatibility
+- Existing weapons default to `Melee` with `Range=1` if not specified
+- Existing monsters default to `MonsterSize.Medium`
+- Agents default to `MonsterSize.Medium`
+- CombatResolver interface unchanged (still takes combatants, returns BattleResult)
+- CombatDirector calls unchanged
+
+### Testing Recommendations
+1. Test melee combat (agent must be adjacent to monster)
+2. Test ranged combat (agent moves into range, then attacks)
+3. Test monster sizes:
+   - Small creatures stacking
+   - Large creatures blocking movement
+   - Medium creatures standard behavior
+4. Test grid boundaries (combatants can't move off grid)
+5. Test multiple combatants (ensure pathfinding avoids allies)
+6. Test movement range calculation (Speed/2)
+7. Test speed stat affecting both initiative and movement
+
+---
+
+## Future Enhancements
+
+1. **Defend Action** - Reduce incoming damage this turn
+2. **Ranged Abilities** - Spells with area of effect
+3. **Terrain Effects** - Obstacles, difficult terrain
+4. **Crowd Control** - Stuns, roots, slows
+5. **Smart Pathfinding** - Avoid allies, seek advantage
+6. **Flanking Mechanics** - Bonuses for surrounding enemy
+7. **Line of Sight** - Visibility-based targeting
+8. **Formations** - Coordinated group movement
+
+---
+
+## Performance Considerations
+
+- CombatGrid uses Dictionary for O(1) occupancy lookup
+- BFS pathfinding is O(n) where n = grid cells (77 for 11x7)
+- Movement validation is O(1) per cell
+- All spatial queries happen once per turn
+- No per-frame updates (resolved completely before animation)
+
+---
+
+## Files Modified/Created
+
+### Modified
+- `Weapon.cs` - Added WeaponType, Range
+- `Monster.cs` - Added MonsterSize
+- `CharacterStats.cs` - Added GetMovementRange()
+- `Combatant.cs` - Added positioning and range methods
+- `CombatEvent.cs` - Added movement event kinds, position fields
+- `CombatResolver.cs` - Complete refactor with grid system
+- `BattleArenaView.cs` - Updated animation, position tracking
+
+### Created
+- `CombatAction.cs` - Action type system
+- `CombatGrid.cs` - Spatial grid management
+- `MovementValidator.cs` - Rule validation system
+
+**Total**: 7 modified, 3 new = 10 files changed
+
+---
+
+## Testing Checklist
+
+- [ ] Project compiles without errors
+- [ ] Basic fight resolves (agents vs monsters)
+- [ ] Melee attacks require adjacency
+- [ ] Ranged attacks work at range
+- [ ] Agents move into range automatically
+- [ ] Movement distance respects Speed stat
+- [ ] Large monsters block space
+- [ ] Small monsters stack (4 per square)
+- [ ] Health potions heal and show animation
+- [ ] Out of range attacks emit proper events
+- [ ] Movement animation plays correctly
+- [ ] Grid placement looks balanced
+- [ ] Final positions are accurate
+- [ ] Arena playback matches log-only mode
+

UserSettings/Layouts/default-6000.dwlt

@@ -19,7 +19,7 @@ MonoBehaviour:
     width: 3440
     height: 1349
   m_ShowMode: 4
-  m_Title: Hierarchy
+  m_Title: Project
   m_RootView: {fileID: 2}
   m_MinSize: {x: 875, y: 300}
   m_MaxSize: {x: 10000, y: 10000}
@@ -279,7 +279,7 @@ MonoBehaviour:
   m_MinSize: {x: 200, y: 56}
   m_MaxSize: {x: 16192, y: 8096}
   vertical: 0
-  controlID: 127
+  controlID: 76
   draggingID: 0
 --- !u!114 &12
 MonoBehaviour:
@@ -773,10 +773,7 @@ MonoBehaviour:
       m_LastClickedID:
         m_Data: 0
       m_ExpandedIDs:
-      - m_Data: -62890
-      - m_Data: -60530
       - m_Data: -1298
-      - m_Data: 45820
       m_RenameOverlay:
         m_UserAcceptedRename: 0
         m_Name: 
@@ -1439,9 +1436,9 @@ MonoBehaviour:
   m_AudioPlay: 0
   m_DebugDrawModesUseInteractiveLightBakingData: 0
   m_Position:
-    m_Target: {x: 15.248607, y: -1.5061598, z: 0}
+    m_Target: {x: -15.330142, y: 12.78174, z: -1.8241996}
     speed: 2
-    m_Value: {x: 15.248607, y: -1.5061598, z: 0}
+    m_Value: {x: -15.330142, y: 12.78174, z: -1.8241996}
   m_RenderMode: 0
   m_CameraMode:
     drawMode: 0
@@ -1491,9 +1488,9 @@ MonoBehaviour:
     speed: 2
     m_Value: {x: 0.00040607058, y: 0.99900454, z: -0.043793336, w: 0.009292002}
   m_Size:
-    m_Target: 22.27303
+    m_Target: 4.8346972
     speed: 2
-    m_Value: 22.27303
+    m_Value: 4.8346972
   m_Ortho:
     m_Target: 0
     speed: 2
@@ -1710,7 +1707,7 @@ MonoBehaviour:
     m_SkipHidden: 0
     m_SearchArea: 0
     m_Folders:
-    - Packages/com.unity.shadergraph/GraphTemplates/Subgraphs
+    - Assets/Scripts/Maze/Agent/Decisions
     m_Globs: []
     m_ProductIds: 
     m_AnyWithAssetOrigin: 0
@@ -1720,29 +1717,36 @@ MonoBehaviour:
   m_ViewMode: 1
   m_StartGridSize: 67
   m_LastFolders:
-  - Packages/com.unity.shadergraph/GraphTemplates/Subgraphs
+  - Assets/Scripts/Maze/Agent/Decisions
   m_LastFoldersGridSize: 67
   m_LastProjectPath: C:\Users\Axel-PC\MazeGenerator
   m_LockTracker:
     m_IsLocked: 0
   m_LastLocalAssetsSearchArea: 0
   m_FolderTreeState:
-    scrollPos: {x: 0, y: 456}
+    scrollPos: {x: 0, y: 204}
     m_SelectedIDs:
-    - m_Data: 46238
+    - m_Data: 46336
     m_LastClickedID:
-      m_Data: 46238
+      m_Data: 46336
     m_ExpandedIDs:
     - m_Data: 0
-    - m_Data: 45912
-    - m_Data: 45914
-    - m_Data: 45916
-    - m_Data: 45918
-    - m_Data: 45920
-    - m_Data: 45922
-    - m_Data: 45924
-    - m_Data: 45926
-    - m_Data: 45928
+    - m_Data: 46000
+    - m_Data: 46002
+    - m_Data: 46004
+    - m_Data: 46006
+    - m_Data: 46008
+    - m_Data: 46010
+    - m_Data: 46012
+    - m_Data: 46014
+    - m_Data: 46016
+    - m_Data: 46018
+    - m_Data: 46020
+    - m_Data: 46022
+    - m_Data: 46024
+    - m_Data: 46026
+    - m_Data: 46028
+    - m_Data: 46030
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -1775,15 +1779,22 @@ MonoBehaviour:
       m_Data: 0
     m_ExpandedIDs:
     - m_Data: 0
-    - m_Data: 45912
-    - m_Data: 45914
-    - m_Data: 45916
-    - m_Data: 45918
-    - m_Data: 45920
-    - m_Data: 45922
-    - m_Data: 45924
-    - m_Data: 45926
-    - m_Data: 45928
+    - m_Data: 46000
+    - m_Data: 46002
+    - m_Data: 46004
+    - m_Data: 46006
+    - m_Data: 46008
+    - m_Data: 46010
+    - m_Data: 46012
+    - m_Data: 46014
+    - m_Data: 46016
+    - m_Data: 46018
+    - m_Data: 46020
+    - m_Data: 46022
+    - m_Data: 46024
+    - m_Data: 46026
+    - m_Data: 46028
+    - m_Data: 46030
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -1811,13 +1822,14 @@ MonoBehaviour:
       m_ResourceFile: 
   m_ListAreaState:
     m_SelectedInstanceIDs:
-    - m_Data: 45780
-    m_LastClickedInstanceID: 45780
-    m_HadKeyboardFocusLastEvent: 1
+    - m_Data: 45534
+    m_LastClickedInstanceID: 45534
+    m_HadKeyboardFocusLastEvent: 0
     m_ExpandedInstanceIDs:
     - m_Data: 70016
     - m_Data: 49188
     - m_Data: 48870
+    - m_Data: 45760
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: