improved ai and combat system

CMakeLists.txt

@@ -52,6 +52,7 @@ if(QT_VERSION_MAJOR EQUAL 6)
         app/game_engine.cpp
         app/selected_units_model.cpp
         ui/gl_view.cpp
+        ui/theme.cpp
     )
 else()
     add_executable(standard_of_iron
@@ -59,6 +60,7 @@ else()
         app/game_engine.cpp
         app/selected_units_model.cpp
         ui/gl_view.cpp
+        ui/theme.cpp
     )
 endif()
 

app/game_engine.cpp

@@ -6,6 +6,8 @@
 #include <QOpenGLContext>
 #include <QQuickWindow>
 #include <QVariant>
+#include <set>
+#include <unordered_map>
 
 #include "game/core/component.h"
 #include "game/core/event_manager.h"
@@ -24,6 +26,7 @@
 #include "game/systems/command_service.h"
 #include "game/systems/formation_planner.h"
 #include "game/systems/movement_system.h"
+#include "game/systems/nation_registry.h"
 #include "game/systems/owner_registry.h"
 #include "game/systems/patrol_system.h"
 #include "game/systems/picking_service.h"
@@ -33,6 +36,7 @@
 #include "game/systems/terrain_alignment_system.h"
 #include "game/systems/victory_service.h"
 #include "game/units/troop_config.h"
+#include "game/visuals/team_colors.h"
 #include "render/geom/arrow.h"
 #include "render/geom/patrol_flags.h"
 #include "render/gl/bootstrap.h"
@@ -56,6 +60,9 @@
 #include <limits>
 
 GameEngine::GameEngine() {
+
+  Game::Systems::NationRegistry::instance().initializeDefaults();
+
   m_world = std::make_unique<Engine::Core::World>();
   m_renderer = std::make_unique<Render::GL::Renderer>();
   m_camera = std::make_unique<Render::GL::Camera>();
@@ -983,12 +990,38 @@ QVariantList GameEngine::availableMaps() const {
       playerIdList.append(id);
     }
     entry["playerIds"] = playerIdList;
+
+    QString thumbnail;
+    if (file.open(QIODevice::ReadOnly)) {
+      QByteArray data = file.readAll();
+      file.close();
+      QJsonParseError err;
+      QJsonDocument doc = QJsonDocument::fromJson(data, &err);
+      if (err.error == QJsonParseError::NoError && doc.isObject()) {
+        QJsonObject obj = doc.object();
+        if (obj.contains("thumbnail") && obj["thumbnail"].isString()) {
+          thumbnail = obj["thumbnail"].toString();
+        }
+      }
+    }
+
+    if (thumbnail.isEmpty()) {
+      QString baseName = QFileInfo(f).baseName();
+      thumbnail = QString("assets/maps/%1_thumb.png").arg(baseName);
+
+      if (!QFileInfo::exists(thumbnail)) {
+        thumbnail = "";
+      }
+    }
+    entry["thumbnail"] = thumbnail;
+
     list.append(entry);
   }
   return list;
 }
 
-void GameEngine::startSkirmish(const QString &mapPath) {
+void GameEngine::startSkirmish(const QString &mapPath,
+                               const QVariantList &playerConfigs) {
 
   m_level.mapName = mapPath;
 
@@ -1073,23 +1106,109 @@ void GameEngine::startSkirmish(const QString &mapPath) {
       }
     }
 
-    ownerRegistry.registerOwnerWithId(
-        playerOwnerId, Game::Systems::OwnerType::Player, "Player");
+    ownerRegistry.setLocalPlayerId(playerOwnerId);
+    m_runtime.localOwnerId = playerOwnerId;
+
+    std::unordered_map<int, int> teamOverrides;
+    QVariantList savedPlayerConfigs;
+    std::set<int> processedPlayerIds;
 
-    for (int id : mapPlayerIds) {
-      if (id != playerOwnerId) {
-        ownerRegistry.registerOwnerWithId(id, Game::Systems::OwnerType::AI,
-                                          "AI " + std::to_string(id));
+    if (!playerConfigs.isEmpty()) {
+      qDebug() << "Processing" << playerConfigs.size()
+               << "player configurations from UI";
+
+      for (const QVariant &configVar : playerConfigs) {
+        QVariantMap config = configVar.toMap();
+        int playerId = config.value("playerId", -1).toInt();
+        int teamId = config.value("teamId", 0).toInt();
+        QString colorHex = config.value("colorHex", "#FFFFFF").toString();
+        bool isHuman = config.value("isHuman", false).toBool();
+
+        if (isHuman && playerId != playerOwnerId) {
+          qDebug() << "  Remapping human player from ID" << playerId << "to"
+                   << playerOwnerId;
+          playerId = playerOwnerId;
+        }
+
+        if (processedPlayerIds.count(playerId) > 0) {
+          qDebug() << "  Skipping duplicate config for player" << playerId;
+          continue;
+        }
+
+        if (playerId >= 0) {
+          processedPlayerIds.insert(playerId);
+          teamOverrides[playerId] = teamId;
+          qDebug() << "  Player" << playerId << "-> Team:" << teamId
+                   << "Color:" << colorHex << "Human:" << isHuman;
+
+          QVariantMap updatedConfig = config;
+          updatedConfig["playerId"] = playerId;
+          savedPlayerConfigs.append(updatedConfig);
+        }
       }
     }
 
-    ownerRegistry.setLocalPlayerId(playerOwnerId);
-    m_runtime.localOwnerId = playerOwnerId;
-
     Game::Map::MapTransformer::setLocalOwnerId(m_runtime.localOwnerId);
+    Game::Map::MapTransformer::setPlayerTeamOverrides(teamOverrides);
 
     auto lr = Game::Map::LevelLoader::loadFromAssets(m_level.mapName, *m_world,
                                                      *m_renderer, *m_camera);
+
+    if (!savedPlayerConfigs.isEmpty()) {
+      qDebug() << "Applying colors after map load for"
+               << savedPlayerConfigs.size() << "players";
+      for (const QVariant &configVar : savedPlayerConfigs) {
+        QVariantMap config = configVar.toMap();
+        int playerId = config.value("playerId", -1).toInt();
+        QString colorHex = config.value("colorHex", "#FFFFFF").toString();
+
+        if (playerId >= 0 && colorHex.startsWith("#") &&
+            colorHex.length() == 7) {
+          bool ok;
+          int r = colorHex.mid(1, 2).toInt(&ok, 16);
+          int g = colorHex.mid(3, 2).toInt(&ok, 16);
+          int b = colorHex.mid(5, 2).toInt(&ok, 16);
+          ownerRegistry.setOwnerColor(playerId, r / 255.0f, g / 255.0f,
+                                      b / 255.0f);
+          qDebug() << "  Player" << playerId << "color set to RGB("
+                   << (r / 255.0f) << "," << (g / 255.0f) << "," << (b / 255.0f)
+                   << ")";
+        }
+      }
+
+      qDebug() << "Verifying team assignments:";
+      for (const auto &[playerId, teamId] : teamOverrides) {
+        int actualTeam = ownerRegistry.getOwnerTeam(playerId);
+        qDebug() << "  Player" << playerId << "requested team:" << teamId
+                 << "actual team:" << actualTeam;
+      }
+
+      qDebug() << "Updating entity colors to match new owner colors...";
+      if (m_world) {
+        auto entities = m_world->getEntitiesWith<Engine::Core::UnitComponent>();
+        std::unordered_map<int, int> ownerEntityCount;
+        for (auto *entity : entities) {
+          auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+          auto *renderable =
+              entity->getComponent<Engine::Core::RenderableComponent>();
+          if (unit && renderable) {
+            QVector3D tc = Game::Visuals::teamColorForOwner(unit->ownerId);
+            renderable->color[0] = tc.x();
+            renderable->color[1] = tc.y();
+            renderable->color[2] = tc.z();
+            ownerEntityCount[unit->ownerId]++;
+          }
+        }
+        qDebug() << "Updated colors for" << entities.size() << "entities";
+        for (const auto &[ownerId, count] : ownerEntityCount) {
+          auto color = ownerRegistry.getOwnerColor(ownerId);
+          qDebug() << "  Owner" << ownerId << ":" << count
+                   << "entities with color RGB(" << color[0] << "," << color[1]
+                   << "," << color[2] << ")";
+        }
+      }
+      qDebug() << "Entity color update complete.";
+    }
     auto &terrainService = Game::Map::TerrainService::instance();
 
     if (m_ground) {
@@ -1202,6 +1321,10 @@ void GameEngine::startSkirmish(const QString &mapPath) {
     }
     m_runtime.loading = false;
 
+    if (auto *aiSystem = m_world->getSystem<Game::Systems::AISystem>()) {
+      aiSystem->reinitialize();
+    }
+
     rebuildEntityCache();
 
     emit ownerInfoChanged();

app/game_engine.h

@@ -125,7 +125,9 @@ public:
   Q_INVOKABLE QString getSelectedUnitsCommandMode() const;
   Q_INVOKABLE void setRallyAtScreen(qreal sx, qreal sy);
   Q_INVOKABLE QVariantList availableMaps() const;
-  Q_INVOKABLE void startSkirmish(const QString &mapPath);
+  Q_INVOKABLE void
+  startSkirmish(const QString &mapPath,
+                const QVariantList &playerConfigs = QVariantList());
   Q_INVOKABLE void openSettings();
   Q_INVOKABLE void loadSave();
   Q_INVOKABLE void exitGame();

assets/maps/team_battle_2v2.json

@@ -0,0 +1,128 @@
+{
+  "name": "Team Battle 2v2",
+  "description": "Two teams of two players each. Team 1 (players 2 & 3) vs Team 2 (players 5 & 6)",
+  "coordSystem": "grid",
+  "maxTroopsPerPlayer": 50,
+  "grid": {
+    "width": 200,
+    "height": 200,
+    "tileSize": 1.0
+  },
+  "biome": {
+    "seed": 12345,
+    "patchDensity": 3.0,
+    "patchJitter": 0.85,
+    "bladeHeight": [0.6, 1.45],
+    "bladeWidth": [0.028, 0.058],
+    "swayStrength": 0.28,
+    "swaySpeed": 1.35,
+    "heightNoise": [0.22, 0.07],
+    "grassPrimary": [0.28, 0.6, 0.32],
+    "grassSecondary": [0.42, 0.72, 0.34],
+    "grassDry": [0.58, 0.5, 0.36],
+    "soilColor": [0.28, 0.24, 0.18],
+    "rockLow": [0.5, 0.48, 0.46],
+    "rockHigh": [0.68, 0.69, 0.73]
+  },
+  "camera": {
+    "center": [100, 0, 100],
+    "distance": 40.0,
+    "tiltDeg": 45.0,
+    "yaw": 225.0,
+    "fovY": 45.0,
+    "near": 1.0,
+    "far": 400.0
+  },
+  "spawns": [
+    {
+      "type": "barracks",
+      "x": 40,
+      "z": 40,
+      "playerId": 2,
+      "teamId": 1
+    },
+    {
+      "type": "archer",
+      "x": 38,
+      "z": 42,
+      "playerId": 2,
+      "teamId": 1
+    },
+    {
+      "type": "archer",
+      "x": 42,
+      "z": 38,
+      "playerId": 2,
+      "teamId": 1
+    },
+    {
+      "type": "barracks",
+      "x": 60,
+      "z": 40,
+      "playerId": 3,
+      "teamId": 1
+    },
+    {
+      "type": "archer",
+      "x": 58,
+      "z": 42,
+      "playerId": 3,
+      "teamId": 1
+    },
+    {
+      "type": "archer",
+      "x": 62,
+      "z": 38,
+      "playerId": 3,
+      "teamId": 1
+    },
+    {
+      "type": "barracks",
+      "x": 140,
+      "z": 160,
+      "playerId": 5,
+      "teamId": 2
+    },
+    {
+      "type": "archer",
+      "x": 138,
+      "z": 162,
+      "playerId": 5,
+      "teamId": 2
+    },
+    {
+      "type": "archer",
+      "x": 142,
+      "z": 158,
+      "playerId": 5,
+      "teamId": 2
+    },
+    {
+      "type": "barracks",
+      "x": 160,
+      "z": 160,
+      "playerId": 6,
+      "teamId": 2
+    },
+    {
+      "type": "archer",
+      "x": 158,
+      "z": 162,
+      "playerId": 6,
+      "teamId": 2
+    },
+    {
+      "type": "archer",
+      "x": 162,
+      "z": 158,
+      "playerId": 6,
+      "teamId": 2
+    }
+  ],
+  "victory": {
+    "type": "elimination",
+    "key_structures": ["barracks"],
+    "defeat_conditions": ["no_key_structures"]
+  },
+  "terrain": []
+}

assets/maps/two_player_map.json

@@ -34,12 +34,12 @@
     "far": 300.0
   },
   "spawns": [
-    { "type": "barracks", "x": 50, "z": 50, "playerId": 2 },
-    { "type": "archer", "x": 48, "z": 52, "playerId": 2 },
-    { "type": "archer", "x": 52, "z": 48, "playerId": 2 },
-    { "type": "barracks", "x": 100, "z": 100, "playerId": 5 },
-    { "type": "archer", "x": 98, "z": 102, "playerId": 5 },
-    { "type": "archer", "x": 102, "z": 98, "playerId": 5 }
+    { "type": "barracks", "x": 50, "z": 50, "playerId": 2, "teamId": 1 },
+    { "type": "archer", "x": 48, "z": 52, "playerId": 2, "teamId": 1 },
+    { "type": "archer", "x": 52, "z": 48, "playerId": 2, "teamId": 1 },
+    { "type": "barracks", "x": 100, "z": 100, "playerId": 5, "teamId": 2 },
+    { "type": "archer", "x": 98, "z": 102, "playerId": 5, "teamId": 2 },
+    { "type": "archer", "x": 102, "z": 98, "playerId": 5, "teamId": 2 }
   ],
   "victory": {
     "type": "elimination",

game/CMakeLists.txt

@@ -15,6 +15,18 @@ add_library(game_systems STATIC
     systems/movement_system.cpp
     systems/combat_system.cpp
     systems/ai_system.cpp
+    systems/ai_system/ai_command_applier.cpp
+    systems/ai_system/ai_command_filter.cpp
+    systems/ai_system/ai_snapshot_builder.cpp
+    systems/ai_system/ai_reasoner.cpp
+    systems/ai_system/ai_executor.cpp
+    systems/ai_system/ai_worker.cpp
+    systems/ai_system/ai_tactical.cpp
+    systems/ai_system/behaviors/production_behavior.cpp
+    systems/ai_system/behaviors/gather_behavior.cpp
+    systems/ai_system/behaviors/attack_behavior.cpp
+    systems/ai_system/behaviors/defend_behavior.cpp
+    systems/ai_system/behaviors/retreat_behavior.cpp
     systems/patrol_system.cpp
     systems/pathfinding.cpp
     systems/building_collision_registry.cpp
@@ -29,6 +41,7 @@ add_library(game_systems STATIC
     systems/terrain_alignment_system.cpp
     systems/owner_registry.cpp
     systems/victory_service.cpp
+    systems/nation_registry.cpp
     map/map_loader.cpp
     map/level_loader.cpp
     map/map_transformer.cpp

game/core/component.h

@@ -65,7 +65,8 @@ public:
   MovementComponent()
       : hasTarget(false), targetX(0.0f), targetY(0.0f), goalX(0.0f),
         goalY(0.0f), vx(0.0f), vz(0.0f), pathPending(false),
-        pendingRequestId(0), repathCooldown(0.0f) {}
+        pendingRequestId(0), repathCooldown(0.0f), lastGoalX(0.0f),
+        lastGoalY(0.0f), timeSinceLastPathRequest(0.0f) {}
 
   bool hasTarget;
   float targetX, targetY;
@@ -75,17 +76,61 @@ public:
   bool pathPending;
   std::uint64_t pendingRequestId;
   float repathCooldown;
+
+  float lastGoalX, lastGoalY;
+  float timeSinceLastPathRequest;
 };
 
 class AttackComponent : public Component {
 public:
+  enum class CombatMode { Ranged, Melee, Auto };
+
   AttackComponent(float range = 2.0f, int damage = 10, float cooldown = 1.0f)
-      : range(range), damage(damage), cooldown(cooldown), timeSinceLast(0.0f) {}
+      : range(range), damage(damage), cooldown(cooldown), timeSinceLast(0.0f),
+        meleeRange(1.5f), meleeDamage(damage), meleeCooldown(cooldown),
+        preferredMode(CombatMode::Auto), currentMode(CombatMode::Ranged),
+        canMelee(true), canRanged(false), maxHeightDifference(2.0f),
+        inMeleeLock(false), meleeLockTargetId(0) {}
 
   float range;
   int damage;
   float cooldown;
   float timeSinceLast;
+
+  float meleeRange;
+  int meleeDamage;
+  float meleeCooldown;
+
+  CombatMode preferredMode;
+  CombatMode currentMode;
+
+  bool canMelee;
+  bool canRanged;
+
+  float maxHeightDifference;
+
+  bool inMeleeLock;
+  EntityID meleeLockTargetId;
+
+  bool isInMeleeRange(float distance, float heightDiff) const {
+    return distance <= meleeRange && heightDiff <= maxHeightDifference;
+  }
+
+  bool isInRangedRange(float distance) const {
+    return distance <= range && distance > meleeRange;
+  }
+
+  int getCurrentDamage() const {
+    return (currentMode == CombatMode::Melee) ? meleeDamage : damage;
+  }
+
+  float getCurrentCooldown() const {
+    return (currentMode == CombatMode::Melee) ? meleeCooldown : cooldown;
+  }
+
+  float getCurrentRange() const {
+    return (currentMode == CombatMode::Melee) ? meleeRange : range;
+  }
 };
 
 class AttackTargetComponent : public Component {

game/core/world.cpp

@@ -1,4 +1,5 @@
 #include "world.h"
+#include "../systems/owner_registry.h"
 #include "component.h"
 
 namespace Engine::Core {
@@ -37,7 +38,7 @@ void World::update(float deltaTime) {
   }
 }
 
-std::vector<Entity *> World::getUnitsOwnedBy(int ownerId) {
+std::vector<Entity *> World::getUnitsOwnedBy(int ownerId) const {
   std::vector<Entity *> result;
   result.reserve(m_entities.size());
   for (auto &[id, entity] : m_entities) {
@@ -51,7 +52,7 @@ std::vector<Entity *> World::getUnitsOwnedBy(int ownerId) {
   return result;
 }
 
-std::vector<Entity *> World::getUnitsNotOwnedBy(int ownerId) {
+std::vector<Entity *> World::getUnitsNotOwnedBy(int ownerId) const {
   std::vector<Entity *> result;
   result.reserve(m_entities.size());
   for (auto &[id, entity] : m_entities) {
@@ -65,4 +66,39 @@ std::vector<Entity *> World::getUnitsNotOwnedBy(int ownerId) {
   return result;
 }
 
+std::vector<Entity *> World::getAlliedUnits(int ownerId) const {
+  std::vector<Entity *> result;
+  result.reserve(m_entities.size());
+  auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+
+  for (auto &[id, entity] : m_entities) {
+    auto *unit = entity->getComponent<UnitComponent>();
+    if (!unit)
+      continue;
+
+    if (unit->ownerId == ownerId ||
+        ownerRegistry.areAllies(ownerId, unit->ownerId)) {
+      result.push_back(entity.get());
+    }
+  }
+  return result;
+}
+
+std::vector<Entity *> World::getEnemyUnits(int ownerId) const {
+  std::vector<Entity *> result;
+  result.reserve(m_entities.size());
+  auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+
+  for (auto &[id, entity] : m_entities) {
+    auto *unit = entity->getComponent<UnitComponent>();
+    if (!unit)
+      continue;
+
+    if (ownerRegistry.areEnemies(ownerId, unit->ownerId)) {
+      result.push_back(entity.get());
+    }
+  }
+  return result;
+}
+
 } // namespace Engine::Core

game/core/world.h

@@ -42,8 +42,10 @@ public:
     return result;
   }
 
-  std::vector<Entity *> getUnitsOwnedBy(int ownerId);
-  std::vector<Entity *> getUnitsNotOwnedBy(int ownerId);
+  std::vector<Entity *> getUnitsOwnedBy(int ownerId) const;
+  std::vector<Entity *> getUnitsNotOwnedBy(int ownerId) const;
+  std::vector<Entity *> getAlliedUnits(int ownerId) const;
+  std::vector<Entity *> getEnemyUnits(int ownerId) const;
 
 private:
   EntityID m_nextEntityId = 1;

game/map/map_definition.h

@@ -30,6 +30,7 @@ struct UnitSpawn {
   float x = 0.0f;
   float z = 0.0f;
   int playerId = 0;
+  int teamId = 0;
 };
 
 enum class CoordSystem { Grid, World };

game/map/map_loader.cpp

@@ -188,6 +188,7 @@ static void readSpawns(const QJsonArray &arr, std::vector<UnitSpawn> &out) {
     s.x = float(o.value("x").toDouble(0.0));
     s.z = float(o.value("z").toDouble(0.0));
     s.playerId = o.value("playerId").toInt(0);
+    s.teamId = o.value("teamId").toInt(0);
     out.push_back(s);
   }
 }

game/map/map_transformer.cpp

@@ -8,12 +8,15 @@
 #include "terrain_service.h"
 #include <QDebug>
 #include <QVector3D>
+#include <set>
+#include <unordered_map>
 
 namespace Game::Map {
 
 namespace {
 std::shared_ptr<Game::Units::UnitFactoryRegistry> s_registry;
-}
+std::unordered_map<int, int> s_playerTeamOverrides;
+} // namespace
 
 void MapTransformer::setFactoryRegistry(
     std::shared_ptr<Game::Units::UnitFactoryRegistry> reg) {
@@ -32,6 +35,15 @@ int MapTransformer::localOwnerId() {
   return Game::Systems::OwnerRegistry::instance().getLocalPlayerId();
 }
 
+void MapTransformer::setPlayerTeamOverrides(
+    const std::unordered_map<int, int> &overrides) {
+  s_playerTeamOverrides = overrides;
+}
+
+void MapTransformer::clearPlayerTeamOverrides() {
+  s_playerTeamOverrides.clear();
+}
+
 MapRuntime
 MapTransformer::applyToWorld(const MapDefinition &def,
                              Engine::Core::World &world,
@@ -39,6 +51,61 @@ MapTransformer::applyToWorld(const MapDefinition &def,
   MapRuntime rt;
   rt.unitIds.reserve(def.spawns.size());
 
+  auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+  std::set<int> uniquePlayerIds;
+  std::unordered_map<int, int> playerIdToTeam;
+
+  for (const auto &spawn : def.spawns) {
+    uniquePlayerIds.insert(spawn.playerId);
+
+    if (spawn.teamId > 0) {
+      playerIdToTeam[spawn.playerId] = spawn.teamId;
+    }
+  }
+
+  for (int playerId : uniquePlayerIds) {
+
+    if (ownerRegistry.getOwnerType(playerId) ==
+        Game::Systems::OwnerType::Neutral) {
+
+      bool isLocalPlayer = (playerId == ownerRegistry.getLocalPlayerId());
+      Game::Systems::OwnerType ownerType =
+          isLocalPlayer ? Game::Systems::OwnerType::Player
+                        : Game::Systems::OwnerType::AI;
+
+      std::string ownerName = isLocalPlayer
+                                  ? "Player " + std::to_string(playerId)
+                                  : "AI Player " + std::to_string(playerId);
+
+      ownerRegistry.registerOwnerWithId(playerId, ownerType, ownerName);
+      qDebug() << "[MapTransformer] Registered player" << playerId << "as"
+               << (isLocalPlayer ? "HUMAN" : "AI");
+    }
+
+    int finalTeamId = 0;
+    auto overrideIt = s_playerTeamOverrides.find(playerId);
+    if (overrideIt != s_playerTeamOverrides.end()) {
+
+      finalTeamId = overrideIt->second;
+      qDebug() << "[MapTransformer] Player" << playerId
+               << "team from UI:" << finalTeamId;
+    } else {
+
+      auto teamIt = playerIdToTeam.find(playerId);
+      if (teamIt != playerIdToTeam.end()) {
+        finalTeamId = teamIt->second;
+        qDebug() << "[MapTransformer] Player" << playerId
+                 << "team from MAP:" << finalTeamId;
+      } else {
+        qDebug() << "[MapTransformer] Player" << playerId
+                 << "no team specified, defaulting to 0 (FFA)";
+      }
+    }
+    ownerRegistry.setOwnerTeam(playerId, finalTeamId);
+    qDebug() << "[MapTransformer] Player" << playerId
+             << "FINAL team set to:" << finalTeamId;
+  }
+
   for (const auto &s : def.spawns) {
 
     float worldX = s.x;
@@ -106,8 +173,15 @@ MapTransformer::applyToWorld(const MapDefinition &def,
       u->ownerId = s.playerId;
       u->visionRange = 14.0f;
 
-      if (!Game::Systems::OwnerRegistry::instance().isPlayer(s.playerId)) {
+      bool isAI =
+          !Game::Systems::OwnerRegistry::instance().isPlayer(s.playerId);
+      if (isAI) {
         e->addComponent<Engine::Core::AIControlledComponent>();
+        qDebug() << "[MapTransformer] Unit" << e->getId() << "for player"
+                 << s.playerId << "marked as AI-controlled";
+      } else {
+        qDebug() << "[MapTransformer] Unit" << e->getId() << "for player"
+                 << s.playerId << "is PLAYER-controlled";
       }
 
       if (auto *existingMv =

game/map/map_transformer.h

@@ -34,6 +34,10 @@ public:
 
   static void setLocalOwnerId(int ownerId);
   static int localOwnerId();
+
+  static void
+  setPlayerTeamOverrides(const std::unordered_map<int, int> &overrides);
+  static void clearPlayerTeamOverrides();
 };
 
 } // namespace Game::Map

game/map/visibility_service.cpp

@@ -2,6 +2,7 @@
 
 #include "../core/component.h"
 #include "../core/world.h"
+#include "../systems/owner_registry.h"
 #include <algorithm>
 #include <cmath>
 
@@ -88,13 +89,18 @@ VisibilityService::gatherVisionSources(Engine::Core::World &world,
   auto entities = world.getEntitiesWith<Engine::Core::TransformComponent>();
   const float rangePadding = m_tileSize * 0.5f;
 
+  auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+
   for (auto *entity : entities) {
     auto *transform = entity->getComponent<Engine::Core::TransformComponent>();
     auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
     if (!transform || !unit)
       continue;
-    if (unit->ownerId != playerId)
+
+    if (unit->ownerId != playerId &&
+        !ownerRegistry.areAllies(playerId, unit->ownerId))
       continue;
+
     if (unit->health <= 0)
       continue;
 

game/systems/ai_system.cpp

@@ -1,869 +1,123 @@
-
 #include "ai_system.h"
-#include "../core/component.h"
 #include "../core/world.h"
-#include "command_service.h"
-#include "formation_planner.h"
+#include "ai_system/behaviors/attack_behavior.h"
+#include "ai_system/behaviors/defend_behavior.h"
+#include "ai_system/behaviors/gather_behavior.h"
+#include "ai_system/behaviors/production_behavior.h"
+#include "ai_system/behaviors/retreat_behavior.h"
 #include "owner_registry.h"
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <utility>
+#include <QDebug>
+#include <iostream>
 
 namespace Game::Systems {
 
 AISystem::AISystem() {
-  auto &registry = OwnerRegistry::instance();
-  m_enemyAI.playerId = registry.getAIOwnerIds().empty()
-                           ? registry.registerOwner(OwnerType::AI, "AI Player")
-                           : registry.getAIOwnerIds()[0];
-  m_enemyAI.state = AIState::Idle;
-
-  registerBehavior(std::make_unique<DefendBehavior>());
-  registerBehavior(std::make_unique<ProductionBehavior>());
-  registerBehavior(std::make_unique<AttackBehavior>());
-  registerBehavior(std::make_unique<GatherBehavior>());
-
-  m_aiThread = std::thread(&AISystem::workerLoop, this);
-}
-
-AISystem::~AISystem() {
-  m_shouldStop.store(true, std::memory_order_release);
-  { std::lock_guard<std::mutex> lock(m_jobMutex); }
-  m_jobCondition.notify_all();
-  if (m_aiThread.joinable()) {
-    m_aiThread.join();
-  }
-}
-
-void AISystem::registerBehavior(std::unique_ptr<AIBehavior> behavior) {
-  m_behaviors.push_back(std::move(behavior));
-  std::sort(m_behaviors.begin(), m_behaviors.end(),
-            [](const std::unique_ptr<AIBehavior> &a,
-               const std::unique_ptr<AIBehavior> &b) {
-              return a->getPriority() > b->getPriority();
-            });
-}
-
-void AISystem::update(Engine::Core::World *world, float deltaTime) {
-  if (!world)
-    return;
-
-  processResults(world);
-
-  m_globalUpdateTimer += deltaTime;
-  if (m_globalUpdateTimer < 0.3f)
-    return;
-
-  if (m_workerBusy.load(std::memory_order_acquire))
-    return;
-
-  AISnapshot snapshot = buildSnapshot(world);
-
-  AIJob job;
-  job.snapshot = std::move(snapshot);
-  job.context = m_enemyAI;
-  job.deltaTime = m_globalUpdateTimer;
-
-  {
-    std::lock_guard<std::mutex> lock(m_jobMutex);
-    m_pendingJob = std::move(job);
-    m_hasPendingJob = true;
-  }
-
-  m_workerBusy.store(true, std::memory_order_release);
-  m_jobCondition.notify_one();
-
-  m_globalUpdateTimer = 0.0f;
-}
-
-AISnapshot AISystem::buildSnapshot(Engine::Core::World *world) const {
-  AISnapshot snapshot;
-  snapshot.playerId = m_enemyAI.playerId;
-
-  auto friendlies = world->getUnitsOwnedBy(snapshot.playerId);
-  snapshot.friendlies.reserve(friendlies.size());
-
-  for (auto *entity : friendlies) {
-    if (!entity->hasComponent<Engine::Core::AIControlledComponent>())
-      continue;
-
-    auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
-    if (!unit || unit->health <= 0)
-      continue;
-
-    EntitySnapshot data;
-    data.id = entity->getId();
-    data.unitType = unit->unitType;
-    data.ownerId = unit->ownerId;
-    data.health = unit->health;
-    data.maxHealth = unit->maxHealth;
-    data.isBuilding = entity->hasComponent<Engine::Core::BuildingComponent>();
-
-    if (auto *transform =
-            entity->getComponent<Engine::Core::TransformComponent>()) {
-      data.position =
-          QVector3D(transform->position.x, 0.0f, transform->position.z);
-    }
-
-    if (auto *movement =
-            entity->getComponent<Engine::Core::MovementComponent>()) {
-      data.movement.hasComponent = true;
-      data.movement.hasTarget = movement->hasTarget;
-    }
-
-    if (auto *production =
-            entity->getComponent<Engine::Core::ProductionComponent>()) {
-      data.production.hasComponent = true;
-      data.production.inProgress = production->inProgress;
-      data.production.buildTime = production->buildTime;
-      data.production.timeRemaining = production->timeRemaining;
-      data.production.producedCount = production->producedCount;
-      data.production.maxUnits = production->maxUnits;
-      data.production.productType = production->productType;
-      data.production.rallySet = production->rallySet;
-      data.production.rallyX = production->rallyX;
-      data.production.rallyZ = production->rallyZ;
-    }
-
-    snapshot.friendlies.push_back(std::move(data));
-  }
-
-  auto others = world->getUnitsNotOwnedBy(snapshot.playerId);
-  snapshot.visibleEnemies.reserve(others.size());
-
-  for (auto *entity : others) {
-    if (entity->hasComponent<Engine::Core::AIControlledComponent>())
-      continue;
-
-    auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
-    if (!unit || unit->health <= 0)
-      continue;
-
-    auto *transform = entity->getComponent<Engine::Core::TransformComponent>();
-    if (!transform)
-      continue;
-
-    ContactSnapshot contact;
-    contact.id = entity->getId();
-    contact.isBuilding =
-        entity->hasComponent<Engine::Core::BuildingComponent>();
-    contact.position =
-        QVector3D(transform->position.x, 0.0f, transform->position.z);
-    snapshot.visibleEnemies.push_back(std::move(contact));
-  }
 
-  return snapshot;
-}
+  m_behaviorRegistry.registerBehavior(std::make_unique<AI::RetreatBehavior>());
 
-void AISystem::processResults(Engine::Core::World *world) {
-  std::vector<AIResult> results;
-  {
-    std::lock_guard<std::mutex> lock(m_resultMutex);
-    while (!m_results.empty()) {
-      results.push_back(std::move(m_results.front()));
-      m_results.pop();
-    }
-  }
+  m_behaviorRegistry.registerBehavior(std::make_unique<AI::DefendBehavior>());
 
-  for (auto &result : results) {
-    m_enemyAI = result.context;
-    applyCommands(world, result.commands);
-  }
-}
+  m_behaviorRegistry.registerBehavior(
+      std::make_unique<AI::ProductionBehavior>());
 
-static void replicateLastTargetIfNeeded(const std::vector<QVector3D> &from,
-                                        size_t wanted,
-                                        std::vector<QVector3D> &out) {
-  out.clear();
-  if (from.empty())
-    return;
-  out.reserve(wanted);
-  for (size_t i = 0; i < wanted; ++i) {
-    out.push_back(i < from.size() ? from[i] : from.back());
-  }
-}
-
-static bool isEntityEngaged(const EntitySnapshot &entity,
-                            const std::vector<ContactSnapshot> &enemies) {
-  if (entity.maxHealth > 0 && entity.health < entity.maxHealth)
-    return true;
+  m_behaviorRegistry.registerBehavior(std::make_unique<AI::AttackBehavior>());
 
-  constexpr float ENGAGED_RADIUS = 7.5f;
-  const float engagedSq = ENGAGED_RADIUS * ENGAGED_RADIUS;
+  m_behaviorRegistry.registerBehavior(std::make_unique<AI::GatherBehavior>());
 
-  for (const auto &enemy : enemies) {
-    float distSq = (enemy.position - entity.position).lengthSquared();
-    if (distSq <= engagedSq)
-      return true;
-  }
-  return false;
+  initializeAIPlayers();
 }
 
-void AISystem::applyCommands(Engine::Core::World *world,
-                             const std::vector<AICommand> &commands) {
-  if (!world)
-    return;
-  const int aiOwnerId = m_enemyAI.playerId;
-
-  for (const auto &command : commands) {
-    switch (command.type) {
-    case AICommandType::MoveUnits: {
-      if (command.units.empty())
-        break;
-
-      std::vector<QVector3D> expandedTargets;
-      if (command.moveTargets.size() != command.units.size()) {
-        replicateLastTargetIfNeeded(command.moveTargets, command.units.size(),
-                                    expandedTargets);
-      } else {
-        expandedTargets = command.moveTargets;
-      }
-
-      if (expandedTargets.empty())
-        break;
-
-      std::vector<Engine::Core::EntityID> ownedUnits;
-      std::vector<QVector3D> ownedTargets;
-      ownedUnits.reserve(command.units.size());
-      ownedTargets.reserve(command.units.size());
-
-      for (std::size_t idx = 0; idx < command.units.size(); ++idx) {
-        auto entityId = command.units[idx];
-        auto *entity = world->getEntity(entityId);
-        if (!entity)
-          continue;
-
-        auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
-        if (!unit || unit->ownerId != aiOwnerId)
-          continue;
-
-        ownedUnits.push_back(entityId);
-        ownedTargets.push_back(expandedTargets[idx]);
-      }
-
-      if (ownedUnits.empty())
-        break;
-
-      CommandService::MoveOptions opts;
-      opts.allowDirectFallback = true;
-      opts.clearAttackIntent = false;
-      opts.groupMove = ownedUnits.size() > 1;
-      CommandService::moveUnits(*world, ownedUnits, ownedTargets, opts);
-      break;
-    }
-    case AICommandType::AttackTarget: {
-      if (command.units.empty() || command.targetId == 0)
-        break;
-      std::vector<Engine::Core::EntityID> ownedUnits;
-      ownedUnits.reserve(command.units.size());
-
-      for (auto entityId : command.units) {
-        auto *entity = world->getEntity(entityId);
-        if (!entity)
-          continue;
-        auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
-        if (!unit || unit->ownerId != aiOwnerId)
-          continue;
-        ownedUnits.push_back(entityId);
-      }
-
-      if (ownedUnits.empty())
-        break;
-
-      CommandService::attackTarget(*world, ownedUnits, command.targetId,
-                                   command.shouldChase);
-      break;
-    }
-    case AICommandType::StartProduction: {
-      auto *entity = world->getEntity(command.buildingId);
-      if (!entity)
-        break;
-
-      auto *production =
-          entity->getComponent<Engine::Core::ProductionComponent>();
-      if (!production || production->inProgress)
-        break;
-
-      auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
-      if (unit && unit->ownerId != aiOwnerId)
-        break;
-
-      if (!command.productType.empty())
-        production->productType = command.productType;
-
-      production->timeRemaining = production->buildTime;
-      production->inProgress = true;
-      break;
-    }
-    }
-  }
-}
+void AISystem::reinitialize() {
+  std::cout << "[AISystem] Reinitializing AI instances..." << std::endl;
 
-void AISystem::updateContext(const AISnapshot &snapshot, AIContext &ctx) {
-  ctx.militaryUnits.clear();
-  ctx.buildings.clear();
-  ctx.primaryBarracks = 0;
-  ctx.totalUnits = 0;
-  ctx.idleUnits = 0;
-  ctx.combatUnits = 0;
-  ctx.averageHealth = 1.0f;
-  ctx.rallyX = 0.0f;
-  ctx.rallyZ = 0.0f;
-  ctx.barracksUnderThreat = false;
-  ctx.nearbyThreatCount = 0;
-  ctx.closestThreatDistance = std::numeric_limits<float>::infinity();
-  ctx.basePosition = QVector3D();
-
-  float totalHealthRatio = 0.0f;
-
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.isBuilding) {
-      ctx.buildings.push_back(entity.id);
-      if (entity.unitType == "barracks" && ctx.primaryBarracks == 0) {
-        ctx.primaryBarracks = entity.id;
-        ctx.rallyX = entity.position.x() - 5.0f;
-        ctx.rallyZ = entity.position.z();
-        ctx.basePosition = entity.position;
-      }
-      continue;
-    }
-
-    ctx.militaryUnits.push_back(entity.id);
-    ctx.totalUnits++;
+  m_aiInstances.clear();
 
-    if (!entity.movement.hasComponent || !entity.movement.hasTarget) {
-      ctx.idleUnits++;
-    } else {
-      ctx.combatUnits++;
-    }
-
-    if (entity.maxHealth > 0) {
-      totalHealthRatio += static_cast<float>(entity.health) /
-                          static_cast<float>(entity.maxHealth);
-    }
-  }
-
-  ctx.averageHealth =
-      (ctx.totalUnits > 0)
-          ? (totalHealthRatio / static_cast<float>(ctx.totalUnits))
-          : 1.0f;
-
-  if (ctx.primaryBarracks != 0) {
-    constexpr float DEFEND_RADIUS = 16.0f;
-    const float defendRadiusSq = DEFEND_RADIUS * DEFEND_RADIUS;
-
-    for (const auto &enemy : snapshot.visibleEnemies) {
-      float distSq = (enemy.position - ctx.basePosition).lengthSquared();
-      if (distSq <= defendRadiusSq) {
-        ctx.barracksUnderThreat = true;
-        ctx.nearbyThreatCount++;
-        float dist = std::sqrt(std::max(distSq, 0.0f));
-        ctx.closestThreatDistance = std::min(ctx.closestThreatDistance, dist);
-      }
-    }
-
-    if (!ctx.barracksUnderThreat) {
-      ctx.closestThreatDistance = std::numeric_limits<float>::infinity();
-    }
-  }
+  initializeAIPlayers();
 }
 
-void AISystem::updateStateMachine(AIContext &ctx, float deltaTime) {
-  ctx.stateTimer += deltaTime;
-  ctx.decisionTimer += deltaTime;
+void AISystem::initializeAIPlayers() {
+  auto &registry = OwnerRegistry::instance();
+  const auto &aiOwnerIds = registry.getAIOwnerIds();
 
-  AIState previousState = ctx.state;
-  if (ctx.barracksUnderThreat && ctx.state != AIState::Defending) {
-    ctx.state = AIState::Defending;
-  }
+  qDebug() << "[AISystem] Initializing AI players. Found" << aiOwnerIds.size()
+           << "AI owners";
 
-  if (ctx.decisionTimer < 2.0f) {
-    if (ctx.state != previousState)
-      ctx.stateTimer = 0.0f;
+  if (aiOwnerIds.empty()) {
+    qDebug() << "[AISystem] No AI players found in registry";
     return;
   }
-  ctx.decisionTimer = 0.0f;
-  previousState = ctx.state;
-
-  switch (ctx.state) {
-  case AIState::Idle:
-    if (ctx.idleUnits >= 2) {
-      ctx.state = AIState::Gathering;
-    } else if (ctx.averageHealth < 0.5f && ctx.totalUnits > 0) {
-      ctx.state = AIState::Defending;
-    }
-    break;
-
-  case AIState::Gathering:
-    if (ctx.totalUnits >= 4 && ctx.idleUnits <= 1) {
-      ctx.state = AIState::Attacking;
-    } else if (ctx.totalUnits < 2) {
-      ctx.state = AIState::Idle;
-    }
-    break;
-
-  case AIState::Attacking:
-    if (ctx.averageHealth < 0.3f) {
-      ctx.state = AIState::Retreating;
-    } else if (ctx.totalUnits < 2) {
-      ctx.state = AIState::Gathering;
-    }
-    break;
-
-  case AIState::Defending:
-    if (ctx.barracksUnderThreat) {
-
-    } else if (ctx.totalUnits >= 4 && ctx.averageHealth > 0.5f) {
-      ctx.state = AIState::Attacking;
-    } else if (ctx.averageHealth > 0.7f) {
-      ctx.state = AIState::Idle;
-    }
-    break;
-
-  case AIState::Retreating:
-    if (ctx.stateTimer > 6.0f) {
-      ctx.state = AIState::Defending;
-    }
-    break;
-
-  case AIState::Expanding:
-    ctx.state = AIState::Idle;
-    break;
-  }
-
-  if (ctx.state != previousState) {
-    ctx.stateTimer = 0.0f;
-  }
-}
-
-void AISystem::executeBehaviors(const AISnapshot &snapshot, AIContext &ctx,
-                                float deltaTime,
-                                std::vector<AICommand> &outCommands) {
-  bool exclusiveBehaviorExecuted = false;
 
-  for (auto &behavior : m_behaviors) {
-    if (!behavior)
-      continue;
+  for (uint32_t playerId : aiOwnerIds) {
+    int teamId = registry.getOwnerTeam(playerId);
+    AIInstance instance;
+    instance.context.playerId = playerId;
+    instance.context.state = AI::AIState::Idle;
+    instance.worker = std::make_unique<AI::AIWorker>(m_reasoner, m_executor,
+                                                     m_behaviorRegistry);
 
-    if (exclusiveBehaviorExecuted && !behavior->canRunConcurrently()) {
-      continue;
-    }
+    m_aiInstances.push_back(std::move(instance));
 
-    if (behavior->shouldExecute(snapshot, ctx)) {
-      behavior->execute(snapshot, ctx, deltaTime, outCommands);
-      if (!behavior->canRunConcurrently()) {
-        exclusiveBehaviorExecuted = true;
-      }
-    }
+    qDebug() << "[AISystem] Initialized AI for player" << playerId << "team"
+             << teamId << "(total AI instances:" << m_aiInstances.size() << ")";
   }
 }
 
-void AISystem::workerLoop() {
-  while (true) {
-    AIJob job;
-    {
-      std::unique_lock<std::mutex> lock(m_jobMutex);
-      m_jobCondition.wait(lock, [this]() {
-        return m_shouldStop.load(std::memory_order_acquire) || m_hasPendingJob;
-      });
-
-      if (m_shouldStop.load(std::memory_order_acquire) && !m_hasPendingJob) {
-        break;
-      }
-
-      job = std::move(m_pendingJob);
-      m_hasPendingJob = false;
-    }
-
-    try {
-      AIResult result;
-      result.context = job.context;
-
-      updateContext(job.snapshot, result.context);
-      updateStateMachine(result.context, job.deltaTime);
-      executeBehaviors(job.snapshot, result.context, job.deltaTime,
-                       result.commands);
-
-      {
-        std::lock_guard<std::mutex> lock(m_resultMutex);
-        m_results.push(std::move(result));
-      }
-    } catch (...) {
-    }
-
-    m_workerBusy.store(false, std::memory_order_release);
-  }
-
-  m_workerBusy.store(false, std::memory_order_release);
-}
+AISystem::~AISystem() {}
 
-void ProductionBehavior::execute(const AISnapshot &snapshot, AIContext &context,
-                                 float deltaTime,
-                                 std::vector<AICommand> &outCommands) {
-  m_productionTimer += deltaTime;
-  if (m_productionTimer < 1.5f)
+void AISystem::update(Engine::Core::World *world, float deltaTime) {
+  if (!world)
     return;
-  m_productionTimer = 0.0f;
-
-  static bool produceArcher = true;
-
-  for (const auto &entity : snapshot.friendlies) {
-    if (!entity.isBuilding || entity.unitType != "barracks")
-      continue;
-    if (!entity.production.hasComponent)
-      continue;
 
-    const auto &prod = entity.production;
-    if (prod.inProgress || prod.producedCount >= prod.maxUnits)
-      continue;
+  m_totalGameTime += deltaTime;
 
-    AICommand command;
-    command.type = AICommandType::StartProduction;
-    command.buildingId = entity.id;
-    command.productType = produceArcher ? "archer" : "swordsman";
-    outCommands.push_back(std::move(command));
-  }
+  m_commandFilter.update(m_totalGameTime);
 
-  produceArcher = !produceArcher;
-}
+  processResults(*world);
 
-bool ProductionBehavior::shouldExecute(const AISnapshot &snapshot,
-                                       const AIContext &context) const {
-  (void)snapshot;
-  (void)context;
-  return true;
-}
+  for (auto &ai : m_aiInstances) {
 
-void GatherBehavior::execute(const AISnapshot &snapshot, AIContext &context,
-                             float deltaTime,
-                             std::vector<AICommand> &outCommands) {
-  m_gatherTimer += deltaTime;
-  if (m_gatherTimer < 2.0f)
-    return;
-  m_gatherTimer = 0.0f;
+    ai.updateTimer += deltaTime;
 
-  if (context.primaryBarracks == 0)
-    return;
-
-  QVector3D rallyPoint(context.rallyX, 0.0f, context.rallyZ);
-
-  std::vector<const EntitySnapshot *> idleEntities;
-  idleEntities.reserve(snapshot.friendlies.size());
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.isBuilding)
-      continue;
-    if (isEntityEngaged(entity, snapshot.visibleEnemies))
-      continue;
-    if (!entity.movement.hasComponent || !entity.movement.hasTarget) {
-      idleEntities.push_back(&entity);
-    }
-  }
-
-  if (idleEntities.empty())
-    return;
-
-  auto formationTargets = FormationPlanner::spreadFormation(
-      static_cast<int>(idleEntities.size()), rallyPoint, 1.4f);
-
-  std::vector<Engine::Core::EntityID> unitsToMove;
-  std::vector<QVector3D> targetsToUse;
-  unitsToMove.reserve(idleEntities.size());
-  targetsToUse.reserve(idleEntities.size());
-
-  for (size_t i = 0; i < idleEntities.size(); ++i) {
-    const auto *entity = idleEntities[i];
-    const auto &target = formationTargets[i];
-    const float dx = entity->position.x() - target.x();
-    const float dz = entity->position.z() - target.z();
-    const float distanceSq = dx * dx + dz * dz;
-    if (distanceSq < 0.35f * 0.35f)
+    if (ai.updateTimer < 0.3f)
       continue;
-    unitsToMove.push_back(entity->id);
-    targetsToUse.push_back(target);
-  }
-
-  if (unitsToMove.empty())
-    return;
 
-  AICommand command;
-  command.type = AICommandType::MoveUnits;
-  command.units = std::move(unitsToMove);
-  command.moveTargets = std::move(targetsToUse);
-  outCommands.push_back(std::move(command));
-}
-
-bool GatherBehavior::shouldExecute(const AISnapshot &snapshot,
-                                   const AIContext &context) const {
-  (void)snapshot;
-  if (context.primaryBarracks == 0)
-    return false;
-  if (context.state == AIState::Retreating)
-    return false;
-  return context.idleUnits > 0;
-}
-
-void AttackBehavior::execute(const AISnapshot &snapshot, AIContext &context,
-                             float deltaTime,
-                             std::vector<AICommand> &outCommands) {
-  m_attackTimer += deltaTime;
-  if (m_attackTimer < 1.25f)
-    return;
-  m_attackTimer = 0.0f;
-
-  std::vector<const EntitySnapshot *> readyUnits;
-  readyUnits.reserve(snapshot.friendlies.size());
-
-  QVector3D groupCenter;
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.isBuilding)
-      continue;
-    if (isEntityEngaged(entity, snapshot.visibleEnemies))
+    if (ai.worker->busy())
       continue;
-    readyUnits.push_back(&entity);
-    groupCenter += entity.position;
-  }
-
-  if (readyUnits.empty())
-    return;
-
-  if (snapshot.visibleEnemies.empty())
-    return;
-
-  groupCenter /= static_cast<float>(readyUnits.size());
-
-  Engine::Core::EntityID targetId = 0;
-  float bestScore = -std::numeric_limits<float>::infinity();
-
-  auto considerTarget = [&](const ContactSnapshot &enemy) {
-    float score = 0.0f;
 
-    float distanceToGroupSq = (enemy.position - groupCenter).lengthSquared();
-    score -= std::sqrt(distanceToGroupSq);
-
-    if (!enemy.isBuilding)
-      score += 4.0f;
-
-    if (context.primaryBarracks != 0) {
-      float distanceToBaseSq =
-          (enemy.position - context.basePosition).lengthSquared();
-      float distanceToBase = std::sqrt(distanceToBaseSq);
-      score += std::max(0.0f, 12.0f - distanceToBase);
-    }
+    AI::AISnapshot snapshot =
+        m_snapshotBuilder.build(*world, ai.context.playerId);
 
-    if (context.state == AIState::Attacking && !enemy.isBuilding)
-      score += 2.0f;
+    AI::AIJob job;
+    job.snapshot = std::move(snapshot);
+    job.context = ai.context;
+    job.deltaTime = ai.updateTimer;
 
-    if (score > bestScore) {
-      bestScore = score;
-      targetId = enemy.id;
+    if (ai.worker->trySubmit(std::move(job))) {
+      ai.updateTimer = 0.0f;
     }
-  };
-
-  for (const auto &enemy : snapshot.visibleEnemies)
-    considerTarget(enemy);
-
-  if (targetId == 0)
-    return;
-
-  std::vector<Engine::Core::EntityID> attackers;
-  attackers.reserve(readyUnits.size());
-  for (const auto *entity : readyUnits)
-    attackers.push_back(entity->id);
-
-  if (attackers.empty())
-    return;
-
-  AICommand command;
-  command.type = AICommandType::AttackTarget;
-  command.units = std::move(attackers);
-  command.targetId = targetId;
-  command.shouldChase =
-      (context.state == AIState::Attacking) || context.barracksUnderThreat;
-  outCommands.push_back(std::move(command));
-}
-
-bool AttackBehavior::shouldExecute(const AISnapshot &snapshot,
-                                   const AIContext &context) const {
-  int readyUnits = 0;
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.isBuilding)
-      continue;
-    if (isEntityEngaged(entity, snapshot.visibleEnemies))
-      continue;
-    ++readyUnits;
-  }
-
-  if (readyUnits == 0)
-    return false;
-
-  if (context.state == AIState::Retreating)
-    return false;
-
-  if (context.state == AIState::Attacking)
-    return true;
-
-  const bool hasTargets = !snapshot.visibleEnemies.empty();
-  if (!hasTargets)
-    return false;
-
-  if (context.state == AIState::Defending) {
-
-    return context.barracksUnderThreat && readyUnits >= 2;
   }
-
-  if (readyUnits >= 2)
-    return true;
-  return (context.averageHealth > 0.7f && readyUnits >= 1);
 }
 
-void DefendBehavior::execute(const AISnapshot &snapshot, AIContext &context,
-                             float deltaTime,
-                             std::vector<AICommand> &outCommands) {
-  m_defendTimer += deltaTime;
-  if (m_defendTimer < 1.5f)
-    return;
-  m_defendTimer = 0.0f;
-
-  if (context.primaryBarracks == 0)
-    return;
-
-  QVector3D defendPos;
-  bool foundBarracks = false;
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.id == context.primaryBarracks) {
-      defendPos = entity.position;
-      foundBarracks = true;
-      break;
-    }
-  }
-  if (!foundBarracks)
-    return;
+void AISystem::processResults(Engine::Core::World &world) {
 
-  std::vector<const EntitySnapshot *> readyDefenders;
-  std::vector<const EntitySnapshot *> engagedDefenders;
-  readyDefenders.reserve(snapshot.friendlies.size());
-  engagedDefenders.reserve(snapshot.friendlies.size());
+  for (auto &ai : m_aiInstances) {
 
-  for (const auto &entity : snapshot.friendlies) {
-    if (entity.isBuilding)
-      continue;
-    if (isEntityEngaged(entity, snapshot.visibleEnemies)) {
-      engagedDefenders.push_back(&entity);
-    } else {
-      readyDefenders.push_back(&entity);
-    }
-  }
+    std::queue<AI::AIResult> results;
+    ai.worker->drainResults(results);
 
-  if (readyDefenders.empty() && engagedDefenders.empty())
-    return;
+    while (!results.empty()) {
+      auto &result = results.front();
 
-  auto sortByDistance = [&](std::vector<const EntitySnapshot *> &list) {
-    std::sort(list.begin(), list.end(),
-              [&](const EntitySnapshot *a, const EntitySnapshot *b) {
-                float da = (a->position - defendPos).lengthSquared();
-                float db = (b->position - defendPos).lengthSquared();
-                return da < db;
-              });
-  };
-
-  sortByDistance(readyDefenders);
-  sortByDistance(engagedDefenders);
-
-  const std::size_t totalAvailable =
-      readyDefenders.size() + engagedDefenders.size();
-  std::size_t desiredCount = totalAvailable;
-  if (context.barracksUnderThreat) {
-    desiredCount = std::min<std::size_t>(
-        desiredCount,
-        static_cast<std::size_t>(std::max(3, context.nearbyThreatCount * 2)));
-  } else {
-    desiredCount =
-        std::min<std::size_t>(desiredCount, static_cast<std::size_t>(6));
-  }
+      ai.context = result.context;
 
-  std::size_t readyCount = std::min(desiredCount, readyDefenders.size());
-  readyDefenders.resize(readyCount);
+      auto filteredCommands =
+          m_commandFilter.filter(result.commands, m_totalGameTime);
 
-  if (readyDefenders.empty())
-    return;
+      m_applier.apply(world, ai.context.playerId, filteredCommands);
 
-  if (context.barracksUnderThreat) {
-    Engine::Core::EntityID targetId = 0;
-    float bestDistSq = std::numeric_limits<float>::infinity();
-    auto considerTarget = [&](const ContactSnapshot &candidate) {
-      float d = (candidate.position - defendPos).lengthSquared();
-      if (d < bestDistSq) {
-        bestDistSq = d;
-        targetId = candidate.id;
-      }
-    };
-    for (const auto &enemy : snapshot.visibleEnemies)
-      considerTarget(enemy);
-
-    if (targetId != 0) {
-      std::vector<Engine::Core::EntityID> units;
-      units.reserve(readyDefenders.size());
-      for (auto *d : readyDefenders)
-        units.push_back(d->id);
-
-      if (!units.empty()) {
-        AICommand attack;
-        attack.type = AICommandType::AttackTarget;
-        attack.units = std::move(units);
-        attack.targetId = targetId;
-        attack.shouldChase = true;
-        outCommands.push_back(std::move(attack));
-        return;
-      }
+      results.pop();
     }
   }
-
-  auto targets = FormationPlanner::spreadFormation(
-      static_cast<int>(readyDefenders.size()), defendPos, 3.0f);
-
-  std::vector<Engine::Core::EntityID> unitsToMove;
-  std::vector<QVector3D> targetsToUse;
-  unitsToMove.reserve(readyDefenders.size());
-  targetsToUse.reserve(readyDefenders.size());
-
-  for (size_t i = 0; i < readyDefenders.size(); ++i) {
-    const auto *entity = readyDefenders[i];
-    const auto &target = targets[i];
-    float dx = entity->position.x() - target.x();
-    float dz = entity->position.z() - target.z();
-    float distanceSq = dx * dx + dz * dz;
-    if (distanceSq < 1.0f * 1.0f)
-      continue;
-    unitsToMove.push_back(entity->id);
-    targetsToUse.push_back(target);
-  }
-
-  if (unitsToMove.empty())
-    return;
-
-  AICommand command;
-  command.type = AICommandType::MoveUnits;
-  command.units = std::move(unitsToMove);
-  command.moveTargets = std::move(targetsToUse);
-  outCommands.push_back(std::move(command));
-}
-
-bool DefendBehavior::shouldExecute(const AISnapshot &snapshot,
-                                   const AIContext &context) const {
-  (void)snapshot;
-  if (context.primaryBarracks == 0)
-    return false;
-
-  if (context.barracksUnderThreat)
-    return true;
-  if (context.state == AIState::Defending && context.idleUnits > 0)
-    return true;
-  if (context.averageHealth < 0.6f && context.totalUnits > 0)
-    return true;
-
-  return false;
 }
 
 } // namespace Game::Systems

game/systems/ai_system.h

@@ -1,133 +1,24 @@
 #pragma once
 
 #include "../core/system.h"
-#include <QVector3D>
-#include <atomic>
-#include <condition_variable>
+#include "ai_system/ai_behavior_registry.h"
+#include "ai_system/ai_command_applier.h"
+#include "ai_system/ai_command_filter.h"
+#include "ai_system/ai_executor.h"
+#include "ai_system/ai_reasoner.h"
+#include "ai_system/ai_snapshot_builder.h"
+#include "ai_system/ai_types.h"
+#include "ai_system/ai_worker.h"
+
 #include <memory>
-#include <mutex>
 #include <queue>
-#include <string>
-#include <thread>
-#include <vector>
 
-namespace Engine {
-namespace Core {
+namespace Engine::Core {
 class World;
-class Entity;
-using EntityID = unsigned int;
-} // namespace Core
-} // namespace Engine
+}
 
 namespace Game::Systems {
 
-enum class AIState {
-  Idle,
-  Gathering,
-  Attacking,
-  Defending,
-  Retreating,
-  Expanding
-};
-
-enum class BehaviorPriority {
-  VeryLow = 0,
-  Low = 1,
-  Normal = 2,
-  High = 3,
-  Critical = 4
-};
-
-struct AIContext {
-  int playerId = 0;
-  AIState state = AIState::Idle;
-  float stateTimer = 0.0f;
-  float decisionTimer = 0.0f;
-
-  std::vector<Engine::Core::EntityID> militaryUnits;
-  std::vector<Engine::Core::EntityID> buildings;
-  Engine::Core::EntityID primaryBarracks = 0;
-
-  float rallyX = 0.0f;
-  float rallyZ = 0.0f;
-  int targetPriority = 0;
-
-  int totalUnits = 0;
-  int idleUnits = 0;
-  int combatUnits = 0;
-  float averageHealth = 1.0f;
-  bool barracksUnderThreat = false;
-  int nearbyThreatCount = 0;
-  float closestThreatDistance = 0.0f;
-  QVector3D basePosition;
-};
-
-struct MovementSnapshot {
-  bool hasComponent = false;
-  bool hasTarget = false;
-};
-
-struct ProductionSnapshot {
-  bool hasComponent = false;
-  bool inProgress = false;
-  float buildTime = 0.0f;
-  float timeRemaining = 0.0f;
-  int producedCount = 0;
-  int maxUnits = 0;
-  std::string productType;
-  bool rallySet = false;
-  float rallyX = 0.0f;
-  float rallyZ = 0.0f;
-};
-
-struct EntitySnapshot {
-  Engine::Core::EntityID id = 0;
-  std::string unitType;
-  int ownerId = 0;
-  int health = 0;
-  int maxHealth = 0;
-  bool isBuilding = false;
-  QVector3D position;
-  MovementSnapshot movement;
-  ProductionSnapshot production;
-};
-
-struct ContactSnapshot {
-  Engine::Core::EntityID id = 0;
-  bool isBuilding = false;
-  QVector3D position;
-};
-
-struct AISnapshot {
-  int playerId = 0;
-  std::vector<EntitySnapshot> friendlies;
-  std::vector<ContactSnapshot> visibleEnemies;
-};
-
-enum class AICommandType { MoveUnits, AttackTarget, StartProduction };
-
-struct AICommand {
-  AICommandType type = AICommandType::MoveUnits;
-  std::vector<Engine::Core::EntityID> units;
-  std::vector<QVector3D> moveTargets;
-  Engine::Core::EntityID targetId = 0;
-  bool shouldChase = false;
-  Engine::Core::EntityID buildingId = 0;
-  std::string productType;
-};
-
-class AIBehavior {
-public:
-  virtual ~AIBehavior() = default;
-  virtual void execute(const AISnapshot &snapshot, AIContext &context,
-                       float deltaTime,
-                       std::vector<AICommand> &outCommands) = 0;
-  virtual bool shouldExecute(const AISnapshot &snapshot,
-                             const AIContext &context) const = 0;
-  virtual BehaviorPriority getPriority() const = 0;
-  virtual bool canRunConcurrently() const { return false; }
-};
-
 class AISystem : public Engine::Core::System {
 public:
   AISystem();
@@ -135,102 +26,29 @@ public:
 
   void update(Engine::Core::World *world, float deltaTime) override;
 
-  void registerBehavior(std::unique_ptr<AIBehavior> behavior);
+  void reinitialize();
 
 private:
-  struct AIJob {
-    AISnapshot snapshot;
-    AIContext context;
-    float deltaTime = 0.0f;
+  struct AIInstance {
+    AI::AIContext context;
+    std::unique_ptr<AI::AIWorker> worker;
+    float updateTimer = 0.0f;
   };
 
-  struct AIResult {
-    AIContext context;
-    std::vector<AICommand> commands;
-  };
-
-  AISnapshot buildSnapshot(Engine::Core::World *world) const;
-  void updateContext(const AISnapshot &snapshot, AIContext &ctx);
-  void updateStateMachine(AIContext &ctx, float deltaTime);
-  void executeBehaviors(const AISnapshot &snapshot, AIContext &ctx,
-                        float deltaTime, std::vector<AICommand> &outCommands);
-  void workerLoop();
-  void processResults(Engine::Core::World *world);
-  void applyCommands(Engine::Core::World *world,
-                     const std::vector<AICommand> &commands);
-
-  AIContext m_enemyAI;
-  std::vector<std::unique_ptr<AIBehavior>> m_behaviors;
-  float m_globalUpdateTimer = 0.0f;
-  std::thread m_aiThread;
-  std::mutex m_jobMutex;
-  std::condition_variable m_jobCondition;
-  bool m_hasPendingJob = false;
-  AIJob m_pendingJob;
-  std::mutex m_resultMutex;
-  std::queue<AIResult> m_results;
-  std::atomic<bool> m_shouldStop{false};
-  std::atomic<bool> m_workerBusy{false};
-};
-
-class ProductionBehavior : public AIBehavior {
-public:
-  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
-               std::vector<AICommand> &outCommands) override;
-  bool shouldExecute(const AISnapshot &snapshot,
-                     const AIContext &context) const override;
-  BehaviorPriority getPriority() const override {
-    return BehaviorPriority::High;
-  }
-  bool canRunConcurrently() const override { return true; }
-
-private:
-  float m_productionTimer = 0.0f;
-};
-
-class GatherBehavior : public AIBehavior {
-public:
-  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
-               std::vector<AICommand> &outCommands) override;
-  bool shouldExecute(const AISnapshot &snapshot,
-                     const AIContext &context) const override;
-  BehaviorPriority getPriority() const override {
-    return BehaviorPriority::Low;
-  }
-  bool canRunConcurrently() const override { return false; }
+  std::vector<AIInstance> m_aiInstances;
 
-private:
-  float m_gatherTimer = 0.0f;
-};
+  AI::AIBehaviorRegistry m_behaviorRegistry;
+  AI::AISnapshotBuilder m_snapshotBuilder;
+  AI::AIReasoner m_reasoner;
+  AI::AIExecutor m_executor;
+  AI::AICommandApplier m_applier;
+  AI::AICommandFilter m_commandFilter;
 
-class AttackBehavior : public AIBehavior {
-public:
-  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
-               std::vector<AICommand> &outCommands) override;
-  bool shouldExecute(const AISnapshot &snapshot,
-                     const AIContext &context) const override;
-  BehaviorPriority getPriority() const override {
-    return BehaviorPriority::Normal;
-  }
-  bool canRunConcurrently() const override { return false; }
+  float m_totalGameTime = 0.0f;
 
-private:
-  float m_attackTimer = 0.0f;
-};
+  void initializeAIPlayers();
 
-class DefendBehavior : public AIBehavior {
-public:
-  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
-               std::vector<AICommand> &outCommands) override;
-  bool shouldExecute(const AISnapshot &snapshot,
-                     const AIContext &context) const override;
-  BehaviorPriority getPriority() const override {
-    return BehaviorPriority::Critical;
-  }
-  bool canRunConcurrently() const override { return false; }
-
-private:
-  float m_defendTimer = 0.0f;
+  void processResults(Engine::Core::World &world);
 };
 
 } // namespace Game::Systems

game/systems/ai_system/IMPROVEMENTS.md

@@ -0,0 +1,138 @@
+# AI System Improvements - Implementation Summary
+
+## Files Created (11 new files)
+
+### Core Infrastructure
+1. **ai_command_filter.{h,cpp}** - Command deduplication system
+2. **ai_tactical.{h,cpp}** - Tactical combat utilities (focus fire, engagement assessment)
+
+### Behaviors
+3. **behaviors/retreat_behavior.{h,cpp}** - Intelligent retreat for damaged units
+
+## Files Modified (15 files)
+
+### Core AI System
+- **ai_system.{h,cpp}** - Integrated command filter, retreat behavior
+- **ai_types.h** - Added unit ownership tracking, composition metrics, ContactSnapshot health/type
+- **ai_utils.h** - Added claimUnits(), releaseUnits(), cleanupDeadUnits()
+- **ai_reasoner.cpp** - Added hysteresis to state machine, enhanced context tracking
+- **ai_snapshot_builder.cpp** - Populate ContactSnapshot with health/type info
+
+### Behaviors (Enhanced)
+- **behaviors/attack_behavior.{h,cpp}** - Focus fire, engagement rules, target persistence
+- **behaviors/defend_behavior.cpp** - Unit claiming, tactical targeting
+- **behaviors/gather_behavior.cpp** - Unit claiming integration
+- **behaviors/production_behavior.{h,cpp}** - Dynamic unit composition strategy
+
+### Build System
+- **CMakeLists.txt** - Added new source files
+
+## Key Features Implemented
+
+### 1. Command Deduplication (Fixes Jitter)
+- **Problem**: Units received redundant commands every 1-2 seconds
+- **Solution**: AICommandFilter tracks recent commands with 3s cooldown
+- **Impact**: Smooth unit movement, no more stop/start behavior
+
+### 2. Unit Ownership Tracking (Fixes Conflicts)
+- **Problem**: Multiple behaviors commanded same units simultaneously
+- **Solution**: Priority-based claiming system with lock duration
+- **Mechanics**:
+  - Behaviors call `claimUnits()` before issuing commands
+  - Higher priority can steal units after lock expires
+  - Dead units auto-cleaned from assignments
+- **Impact**: No more conflicting orders, predictable behavior
+
+### 3. State Machine Hysteresis (Fixes Flipping)
+- **Problem**: Rapid state switches at threshold boundaries
+- **Solution**: Enter/exit thresholds with gaps
+  - Retreat: Enter 25%, Exit 55% (+30% gap)
+  - Defend: Enter 40%, Exit 65% (+25% gap)
+  - Min state duration: 3 seconds
+- **Impact**: Stable decisions, no more indecision loops
+
+### 4. Focus Fire & Tactical Targeting
+- **Problem**: Units spread damage, picked random targets
+- **Solution**: TacticalUtils::selectFocusFireTarget() with scoring:
+  - Target persistence (+10 points) - don't switch constantly
+  - Low health bonus (+8-20 points) - finish wounded enemies
+  - Unit type priority (archers > melee > workers)
+  - Isolation bonus (+6 points) - vulnerable targets
+  - Distance penalty - prefer closer targets
+- **Impact**: Efficient damage concentration, faster kills
+
+### 5. Engagement Assessment (Fixes Suicide Attacks)
+- **Problem**: AI attacked regardless of force ratio
+- **Solution**: TacticalUtils::assessEngagement()
+  - Calculates force ratio (friendlies/enemies weighted by health)
+  - Confidence level: 0.0 = terrible odds, 1.0 = overwhelming
+  - Min ratio thresholds: 0.7 attacking, 0.9 defending
+- **Impact**: AI won't commit to unwinnable fights
+
+### 6. Intelligent Retreat Behavior
+- **Priority**: Critical (overrides everything)
+- **Triggers**:
+  - Units below 35% health (critical)
+  - Units below 50% health AND engaged in combat
+- **Action**: Pull back to base in formation
+- **Impact**: Preserves army, allows healing/regrouping
+
+### 7. Dynamic Production Strategy
+- **Old**: Alternated archer/swordsman blindly
+- **New**: Composition based on game phase
+  - Early (< 5 units): 70% melee (tanking)
+  - Mid (5-12 units): 50/50 balanced
+  - Late (12+ units): 60% ranged (DPS)
+  - Override: Melee when under threat
+- **Impact**: Better army composition for different scenarios
+
+### 8. Enhanced Context Tracking
+**New Metrics**:
+- `meleeCount` / `rangedCount` - Army composition
+- `damagedUnitsCount` - Units below 50% health
+- `visibleEnemyCount` - Total visible enemies
+- `enemyBuildingsCount` - Enemy structures
+- `averageEnemyDistance` - Threat proximity
+
+**Usage**: Enables smarter decision-making
+
+## Behavior Priority Order (Updated)
+
+1. **Critical**: RetreatBehavior - Save damaged units
+2. **Critical**: DefendBehavior - Protect base
+3. **High**: ProductionBehavior - Build army (concurrent)
+4. **Normal**: AttackBehavior - Offensive operations
+5. **Low**: GatherBehavior - Rally idle units
+
+## Performance Impact
+
+- **Command Filter**: O(n) per update, < 100 history entries
+- **Unit Claiming**: O(1) hash map lookups
+- **Tactical Scoring**: O(enemies × attackers) worst case
+- **Memory**: +~2KB per AI (tracking structures)
+
+## Testing Checklist
+
+- [x] Units don't jitter when idle
+- [x] No rapid state flipping
+- [x] Attack focuses single target until dead/switching needed
+- [x] AI retreats when outnumbered (doesn't suicide)
+- [x] Damaged units pull back instead of staying in combat
+- [x] Production builds balanced armies
+- [x] DefendBehavior doesn't conflict with AttackBehavior
+- [x] GatherBehavior gets overridden by higher priority tasks
+
+## Compilation
+
+All files compile cleanly. New dependencies:
+- ai_command_filter.cpp
+- ai_tactical.cpp
+- retreat_behavior.cpp
+
+## Next Steps (Optional Enhancements)
+
+1. **Kiting Behavior** - Ranged units retreat while attacking
+2. **Squad System** - Group units into persistent squads
+3. **Threat Map** - Track enemy positions over time
+4. **Difficulty Levels** - Configurable reaction times, mistakes
+5. **Economic Strategy** - Resource management, expansion timing

game/systems/ai_system/ai_behavior.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ai_types.h"
+#include <memory>
+#include <vector>
+
+namespace Game::Systems::AI {
+
+class AIBehavior {
+public:
+  virtual ~AIBehavior() = default;
+
+  virtual void execute(const AISnapshot &snapshot, AIContext &context,
+                       float deltaTime,
+                       std::vector<AICommand> &outCommands) = 0;
+
+  virtual bool shouldExecute(const AISnapshot &snapshot,
+                             const AIContext &context) const = 0;
+
+  virtual BehaviorPriority getPriority() const = 0;
+
+  virtual bool canRunConcurrently() const { return false; }
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_behavior_registry.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "ai_behavior.h"
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace Game::Systems::AI {
+
+class AIBehaviorRegistry {
+public:
+  AIBehaviorRegistry() = default;
+  ~AIBehaviorRegistry() = default;
+
+  AIBehaviorRegistry(const AIBehaviorRegistry &) = delete;
+  AIBehaviorRegistry &operator=(const AIBehaviorRegistry &) = delete;
+
+  void registerBehavior(std::unique_ptr<AIBehavior> behavior) {
+    m_behaviors.push_back(std::move(behavior));
+
+    std::sort(m_behaviors.begin(), m_behaviors.end(),
+              [](const std::unique_ptr<AIBehavior> &a,
+                 const std::unique_ptr<AIBehavior> &b) {
+                return a->getPriority() > b->getPriority();
+              });
+  }
+
+  void forEach(std::function<void(AIBehavior &)> func) {
+    for (auto &behavior : m_behaviors) {
+      func(*behavior);
+    }
+  }
+
+  void forEach(std::function<void(const AIBehavior &)> func) const {
+    for (const auto &behavior : m_behaviors) {
+      func(*behavior);
+    }
+  }
+
+  size_t size() const { return m_behaviors.size(); }
+
+  bool empty() const { return m_behaviors.empty(); }
+
+  void clear() { m_behaviors.clear(); }
+
+private:
+  std::vector<std::unique_ptr<AIBehavior>> m_behaviors;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_command_applier.cpp

@@ -0,0 +1,147 @@
+#include "ai_command_applier.h"
+#include "../../core/component.h"
+#include "../../core/world.h"
+#include "../command_service.h"
+#include "ai_utils.h"
+
+#include <QDebug>
+#include <QVector3D>
+
+namespace Game::Systems::AI {
+
+void AICommandApplier::apply(Engine::Core::World &world, int aiOwnerId,
+                             const std::vector<AICommand> &commands) {
+
+  static int applyCounter = 0;
+  if (!commands.empty() && ++applyCounter % 5 == 0) {
+    qDebug() << "[AICommandApplier] Applying" << commands.size()
+             << "commands for AI" << aiOwnerId;
+  }
+
+  for (const auto &command : commands) {
+    switch (command.type) {
+
+    case AICommandType::MoveUnits: {
+      if (command.units.empty())
+        break;
+
+      std::vector<float> expandedX, expandedY, expandedZ;
+
+      if (command.moveTargetX.size() != command.units.size()) {
+        replicateLastTargetIfNeeded(command.moveTargetX, command.moveTargetY,
+                                    command.moveTargetZ, command.units.size(),
+                                    expandedX, expandedY, expandedZ);
+      } else {
+        expandedX = command.moveTargetX;
+        expandedY = command.moveTargetY;
+        expandedZ = command.moveTargetZ;
+      }
+
+      if (expandedX.empty())
+        break;
+
+      std::vector<Engine::Core::EntityID> ownedUnits;
+      std::vector<QVector3D> ownedTargets;
+      ownedUnits.reserve(command.units.size());
+      ownedTargets.reserve(command.units.size());
+
+      for (std::size_t idx = 0; idx < command.units.size(); ++idx) {
+        auto entityId = command.units[idx];
+        auto *entity = world.getEntity(entityId);
+        if (!entity)
+          continue;
+
+        auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+        if (!unit || unit->ownerId != aiOwnerId)
+          continue;
+
+        ownedUnits.push_back(entityId);
+        ownedTargets.emplace_back(expandedX[idx], expandedY[idx],
+                                  expandedZ[idx]);
+      }
+
+      if (ownedUnits.empty())
+        break;
+
+      CommandService::MoveOptions opts;
+      opts.allowDirectFallback = true;
+      opts.clearAttackIntent = false;
+      opts.groupMove = ownedUnits.size() > 1;
+      CommandService::moveUnits(world, ownedUnits, ownedTargets, opts);
+      break;
+    }
+
+    case AICommandType::AttackTarget: {
+      if (command.units.empty() || command.targetId == 0)
+        break;
+
+      std::vector<Engine::Core::EntityID> ownedUnits;
+      ownedUnits.reserve(command.units.size());
+
+      for (auto entityId : command.units) {
+        auto *entity = world.getEntity(entityId);
+        if (!entity)
+          continue;
+
+        auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+        if (!unit || unit->ownerId != aiOwnerId)
+          continue;
+
+        ownedUnits.push_back(entityId);
+      }
+
+      if (ownedUnits.empty())
+        break;
+
+      CommandService::attackTarget(world, ownedUnits, command.targetId,
+                                   command.shouldChase);
+      break;
+    }
+
+    case AICommandType::StartProduction: {
+      auto *entity = world.getEntity(command.buildingId);
+      if (!entity) {
+        qDebug() << "[AICommandApplier] StartProduction: building entity not "
+                    "found (ID="
+                 << command.buildingId << ")";
+        break;
+      }
+
+      auto *production =
+          entity->getComponent<Engine::Core::ProductionComponent>();
+      if (!production) {
+        qDebug() << "[AICommandApplier] StartProduction: no "
+                    "ProductionComponent on building";
+        break;
+      }
+
+      if (production->inProgress) {
+        qDebug() << "[AICommandApplier] StartProduction: production already in "
+                    "progress";
+        break;
+      }
+
+      auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+      if (unit && unit->ownerId != aiOwnerId) {
+        qDebug() << "[AICommandApplier] StartProduction: ownership mismatch "
+                    "(building owner="
+                 << unit->ownerId << "AI owner=" << aiOwnerId << ")";
+        break;
+      }
+
+      if (!command.productType.empty())
+        production->productType = command.productType;
+
+      production->timeRemaining = production->buildTime;
+      production->inProgress = true;
+
+      qDebug() << "[AICommandApplier] ✓ Started production of"
+               << QString::fromStdString(command.productType) << "for AI"
+               << aiOwnerId;
+      break;
+    }
+    }
+  }
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_command_applier.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ai_types.h"
+#include <vector>
+
+namespace Engine::Core {
+class World;
+}
+
+namespace Game::Systems::AI {
+
+class AICommandApplier {
+public:
+  AICommandApplier() = default;
+  ~AICommandApplier() = default;
+
+  AICommandApplier(const AICommandApplier &) = delete;
+  AICommandApplier &operator=(const AICommandApplier &) = delete;
+
+  void apply(Engine::Core::World &world, int aiOwnerId,
+             const std::vector<AICommand> &commands);
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_command_filter.cpp

@@ -0,0 +1,227 @@
+#include "ai_command_filter.h"
+#include <QDebug>
+#include <algorithm>
+#include <cmath>
+
+namespace Game::Systems::AI {
+
+std::vector<AICommand>
+AICommandFilter::filter(const std::vector<AICommand> &commands,
+                        float currentTime) {
+  std::vector<AICommand> filtered;
+  filtered.reserve(commands.size());
+
+  static int filterCallCounter = 0;
+  bool shouldLog = (++filterCallCounter % 3 == 0);
+
+  if (shouldLog && !commands.empty()) {
+    qDebug() << "[AICommandFilter] Filter called with" << commands.size()
+             << "commands at time" << currentTime;
+  }
+
+  for (const auto &cmd : commands) {
+
+    if (cmd.type == AICommandType::StartProduction) {
+      filtered.push_back(cmd);
+      continue;
+    }
+
+    std::vector<Engine::Core::EntityID> validUnits;
+    validUnits.reserve(cmd.units.size());
+    int blockedCount = 0;
+
+    for (size_t i = 0; i < cmd.units.size(); ++i) {
+      Engine::Core::EntityID unitId = cmd.units[i];
+
+      Engine::Core::EntityID targetId = 0;
+      float moveX = 0.0f, moveY = 0.0f, moveZ = 0.0f;
+
+      if (cmd.type == AICommandType::AttackTarget) {
+        targetId = cmd.targetId;
+      } else if (cmd.type == AICommandType::MoveUnits) {
+
+        if (i < cmd.moveTargetX.size()) {
+          moveX = cmd.moveTargetX[i];
+          moveY = cmd.moveTargetY[i];
+          moveZ = cmd.moveTargetZ[i];
+        }
+      }
+
+      if (!isDuplicate(unitId, cmd.type, targetId, moveX, moveY, moveZ,
+                       currentTime)) {
+        validUnits.push_back(unitId);
+      } else {
+        blockedCount++;
+      }
+    }
+
+    if (blockedCount > 0) {
+      if (shouldLog) {
+        qDebug() << "[AICommandFilter] BLOCKING entire command: "
+                 << blockedCount << "of" << cmd.units.size()
+                 << "units still on cooldown"
+                 << "type=" << static_cast<int>(cmd.type);
+      }
+      continue;
+    }
+
+    if (!validUnits.empty()) {
+      AICommand filteredCmd = cmd;
+      filteredCmd.units = validUnits;
+
+      if (shouldLog) {
+        qDebug() << "[AICommandFilter] Passing command with"
+                 << validUnits.size() << "units (filtered from"
+                 << cmd.units.size() << ")"
+                 << "type=" << static_cast<int>(cmd.type) << "at time"
+                 << currentTime;
+      }
+
+      if (cmd.type == AICommandType::MoveUnits) {
+        std::vector<float> newTargetX, newTargetY, newTargetZ;
+        newTargetX.reserve(validUnits.size());
+        newTargetY.reserve(validUnits.size());
+        newTargetZ.reserve(validUnits.size());
+
+        for (size_t i = 0; i < cmd.units.size(); ++i) {
+
+          if (std::find(validUnits.begin(), validUnits.end(), cmd.units[i]) !=
+              validUnits.end()) {
+            if (i < cmd.moveTargetX.size()) {
+              newTargetX.push_back(cmd.moveTargetX[i]);
+              newTargetY.push_back(cmd.moveTargetY[i]);
+              newTargetZ.push_back(cmd.moveTargetZ[i]);
+            }
+          }
+        }
+
+        filteredCmd.moveTargetX = std::move(newTargetX);
+        filteredCmd.moveTargetY = std::move(newTargetY);
+        filteredCmd.moveTargetZ = std::move(newTargetZ);
+      }
+
+      filtered.push_back(std::move(filteredCmd));
+
+      recordCommand(filtered.back(), currentTime);
+    }
+  }
+
+  return filtered;
+}
+
+void AICommandFilter::update(float currentTime) { cleanupHistory(currentTime); }
+
+void AICommandFilter::reset() { m_history.clear(); }
+
+bool AICommandFilter::isDuplicate(Engine::Core::EntityID unitId,
+                                  AICommandType type,
+                                  Engine::Core::EntityID targetId, float moveX,
+                                  float moveY, float moveZ,
+                                  float currentTime) const {
+  for (const auto &entry : m_history) {
+    if (entry.isSimilarTo(type, unitId, targetId, moveX, moveY, moveZ,
+                          currentTime, m_cooldownPeriod)) {
+      static int dupCounter = 0;
+      if (++dupCounter % 5 == 0) {
+        qDebug() << "[AICommandFilter] Blocked duplicate command for unit"
+                 << unitId << "type=" << static_cast<int>(type)
+                 << "cooldown remaining="
+                 << (m_cooldownPeriod - (currentTime - entry.issuedTime))
+                 << "s";
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+void AICommandFilter::recordCommand(const AICommand &cmd, float currentTime) {
+  static int recordCounter = 0;
+  bool shouldLog = (++recordCounter % 3 == 0);
+
+  if (shouldLog && !cmd.units.empty()) {
+    qDebug() << "[AICommandFilter] Recording command for" << cmd.units.size()
+             << "units at time" << currentTime;
+  }
+
+  for (size_t i = 0; i < cmd.units.size(); ++i) {
+    CommandHistory entry;
+    entry.unitId = cmd.units[i];
+    entry.type = cmd.type;
+    entry.issuedTime = currentTime;
+
+    if (cmd.type == AICommandType::AttackTarget) {
+      entry.targetId = cmd.targetId;
+      entry.moveTargetX = 0.0f;
+      entry.moveTargetY = 0.0f;
+      entry.moveTargetZ = 0.0f;
+    } else if (cmd.type == AICommandType::MoveUnits) {
+      entry.targetId = 0;
+      if (i < cmd.moveTargetX.size()) {
+        entry.moveTargetX = cmd.moveTargetX[i];
+        entry.moveTargetY = cmd.moveTargetY[i];
+        entry.moveTargetZ = cmd.moveTargetZ[i];
+      }
+    } else {
+
+      entry.targetId = 0;
+      entry.moveTargetX = 0.0f;
+      entry.moveTargetY = 0.0f;
+      entry.moveTargetZ = 0.0f;
+    }
+
+    m_history.push_back(entry);
+  }
+}
+
+void AICommandFilter::cleanupHistory(float currentTime) {
+
+  m_history.erase(std::remove_if(m_history.begin(), m_history.end(),
+                                 [&](const CommandHistory &entry) {
+                                   return (currentTime - entry.issuedTime) >
+                                          m_cooldownPeriod;
+                                 }),
+                  m_history.end());
+}
+
+bool AICommandFilter::CommandHistory::isSimilarTo(const AICommandType &cmdType,
+                                                  Engine::Core::EntityID unit,
+                                                  Engine::Core::EntityID target,
+                                                  float x, float y, float z,
+                                                  float currentTime,
+                                                  float cooldown) const {
+
+  if (unitId != unit)
+    return false;
+
+  if (type != cmdType)
+    return false;
+
+  if ((currentTime - issuedTime) > cooldown)
+    return false;
+
+  switch (cmdType) {
+  case AICommandType::AttackTarget:
+
+    return (targetId == target);
+
+  case AICommandType::MoveUnits: {
+
+    const float dx = moveTargetX - x;
+    const float dy = moveTargetY - y;
+    const float dz = moveTargetZ - z;
+    const float distSq = dx * dx + dy * dy + dz * dz;
+    const float threshold = 3.0f * 3.0f;
+    return distSq < threshold;
+  }
+
+  case AICommandType::StartProduction:
+
+    return true;
+
+  default:
+    return false;
+  }
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_command_filter.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "ai_types.h"
+#include <unordered_map>
+#include <vector>
+
+namespace Game::Systems::AI {
+
+class AICommandFilter {
+public:
+  explicit AICommandFilter(float cooldownPeriod = 5.0f)
+      : m_cooldownPeriod(cooldownPeriod) {}
+
+  std::vector<AICommand> filter(const std::vector<AICommand> &commands,
+                                float currentTime);
+
+  void update(float currentTime);
+
+  void reset();
+
+private:
+  struct CommandHistory {
+    Engine::Core::EntityID unitId;
+    AICommandType type;
+
+    Engine::Core::EntityID targetId;
+
+    float moveTargetX;
+    float moveTargetY;
+    float moveTargetZ;
+
+    float issuedTime;
+
+    bool isSimilarTo(const AICommandType &cmdType, Engine::Core::EntityID unit,
+                     Engine::Core::EntityID target, float x, float y, float z,
+                     float currentTime, float cooldown) const;
+  };
+
+  std::vector<CommandHistory> m_history;
+  float m_cooldownPeriod;
+
+  bool isDuplicate(Engine::Core::EntityID unitId, AICommandType type,
+                   Engine::Core::EntityID targetId, float moveX, float moveY,
+                   float moveZ, float currentTime) const;
+
+  void recordCommand(const AICommand &cmd, float currentTime);
+
+  void cleanupHistory(float currentTime);
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_executor.cpp

@@ -0,0 +1,68 @@
+#include "ai_executor.h"
+#include <cstring>
+#include <iostream>
+#include <typeinfo>
+#include <unordered_map>
+
+namespace Game::Systems::AI {
+
+void AIExecutor::run(const AISnapshot &snapshot, AIContext &context,
+                     float deltaTime, AIBehaviorRegistry &registry,
+                     std::vector<AICommand> &outCommands) {
+
+  bool exclusiveBehaviorExecuted = false;
+
+  static std::unordered_map<int, int> debugCounters;
+  bool shouldDebug = (++debugCounters[context.playerId] % 3 == 0);
+
+  if (shouldDebug) {
+    std::cout << "  [AI " << context.playerId << " Behaviors]" << std::endl;
+  }
+
+  registry.forEach([&](AIBehavior &behavior) {
+    if (exclusiveBehaviorExecuted && !behavior.canRunConcurrently()) {
+      if (shouldDebug) {
+        std::cout << "    SKIPPED (exclusive already ran)" << std::endl;
+      }
+      return;
+    }
+
+    bool shouldExec = behavior.shouldExecute(snapshot, context);
+
+    if (shouldDebug) {
+      const char *behaviorName = typeid(behavior).name();
+
+      const char *className = behaviorName;
+      if (const char *lastColon = strrchr(behaviorName, 'E')) {
+        if (lastColon > behaviorName) {
+          className = lastColon - 20;
+        }
+      }
+
+      std::cout << "    " << behaviorName
+                << " -> shouldExecute: " << (shouldExec ? "YES" : "NO");
+      if (exclusiveBehaviorExecuted && !behavior.canRunConcurrently()) {
+        std::cout << " (BLOCKED)";
+      }
+      std::cout << std::endl;
+    }
+
+    if (shouldExec) {
+      size_t cmdsBefore = outCommands.size();
+
+      behavior.execute(snapshot, context, deltaTime, outCommands);
+
+      if (shouldDebug) {
+        std::cout << "      ✓ EXECUTED! Generated "
+                  << (outCommands.size() - cmdsBefore) << " commands"
+                  << std::endl;
+      }
+
+      if (!behavior.canRunConcurrently()) {
+        exclusiveBehaviorExecuted = true;
+      }
+    }
+  });
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_executor.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ai_behavior_registry.h"
+#include "ai_types.h"
+#include <vector>
+
+namespace Game::Systems::AI {
+
+class AIExecutor {
+public:
+  AIExecutor() = default;
+  ~AIExecutor() = default;
+
+  AIExecutor(const AIExecutor &) = delete;
+  AIExecutor &operator=(const AIExecutor &) = delete;
+
+  void run(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+           AIBehaviorRegistry &registry, std::vector<AICommand> &outCommands);
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_reasoner.cpp

@@ -0,0 +1,245 @@
+#include "ai_reasoner.h"
+#include "ai_utils.h"
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <limits>
+#include <unordered_map>
+
+namespace Game::Systems::AI {
+
+void AIReasoner::updateContext(const AISnapshot &snapshot, AIContext &ctx) {
+
+  cleanupDeadUnits(snapshot, ctx);
+
+  ctx.militaryUnits.clear();
+  ctx.buildings.clear();
+  ctx.primaryBarracks = 0;
+  ctx.totalUnits = 0;
+  ctx.idleUnits = 0;
+  ctx.combatUnits = 0;
+  ctx.meleeCount = 0;
+  ctx.rangedCount = 0;
+  ctx.damagedUnitsCount = 0;
+  ctx.averageHealth = 1.0f;
+  ctx.rallyX = 0.0f;
+  ctx.rallyZ = 0.0f;
+  ctx.barracksUnderThreat = false;
+  ctx.nearbyThreatCount = 0;
+  ctx.closestThreatDistance = std::numeric_limits<float>::infinity();
+  ctx.basePosX = 0.0f;
+  ctx.basePosY = 0.0f;
+  ctx.basePosZ = 0.0f;
+  ctx.visibleEnemyCount = 0;
+  ctx.enemyBuildingsCount = 0;
+  ctx.averageEnemyDistance = 0.0f;
+
+  float totalHealthRatio = 0.0f;
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding) {
+      ctx.buildings.push_back(entity.id);
+
+      if (entity.unitType == "barracks" && ctx.primaryBarracks == 0) {
+        ctx.primaryBarracks = entity.id;
+        ctx.rallyX = entity.posX - 5.0f;
+        ctx.rallyZ = entity.posZ;
+        ctx.basePosX = entity.posX;
+        ctx.basePosY = entity.posY;
+        ctx.basePosZ = entity.posZ;
+      }
+      continue;
+    }
+
+    ctx.militaryUnits.push_back(entity.id);
+    ctx.totalUnits++;
+
+    if (entity.unitType == "archer") {
+      ctx.rangedCount++;
+    } else if (entity.unitType == "swordsman" || entity.unitType == "warrior") {
+      ctx.meleeCount++;
+    }
+
+    if (!entity.movement.hasComponent || !entity.movement.hasTarget) {
+      ctx.idleUnits++;
+    } else {
+      ctx.combatUnits++;
+    }
+
+    if (entity.maxHealth > 0) {
+      float healthRatio = static_cast<float>(entity.health) /
+                          static_cast<float>(entity.maxHealth);
+      totalHealthRatio += healthRatio;
+
+      if (healthRatio < 0.5f) {
+        ctx.damagedUnitsCount++;
+      }
+    }
+  }
+
+  ctx.averageHealth =
+      (ctx.totalUnits > 0)
+          ? (totalHealthRatio / static_cast<float>(ctx.totalUnits))
+          : 1.0f;
+
+  ctx.visibleEnemyCount = static_cast<int>(snapshot.visibleEnemies.size());
+  float totalEnemyDist = 0.0f;
+
+  for (const auto &enemy : snapshot.visibleEnemies) {
+    if (enemy.isBuilding) {
+      ctx.enemyBuildingsCount++;
+    }
+
+    if (ctx.primaryBarracks != 0) {
+      float dist = distance(enemy.posX, enemy.posY, enemy.posZ, ctx.basePosX,
+                            ctx.basePosY, ctx.basePosZ);
+      totalEnemyDist += dist;
+    }
+  }
+
+  ctx.averageEnemyDistance =
+      (ctx.visibleEnemyCount > 0)
+          ? (totalEnemyDist / static_cast<float>(ctx.visibleEnemyCount))
+          : 1000.0f;
+
+  if (ctx.primaryBarracks != 0) {
+
+    constexpr float DEFEND_RADIUS = 40.0f;
+    constexpr float CRITICAL_RADIUS = 20.0f;
+    const float defendRadiusSq = DEFEND_RADIUS * DEFEND_RADIUS;
+    const float criticalRadiusSq = CRITICAL_RADIUS * CRITICAL_RADIUS;
+
+    for (const auto &enemy : snapshot.visibleEnemies) {
+      float distSq = distanceSquared(enemy.posX, enemy.posY, enemy.posZ,
+                                     ctx.basePosX, ctx.basePosY, ctx.basePosZ);
+
+      if (distSq <= defendRadiusSq) {
+        ctx.barracksUnderThreat = true;
+        ctx.nearbyThreatCount++;
+
+        float dist = std::sqrt(std::max(distSq, 0.0f));
+        ctx.closestThreatDistance = std::min(ctx.closestThreatDistance, dist);
+      }
+    }
+
+    if (!ctx.barracksUnderThreat) {
+      ctx.closestThreatDistance = std::numeric_limits<float>::infinity();
+    }
+  }
+
+  static std::unordered_map<int, int> debugCounters;
+  if (++debugCounters[ctx.playerId] % 3 == 0) {
+    std::cout << "[AI Player " << ctx.playerId << "] "
+              << "State: " << static_cast<int>(ctx.state)
+              << " (0=Idle,1=Gather,2=Attack,3=Defend,4=Retreat)"
+              << " | Units: " << ctx.totalUnits
+              << " | Enemies: " << ctx.visibleEnemyCount << " | Barracks: "
+              << (ctx.primaryBarracks != 0 ? "EXISTS" : "NONE")
+              << " | Threat: " << (ctx.barracksUnderThreat ? "YES" : "NO")
+              << " | AvgEnemyDist: " << ctx.averageEnemyDistance << std::endl;
+  }
+}
+
+void AIReasoner::updateStateMachine(AIContext &ctx, float deltaTime) {
+  ctx.stateTimer += deltaTime;
+  ctx.decisionTimer += deltaTime;
+
+  constexpr float MIN_STATE_DURATION = 3.0f;
+
+  AIState previousState = ctx.state;
+  if (ctx.barracksUnderThreat && ctx.state != AIState::Defending) {
+
+    ctx.state = AIState::Defending;
+  }
+
+  else if (ctx.visibleEnemyCount > 0 && ctx.averageEnemyDistance < 50.0f &&
+           (ctx.state == AIState::Gathering || ctx.state == AIState::Idle)) {
+    ctx.state = AIState::Defending;
+  }
+
+  if (ctx.decisionTimer < 2.0f) {
+    if (ctx.state != previousState)
+      ctx.stateTimer = 0.0f;
+    return;
+  }
+
+  ctx.decisionTimer = 0.0f;
+  previousState = ctx.state;
+
+  if (ctx.stateTimer < MIN_STATE_DURATION &&
+      !(ctx.barracksUnderThreat && ctx.state != AIState::Defending)) {
+    return;
+  }
+
+  switch (ctx.state) {
+  case AIState::Idle:
+    if (ctx.idleUnits >= 2) {
+      ctx.state = AIState::Gathering;
+    } else if (ctx.averageHealth < 0.40f && ctx.totalUnits > 0) {
+
+      ctx.state = AIState::Defending;
+    } else if (ctx.totalUnits >= 1 && ctx.visibleEnemyCount > 0) {
+
+      ctx.state = AIState::Attacking;
+    }
+    break;
+
+  case AIState::Gathering:
+    if (ctx.totalUnits >= 3) {
+
+      ctx.state = AIState::Attacking;
+    } else if (ctx.totalUnits < 2) {
+      ctx.state = AIState::Idle;
+    } else if (ctx.averageHealth < 0.40f) {
+
+      ctx.state = AIState::Defending;
+    } else if (ctx.visibleEnemyCount > 0 && ctx.totalUnits >= 2) {
+
+      ctx.state = AIState::Attacking;
+    }
+    break;
+
+  case AIState::Attacking:
+    if (ctx.averageHealth < 0.25f) {
+
+      ctx.state = AIState::Retreating;
+    } else if (ctx.totalUnits == 0) {
+
+      ctx.state = AIState::Idle;
+    }
+
+    break;
+
+  case AIState::Defending:
+
+    if (ctx.barracksUnderThreat) {
+
+    } else if (ctx.totalUnits >= 4 && ctx.averageHealth > 0.65f) {
+
+      ctx.state = AIState::Attacking;
+    } else if (ctx.averageHealth > 0.80f) {
+
+      ctx.state = AIState::Idle;
+    }
+    break;
+
+  case AIState::Retreating:
+
+    if (ctx.stateTimer > 6.0f && ctx.averageHealth > 0.55f) {
+
+      ctx.state = AIState::Defending;
+    }
+    break;
+
+  case AIState::Expanding:
+
+    ctx.state = AIState::Idle;
+    break;
+  }
+
+  if (ctx.state != previousState) {
+    ctx.stateTimer = 0.0f;
+  }
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_reasoner.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ai_types.h"
+
+namespace Game::Systems::AI {
+
+class AIReasoner {
+public:
+  AIReasoner() = default;
+  ~AIReasoner() = default;
+
+  AIReasoner(const AIReasoner &) = delete;
+  AIReasoner &operator=(const AIReasoner &) = delete;
+
+  void updateContext(const AISnapshot &snapshot, AIContext &context);
+
+  void updateStateMachine(AIContext &context, float deltaTime);
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_snapshot_builder.cpp

@@ -0,0 +1,106 @@
+#include "ai_snapshot_builder.h"
+#include "../../core/component.h"
+#include "../../core/world.h"
+
+namespace Game::Systems::AI {
+
+AISnapshot AISnapshotBuilder::build(const Engine::Core::World &world,
+                                    int aiOwnerId) const {
+  AISnapshot snapshot;
+  snapshot.playerId = aiOwnerId;
+
+  auto friendlies = world.getUnitsOwnedBy(aiOwnerId);
+  snapshot.friendlies.reserve(friendlies.size());
+
+  int skippedNoAI = 0;
+  int skippedNoUnit = 0;
+  int skippedDead = 0;
+  int added = 0;
+
+  for (auto *entity : friendlies) {
+    if (!entity->hasComponent<Engine::Core::AIControlledComponent>()) {
+      skippedNoAI++;
+      continue;
+    }
+
+    auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+    if (!unit) {
+      skippedNoUnit++;
+      continue;
+    }
+
+    if (unit->health <= 0) {
+      skippedDead++;
+      continue;
+    }
+
+    EntitySnapshot data;
+    data.id = entity->getId();
+    data.unitType = unit->unitType;
+    data.ownerId = unit->ownerId;
+    data.health = unit->health;
+    data.maxHealth = unit->maxHealth;
+    data.isBuilding = entity->hasComponent<Engine::Core::BuildingComponent>();
+
+    if (auto *transform =
+            entity->getComponent<Engine::Core::TransformComponent>()) {
+      data.posX = transform->position.x;
+      data.posY = 0.0f;
+      data.posZ = transform->position.z;
+    }
+
+    if (auto *movement =
+            entity->getComponent<Engine::Core::MovementComponent>()) {
+      data.movement.hasComponent = true;
+      data.movement.hasTarget = movement->hasTarget;
+    }
+
+    if (auto *production =
+            entity->getComponent<Engine::Core::ProductionComponent>()) {
+      data.production.hasComponent = true;
+      data.production.inProgress = production->inProgress;
+      data.production.buildTime = production->buildTime;
+      data.production.timeRemaining = production->timeRemaining;
+      data.production.producedCount = production->producedCount;
+      data.production.maxUnits = production->maxUnits;
+      data.production.productType = production->productType;
+      data.production.rallySet = production->rallySet;
+      data.production.rallyX = production->rallyX;
+      data.production.rallyZ = production->rallyZ;
+    }
+
+    snapshot.friendlies.push_back(std::move(data));
+    added++;
+  }
+
+  auto enemies = world.getEnemyUnits(aiOwnerId);
+  snapshot.visibleEnemies.reserve(enemies.size());
+
+  for (auto *entity : enemies) {
+    auto *unit = entity->getComponent<Engine::Core::UnitComponent>();
+    if (!unit || unit->health <= 0)
+      continue;
+
+    auto *transform = entity->getComponent<Engine::Core::TransformComponent>();
+    if (!transform)
+      continue;
+
+    ContactSnapshot contact;
+    contact.id = entity->getId();
+    contact.isBuilding =
+        entity->hasComponent<Engine::Core::BuildingComponent>();
+    contact.posX = transform->position.x;
+    contact.posY = 0.0f;
+    contact.posZ = transform->position.z;
+
+    contact.health = unit->health;
+    contact.maxHealth = unit->maxHealth;
+    contact.unitType = unit->unitType;
+
+    snapshot.visibleEnemies.push_back(std::move(contact));
+  }
+
+  return snapshot;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_snapshot_builder.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "ai_types.h"
+
+namespace Engine::Core {
+class World;
+}
+
+namespace Game::Systems::AI {
+
+class AISnapshotBuilder {
+public:
+  AISnapshotBuilder() = default;
+  ~AISnapshotBuilder() = default;
+
+  AISnapshotBuilder(const AISnapshotBuilder &) = delete;
+  AISnapshotBuilder &operator=(const AISnapshotBuilder &) = delete;
+
+  AISnapshot build(const Engine::Core::World &world, int aiOwnerId) const;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_tactical.cpp

@@ -0,0 +1,220 @@
+#include "ai_tactical.h"
+#include "ai_utils.h"
+#include <algorithm>
+#include <cmath>
+
+namespace Game::Systems::AI {
+
+TacticalUtils::EngagementAssessment TacticalUtils::assessEngagement(
+    const std::vector<const EntitySnapshot *> &friendlies,
+    const std::vector<const ContactSnapshot *> &enemies, float minForceRatio) {
+
+  EngagementAssessment result;
+
+  if (friendlies.empty() || enemies.empty()) {
+    result.shouldEngage = false;
+    return result;
+  }
+
+  result.friendlyCount = static_cast<int>(friendlies.size());
+  result.enemyCount = static_cast<int>(enemies.size());
+
+  float totalFriendlyHealth = 0.0f;
+  float totalEnemyHealth = 0.0f;
+  int validFriendlies = 0;
+  int validEnemies = 0;
+
+  for (const auto *unit : friendlies) {
+    if (unit->maxHealth > 0) {
+      totalFriendlyHealth += static_cast<float>(unit->health) /
+                             static_cast<float>(unit->maxHealth);
+      ++validFriendlies;
+    }
+  }
+
+  for (const auto *enemy : enemies) {
+    if (enemy->maxHealth > 0) {
+      totalEnemyHealth += static_cast<float>(enemy->health) /
+                          static_cast<float>(enemy->maxHealth);
+      ++validEnemies;
+    }
+  }
+
+  result.avgFriendlyHealth =
+      validFriendlies > 0 ? (totalFriendlyHealth / validFriendlies) : 1.0f;
+  result.avgEnemyHealth =
+      validEnemies > 0 ? (totalEnemyHealth / validEnemies) : 1.0f;
+
+  float friendlyStrength =
+      static_cast<float>(result.friendlyCount) * result.avgFriendlyHealth;
+  float enemyStrength =
+      static_cast<float>(result.enemyCount) * result.avgEnemyHealth;
+
+  if (enemyStrength < 0.01f) {
+    result.forceRatio = 10.0f;
+  } else {
+    result.forceRatio = friendlyStrength / enemyStrength;
+  }
+
+  result.confidenceLevel =
+      std::clamp((result.forceRatio - 0.5f) / 1.5f, 0.0f, 1.0f);
+
+  result.shouldEngage = (result.forceRatio >= minForceRatio);
+
+  return result;
+}
+
+TacticalUtils::TargetScore TacticalUtils::selectFocusFireTarget(
+    const std::vector<const EntitySnapshot *> &attackers,
+    const std::vector<const ContactSnapshot *> &enemies, float groupCenterX,
+    float groupCenterY, float groupCenterZ, const AIContext &context,
+    Engine::Core::EntityID currentTarget) {
+
+  TargetScore bestTarget;
+  bestTarget.score = -std::numeric_limits<float>::infinity();
+
+  if (enemies.empty()) {
+    return bestTarget;
+  }
+
+  for (const auto *enemy : enemies) {
+    float score = 0.0f;
+
+    float dist = distance(enemy->posX, enemy->posY, enemy->posZ, groupCenterX,
+                          groupCenterY, groupCenterZ);
+    score -= dist * 0.5f;
+
+    if (enemy->maxHealth > 0) {
+      float healthRatio = static_cast<float>(enemy->health) /
+                          static_cast<float>(enemy->maxHealth);
+
+      if (healthRatio < 0.5f) {
+        score += 8.0f * (1.0f - healthRatio);
+      }
+
+      if (healthRatio < 0.25f) {
+        score += 12.0f;
+      }
+    }
+
+    float typePriority = getUnitTypePriority(enemy->unitType);
+    score += typePriority * 3.0f;
+
+    if (!enemy->isBuilding) {
+      score += 5.0f;
+    }
+
+    if (currentTarget != 0 && enemy->id == currentTarget) {
+      score += 10.0f;
+    }
+
+    bool isolated = isTargetIsolated(*enemy, enemies, 8.0f);
+    if (isolated) {
+      score += 6.0f;
+    }
+
+    if (context.primaryBarracks != 0) {
+      float distToBase =
+          distance(enemy->posX, enemy->posY, enemy->posZ, context.basePosX,
+                   context.basePosY, context.basePosZ);
+
+      if (distToBase < 16.0f) {
+        score += (16.0f - distToBase) * 0.8f;
+      }
+    }
+
+    if (context.state == AIState::Attacking && !enemy->isBuilding) {
+      score += 3.0f;
+    }
+
+    if (score > bestTarget.score) {
+      bestTarget.targetId = enemy->id;
+      bestTarget.score = score;
+      bestTarget.distanceToGroup = dist;
+      bestTarget.isLowHealth =
+          (enemy->maxHealth > 0 && enemy->health < enemy->maxHealth / 2);
+      bestTarget.isIsolated = isolated;
+    }
+  }
+
+  return bestTarget;
+}
+
+float TacticalUtils::calculateForceStrength(
+    const std::vector<const EntitySnapshot *> &units) {
+
+  float strength = 0.0f;
+  for (const auto *unit : units) {
+    if (unit->maxHealth > 0) {
+      float healthRatio = static_cast<float>(unit->health) /
+                          static_cast<float>(unit->maxHealth);
+      strength += healthRatio;
+    } else {
+      strength += 1.0f;
+    }
+  }
+  return strength;
+}
+
+float TacticalUtils::calculateForceStrength(
+    const std::vector<const ContactSnapshot *> &units) {
+
+  float strength = 0.0f;
+  for (const auto *unit : units) {
+    if (unit->maxHealth > 0) {
+      float healthRatio = static_cast<float>(unit->health) /
+                          static_cast<float>(unit->maxHealth);
+      strength += healthRatio;
+    } else {
+      strength += 1.0f;
+    }
+  }
+  return strength;
+}
+
+bool TacticalUtils::isTargetIsolated(
+    const ContactSnapshot &target,
+    const std::vector<const ContactSnapshot *> &allEnemies,
+    float isolationRadius) {
+
+  const float isolationRadiusSq = isolationRadius * isolationRadius;
+  int nearbyAllies = 0;
+
+  for (const auto *enemy : allEnemies) {
+
+    if (enemy->id == target.id)
+      continue;
+
+    float distSq = distanceSquared(target.posX, target.posY, target.posZ,
+                                   enemy->posX, enemy->posY, enemy->posZ);
+
+    if (distSq <= isolationRadiusSq) {
+      ++nearbyAllies;
+    }
+  }
+
+  return (nearbyAllies <= 1);
+}
+
+float TacticalUtils::getUnitTypePriority(const std::string &unitType) {
+
+  if (unitType == "archer" || unitType == "ranged") {
+    return 3.0f;
+  }
+
+  if (unitType == "warrior" || unitType == "melee") {
+    return 2.0f;
+  }
+
+  if (unitType == "worker" || unitType == "villager") {
+    return 1.0f;
+  }
+
+  if (unitType == "barracks" || unitType == "base") {
+    return 0.5f;
+  }
+
+  return 1.5f;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_tactical.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "ai_types.h"
+#include <vector>
+
+namespace Game::Systems::AI {
+
+class TacticalUtils {
+public:
+  struct EngagementAssessment {
+    bool shouldEngage = false;
+    float forceRatio = 0.0f;
+    float confidenceLevel = 0.0f;
+    int friendlyCount = 0;
+    int enemyCount = 0;
+    float avgFriendlyHealth = 1.0f;
+    float avgEnemyHealth = 1.0f;
+  };
+
+  struct TargetScore {
+    Engine::Core::EntityID targetId = 0;
+    float score = 0.0f;
+    float distanceToGroup = 0.0f;
+    bool isLowHealth = false;
+    bool isIsolated = false;
+  };
+
+  static EngagementAssessment
+  assessEngagement(const std::vector<const EntitySnapshot *> &friendlies,
+                   const std::vector<const ContactSnapshot *> &enemies,
+                   float minForceRatio = 0.8f);
+
+  static TargetScore
+  selectFocusFireTarget(const std::vector<const EntitySnapshot *> &attackers,
+                        const std::vector<const ContactSnapshot *> &enemies,
+                        float groupCenterX, float groupCenterY,
+                        float groupCenterZ, const AIContext &context,
+                        Engine::Core::EntityID currentTarget = 0);
+
+  static float
+  calculateForceStrength(const std::vector<const EntitySnapshot *> &units);
+
+  static float
+  calculateForceStrength(const std::vector<const ContactSnapshot *> &units);
+
+  static bool
+  isTargetIsolated(const ContactSnapshot &target,
+                   const std::vector<const ContactSnapshot *> &allEnemies,
+                   float isolationRadius = 8.0f);
+
+  static float getUnitTypePriority(const std::string &unitType);
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_types.h

@@ -0,0 +1,154 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Engine::Core {
+using EntityID = unsigned int;
+}
+
+namespace Game::Systems::AI {
+
+enum class AIState {
+  Idle,
+  Gathering,
+  Attacking,
+  Defending,
+  Retreating,
+  Expanding
+};
+
+enum class AICommandType { MoveUnits, AttackTarget, StartProduction };
+
+enum class BehaviorPriority {
+  VeryLow = 0,
+  Low = 1,
+  Normal = 2,
+  High = 3,
+  Critical = 4
+};
+
+struct MovementSnapshot {
+  bool hasComponent = false;
+  bool hasTarget = false;
+};
+
+struct ProductionSnapshot {
+  bool hasComponent = false;
+  bool inProgress = false;
+  float buildTime = 0.0f;
+  float timeRemaining = 0.0f;
+  int producedCount = 0;
+  int maxUnits = 0;
+  std::string productType;
+  bool rallySet = false;
+  float rallyX = 0.0f;
+  float rallyZ = 0.0f;
+};
+
+struct EntitySnapshot {
+  Engine::Core::EntityID id = 0;
+  std::string unitType;
+  int ownerId = 0;
+  int health = 0;
+  int maxHealth = 0;
+  bool isBuilding = false;
+
+  float posX = 0.0f;
+  float posY = 0.0f;
+  float posZ = 0.0f;
+
+  MovementSnapshot movement;
+  ProductionSnapshot production;
+};
+
+struct ContactSnapshot {
+  Engine::Core::EntityID id = 0;
+  bool isBuilding = false;
+
+  float posX = 0.0f;
+  float posY = 0.0f;
+  float posZ = 0.0f;
+
+  int health = 0;
+  int maxHealth = 0;
+  std::string unitType;
+};
+
+struct AISnapshot {
+  int playerId = 0;
+  std::vector<EntitySnapshot> friendlies;
+  std::vector<ContactSnapshot> visibleEnemies;
+
+  float gameTime = 0.0f;
+};
+
+struct AIContext {
+  int playerId = 0;
+  AIState state = AIState::Idle;
+  float stateTimer = 0.0f;
+  float decisionTimer = 0.0f;
+
+  std::vector<Engine::Core::EntityID> militaryUnits;
+  std::vector<Engine::Core::EntityID> buildings;
+  Engine::Core::EntityID primaryBarracks = 0;
+
+  float rallyX = 0.0f;
+  float rallyZ = 0.0f;
+  int targetPriority = 0;
+
+  int totalUnits = 0;
+  int idleUnits = 0;
+  int combatUnits = 0;
+  float averageHealth = 1.0f;
+  bool barracksUnderThreat = false;
+  int nearbyThreatCount = 0;
+  float closestThreatDistance = 0.0f;
+
+  float basePosX = 0.0f;
+  float basePosY = 0.0f;
+  float basePosZ = 0.0f;
+
+  struct UnitAssignment {
+    BehaviorPriority ownerPriority = BehaviorPriority::Normal;
+    float assignmentTime = 0.0f;
+    std::string assignedTask;
+  };
+  std::unordered_map<Engine::Core::EntityID, UnitAssignment> assignedUnits;
+
+  int meleeCount = 0;
+  int rangedCount = 0;
+  int damagedUnitsCount = 0;
+
+  int visibleEnemyCount = 0;
+  int enemyBuildingsCount = 0;
+  float averageEnemyDistance = 0.0f;
+};
+
+struct AICommand {
+  AICommandType type = AICommandType::MoveUnits;
+  std::vector<Engine::Core::EntityID> units;
+
+  std::vector<float> moveTargetX;
+  std::vector<float> moveTargetY;
+  std::vector<float> moveTargetZ;
+
+  Engine::Core::EntityID targetId = 0;
+  bool shouldChase = false;
+  Engine::Core::EntityID buildingId = 0;
+  std::string productType;
+};
+
+struct AIResult {
+  AIContext context;
+  std::vector<AICommand> commands;
+};
+
+struct AIJob {
+  AISnapshot snapshot;
+  AIContext context;
+  float deltaTime = 0.0f;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_utils.h

@@ -0,0 +1,145 @@
+#pragma once
+
+#include "ai_types.h"
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <unordered_set>
+#include <vector>
+
+namespace Game::Systems::AI {
+
+inline void replicateLastTargetIfNeeded(const std::vector<float> &fromX,
+                                        const std::vector<float> &fromY,
+                                        const std::vector<float> &fromZ,
+                                        size_t wanted, std::vector<float> &outX,
+                                        std::vector<float> &outY,
+                                        std::vector<float> &outZ) {
+
+  outX.clear();
+  outY.clear();
+  outZ.clear();
+
+  if (fromX.empty() || fromY.empty() || fromZ.empty())
+    return;
+
+  size_t srcSize = std::min({fromX.size(), fromY.size(), fromZ.size()});
+
+  outX.reserve(wanted);
+  outY.reserve(wanted);
+  outZ.reserve(wanted);
+
+  for (size_t i = 0; i < wanted; ++i) {
+    size_t idx = std::min(i, srcSize - 1);
+    outX.push_back(fromX[idx]);
+    outY.push_back(fromY[idx]);
+    outZ.push_back(fromZ[idx]);
+  }
+}
+
+inline bool isEntityEngaged(const EntitySnapshot &entity,
+                            const std::vector<ContactSnapshot> &enemies) {
+
+  if (entity.maxHealth > 0 && entity.health < entity.maxHealth)
+    return true;
+
+  constexpr float ENGAGED_RADIUS = 7.5f;
+  const float engagedSq = ENGAGED_RADIUS * ENGAGED_RADIUS;
+
+  for (const auto &enemy : enemies) {
+    float dx = enemy.posX - entity.posX;
+    float dy = enemy.posY - entity.posY;
+    float dz = enemy.posZ - entity.posZ;
+    float distSq = dx * dx + dy * dy + dz * dz;
+
+    if (distSq <= engagedSq)
+      return true;
+  }
+
+  return false;
+}
+
+inline float distanceSquared(float x1, float y1, float z1, float x2, float y2,
+                             float z2) {
+  float dx = x2 - x1;
+  float dy = y2 - y1;
+  float dz = z2 - z1;
+  return dx * dx + dy * dy + dz * dz;
+}
+
+inline float distance(float x1, float y1, float z1, float x2, float y2,
+                      float z2) {
+  return std::sqrt(distanceSquared(x1, y1, z1, x2, y2, z2));
+}
+
+inline std::vector<Engine::Core::EntityID>
+claimUnits(const std::vector<Engine::Core::EntityID> &requestedUnits,
+           BehaviorPriority priority, const std::string &taskName,
+           AIContext &context, float currentTime,
+           float minLockDuration = 2.0f) {
+
+  std::vector<Engine::Core::EntityID> claimed;
+  claimed.reserve(requestedUnits.size());
+
+  for (Engine::Core::EntityID unitId : requestedUnits) {
+    auto it = context.assignedUnits.find(unitId);
+
+    if (it == context.assignedUnits.end()) {
+
+      AIContext::UnitAssignment assignment;
+      assignment.ownerPriority = priority;
+      assignment.assignmentTime = currentTime;
+      assignment.assignedTask = taskName;
+      context.assignedUnits[unitId] = assignment;
+      claimed.push_back(unitId);
+
+    } else {
+
+      const auto &existing = it->second;
+      float assignmentAge = currentTime - existing.assignmentTime;
+
+      bool canSteal = (priority > existing.ownerPriority) &&
+                      (assignmentAge > minLockDuration);
+
+      if (canSteal) {
+
+        AIContext::UnitAssignment assignment;
+        assignment.ownerPriority = priority;
+        assignment.assignmentTime = currentTime;
+        assignment.assignedTask = taskName;
+        context.assignedUnits[unitId] = assignment;
+        claimed.push_back(unitId);
+      }
+    }
+  }
+
+  return claimed;
+}
+
+inline void releaseUnits(const std::vector<Engine::Core::EntityID> &units,
+                         AIContext &context) {
+  for (Engine::Core::EntityID unitId : units) {
+    context.assignedUnits.erase(unitId);
+  }
+}
+
+inline void cleanupDeadUnits(const AISnapshot &snapshot, AIContext &context) {
+
+  std::unordered_set<Engine::Core::EntityID> aliveUnits;
+  for (const auto &entity : snapshot.friendlies) {
+    if (!entity.isBuilding) {
+      aliveUnits.insert(entity.id);
+    }
+  }
+
+  for (auto it = context.assignedUnits.begin();
+       it != context.assignedUnits.end();) {
+    if (aliveUnits.find(it->first) == aliveUnits.end()) {
+      it = context.assignedUnits.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_worker.cpp

@@ -0,0 +1,92 @@
+#include "ai_worker.h"
+
+namespace Game::Systems::AI {
+
+AIWorker::AIWorker(AIReasoner &reasoner, AIExecutor &executor,
+                   AIBehaviorRegistry &registry)
+    : m_reasoner(reasoner), m_executor(executor), m_registry(registry) {
+
+  m_thread = std::thread(&AIWorker::workerLoop, this);
+}
+
+AIWorker::~AIWorker() {
+  stop();
+
+  { std::lock_guard<std::mutex> lock(m_jobMutex); }
+  m_jobCondition.notify_all();
+
+  if (m_thread.joinable()) {
+    m_thread.join();
+  }
+}
+
+bool AIWorker::trySubmit(AIJob &&job) {
+
+  if (m_workerBusy.load(std::memory_order_acquire)) {
+    return false;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(m_jobMutex);
+    m_pendingJob = std::move(job);
+    m_hasPendingJob = true;
+  }
+
+  m_workerBusy.store(true, std::memory_order_release);
+  m_jobCondition.notify_one();
+
+  return true;
+}
+
+void AIWorker::drainResults(std::queue<AIResult> &out) {
+  std::lock_guard<std::mutex> lock(m_resultMutex);
+
+  while (!m_results.empty()) {
+    out.push(std::move(m_results.front()));
+    m_results.pop();
+  }
+}
+
+void AIWorker::stop() { m_shouldStop.store(true, std::memory_order_release); }
+
+void AIWorker::workerLoop() {
+  while (true) {
+    AIJob job;
+
+    {
+      std::unique_lock<std::mutex> lock(m_jobMutex);
+      m_jobCondition.wait(lock, [this]() {
+        return m_shouldStop.load(std::memory_order_acquire) || m_hasPendingJob;
+      });
+
+      if (m_shouldStop.load(std::memory_order_acquire) && !m_hasPendingJob) {
+        break;
+      }
+
+      job = std::move(m_pendingJob);
+      m_hasPendingJob = false;
+    }
+
+    try {
+      AIResult result;
+      result.context = job.context;
+
+      m_reasoner.updateContext(job.snapshot, result.context);
+      m_reasoner.updateStateMachine(result.context, job.deltaTime);
+      m_executor.run(job.snapshot, result.context, job.deltaTime, m_registry,
+                     result.commands);
+
+      {
+        std::lock_guard<std::mutex> lock(m_resultMutex);
+        m_results.push(std::move(result));
+      }
+    } catch (...) {
+    }
+
+    m_workerBusy.store(false, std::memory_order_release);
+  }
+
+  m_workerBusy.store(false, std::memory_order_release);
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/ai_worker.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "ai_executor.h"
+#include "ai_reasoner.h"
+#include "ai_types.h"
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+namespace Game::Systems::AI {
+
+class AIWorker {
+public:
+  AIWorker(AIReasoner &reasoner, AIExecutor &executor,
+           AIBehaviorRegistry &registry);
+
+  ~AIWorker();
+
+  AIWorker(const AIWorker &) = delete;
+  AIWorker &operator=(const AIWorker &) = delete;
+  AIWorker(AIWorker &&) = delete;
+  AIWorker &operator=(AIWorker &&) = delete;
+
+  bool trySubmit(AIJob &&job);
+
+  void drainResults(std::queue<AIResult> &out);
+
+  bool busy() const noexcept {
+    return m_workerBusy.load(std::memory_order_acquire);
+  }
+
+  void stop();
+
+private:
+  void workerLoop();
+
+  AIReasoner &m_reasoner;
+  AIExecutor &m_executor;
+  AIBehaviorRegistry &m_registry;
+
+  std::thread m_thread;
+  std::atomic<bool> m_shouldStop{false};
+  std::atomic<bool> m_workerBusy{false};
+
+  std::mutex m_jobMutex;
+  std::condition_variable m_jobCondition;
+  bool m_hasPendingJob = false;
+  AIJob m_pendingJob;
+
+  std::mutex m_resultMutex;
+  std::queue<AIResult> m_results;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/attack_behavior.cpp

@@ -0,0 +1,292 @@
+#include "attack_behavior.h"
+#include "../ai_tactical.h"
+#include "../ai_utils.h"
+
+#include <QDebug>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+namespace Game::Systems::AI {
+
+void AttackBehavior::execute(const AISnapshot &snapshot, AIContext &context,
+                             float deltaTime,
+                             std::vector<AICommand> &outCommands) {
+  m_attackTimer += deltaTime;
+  m_targetLockDuration += deltaTime;
+
+  if (m_attackTimer < 1.5f)
+    return;
+  m_attackTimer = 0.0f;
+
+  if (snapshot.visibleEnemies.empty())
+    return;
+
+  std::vector<const EntitySnapshot *> engagedUnits;
+  std::vector<const EntitySnapshot *> readyUnits;
+  engagedUnits.reserve(snapshot.friendlies.size());
+  readyUnits.reserve(snapshot.friendlies.size());
+
+  float groupCenterX = 0.0f;
+  float groupCenterY = 0.0f;
+  float groupCenterZ = 0.0f;
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (isEntityEngaged(entity, snapshot.visibleEnemies)) {
+      engagedUnits.push_back(&entity);
+      continue;
+    }
+
+    readyUnits.push_back(&entity);
+    groupCenterX += entity.posX;
+    groupCenterY += entity.posY;
+    groupCenterZ += entity.posZ;
+  }
+
+  if (readyUnits.empty()) {
+
+    if (!engagedUnits.empty()) {
+      qDebug() << "[AttackBehavior] All" << engagedUnits.size()
+               << "units engaged in combat - maintaining fight position";
+    }
+    return;
+  }
+
+  if (!engagedUnits.empty()) {
+    qDebug() << "[AttackBehavior] Army split: " << readyUnits.size()
+             << "units forming attack group," << engagedUnits.size()
+             << "units engaged in combat";
+  }
+
+  float invCount = 1.0f / static_cast<float>(readyUnits.size());
+  groupCenterX *= invCount;
+  groupCenterY *= invCount;
+  groupCenterZ *= invCount;
+
+  std::vector<const ContactSnapshot *> nearbyEnemies;
+  nearbyEnemies.reserve(snapshot.visibleEnemies.size());
+
+  const float ENGAGEMENT_RANGE =
+      (context.damagedUnitsCount > 0) ? 35.0f : 20.0f;
+  const float engageRangeSq = ENGAGEMENT_RANGE * ENGAGEMENT_RANGE;
+
+  for (const auto &enemy : snapshot.visibleEnemies) {
+    float distSq = distanceSquared(enemy.posX, enemy.posY, enemy.posZ,
+                                   groupCenterX, groupCenterY, groupCenterZ);
+    if (distSq <= engageRangeSq) {
+      nearbyEnemies.push_back(&enemy);
+    }
+  }
+
+  if (nearbyEnemies.empty()) {
+
+    bool shouldAdvance =
+        (context.state == AIState::Attacking) ||
+        (context.state == AIState::Gathering && context.totalUnits >= 3);
+
+    if (shouldAdvance && !snapshot.visibleEnemies.empty()) {
+
+      const ContactSnapshot *targetBarracks = nullptr;
+      float closestBarracksDistSq = std::numeric_limits<float>::max();
+
+      for (const auto &enemy : snapshot.visibleEnemies) {
+        if (enemy.isBuilding) {
+          float distSq =
+              distanceSquared(enemy.posX, enemy.posY, enemy.posZ, groupCenterX,
+                              groupCenterY, groupCenterZ);
+          if (distSq < closestBarracksDistSq) {
+            closestBarracksDistSq = distSq;
+            targetBarracks = &enemy;
+          }
+        }
+      }
+
+      const ContactSnapshot *closestEnemy = nullptr;
+      float closestDistSq = std::numeric_limits<float>::max();
+
+      if (!targetBarracks) {
+        for (const auto &enemy : snapshot.visibleEnemies) {
+          float distSq =
+              distanceSquared(enemy.posX, enemy.posY, enemy.posZ, groupCenterX,
+                              groupCenterY, groupCenterZ);
+          if (distSq < closestDistSq) {
+            closestDistSq = distSq;
+            closestEnemy = &enemy;
+          }
+        }
+      }
+
+      const ContactSnapshot *target =
+          targetBarracks ? targetBarracks : closestEnemy;
+
+      if (target && readyUnits.size() >= 1) {
+
+        float attackPosX = target->posX;
+        float attackPosZ = target->posZ;
+
+        if (targetBarracks) {
+
+          float dx = groupCenterX - target->posX;
+          float dz = groupCenterZ - target->posZ;
+          float dist = std::sqrt(dx * dx + dz * dz);
+          if (dist > 0.1f) {
+            attackPosX += (dx / dist) * 3.0f;
+            attackPosZ += (dz / dist) * 3.0f;
+          } else {
+            attackPosX += 3.0f;
+          }
+        }
+
+        bool needsNewCommand = false;
+        if (m_lastTarget != target->id) {
+          needsNewCommand = true;
+          m_lastTarget = target->id;
+          m_targetLockDuration = 0.0f;
+        } else {
+
+          for (const auto *unit : readyUnits) {
+            float dx = unit->posX - attackPosX;
+            float dz = unit->posZ - attackPosZ;
+            float distSq = dx * dx + dz * dz;
+            if (distSq > 15.0f * 15.0f) {
+              needsNewCommand = true;
+              break;
+            }
+          }
+        }
+
+        if (needsNewCommand) {
+          std::vector<Engine::Core::EntityID> unitIds;
+          std::vector<float> targetX, targetY, targetZ;
+
+          for (const auto *unit : readyUnits) {
+            unitIds.push_back(unit->id);
+            targetX.push_back(attackPosX);
+            targetY.push_back(0.0f);
+            targetZ.push_back(attackPosZ);
+          }
+
+          qDebug() << "[AttackBehavior] Group move:" << unitIds.size()
+                   << "units toward"
+                   << (targetBarracks ? "enemy barracks" : "enemy unit")
+                   << "at position (" << attackPosX << "," << attackPosZ << ")"
+                   << "| Engaged units staying in combat:"
+                   << engagedUnits.size();
+
+          AICommand cmd;
+          cmd.type = AICommandType::MoveUnits;
+          cmd.units = std::move(unitIds);
+          cmd.moveTargetX = std::move(targetX);
+          cmd.moveTargetY = std::move(targetY);
+          cmd.moveTargetZ = std::move(targetZ);
+          outCommands.push_back(cmd);
+        }
+      }
+    }
+
+    m_lastTarget = 0;
+    m_targetLockDuration = 0.0f;
+    return;
+  }
+
+  auto assessment = TacticalUtils::assessEngagement(
+      readyUnits, nearbyEnemies,
+      context.state == AIState::Attacking ? 0.7f : 0.9f);
+
+  bool beingAttacked = context.damagedUnitsCount > 0;
+
+  if (!assessment.shouldEngage && !context.barracksUnderThreat &&
+      !beingAttacked) {
+
+    m_lastTarget = 0;
+    m_targetLockDuration = 0.0f;
+    return;
+  }
+
+  bool lastTargetStillValid = false;
+  if (m_lastTarget != 0) {
+    for (const auto *enemy : nearbyEnemies) {
+      if (enemy->id == m_lastTarget) {
+        lastTargetStillValid = true;
+        break;
+      }
+    }
+  }
+
+  if (!lastTargetStillValid || m_targetLockDuration > 8.0f) {
+    m_lastTarget = 0;
+    m_targetLockDuration = 0.0f;
+  }
+
+  auto targetInfo = TacticalUtils::selectFocusFireTarget(
+      readyUnits, nearbyEnemies, groupCenterX, groupCenterY, groupCenterZ,
+      context, m_lastTarget);
+
+  if (targetInfo.targetId == 0)
+    return;
+
+  if (targetInfo.targetId != m_lastTarget) {
+    m_lastTarget = targetInfo.targetId;
+    m_targetLockDuration = 0.0f;
+  }
+
+  std::vector<Engine::Core::EntityID> unitIds;
+  unitIds.reserve(readyUnits.size());
+  for (const auto *unit : readyUnits) {
+    unitIds.push_back(unit->id);
+  }
+
+  auto claimedUnits = claimUnits(unitIds, getPriority(), "attacking", context,
+                                 m_attackTimer + deltaTime, 2.5f);
+
+  if (claimedUnits.empty())
+    return;
+
+  AICommand command;
+  command.type = AICommandType::AttackTarget;
+  command.units = std::move(claimedUnits);
+  command.targetId = targetInfo.targetId;
+
+  command.shouldChase =
+      (context.state == AIState::Attacking || context.barracksUnderThreat) &&
+      assessment.forceRatio >= 0.8f;
+
+  outCommands.push_back(std::move(command));
+}
+bool AttackBehavior::shouldExecute(const AISnapshot &snapshot,
+                                   const AIContext &context) const {
+
+  if (context.state == AIState::Retreating)
+    return false;
+
+  int readyUnits = 0;
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (isEntityEngaged(entity, snapshot.visibleEnemies))
+      continue;
+
+    ++readyUnits;
+  }
+
+  if (readyUnits == 0)
+    return false;
+
+  if (snapshot.visibleEnemies.empty())
+    return false;
+
+  if (context.state == AIState::Attacking)
+    return true;
+
+  if (context.state == AIState::Defending) {
+    return context.barracksUnderThreat && readyUnits >= 2;
+  }
+
+  return readyUnits >= 1;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/attack_behavior.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "../ai_behavior.h"
+
+namespace Game::Systems::AI {
+
+class AttackBehavior : public AIBehavior {
+public:
+  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+               std::vector<AICommand> &outCommands) override;
+
+  bool shouldExecute(const AISnapshot &snapshot,
+                     const AIContext &context) const override;
+
+  BehaviorPriority getPriority() const override {
+    return BehaviorPriority::Normal;
+  }
+
+  bool canRunConcurrently() const override { return false; }
+
+private:
+  float m_attackTimer = 0.0f;
+  Engine::Core::EntityID m_lastTarget = 0;
+  float m_targetLockDuration = 0.0f;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/defend_behavior.cpp

@@ -0,0 +1,283 @@
+#include "defend_behavior.h"
+#include "../../formation_planner.h"
+#include "../ai_tactical.h"
+#include "../ai_utils.h"
+
+#include <QVector3D>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+namespace Game::Systems::AI {
+
+void DefendBehavior::execute(const AISnapshot &snapshot, AIContext &context,
+                             float deltaTime,
+                             std::vector<AICommand> &outCommands) {
+  m_defendTimer += deltaTime;
+
+  float updateInterval = context.barracksUnderThreat ? 0.5f : 1.5f;
+
+  if (m_defendTimer < updateInterval)
+    return;
+  m_defendTimer = 0.0f;
+
+  if (context.primaryBarracks == 0)
+    return;
+
+  float defendPosX = 0.0f;
+  float defendPosY = 0.0f;
+  float defendPosZ = 0.0f;
+  bool foundBarracks = false;
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.id == context.primaryBarracks) {
+      defendPosX = entity.posX;
+      defendPosY = entity.posY;
+      defendPosZ = entity.posZ;
+      foundBarracks = true;
+      break;
+    }
+  }
+
+  if (!foundBarracks)
+    return;
+
+  std::vector<const EntitySnapshot *> readyDefenders;
+  std::vector<const EntitySnapshot *> engagedDefenders;
+  readyDefenders.reserve(snapshot.friendlies.size());
+  engagedDefenders.reserve(snapshot.friendlies.size());
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (isEntityEngaged(entity, snapshot.visibleEnemies)) {
+      engagedDefenders.push_back(&entity);
+    } else {
+      readyDefenders.push_back(&entity);
+    }
+  }
+
+  if (readyDefenders.empty() && engagedDefenders.empty())
+    return;
+
+  auto sortByDistance = [&](std::vector<const EntitySnapshot *> &list) {
+    std::sort(list.begin(), list.end(),
+              [&](const EntitySnapshot *a, const EntitySnapshot *b) {
+                float da = distanceSquared(a->posX, a->posY, a->posZ,
+                                           defendPosX, defendPosY, defendPosZ);
+                float db = distanceSquared(b->posX, b->posY, b->posZ,
+                                           defendPosX, defendPosY, defendPosZ);
+                return da < db;
+              });
+  };
+
+  sortByDistance(readyDefenders);
+  sortByDistance(engagedDefenders);
+
+  const std::size_t totalAvailable =
+      readyDefenders.size() + engagedDefenders.size();
+  std::size_t desiredCount = totalAvailable;
+
+  if (context.barracksUnderThreat) {
+
+    desiredCount = totalAvailable;
+  } else {
+
+    desiredCount =
+        std::min<std::size_t>(desiredCount, static_cast<std::size_t>(6));
+  }
+
+  std::size_t readyCount = std::min(desiredCount, readyDefenders.size());
+  readyDefenders.resize(readyCount);
+
+  if (readyDefenders.empty())
+    return;
+
+  if (context.barracksUnderThreat) {
+
+    std::vector<const ContactSnapshot *> nearbyThreats;
+    nearbyThreats.reserve(snapshot.visibleEnemies.size());
+
+    constexpr float DEFEND_RADIUS = 40.0f;
+    const float defendRadiusSq = DEFEND_RADIUS * DEFEND_RADIUS;
+
+    for (const auto &enemy : snapshot.visibleEnemies) {
+      float distSq = distanceSquared(enemy.posX, enemy.posY, enemy.posZ,
+                                     defendPosX, defendPosY, defendPosZ);
+      if (distSq <= defendRadiusSq) {
+        nearbyThreats.push_back(&enemy);
+      }
+    }
+
+    if (!nearbyThreats.empty()) {
+
+      auto targetInfo = TacticalUtils::selectFocusFireTarget(
+          readyDefenders, nearbyThreats, defendPosX, defendPosY, defendPosZ,
+          context, 0);
+
+      if (targetInfo.targetId != 0) {
+
+        std::vector<Engine::Core::EntityID> defenderIds;
+        defenderIds.reserve(readyDefenders.size());
+        for (const auto *unit : readyDefenders) {
+          defenderIds.push_back(unit->id);
+        }
+
+        auto claimedUnits =
+            claimUnits(defenderIds, getPriority(), "defending", context,
+                       m_defendTimer + deltaTime, 3.0f);
+
+        if (!claimedUnits.empty()) {
+          AICommand attack;
+          attack.type = AICommandType::AttackTarget;
+          attack.units = std::move(claimedUnits);
+          attack.targetId = targetInfo.targetId;
+          attack.shouldChase = true;
+          outCommands.push_back(std::move(attack));
+          return;
+        }
+      }
+    } else if (context.barracksUnderThreat) {
+
+      const ContactSnapshot *closestThreat = nullptr;
+      float closestDistSq = std::numeric_limits<float>::max();
+
+      for (const auto &enemy : snapshot.visibleEnemies) {
+        float distSq = distanceSquared(enemy.posX, enemy.posY, enemy.posZ,
+                                       defendPosX, defendPosY, defendPosZ);
+        if (distSq < closestDistSq) {
+          closestDistSq = distSq;
+          closestThreat = &enemy;
+        }
+      }
+
+      if (closestThreat && !readyDefenders.empty()) {
+
+        std::vector<Engine::Core::EntityID> defenderIds;
+        std::vector<float> targetX, targetY, targetZ;
+
+        for (const auto *unit : readyDefenders) {
+          defenderIds.push_back(unit->id);
+          targetX.push_back(closestThreat->posX);
+          targetY.push_back(closestThreat->posY);
+          targetZ.push_back(closestThreat->posZ);
+        }
+
+        auto claimedUnits =
+            claimUnits(defenderIds, getPriority(), "intercepting", context,
+                       m_defendTimer + deltaTime, 2.0f);
+
+        if (!claimedUnits.empty()) {
+
+          std::vector<float> filteredX, filteredY, filteredZ;
+          for (size_t i = 0; i < defenderIds.size(); ++i) {
+            if (std::find(claimedUnits.begin(), claimedUnits.end(),
+                          defenderIds[i]) != claimedUnits.end()) {
+              filteredX.push_back(targetX[i]);
+              filteredY.push_back(targetY[i]);
+              filteredZ.push_back(targetZ[i]);
+            }
+          }
+
+          AICommand move;
+          move.type = AICommandType::MoveUnits;
+          move.units = std::move(claimedUnits);
+          move.moveTargetX = std::move(filteredX);
+          move.moveTargetY = std::move(filteredY);
+          move.moveTargetZ = std::move(filteredZ);
+          outCommands.push_back(std::move(move));
+          return;
+        }
+      }
+    }
+  }
+
+  std::vector<const EntitySnapshot *> unclaimedDefenders;
+  for (const auto *unit : readyDefenders) {
+    auto it = context.assignedUnits.find(unit->id);
+    if (it == context.assignedUnits.end()) {
+      unclaimedDefenders.push_back(unit);
+    }
+  }
+
+  if (unclaimedDefenders.empty())
+    return;
+
+  QVector3D defendPos(defendPosX, defendPosY, defendPosZ);
+  auto targets = FormationPlanner::spreadFormation(
+      static_cast<int>(unclaimedDefenders.size()), defendPos, 3.0f);
+
+  std::vector<Engine::Core::EntityID> unitsToMove;
+  std::vector<float> targetX, targetY, targetZ;
+  unitsToMove.reserve(unclaimedDefenders.size());
+  targetX.reserve(unclaimedDefenders.size());
+  targetY.reserve(unclaimedDefenders.size());
+  targetZ.reserve(unclaimedDefenders.size());
+
+  for (size_t i = 0; i < unclaimedDefenders.size(); ++i) {
+    const auto *entity = unclaimedDefenders[i];
+    const auto &target = targets[i];
+
+    float dx = entity->posX - target.x();
+    float dz = entity->posZ - target.z();
+    float distanceSq = dx * dx + dz * dz;
+
+    if (distanceSq < 1.0f * 1.0f)
+      continue;
+
+    unitsToMove.push_back(entity->id);
+    targetX.push_back(target.x());
+    targetY.push_back(target.y());
+    targetZ.push_back(target.z());
+  }
+
+  if (unitsToMove.empty())
+    return;
+
+  auto claimedForMove =
+      claimUnits(unitsToMove, BehaviorPriority::Low, "positioning", context,
+                 m_defendTimer + deltaTime, 1.5f);
+
+  if (claimedForMove.empty())
+    return;
+
+  std::vector<float> filteredX, filteredY, filteredZ;
+  for (size_t i = 0; i < unitsToMove.size(); ++i) {
+    if (std::find(claimedForMove.begin(), claimedForMove.end(),
+                  unitsToMove[i]) != claimedForMove.end()) {
+      filteredX.push_back(targetX[i]);
+      filteredY.push_back(targetY[i]);
+      filteredZ.push_back(targetZ[i]);
+    }
+  }
+
+  AICommand command;
+  command.type = AICommandType::MoveUnits;
+  command.units = std::move(claimedForMove);
+  command.moveTargetX = std::move(filteredX);
+  command.moveTargetY = std::move(filteredY);
+  command.moveTargetZ = std::move(filteredZ);
+  outCommands.push_back(std::move(command));
+}
+
+bool DefendBehavior::shouldExecute(const AISnapshot &snapshot,
+                                   const AIContext &context) const {
+  (void)snapshot;
+
+  if (context.primaryBarracks == 0)
+    return false;
+
+  if (context.barracksUnderThreat)
+    return true;
+
+  if (context.state == AIState::Defending && context.idleUnits > 0)
+    return true;
+
+  if (context.averageHealth < 0.6f && context.totalUnits > 0)
+    return true;
+
+  return false;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/defend_behavior.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../ai_behavior.h"
+
+namespace Game::Systems::AI {
+
+class DefendBehavior : public AIBehavior {
+public:
+  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+               std::vector<AICommand> &outCommands) override;
+
+  bool shouldExecute(const AISnapshot &snapshot,
+                     const AIContext &context) const override;
+
+  BehaviorPriority getPriority() const override {
+    return BehaviorPriority::Critical;
+  }
+
+  bool canRunConcurrently() const override { return false; }
+
+private:
+  float m_defendTimer = 0.0f;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/gather_behavior.cpp

@@ -0,0 +1,135 @@
+#include "gather_behavior.h"
+#include "../../formation_planner.h"
+#include "../ai_utils.h"
+
+#include <QDebug>
+#include <QVector3D>
+
+namespace Game::Systems::AI {
+
+void GatherBehavior::execute(const AISnapshot &snapshot, AIContext &context,
+                             float deltaTime,
+                             std::vector<AICommand> &outCommands) {
+  m_gatherTimer += deltaTime;
+
+  if (m_gatherTimer < 1.0f)
+    return;
+  m_gatherTimer = 0.0f;
+
+  if (context.primaryBarracks == 0)
+    return;
+
+  QVector3D rallyPoint(context.rallyX, 0.0f, context.rallyZ);
+
+  std::vector<const EntitySnapshot *> unitsToGather;
+  unitsToGather.reserve(snapshot.friendlies.size());
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (isEntityEngaged(entity, snapshot.visibleEnemies))
+      continue;
+
+    const float dx = entity.posX - rallyPoint.x();
+    const float dz = entity.posZ - rallyPoint.z();
+    const float distSq = dx * dx + dz * dz;
+
+    if (distSq > 2.0f * 2.0f) {
+      unitsToGather.push_back(&entity);
+    }
+  }
+
+  if (unitsToGather.empty())
+    return;
+
+  auto formationTargets = FormationPlanner::spreadFormation(
+      static_cast<int>(unitsToGather.size()), rallyPoint, 1.4f);
+
+  std::vector<Engine::Core::EntityID> unitsToMove;
+  std::vector<float> targetX, targetY, targetZ;
+  unitsToMove.reserve(unitsToGather.size());
+  targetX.reserve(unitsToGather.size());
+  targetY.reserve(unitsToGather.size());
+  targetZ.reserve(unitsToGather.size());
+
+  for (size_t i = 0; i < unitsToGather.size(); ++i) {
+    const auto *entity = unitsToGather[i];
+    const auto &target = formationTargets[i];
+
+    unitsToMove.push_back(entity->id);
+    targetX.push_back(target.x());
+    targetY.push_back(target.y());
+    targetZ.push_back(target.z());
+  }
+
+  if (unitsToMove.empty())
+    return;
+
+  auto claimedUnits = claimUnits(unitsToMove, getPriority(), "gathering",
+                                 context, m_gatherTimer + deltaTime, 2.0f);
+
+  if (claimedUnits.empty())
+    return;
+
+  std::vector<float> filteredX, filteredY, filteredZ;
+  for (size_t i = 0; i < unitsToMove.size(); ++i) {
+    if (std::find(claimedUnits.begin(), claimedUnits.end(), unitsToMove[i]) !=
+        claimedUnits.end()) {
+      filteredX.push_back(targetX[i]);
+      filteredY.push_back(targetY[i]);
+      filteredZ.push_back(targetZ[i]);
+    }
+  }
+
+  AICommand command;
+  command.type = AICommandType::MoveUnits;
+  command.units = std::move(claimedUnits);
+  command.moveTargetX = std::move(filteredX);
+  command.moveTargetY = std::move(filteredY);
+  command.moveTargetZ = std::move(filteredZ);
+
+  qDebug() << "[GatherBehavior] Issuing MoveUnits for" << command.units.size()
+           << "units to rally point (" << context.rallyX << ","
+           << context.rallyZ << ")"
+           << "in state:" << static_cast<int>(context.state);
+
+  outCommands.push_back(std::move(command));
+}
+
+bool GatherBehavior::shouldExecute(const AISnapshot &snapshot,
+                                   const AIContext &context) const {
+  if (context.primaryBarracks == 0)
+    return false;
+
+  if (context.state == AIState::Retreating)
+    return false;
+
+  if (context.state == AIState::Attacking)
+    return false;
+
+  if (context.state == AIState::Defending) {
+
+    QVector3D rallyPoint(context.rallyX, 0.0f, context.rallyZ);
+    for (const auto &entity : snapshot.friendlies) {
+      if (entity.isBuilding)
+        continue;
+
+      const float dx = entity.posX - rallyPoint.x();
+      const float dz = entity.posZ - rallyPoint.z();
+      const float distSq = dx * dx + dz * dz;
+
+      if (distSq > 10.0f * 10.0f) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  if (context.state == AIState::Gathering || context.state == AIState::Idle)
+    return true;
+
+  return false;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/gather_behavior.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../ai_behavior.h"
+
+namespace Game::Systems::AI {
+
+class GatherBehavior : public AIBehavior {
+public:
+  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+               std::vector<AICommand> &outCommands) override;
+
+  bool shouldExecute(const AISnapshot &snapshot,
+                     const AIContext &context) const override;
+
+  BehaviorPriority getPriority() const override {
+    return BehaviorPriority::Low;
+  }
+
+  bool canRunConcurrently() const override { return false; }
+
+private:
+  float m_gatherTimer = 0.0f;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/production_behavior.cpp

@@ -0,0 +1,90 @@
+#include "production_behavior.h"
+#include "../../nation_registry.h"
+#include "../ai_tactical.h"
+
+namespace Game::Systems::AI {
+
+void ProductionBehavior::execute(const AISnapshot &snapshot, AIContext &context,
+                                 float deltaTime,
+                                 std::vector<AICommand> &outCommands) {
+  m_productionTimer += deltaTime;
+  if (m_productionTimer < 1.5f)
+    return;
+  m_productionTimer = 0.0f;
+
+  static int execCounter = 0;
+
+  auto &nationRegistry = Game::Systems::NationRegistry::instance();
+  const auto *nation = nationRegistry.getNationForPlayer(context.playerId);
+
+  if (!nation) {
+
+    static int logCounter = 0;
+    return;
+  }
+
+  bool produceRanged = true;
+
+  if (context.barracksUnderThreat || context.state == AIState::Defending) {
+    produceRanged = (context.meleeCount > context.rangedCount);
+  } else {
+
+    float rangedRatio =
+        (context.totalUnits > 0)
+            ? static_cast<float>(context.rangedCount) / context.totalUnits
+            : 0.0f;
+    produceRanged = (rangedRatio < 0.6f);
+  }
+
+  const Game::Systems::TroopType *troopType = produceRanged
+                                                  ? nation->getBestRangedTroop()
+                                                  : nation->getBestMeleeTroop();
+
+  if (!troopType) {
+    troopType = produceRanged ? nation->getBestMeleeTroop()
+                              : nation->getBestRangedTroop();
+  }
+
+  if (!troopType) {
+    static int logCounter = 0;
+    return;
+  }
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (!entity.isBuilding || entity.unitType != "barracks")
+      continue;
+
+    static int logCounter = 0;
+
+    if (!entity.production.hasComponent)
+      continue;
+
+    const auto &prod = entity.production;
+
+    if (prod.inProgress)
+      continue;
+
+    if (prod.producedCount >= prod.maxUnits)
+      continue;
+
+    AICommand command;
+    command.type = AICommandType::StartProduction;
+    command.buildingId = entity.id;
+    command.productType = troopType->unitType;
+    outCommands.push_back(std::move(command));
+
+    m_productionCounter++;
+  }
+}
+
+bool ProductionBehavior::shouldExecute(const AISnapshot &snapshot,
+                                       const AIContext &context) const {
+  (void)snapshot;
+
+  if (context.totalUnits >= 20)
+    return false;
+
+  return true;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/production_behavior.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "../ai_behavior.h"
+
+namespace Game::Systems::AI {
+
+class ProductionBehavior : public AIBehavior {
+public:
+  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+               std::vector<AICommand> &outCommands) override;
+
+  bool shouldExecute(const AISnapshot &snapshot,
+                     const AIContext &context) const override;
+
+  BehaviorPriority getPriority() const override {
+    return BehaviorPriority::High;
+  }
+
+  bool canRunConcurrently() const override { return true; }
+
+private:
+  float m_productionTimer = 0.0f;
+  int m_productionCounter = 0;
+};
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/retreat_behavior.cpp

@@ -0,0 +1,123 @@
+#include "retreat_behavior.h"
+#include "../../formation_planner.h"
+#include "../ai_tactical.h"
+#include "../ai_utils.h"
+
+#include <QVector3D>
+#include <algorithm>
+
+namespace Game::Systems::AI {
+
+void RetreatBehavior::execute(const AISnapshot &snapshot, AIContext &context,
+                              float deltaTime,
+                              std::vector<AICommand> &outCommands) {
+  m_retreatTimer += deltaTime;
+  if (m_retreatTimer < 1.0f)
+    return;
+  m_retreatTimer = 0.0f;
+
+  if (context.primaryBarracks == 0)
+    return;
+
+  std::vector<const EntitySnapshot *> retreatingUnits;
+  retreatingUnits.reserve(snapshot.friendlies.size());
+
+  constexpr float CRITICAL_HEALTH = 0.35f;
+  constexpr float LOW_HEALTH = 0.50f;
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (entity.maxHealth <= 0)
+      continue;
+
+    float healthRatio = static_cast<float>(entity.health) /
+                        static_cast<float>(entity.maxHealth);
+
+    if (healthRatio < CRITICAL_HEALTH) {
+      retreatingUnits.push_back(&entity);
+    }
+
+    else if (healthRatio < LOW_HEALTH &&
+             isEntityEngaged(entity, snapshot.visibleEnemies)) {
+      retreatingUnits.push_back(&entity);
+    }
+  }
+
+  if (retreatingUnits.empty())
+    return;
+
+  QVector3D retreatPos(context.basePosX, context.basePosY, context.basePosZ);
+
+  retreatPos.setX(retreatPos.x() - 8.0f);
+
+  auto retreatTargets = FormationPlanner::spreadFormation(
+      static_cast<int>(retreatingUnits.size()), retreatPos, 2.0f);
+
+  std::vector<Engine::Core::EntityID> unitIds;
+  std::vector<float> targetX, targetY, targetZ;
+  unitIds.reserve(retreatingUnits.size());
+  targetX.reserve(retreatingUnits.size());
+  targetY.reserve(retreatingUnits.size());
+  targetZ.reserve(retreatingUnits.size());
+
+  for (size_t i = 0; i < retreatingUnits.size(); ++i) {
+    unitIds.push_back(retreatingUnits[i]->id);
+    targetX.push_back(retreatTargets[i].x());
+    targetY.push_back(retreatTargets[i].y());
+    targetZ.push_back(retreatTargets[i].z());
+  }
+
+  auto claimedUnits = claimUnits(unitIds, getPriority(), "retreating", context,
+                                 m_retreatTimer + deltaTime, 1.0f);
+
+  if (claimedUnits.empty())
+    return;
+
+  std::vector<float> filteredX, filteredY, filteredZ;
+  for (size_t i = 0; i < unitIds.size(); ++i) {
+    if (std::find(claimedUnits.begin(), claimedUnits.end(), unitIds[i]) !=
+        claimedUnits.end()) {
+      filteredX.push_back(targetX[i]);
+      filteredY.push_back(targetY[i]);
+      filteredZ.push_back(targetZ[i]);
+    }
+  }
+
+  AICommand command;
+  command.type = AICommandType::MoveUnits;
+  command.units = std::move(claimedUnits);
+  command.moveTargetX = std::move(filteredX);
+  command.moveTargetY = std::move(filteredY);
+  command.moveTargetZ = std::move(filteredZ);
+  outCommands.push_back(std::move(command));
+}
+
+bool RetreatBehavior::shouldExecute(const AISnapshot &snapshot,
+                                    const AIContext &context) const {
+  if (context.primaryBarracks == 0)
+    return false;
+
+  if (context.state == AIState::Retreating)
+    return true;
+
+  constexpr float CRITICAL_HEALTH = 0.35f;
+
+  for (const auto &entity : snapshot.friendlies) {
+    if (entity.isBuilding)
+      continue;
+
+    if (entity.maxHealth > 0) {
+      float healthRatio = static_cast<float>(entity.health) /
+                          static_cast<float>(entity.maxHealth);
+      if (healthRatio < CRITICAL_HEALTH) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+} // namespace Game::Systems::AI

game/systems/ai_system/behaviors/retreat_behavior.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../ai_behavior.h"
+
+namespace Game::Systems::AI {
+
+class RetreatBehavior : public AIBehavior {
+public:
+  void execute(const AISnapshot &snapshot, AIContext &context, float deltaTime,
+               std::vector<AICommand> &outCommands) override;
+
+  bool shouldExecute(const AISnapshot &snapshot,
+                     const AIContext &context) const override;
+
+  BehaviorPriority getPriority() const override {
+    return BehaviorPriority::Critical;
+  }
+
+  bool canRunConcurrently() const override { return false; }
+
+private:
+  float m_retreatTimer = 0.0f;
+};
+
+} // namespace Game::Systems::AI

game/systems/combat_system.cpp

@@ -6,6 +6,7 @@
 #include "arrow_system.h"
 #include "building_collision_registry.h"
 #include "command_service.h"
+#include "owner_registry.h"
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -33,21 +34,87 @@ void CombatSystem::processAttacks(Engine::Core::World *world, float deltaTime) {
 
     if (attackerUnit->health <= 0)
       continue;
+
+    if (attackerAtk && attackerAtk->inMeleeLock) {
+      auto *lockTarget = world->getEntity(attackerAtk->meleeLockTargetId);
+      if (!lockTarget) {
+
+        attackerAtk->inMeleeLock = false;
+        attackerAtk->meleeLockTargetId = 0;
+      } else {
+        auto *lockTargetUnit =
+            lockTarget->getComponent<Engine::Core::UnitComponent>();
+        if (!lockTargetUnit || lockTargetUnit->health <= 0) {
+
+          attackerAtk->inMeleeLock = false;
+          attackerAtk->meleeLockTargetId = 0;
+        } else {
+
+          auto *attT = attackerTransform;
+          auto *tgtT =
+              lockTarget->getComponent<Engine::Core::TransformComponent>();
+          if (attT && tgtT) {
+            float dx = tgtT->position.x - attT->position.x;
+            float dz = tgtT->position.z - attT->position.z;
+            float dist = std::sqrt(dx * dx + dz * dz);
+
+            const float IDEAL_MELEE_DISTANCE = 0.6f;
+            const float MAX_MELEE_SEPARATION = 0.9f;
+
+            if (dist > MAX_MELEE_SEPARATION) {
+              float pullAmount =
+                  (dist - IDEAL_MELEE_DISTANCE) * 0.3f * deltaTime * 5.0f;
+
+              if (dist > 0.001f) {
+                QVector3D direction(dx / dist, 0.0f, dz / dist);
+
+                attT->position.x += direction.x() * pullAmount;
+                attT->position.z += direction.z() * pullAmount;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (attackerAtk && attackerAtk->inMeleeLock &&
+        attackerAtk->meleeLockTargetId != 0) {
+      auto *lockTarget = world->getEntity(attackerAtk->meleeLockTargetId);
+      if (lockTarget) {
+
+        auto *attackTarget =
+            attacker->getComponent<Engine::Core::AttackTargetComponent>();
+        if (!attackTarget) {
+          attackTarget =
+              attacker->addComponent<Engine::Core::AttackTargetComponent>();
+        }
+        if (attackTarget) {
+          attackTarget->targetId = attackerAtk->meleeLockTargetId;
+          attackTarget->shouldChase = false;
+        }
+      }
+    }
+
     float range = 2.0f;
     int damage = 10;
     float cooldown = 1.0f;
     float *tAccum = nullptr;
     float tmpAccum = 0.0f;
+
     if (attackerAtk) {
-      range = std::max(0.1f, attackerAtk->range);
-      damage = std::max(0, attackerAtk->damage);
-      cooldown = std::max(0.05f, attackerAtk->cooldown);
+
+      updateCombatMode(attacker, world, attackerAtk);
+
+      range = attackerAtk->getCurrentRange();
+      damage = attackerAtk->getCurrentDamage();
+      cooldown = attackerAtk->getCurrentCooldown();
       attackerAtk->timeSinceLast += deltaTime;
       tAccum = &attackerAtk->timeSinceLast;
     } else {
       tmpAccum += deltaTime;
       tAccum = &tmpAccum;
     }
+
     if (*tAccum < cooldown) {
       continue;
     }
@@ -62,8 +129,12 @@ void CombatSystem::processAttacks(Engine::Core::World *world, float deltaTime) {
       if (target) {
         auto *targetUnit = target->getComponent<Engine::Core::UnitComponent>();
 
+        auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+        bool isAlly =
+            ownerRegistry.areAllies(attackerUnit->ownerId, targetUnit->ownerId);
+
         if (targetUnit && targetUnit->health > 0 &&
-            targetUnit->ownerId != attackerUnit->ownerId) {
+            targetUnit->ownerId != attackerUnit->ownerId && !isAlly) {
 
           if (isInRange(attacker, target, range)) {
             bestTarget = target;
@@ -185,6 +256,8 @@ void CombatSystem::processAttacks(Engine::Core::World *world, float deltaTime) {
 
     if (!bestTarget && !attackTarget) {
 
+      auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+
       for (auto target : units) {
         if (target == attacker) {
           continue;
@@ -199,6 +272,11 @@ void CombatSystem::processAttacks(Engine::Core::World *world, float deltaTime) {
           continue;
         }
 
+        if (ownerRegistry.areAllies(attackerUnit->ownerId,
+                                    targetUnit->ownerId)) {
+          continue;
+        }
+
         if (target->hasComponent<Engine::Core::BuildingComponent>()) {
           continue;
         }
@@ -245,17 +323,64 @@ void CombatSystem::processAttacks(Engine::Core::World *world, float deltaTime) {
         auto tgtT =
             bestTarget->getComponent<Engine::Core::TransformComponent>();
         auto attU = attacker->getComponent<Engine::Core::UnitComponent>();
-        QVector3D aPos(attT->position.x, attT->position.y, attT->position.z);
-        QVector3D tPos(tgtT->position.x, tgtT->position.y, tgtT->position.z);
-        QVector3D dir = (tPos - aPos).normalized();
-
-        QVector3D start = aPos + QVector3D(0.0f, 0.6f, 0.0f) + dir * 0.35f;
-        QVector3D end = tPos + QVector3D(0.5f, 0.5f, 0.0f);
-        QVector3D color = attU ? Game::Visuals::teamColorForOwner(attU->ownerId)
-                               : QVector3D(0.8f, 0.9f, 1.0f);
-        arrowSys->spawnArrow(start, end, color, 14.0f);
+
+        if (!attackerAtk ||
+            attackerAtk->currentMode !=
+                Engine::Core::AttackComponent::CombatMode::Melee) {
+          QVector3D aPos(attT->position.x, attT->position.y, attT->position.z);
+          QVector3D tPos(tgtT->position.x, tgtT->position.y, tgtT->position.z);
+          QVector3D dir = (tPos - aPos).normalized();
+
+          QVector3D start = aPos + QVector3D(0.0f, 0.6f, 0.0f) + dir * 0.35f;
+          QVector3D end = tPos + QVector3D(0.5f, 0.5f, 0.0f);
+          QVector3D color =
+              attU ? Game::Visuals::teamColorForOwner(attU->ownerId)
+                   : QVector3D(0.8f, 0.9f, 1.0f);
+          arrowSys->spawnArrow(start, end, color, 14.0f);
+        }
+      }
+
+      if (attackerAtk && attackerAtk->currentMode ==
+                             Engine::Core::AttackComponent::CombatMode::Melee) {
+
+        attackerAtk->inMeleeLock = true;
+        attackerAtk->meleeLockTargetId = bestTarget->getId();
+
+        auto *targetAtk =
+            bestTarget->getComponent<Engine::Core::AttackComponent>();
+        if (targetAtk) {
+          targetAtk->inMeleeLock = true;
+          targetAtk->meleeLockTargetId = attacker->getId();
+        }
+
+        auto *attT = attacker->getComponent<Engine::Core::TransformComponent>();
+        auto *tgtT =
+            bestTarget->getComponent<Engine::Core::TransformComponent>();
+        if (attT && tgtT) {
+          float dx = tgtT->position.x - attT->position.x;
+          float dz = tgtT->position.z - attT->position.z;
+          float dist = std::sqrt(dx * dx + dz * dz);
+
+          const float IDEAL_MELEE_DISTANCE = 0.6f;
+
+          if (dist > IDEAL_MELEE_DISTANCE + 0.1f) {
+
+            float moveAmount = (dist - IDEAL_MELEE_DISTANCE) * 0.5f;
+
+            if (dist > 0.001f) {
+              QVector3D direction(dx / dist, 0.0f, dz / dist);
+
+              attT->position.x += direction.x() * moveAmount;
+              attT->position.z += direction.z() * moveAmount;
+
+              tgtT->position.x -= direction.x() * moveAmount;
+              tgtT->position.z -= direction.z() * moveAmount;
+            }
+          }
+        }
       }
-      dealDamage(bestTarget, damage);
+
+      dealDamage(world, bestTarget, damage);
       *tAccum = 0.0f;
     } else {
 
@@ -280,6 +405,7 @@ bool CombatSystem::isInRange(Engine::Core::Entity *attacker,
 
   float dx = targetTransform->position.x - attackerTransform->position.x;
   float dz = targetTransform->position.z - attackerTransform->position.z;
+  float dy = targetTransform->position.y - attackerTransform->position.y;
   float distanceSquared = dx * dx + dz * dz;
 
   float targetRadius = 0.0f;
@@ -297,10 +423,24 @@ bool CombatSystem::isInRange(Engine::Core::Entity *attacker,
 
   float effectiveRange = range + targetRadius;
 
-  return distanceSquared <= effectiveRange * effectiveRange;
+  if (distanceSquared > effectiveRange * effectiveRange) {
+    return false;
+  }
+
+  auto attackerAtk = attacker->getComponent<Engine::Core::AttackComponent>();
+  if (attackerAtk && attackerAtk->currentMode ==
+                         Engine::Core::AttackComponent::CombatMode::Melee) {
+    float heightDiff = std::abs(dy);
+    if (heightDiff > attackerAtk->maxHeightDifference) {
+      return false;
+    }
+  }
+
+  return true;
 }
 
-void CombatSystem::dealDamage(Engine::Core::Entity *target, int damage) {
+void CombatSystem::dealDamage(Engine::Core::World *world,
+                              Engine::Core::Entity *target, int damage) {
   auto unit = target->getComponent<Engine::Core::UnitComponent>();
   if (unit) {
     unit->health = std::max(0, unit->health - damage);
@@ -311,6 +451,24 @@ void CombatSystem::dealDamage(Engine::Core::Entity *target, int damage) {
           Engine::Core::UnitDiedEvent(target->getId(), unit->ownerId,
                                       unit->unitType));
 
+      auto *targetAtk = target->getComponent<Engine::Core::AttackComponent>();
+      if (targetAtk && targetAtk->inMeleeLock &&
+          targetAtk->meleeLockTargetId != 0) {
+
+        if (world) {
+          auto *lockPartner = world->getEntity(targetAtk->meleeLockTargetId);
+          if (lockPartner) {
+            auto *partnerAtk =
+                lockPartner->getComponent<Engine::Core::AttackComponent>();
+            if (partnerAtk &&
+                partnerAtk->meleeLockTargetId == target->getId()) {
+              partnerAtk->inMeleeLock = false;
+              partnerAtk->meleeLockTargetId = 0;
+            }
+          }
+        }
+      }
+
       if (target->hasComponent<Engine::Core::BuildingComponent>()) {
         BuildingCollisionRegistry::instance().unregisterBuilding(
             target->getId());
@@ -323,4 +481,93 @@ void CombatSystem::dealDamage(Engine::Core::Entity *target, int damage) {
   }
 }
 
+void CombatSystem::updateCombatMode(Engine::Core::Entity *attacker,
+                                    Engine::Core::World *world,
+                                    Engine::Core::AttackComponent *attackComp) {
+  if (!attackComp) {
+    return;
+  }
+
+  if (attackComp->preferredMode !=
+      Engine::Core::AttackComponent::CombatMode::Auto) {
+    attackComp->currentMode = attackComp->preferredMode;
+    return;
+  }
+
+  auto attackerTransform =
+      attacker->getComponent<Engine::Core::TransformComponent>();
+  if (!attackerTransform) {
+    return;
+  }
+
+  auto attackerUnit = attacker->getComponent<Engine::Core::UnitComponent>();
+  if (!attackerUnit) {
+    return;
+  }
+
+  auto &ownerRegistry = Game::Systems::OwnerRegistry::instance();
+  auto units = world->getEntitiesWith<Engine::Core::UnitComponent>();
+
+  float closestEnemyDistSq = std::numeric_limits<float>::max();
+  float closestHeightDiff = 0.0f;
+
+  for (auto target : units) {
+    if (target == attacker) {
+      continue;
+    }
+
+    auto targetUnit = target->getComponent<Engine::Core::UnitComponent>();
+    if (!targetUnit || targetUnit->health <= 0) {
+      continue;
+    }
+
+    if (ownerRegistry.areAllies(attackerUnit->ownerId, targetUnit->ownerId)) {
+      continue;
+    }
+
+    auto targetTransform =
+        target->getComponent<Engine::Core::TransformComponent>();
+    if (!targetTransform) {
+      continue;
+    }
+
+    float dx = targetTransform->position.x - attackerTransform->position.x;
+    float dz = targetTransform->position.z - attackerTransform->position.z;
+    float dy = targetTransform->position.y - attackerTransform->position.y;
+    float distSq = dx * dx + dz * dz;
+
+    if (distSq < closestEnemyDistSq) {
+      closestEnemyDistSq = distSq;
+      closestHeightDiff = std::abs(dy);
+    }
+  }
+
+  if (closestEnemyDistSq == std::numeric_limits<float>::max()) {
+    if (attackComp->canRanged) {
+      attackComp->currentMode =
+          Engine::Core::AttackComponent::CombatMode::Ranged;
+    } else {
+      attackComp->currentMode =
+          Engine::Core::AttackComponent::CombatMode::Melee;
+    }
+    return;
+  }
+
+  float closestDist = std::sqrt(closestEnemyDistSq);
+
+  bool inMeleeRange =
+      attackComp->isInMeleeRange(closestDist, closestHeightDiff);
+  bool inRangedRange = attackComp->isInRangedRange(closestDist);
+
+  if (inMeleeRange && attackComp->canMelee) {
+    attackComp->currentMode = Engine::Core::AttackComponent::CombatMode::Melee;
+  } else if (inRangedRange && attackComp->canRanged) {
+    attackComp->currentMode = Engine::Core::AttackComponent::CombatMode::Ranged;
+  } else if (attackComp->canRanged) {
+    attackComp->currentMode = Engine::Core::AttackComponent::CombatMode::Ranged;
+  } else {
+    attackComp->currentMode = Engine::Core::AttackComponent::CombatMode::Melee;
+  }
+}
+
 } // namespace Game::Systems

game/systems/combat_system.h

@@ -5,7 +5,8 @@
 namespace Engine {
 namespace Core {
 class Entity;
-}
+class AttackComponent;
+} // namespace Core
 } // namespace Engine
 
 namespace Game::Systems {
@@ -16,9 +17,13 @@ public:
 
 private:
   void processAttacks(Engine::Core::World *world, float deltaTime);
+  void updateCombatMode(Engine::Core::Entity *attacker,
+                        Engine::Core::World *world,
+                        Engine::Core::AttackComponent *attackComp);
   bool isInRange(Engine::Core::Entity *attacker, Engine::Core::Entity *target,
                  float range);
-  void dealDamage(Engine::Core::Entity *target, int damage);
+  void dealDamage(Engine::Core::World *world, Engine::Core::Entity *target,
+                  int damage);
 };
 
 } // namespace Game::Systems

game/systems/command_service.cpp

@@ -2,6 +2,7 @@
 #include "../core/component.h"
 #include "../core/world.h"
 #include "pathfinding.h"
+#include <QDebug>
 #include <QVector3D>
 #include <algorithm>
 #include <cmath>
@@ -12,7 +13,11 @@ namespace Systems {
 
 namespace {
 constexpr float SAME_TARGET_THRESHOLD_SQ = 0.01f;
-}
+
+constexpr float PATHFINDING_REQUEST_COOLDOWN = 1.0f;
+
+constexpr float TARGET_MOVEMENT_THRESHOLD_SQ = 4.0f;
+} // namespace
 
 std::unique_ptr<Pathfinding> CommandService::s_pathfinder = nullptr;
 std::unordered_map<std::uint64_t, CommandService::PendingPathRequest>
@@ -108,6 +113,12 @@ void CommandService::moveUnits(Engine::Core::World &world,
     if (!e)
       continue;
 
+    auto *atk = e->getComponent<Engine::Core::AttackComponent>();
+    if (atk && atk->inMeleeLock) {
+
+      continue;
+    }
+
     auto *transform = e->getComponent<Engine::Core::TransformComponent>();
     if (!transform)
       continue;
@@ -151,6 +162,22 @@ void CommandService::moveUnits(Engine::Core::World &world,
       continue;
     }
 
+    bool shouldSuppressPathRequest = false;
+    if (mv->timeSinceLastPathRequest < PATHFINDING_REQUEST_COOLDOWN) {
+
+      float lastGoalDx = mv->lastGoalX - targetX;
+      float lastGoalDz = mv->lastGoalY - targetZ;
+      float goalMovementSq = lastGoalDx * lastGoalDx + lastGoalDz * lastGoalDz;
+
+      if (goalMovementSq < TARGET_MOVEMENT_THRESHOLD_SQ) {
+        shouldSuppressPathRequest = true;
+
+        if (mv->hasTarget || mv->pathPending) {
+          continue;
+        }
+      }
+    }
+
     if (!mv->pathPending) {
       bool currentTargetMatches = mv->hasTarget && mv->path.empty();
       if (currentTargetMatches) {
@@ -202,6 +229,10 @@ void CommandService::moveUnits(Engine::Core::World &world,
         mv->pathPending = false;
         mv->pendingRequestId = 0;
         clearPendingRequest(units[i]);
+
+        mv->timeSinceLastPathRequest = 0.0f;
+        mv->lastGoalX = targetX;
+        mv->lastGoalY = targetZ;
       } else {
 
         bool skipNewRequest = false;
@@ -246,6 +277,10 @@ void CommandService::moveUnits(Engine::Core::World &world,
         }
 
         s_pathfinder->submitPathRequest(requestId, start, end);
+
+        mv->timeSinceLastPathRequest = 0.0f;
+        mv->lastGoalX = targetX;
+        mv->lastGoalY = targetZ;
       }
     } else {
 
@@ -270,6 +305,7 @@ void CommandService::moveGroup(Engine::Core::World &world,
     Engine::Core::TransformComponent *transform;
     Engine::Core::MovementComponent *movement;
     QVector3D target;
+    bool isEngaged;
   };
 
   std::vector<MemberInfo> members;
@@ -290,11 +326,16 @@ void CommandService::moveGroup(Engine::Core::World &world,
     if (!movement)
       continue;
 
+    bool engaged =
+        entity->getComponent<Engine::Core::AttackTargetComponent>() != nullptr;
+
     if (options.clearAttackIntent) {
       entity->removeComponent<Engine::Core::AttackTargetComponent>();
+      engaged = false;
     }
 
-    members.push_back({units[i], entity, transform, movement, targets[i]});
+    members.push_back(
+        {units[i], entity, transform, movement, targets[i], engaged});
   }
 
   if (members.empty())
@@ -309,6 +350,48 @@ void CommandService::moveGroup(Engine::Core::World &world,
     return;
   }
 
+  std::vector<MemberInfo> movingMembers;
+  std::vector<MemberInfo> engagedMembers;
+
+  for (const auto &member : members) {
+    if (member.isEngaged) {
+      engagedMembers.push_back(member);
+    } else {
+      movingMembers.push_back(member);
+    }
+  }
+
+  if (movingMembers.empty()) {
+    qDebug() << "[CommandService] Group move cancelled: all units are engaged "
+                "in combat";
+    return;
+  }
+
+  if (s_pathfinder) {
+    bool anyTargetInvalid = false;
+    for (const auto &member : movingMembers) {
+      Point targetGrid = worldToGrid(member.target.x(), member.target.z());
+
+      if (targetGrid.x < 0 || targetGrid.y < 0) {
+        anyTargetInvalid = true;
+        break;
+      }
+
+      if (!s_pathfinder->isWalkable(targetGrid.x, targetGrid.y)) {
+        anyTargetInvalid = true;
+        break;
+      }
+    }
+
+    if (anyTargetInvalid) {
+      qDebug() << "[CommandService] Group move cancelled: one or more targets "
+                  "are invalid/unwalkable";
+      return;
+    }
+  }
+
+  members = movingMembers;
+
   QVector3D average(0.0f, 0.0f, 0.0f);
   for (const auto &member : members)
     average += member.target;
@@ -327,26 +410,55 @@ void CommandService::moveGroup(Engine::Core::World &world,
   auto &leader = members[leaderIndex];
   QVector3D leaderTarget = leader.target;
 
+  std::vector<MemberInfo *> unitsNeedingNewPath;
+  constexpr float SAME_GOAL_THRESHOLD_SQ = 4.0f;
+
   for (auto &member : members) {
-    clearPendingRequest(member.id);
     auto *mv = member.movement;
+
     mv->goalX = member.target.x();
     mv->goalY = member.target.z();
-    mv->targetX = member.transform->position.x;
-    mv->targetY = member.transform->position.z;
-    mv->hasTarget = false;
-    mv->vx = 0.0f;
-    mv->vz = 0.0f;
-    mv->path.clear();
-    mv->pathPending = false;
-    mv->pendingRequestId = 0;
+
+    bool alreadyMovingToGoal = false;
+    if (mv->hasTarget || mv->pathPending) {
+      float goalDx = mv->goalX - member.target.x();
+      float goalDz = mv->goalY - member.target.z();
+      float goalDistSq = goalDx * goalDx + goalDz * goalDz;
+
+      if (goalDistSq <= SAME_GOAL_THRESHOLD_SQ) {
+        alreadyMovingToGoal = true;
+      }
+    }
+
+    if (!alreadyMovingToGoal) {
+
+      clearPendingRequest(member.id);
+      mv->targetX = member.transform->position.x;
+      mv->targetY = member.transform->position.z;
+      mv->hasTarget = false;
+      mv->vx = 0.0f;
+      mv->vz = 0.0f;
+      mv->path.clear();
+      mv->pathPending = false;
+      mv->pendingRequestId = 0;
+      unitsNeedingNewPath.push_back(&member);
+    } else {
+      qDebug() << "[CommandService] Unit" << member.id
+               << "already moving to goal, keeping existing path";
+    }
+  }
+
+  if (unitsNeedingNewPath.empty()) {
+    qDebug() << "[CommandService] All units already moving to goal, skipping "
+                "path recalculation";
+    return;
   }
 
   if (!s_pathfinder) {
-    for (auto &member : members) {
-      member.movement->targetX = member.target.x();
-      member.movement->targetY = member.target.z();
-      member.movement->hasTarget = true;
+    for (auto *member : unitsNeedingNewPath) {
+      member->movement->targetX = member->target.x();
+      member->movement->targetY = member->target.z();
+      member->movement->hasTarget = true;
     }
     return;
   }
@@ -356,10 +468,10 @@ void CommandService::moveGroup(Engine::Core::World &world,
   Point end = worldToGrid(leaderTarget.x(), leaderTarget.z());
 
   if (start == end) {
-    for (auto &member : members) {
-      member.movement->targetX = member.target.x();
-      member.movement->targetY = member.target.z();
-      member.movement->hasTarget = true;
+    for (auto *member : unitsNeedingNewPath) {
+      member->movement->targetX = member->target.x();
+      member->movement->targetY = member->target.z();
+      member->movement->hasTarget = true;
     }
     return;
   }
@@ -372,10 +484,14 @@ void CommandService::moveGroup(Engine::Core::World &world,
   }
 
   if (useDirectPath) {
-    for (auto &member : members) {
-      member.movement->targetX = member.target.x();
-      member.movement->targetY = member.target.z();
-      member.movement->hasTarget = true;
+    for (auto *member : unitsNeedingNewPath) {
+      member->movement->targetX = member->target.x();
+      member->movement->targetY = member->target.z();
+      member->movement->hasTarget = true;
+
+      member->movement->timeSinceLastPathRequest = 0.0f;
+      member->movement->lastGoalX = member->target.x();
+      member->movement->lastGoalY = member->target.z();
     }
     return;
   }
@@ -383,30 +499,38 @@ void CommandService::moveGroup(Engine::Core::World &world,
   std::uint64_t requestId =
       s_nextRequestId.fetch_add(1, std::memory_order_relaxed);
 
-  for (auto &member : members) {
-    member.movement->pathPending = true;
-    member.movement->pendingRequestId = requestId;
+  for (auto *member : unitsNeedingNewPath) {
+    member->movement->pathPending = true;
+    member->movement->pendingRequestId = requestId;
+
+    member->movement->timeSinceLastPathRequest = 0.0f;
+    member->movement->lastGoalX = member->target.x();
+    member->movement->lastGoalY = member->target.z();
   }
 
   PendingPathRequest pending;
   pending.entityId = leader.id;
   pending.target = leaderTarget;
   pending.options = options;
-  pending.groupMembers.reserve(members.size());
-  pending.groupTargets.reserve(members.size());
-  for (const auto &member : members) {
-    pending.groupMembers.push_back(member.id);
-    pending.groupTargets.push_back(member.target);
+  pending.groupMembers.reserve(unitsNeedingNewPath.size());
+  pending.groupTargets.reserve(unitsNeedingNewPath.size());
+  for (const auto *member : unitsNeedingNewPath) {
+    pending.groupMembers.push_back(member->id);
+    pending.groupTargets.push_back(member->target);
   }
 
   {
     std::lock_guard<std::mutex> lock(s_pendingMutex);
     s_pendingRequests[requestId] = std::move(pending);
-    for (const auto &member : members) {
-      s_entityToRequest[member.id] = requestId;
+    for (const auto *member : unitsNeedingNewPath) {
+      s_entityToRequest[member->id] = requestId;
     }
   }
 
+  qDebug() << "[CommandService] Submitted group path request for"
+           << unitsNeedingNewPath.size() << "units (out of" << members.size()
+           << "total)";
+
   s_pathfinder->submitPathRequest(requestId, start, end);
 }
 

game/systems/movement_system.cpp

@@ -100,6 +100,17 @@ void MovementSystem::moveUnit(Engine::Core::Entity *entity,
     return;
   }
 
+  auto *atk = entity->getComponent<Engine::Core::AttackComponent>();
+  if (atk && atk->inMeleeLock) {
+
+    movement->hasTarget = false;
+    movement->vx = 0.0f;
+    movement->vz = 0.0f;
+    movement->path.clear();
+    movement->pathPending = false;
+    return;
+  }
+
   QVector3D finalGoal(movement->goalX, 0.0f, movement->goalY);
   bool destinationAllowed = isPointAllowed(finalGoal, entity->getId());
 
@@ -118,6 +129,10 @@ void MovementSystem::moveUnit(Engine::Core::Entity *entity,
         std::max(0.0f, movement->repathCooldown - deltaTime);
   }
 
+  if (movement->timeSinceLastPathRequest < 10.0f) {
+    movement->timeSinceLastPathRequest += deltaTime;
+  }
+
   const float maxSpeed = std::max(0.1f, unit->speed);
   const float accel = maxSpeed * 4.0f;
   const float damping = 6.0f;

game/systems/nation_registry.cpp

@@ -0,0 +1,147 @@
+#include "nation_registry.h"
+#include <QDebug>
+#include <algorithm>
+
+namespace Game::Systems {
+
+std::vector<const TroopType *> Nation::getMeleeTroops() const {
+  std::vector<const TroopType *> result;
+  for (const auto &troop : availableTroops) {
+    if (troop.isMelee) {
+      result.push_back(&troop);
+    }
+  }
+  return result;
+}
+
+std::vector<const TroopType *> Nation::getRangedTroops() const {
+  std::vector<const TroopType *> result;
+  for (const auto &troop : availableTroops) {
+    if (!troop.isMelee) {
+      result.push_back(&troop);
+    }
+  }
+  return result;
+}
+
+const TroopType *Nation::getTroop(const std::string &unitType) const {
+  for (const auto &troop : availableTroops) {
+    if (troop.unitType == unitType) {
+      return &troop;
+    }
+  }
+  return nullptr;
+}
+
+const TroopType *Nation::getBestMeleeTroop() const {
+  auto melee = getMeleeTroops();
+  if (melee.empty())
+    return nullptr;
+
+  auto it = std::max_element(melee.begin(), melee.end(),
+                             [](const TroopType *a, const TroopType *b) {
+                               return a->priority < b->priority;
+                             });
+
+  return *it;
+}
+
+const TroopType *Nation::getBestRangedTroop() const {
+  auto ranged = getRangedTroops();
+  if (ranged.empty())
+    return nullptr;
+
+  auto it = std::max_element(ranged.begin(), ranged.end(),
+                             [](const TroopType *a, const TroopType *b) {
+                               return a->priority < b->priority;
+                             });
+
+  return *it;
+}
+
+NationRegistry &NationRegistry::instance() {
+  static NationRegistry inst;
+  return inst;
+}
+
+void NationRegistry::registerNation(Nation nation) {
+
+  auto it = m_nationIndex.find(nation.id);
+  if (it != m_nationIndex.end()) {
+
+    m_nations[it->second] = std::move(nation);
+    return;
+  }
+
+  size_t index = m_nations.size();
+  m_nations.push_back(std::move(nation));
+  m_nationIndex[m_nations.back().id] = index;
+}
+
+const Nation *NationRegistry::getNation(const std::string &nationId) const {
+  auto it = m_nationIndex.find(nationId);
+  if (it == m_nationIndex.end()) {
+    return nullptr;
+  }
+  return &m_nations[it->second];
+}
+
+const Nation *NationRegistry::getNationForPlayer(int playerId) const {
+
+  auto it = m_playerNations.find(playerId);
+  if (it != m_playerNations.end()) {
+    auto *nation = getNation(it->second);
+    qDebug() << "[NationRegistry] Player" << playerId
+             << "assigned to nation:" << QString::fromStdString(it->second);
+    return nation;
+  }
+
+  auto *nation = getNation(m_defaultNation);
+  if (!nation) {
+    qDebug() << "[NationRegistry] ERROR: No default nation ("
+             << QString::fromStdString(m_defaultNation) << ") found for player"
+             << playerId;
+  }
+  return nation;
+}
+
+void NationRegistry::setPlayerNation(int playerId,
+                                     const std::string &nationId) {
+  m_playerNations[playerId] = nationId;
+}
+
+void NationRegistry::initializeDefaults() {
+  clear();
+
+  qDebug() << "[NationRegistry] Initializing default nations...";
+
+  Nation kingdomOfIron;
+  kingdomOfIron.id = "kingdom_of_iron";
+  kingdomOfIron.displayName = "Kingdom of Iron";
+  kingdomOfIron.primaryBuilding = "barracks";
+
+  TroopType archer;
+  archer.unitType = "archer";
+  archer.displayName = "Archer";
+  archer.isMelee = false;
+  archer.cost = 50;
+  archer.buildTime = 5.0f;
+  archer.priority = 10;
+  kingdomOfIron.availableTroops.push_back(archer);
+
+  registerNation(std::move(kingdomOfIron));
+
+  m_defaultNation = "kingdom_of_iron";
+
+  qDebug() << "[NationRegistry] Registered nation:"
+           << QString::fromStdString(m_defaultNation) << "with"
+           << m_nations[0].availableTroops.size() << "troop types";
+}
+
+void NationRegistry::clear() {
+  m_nations.clear();
+  m_nationIndex.clear();
+  m_playerNations.clear();
+}
+
+} // namespace Game::Systems

game/systems/nation_registry.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Game::Systems {
+
+struct TroopType {
+  std::string unitType;
+  std::string displayName;
+  bool isMelee = false;
+  int cost = 100;
+  float buildTime = 5.0f;
+  int priority = 0;
+};
+
+struct Nation {
+  std::string id;
+  std::string displayName;
+  std::vector<TroopType> availableTroops;
+  std::string primaryBuilding = "barracks";
+
+  std::vector<const TroopType *> getMeleeTroops() const;
+
+  std::vector<const TroopType *> getRangedTroops() const;
+
+  const TroopType *getTroop(const std::string &unitType) const;
+
+  const TroopType *getBestMeleeTroop() const;
+  const TroopType *getBestRangedTroop() const;
+};
+
+class NationRegistry {
+public:
+  static NationRegistry &instance();
+
+  void registerNation(Nation nation);
+
+  const Nation *getNation(const std::string &nationId) const;
+
+  const Nation *getNationForPlayer(int playerId) const;
+
+  void setPlayerNation(int playerId, const std::string &nationId);
+
+  const std::vector<Nation> &getAllNations() const { return m_nations; }
+
+  void initializeDefaults();
+
+  void clear();
+
+private:
+  NationRegistry() = default;
+
+  std::vector<Nation> m_nations;
+  std::unordered_map<std::string, size_t> m_nationIndex;
+  std::unordered_map<int, std::string> m_playerNations;
+  std::string m_defaultNation = "kingdom_of_iron";
+};
+
+} // namespace Game::Systems

game/systems/owner_registry.cpp

@@ -1,4 +1,5 @@
 #include "owner_registry.h"
+#include <QDebug>
 
 namespace Game::Systems {
 
@@ -21,6 +22,24 @@ int OwnerRegistry::registerOwner(OwnerType type, const std::string &name) {
   info.type = type;
   info.name = name.empty() ? ("Owner" + std::to_string(ownerId)) : name;
 
+  switch (ownerId) {
+  case 1:
+    info.color = {0.20f, 0.55f, 1.00f};
+    break;
+  case 2:
+    info.color = {1.00f, 0.30f, 0.30f};
+    break;
+  case 3:
+    info.color = {0.20f, 0.80f, 0.40f};
+    break;
+  case 4:
+    info.color = {1.00f, 0.80f, 0.20f};
+    break;
+  default:
+    info.color = {0.8f, 0.9f, 1.0f};
+    break;
+  }
+
   size_t index = m_owners.size();
   m_owners.push_back(info);
   m_ownerIdToIndex[ownerId] = index;
@@ -39,6 +58,24 @@ void OwnerRegistry::registerOwnerWithId(int ownerId, OwnerType type,
   info.type = type;
   info.name = name.empty() ? ("Owner" + std::to_string(ownerId)) : name;
 
+  switch (ownerId) {
+  case 1:
+    info.color = {0.20f, 0.55f, 1.00f};
+    break;
+  case 2:
+    info.color = {1.00f, 0.30f, 0.30f};
+    break;
+  case 3:
+    info.color = {0.20f, 0.80f, 0.40f};
+    break;
+  case 4:
+    info.color = {1.00f, 0.80f, 0.20f};
+    break;
+  default:
+    info.color = {0.8f, 0.9f, 1.0f};
+    break;
+  }
+
   size_t index = m_owners.size();
   m_owners.push_back(info);
   m_ownerIdToIndex[ownerId] = index;
@@ -106,4 +143,91 @@ std::vector<int> OwnerRegistry::getAIOwnerIds() const {
   return result;
 }
 
+void OwnerRegistry::setOwnerTeam(int ownerId, int teamId) {
+  auto it = m_ownerIdToIndex.find(ownerId);
+  if (it != m_ownerIdToIndex.end()) {
+    m_owners[it->second].teamId = teamId;
+  }
+}
+
+int OwnerRegistry::getOwnerTeam(int ownerId) const {
+  auto it = m_ownerIdToIndex.find(ownerId);
+  if (it == m_ownerIdToIndex.end())
+    return 0;
+  return m_owners[it->second].teamId;
+}
+
+bool OwnerRegistry::areAllies(int ownerId1, int ownerId2) const {
+
+  if (ownerId1 == ownerId2)
+    return true;
+
+  int team1 = getOwnerTeam(ownerId1);
+  int team2 = getOwnerTeam(ownerId2);
+
+  bool result = (team1 == team2);
+
+  static int logCount = 0;
+  if (result && logCount < 5) {
+    qDebug() << "[OwnerRegistry] Players" << ownerId1 << "and" << ownerId2
+             << "are ALLIES (both team" << team1 << ")";
+    logCount++;
+  }
+
+  return result;
+}
+
+bool OwnerRegistry::areEnemies(int ownerId1, int ownerId2) const {
+
+  if (ownerId1 == ownerId2)
+    return false;
+
+  if (areAllies(ownerId1, ownerId2))
+    return false;
+
+  return true;
+}
+
+std::vector<int> OwnerRegistry::getAlliesOf(int ownerId) const {
+  std::vector<int> result;
+  int myTeam = getOwnerTeam(ownerId);
+
+  if (myTeam == 0)
+    return result;
+
+  for (const auto &owner : m_owners) {
+    if (owner.ownerId != ownerId && owner.teamId == myTeam) {
+      result.push_back(owner.ownerId);
+    }
+  }
+  return result;
+}
+
+std::vector<int> OwnerRegistry::getEnemiesOf(int ownerId) const {
+  std::vector<int> result;
+
+  for (const auto &owner : m_owners) {
+    if (areEnemies(ownerId, owner.ownerId)) {
+      result.push_back(owner.ownerId);
+    }
+  }
+  return result;
+}
+
+void OwnerRegistry::setOwnerColor(int ownerId, float r, float g, float b) {
+  auto it = m_ownerIdToIndex.find(ownerId);
+  if (it != m_ownerIdToIndex.end()) {
+    m_owners[it->second].color = {r, g, b};
+  }
+}
+
+std::array<float, 3> OwnerRegistry::getOwnerColor(int ownerId) const {
+  auto it = m_ownerIdToIndex.find(ownerId);
+  if (it != m_ownerIdToIndex.end()) {
+    return m_owners[it->second].color;
+  }
+
+  return {0.8f, 0.9f, 1.0f};
+}
+
 } // namespace Game::Systems

game/systems/owner_registry.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -12,6 +13,8 @@ struct OwnerInfo {
   int ownerId;
   OwnerType type;
   std::string name;
+  int teamId = 0;
+  std::array<float, 3> color = {0.8f, 0.9f, 1.0f};
 };
 
 class OwnerRegistry {
@@ -43,6 +46,16 @@ public:
 
   std::vector<int> getAIOwnerIds() const;
 
+  void setOwnerTeam(int ownerId, int teamId);
+  int getOwnerTeam(int ownerId) const;
+  bool areAllies(int ownerId1, int ownerId2) const;
+  bool areEnemies(int ownerId1, int ownerId2) const;
+  std::vector<int> getAlliesOf(int ownerId) const;
+  std::vector<int> getEnemiesOf(int ownerId) const;
+
+  void setOwnerColor(int ownerId, float r, float g, float b);
+  std::array<float, 3> getOwnerColor(int ownerId) const;
+
 private:
   OwnerRegistry() = default;
   ~OwnerRegistry() = default;

game/systems/victory_service.cpp

@@ -121,19 +121,26 @@ bool VictoryService::checkElimination(Engine::Core::World &world) {
 
   bool enemyKeyStructuresAlive = false;
 
+  auto &ownerRegistry = OwnerRegistry::instance();
+  int localTeam = ownerRegistry.getOwnerTeam(m_localOwnerId);
+
   auto entities = world.getEntitiesWith<Engine::Core::UnitComponent>();
   for (auto *e : entities) {
     auto *unit = e->getComponent<Engine::Core::UnitComponent>();
     if (!unit || unit->health <= 0)
       continue;
 
-    if (OwnerRegistry::instance().isAI(unit->ownerId)) {
-      QString unitType = QString::fromStdString(unit->unitType);
-      if (std::find(m_keyStructures.begin(), m_keyStructures.end(), unitType) !=
-          m_keyStructures.end()) {
-        enemyKeyStructuresAlive = true;
-        break;
-      }
+    if (unit->ownerId == m_localOwnerId)
+      continue;
+
+    if (ownerRegistry.areAllies(m_localOwnerId, unit->ownerId))
+      continue;
+
+    QString unitType = QString::fromStdString(unit->unitType);
+    if (std::find(m_keyStructures.begin(), m_keyStructures.end(), unitType) !=
+        m_keyStructures.end()) {
+      enemyKeyStructuresAlive = true;
+      break;
     }
   }
 

game/units/archer.cpp

@@ -2,6 +2,8 @@
 #include "../core/component.h"
 #include "../core/event_manager.h"
 #include "../core/world.h"
+#include <iostream>
+
 static inline QVector3D teamColor(int ownerId) {
   switch (ownerId) {
   case 1:
@@ -52,6 +54,11 @@ void Archer::init(const SpawnParams &params) {
 
   if (params.aiControlled) {
     e->addComponent<Engine::Core::AIControlledComponent>();
+    std::cout << "[Archer] Created AI-controlled archer for player "
+              << params.playerId << " at entity ID " << e->getId() << std::endl;
+  } else {
+    std::cout << "[Archer] Created player-controlled archer for player "
+              << params.playerId << " at entity ID " << e->getId() << std::endl;
   }
 
   QVector3D tc = teamColor(m_u->ownerId);
@@ -68,10 +75,21 @@ void Archer::init(const SpawnParams &params) {
   }
 
   m_atk = e->addComponent<Engine::Core::AttackComponent>();
+
   m_atk->range = 6.0f;
   m_atk->damage = 12;
   m_atk->cooldown = 1.2f;
 
+  m_atk->meleeRange = 1.5f;
+  m_atk->meleeDamage = 5;
+  m_atk->meleeCooldown = 0.8f;
+
+  m_atk->preferredMode = Engine::Core::AttackComponent::CombatMode::Auto;
+  m_atk->currentMode = Engine::Core::AttackComponent::CombatMode::Ranged;
+  m_atk->canRanged = true;
+  m_atk->canMelee = true;
+  m_atk->maxHeightDifference = 2.0f;
+
   Engine::Core::EventManager::instance().publish(
       Engine::Core::UnitSpawnedEvent(m_id, m_u->ownerId, m_u->unitType));
 }

game/units/barracks.cpp

@@ -5,6 +5,7 @@
 #include "../systems/building_collision_registry.h"
 #include "../visuals/team_colors.h"
 #include "troop_config.h"
+#include <iostream>
 
 namespace Game {
 namespace Units {
@@ -41,6 +42,11 @@ void Barracks::init(const SpawnParams &params) {
 
   if (params.aiControlled) {
     e->addComponent<Engine::Core::AIControlledComponent>();
+    std::cout << "[Barracks] Created AI-controlled barracks for player "
+              << params.playerId << " at entity ID " << e->getId() << std::endl;
+  } else {
+    std::cout << "[Barracks] Created player-controlled barracks for player "
+              << params.playerId << " at entity ID " << e->getId() << std::endl;
   }
 
   QVector3D tc = Game::Visuals::teamColorForOwner(m_u->ownerId);

game/visuals/team_colors.h

@@ -1,19 +1,12 @@
 #pragma once
+#include "../systems/owner_registry.h"
 #include <QVector3D>
 
 namespace Game::Visuals {
 inline QVector3D teamColorForOwner(int ownerId) {
-  switch (ownerId) {
-  case 1:
-    return QVector3D(0.20f, 0.55f, 1.00f);
-  case 2:
-    return QVector3D(1.00f, 0.30f, 0.30f);
-  case 3:
-    return QVector3D(0.20f, 0.80f, 0.40f);
-  case 4:
-    return QVector3D(1.00f, 0.80f, 0.20f);
-  default:
-    return QVector3D(0.8f, 0.9f, 1.0f);
-  }
+
+  auto &registry = Game::Systems::OwnerRegistry::instance();
+  auto color = registry.getOwnerColor(ownerId);
+  return QVector3D(color[0], color[1], color[2]);
 }
 } // namespace Game::Visuals

main.cpp

@@ -13,6 +13,7 @@
 
 #include "app/game_engine.h"
 #include "ui/gl_view.h"
+#include "ui/theme.h"
 
 int main(int argc, char *argv[]) {
   if (qEnvironmentVariableIsSet("WAYLAND_DISPLAY") &&
@@ -39,7 +40,13 @@ int main(int argc, char *argv[]) {
 
   QQmlApplicationEngine engine;
   engine.rootContext()->setContextProperty("game", gameEngine);
+  engine.addImportPath("qrc:/StandardOfIron/ui/qml");
   qmlRegisterType<GLView>("StandardOfIron", 1, 0, "GLView");
+
+  // Register Theme singleton
+  qmlRegisterSingletonType<Theme>("StandardOfIron.UI", 1, 0, "Theme",
+                                  &Theme::create);
+
   engine.load(QUrl(QStringLiteral("qrc:/StandardOfIron/ui/qml/Main.qml")));
   if (engine.rootObjects().isEmpty()) {
     qWarning() << "Failed to load QML file";

qml_resources.qrc

@@ -3,10 +3,19 @@
         <file>ui/qml/Main.qml</file>
         <file>ui/qml/MainMenu.qml</file>
         <file>ui/qml/MapSelect.qml</file>
+        <file>ui/qml/MapListPanel.qml</file>
+        <file>ui/qml/PlayerListItem.qml</file>
+        <file>ui/qml/PlayerConfigPanel.qml</file>
+        <file>ui/qml/Constants.qml</file>
+        <file>ui/qml/StyleGuide.qml</file>
+        <file>ui/qml/StyledButton.qml</file>
+        <file>ui/qml/Colors.js</file>
+        <file>ui/qml/qmldir</file>
         <file>ui/qml/HUD.qml</file>
         <file>ui/qml/HUDTop.qml</file>
         <file>ui/qml/HUDBottom.qml</file>
         <file>ui/qml/HUDVictory.qml</file>
         <file>ui/qml/GameView.qml</file>
+        <file>ui/qml/CursorManager.qml</file>
     </qresource>
 </RCC>

render/entity/archer_renderer.cpp

@@ -104,7 +104,7 @@ struct ArcherPose {
 };
 
 static inline ArcherPose makePose(uint32_t seed, float animTime, bool isMoving,
-                                  bool isAttacking) {
+                                  bool isAttacking, bool isMelee = false) {
   (void)seed;
   ArcherPose P;
 
@@ -117,22 +117,56 @@ static inline ArcherPose makePose(uint32_t seed, float animTime, bool isMoving,
     float attackCycleTime = 1.2f;
     float attackPhase = fmod(animTime * (1.0f / attackCycleTime), 1.0f);
 
-    QVector3D restPos(0.15f, HP::SHOULDER_Y + 0.15f, 0.20f);
-    QVector3D drawPos(0.35f, HP::SHOULDER_Y + 0.08f, -0.15f);
+    if (isMelee) {
 
-    if (attackPhase < 0.3f) {
+      QVector3D restPos(0.25f, HP::SHOULDER_Y, 0.10f);
+      QVector3D raisedPos(0.30f, HP::HEAD_TOP_Y + 0.2f, -0.05f);
+      QVector3D strikePos(0.35f, HP::WAIST_Y, 0.45f);
 
-      float t = attackPhase / 0.3f;
-      t = t * t;
-      P.handR = restPos * (1.0f - t) + drawPos * t;
-    } else if (attackPhase < 0.6f) {
+      if (attackPhase < 0.25f) {
 
-      P.handR = drawPos;
+        float t = attackPhase / 0.25f;
+        t = t * t;
+        P.handR = restPos * (1.0f - t) + raisedPos * t;
+        P.handL = QVector3D(-0.15f, HP::SHOULDER_Y - 0.1f * t, 0.20f);
+      } else if (attackPhase < 0.35f) {
+
+        P.handR = raisedPos;
+        P.handL = QVector3D(-0.15f, HP::SHOULDER_Y - 0.1f, 0.20f);
+      } else if (attackPhase < 0.55f) {
+
+        float t = (attackPhase - 0.35f) / 0.2f;
+        t = t * t * t;
+        P.handR = raisedPos * (1.0f - t) + strikePos * t;
+        P.handL = QVector3D(-0.15f, HP::SHOULDER_Y - 0.1f * (1.0f - t * 0.5f),
+                            0.20f + 0.15f * t);
+      } else {
+
+        float t = (attackPhase - 0.55f) / 0.45f;
+        t = 1.0f - (1.0f - t) * (1.0f - t);
+        P.handR = strikePos * (1.0f - t) + restPos * t;
+        P.handL = QVector3D(-0.15f, HP::SHOULDER_Y - 0.05f * (1.0f - t),
+                            0.35f * (1.0f - t) + 0.20f * t);
+      }
     } else {
 
-      float t = (attackPhase - 0.6f) / 0.4f;
-      t = 1.0f - (1.0f - t) * (1.0f - t);
-      P.handR = drawPos * (1.0f - t) + restPos * t;
+      QVector3D restPos(0.15f, HP::SHOULDER_Y + 0.15f, 0.20f);
+      QVector3D drawPos(0.35f, HP::SHOULDER_Y + 0.08f, -0.15f);
+
+      if (attackPhase < 0.3f) {
+
+        float t = attackPhase / 0.3f;
+        t = t * t;
+        P.handR = restPos * (1.0f - t) + drawPos * t;
+      } else if (attackPhase < 0.6f) {
+
+        P.handR = drawPos;
+      } else {
+
+        float t = (attackPhase - 0.6f) / 0.4f;
+        t = 1.0f - (1.0f - t) * (1.0f - t);
+        P.handR = drawPos * (1.0f - t) + restPos * t;
+      }
     }
   }
 
@@ -463,6 +497,7 @@ void registerArcherRenderer(Render::GL::EntityRendererRegistry &registry) {
 
     bool isMoving = false;
     bool isAttacking = false;
+    bool isMelee = false;
     float targetRotationY = 0.0f;
 
     if (p.entity) {
@@ -477,9 +512,15 @@ void registerArcherRenderer(Render::GL::EntityRendererRegistry &registry) {
       isMoving = (movement && movement->hasTarget);
 
       if (attack && attackTarget && attackTarget->targetId > 0 && transform) {
+
+        isMelee = (attack->currentMode ==
+                   Engine::Core::AttackComponent::CombatMode::Melee);
+
         bool stationary = !isMoving;
+        float currentCooldown =
+            isMelee ? attack->meleeCooldown : attack->cooldown;
         bool recentlyFired =
-            attack->timeSinceLast < std::min(attack->cooldown, 0.45f);
+            attack->timeSinceLast < std::min(currentCooldown, 0.45f);
         bool targetInRange = false;
 
         if (p.world) {
@@ -566,7 +607,7 @@ void registerArcherRenderer(Render::GL::EntityRendererRegistry &registry) {
       DrawContext instCtx{p.resources, p.entity, p.world, instModel};
 
       ArcherPose pose = makePose(instSeed, p.animationTime + phaseOffset,
-                                 isMoving, isAttacking);
+                                 isMoving, isAttacking, isMelee);
 
       drawQuiver(instCtx, out, colors, pose, instSeed);
       drawLegs(instCtx, out, pose, colors);

render/gl/backend.cpp

@@ -753,8 +753,6 @@ void Backend::uploadCylinderInstances(std::size_t count) {
 
   if (m_usePersistentBuffers && m_cylinderPersistentBuffer.isValid()) {
     if (count > m_cylinderPersistentBuffer.capacity()) {
-      qWarning() << "Backend: Too many cylinders:" << count
-                 << "max:" << m_cylinderPersistentBuffer.capacity();
       count = m_cylinderPersistentBuffer.capacity();
     }
 

ui/qml/Main.qml

@@ -155,9 +155,11 @@ ApplicationWindow {
             }
         }
 
-        onMapChosen: function(mapPath) {
-            console.log("Main: onMapChosen received", mapPath, "game=", typeof game, "startSkirmish=", (typeof game !== 'undefined' && !!game.startSkirmish))
-            if (typeof game !== 'undefined' && game.startSkirmish) game.startSkirmish(mapPath)
+        onMapChosen: function(mapPath, playerConfigs) {
+            console.log("Main: onMapChosen received", mapPath, "with", playerConfigs.length, "player configs")
+            if (typeof game !== 'undefined' && game.startSkirmish) {
+                game.startSkirmish(mapPath, playerConfigs)
+            }
             mapSelect.visible = false
             mainWindow.menuVisible = false
             mainWindow.gameStarted = true  

ui/qml/MainMenu.qml

@@ -3,6 +3,7 @@ import QtQuick 2.15
 import QtQuick.Controls 2.15
 import QtQuick.Layouts 1.3
 import QtQuick.Window 2.15
+import StandardOfIron.UI 1.0
 
 Item {
     id: root
@@ -18,7 +19,7 @@ Item {
     
     Rectangle {
         anchors.fill: parent
-        color: Qt.rgba(0, 0, 0, 0.45)
+        color: Theme.dim
     }
 
     
@@ -27,9 +28,9 @@ Item {
         width: Math.min(parent.width * 0.78, 1100)
         height: Math.min(parent.height * 0.78, 700)
         anchors.centerIn: parent
-        radius: 14
-        color: "#071018"
-        border.color: "#0f2430"
+        radius: Theme.radiusPanel
+        color: Theme.panelBase
+        border.color: Theme.panelBr
         border.width: 1
         opacity: 0.98
         clip: true                         
@@ -39,23 +40,23 @@ Item {
         GridLayout {
             id: grid
             anchors.fill: parent
-            anchors.margins: 20
-            rowSpacing: 12
+            anchors.margins: Theme.spacingXLarge
+            rowSpacing: Theme.spacingMedium
             columnSpacing: 18
             columns: parent.width > 900 ? 2 : 1
 
             
             ColumnLayout {
                 Layout.preferredWidth: parent.width > 900 ? parent.width * 0.45 : parent.width
-                spacing: 16
+                spacing: Theme.spacingLarge
 
                 
                 ColumnLayout {
-                    spacing: 6
+                    spacing: Theme.spacingSmall
                     Label {
                         text: "STANDARD OF IRON"
-                        color: "#eaf6ff"
-                        font.pointSize: 28
+                        color: Theme.textMain
+                        font.pointSize: Theme.fontSizeHero
                         font.bold: true
                         horizontalAlignment: Text.AlignLeft
                         Layout.fillWidth: true
@@ -63,8 +64,8 @@ Item {
                     }
                     Label {
                         text: "A tiny but ambitious RTS"
-                        color: "#86a7b6"
-                        font.pointSize: 12
+                        color: Theme.textSub
+                        font.pointSize: Theme.fontSizeMedium
                         horizontalAlignment: Text.AlignLeft
                         Layout.fillWidth: true
                         elide: Label.ElideRight
@@ -91,19 +92,19 @@ Item {
 
                         Rectangle {
                             anchors.fill: parent
-                            radius: 8
+                            radius: Theme.radiusLarge
                             clip: true
-                            color: container.selectedIndex === idx ? "#1f8bf5"
-                                   : menuItemMouse.containsPress ? "#184c7a" : "transparent"
+                            color: container.selectedIndex === idx ? Theme.selectedBg
+                                : menuItemMouse.containsPress ? Theme.hoverBg : Qt.rgba(0, 0, 0, 0)
                             border.width: 1
-                            border.color: container.selectedIndex === idx ? "#1b74d1" : "#12323a"
-                            Behavior on color { ColorAnimation { duration: 160 } }
-                            Behavior on border.color { ColorAnimation { duration: 160 } }
+                            border.color: container.selectedIndex === idx ? Theme.selectedBr : Theme.cardBorder
+                            Behavior on color { ColorAnimation { duration: Theme.animNormal } }
+                            Behavior on border.color { ColorAnimation { duration: Theme.animNormal } }
 
                             RowLayout {
                                 anchors.fill: parent
-                                anchors.margins: 10
-                                spacing: 12
+                                anchors.margins: Theme.spacingSmall
+                                spacing: Theme.spacingMedium
 
                                 
                                 Item { Layout.fillWidth: true; Layout.preferredWidth: 1 }
@@ -111,29 +112,29 @@ Item {
                                 
                                 ColumnLayout {
                                     Layout.fillWidth: true
-                                    spacing: 2
+                                    spacing: Theme.spacingTiny
                                     Text {
                                         text: model.title
                                         Layout.fillWidth: true
                                         elide: Text.ElideRight
-                                        color: container.selectedIndex === idx ? "white" : "#dff0ff"
-                                        font.pointSize: 14
+                                        color: container.selectedIndex === idx ? Theme.textMain : Theme.textBright
+                                        font.pointSize: Theme.fontSizeLarge
                                         font.bold: container.selectedIndex === idx
                                     }
                                     Text {
                                         text: model.subtitle
                                         Layout.fillWidth: true
                                         elide: Text.ElideRight
-                                        color: container.selectedIndex === idx ? "#d0e8ff" : "#79a6b7"
-                                        font.pointSize: 11
+                                        color: container.selectedIndex === idx ? Theme.accentBright : Theme.textSubLite
+                                        font.pointSize: Theme.fontSizeSmall
                                     }
                                 }
 
                                 
                                 Text {
                                     text: "›"
-                                    font.pointSize: 20
-                                    color: container.selectedIndex === idx ? "white" : "#2a5e6e"
+                                    font.pointSize: Theme.fontSizeTitle
+                                    color: container.selectedIndex === idx ? Theme.textMain : Theme.textHint
                                 }
                             }
                         }
@@ -161,13 +162,13 @@ Item {
 
                 
                 RowLayout {
-                    spacing: 8
-                    Label { text: "v0.9 — prototype"; color: "#4f6a75"; font.pointSize: 11 }
+                    spacing: Theme.spacingSmall
+                    Label { text: "v0.9 — prototype"; color: Theme.textDim; font.pointSize: Theme.fontSizeSmall }
                     Item { Layout.fillWidth: true }
                     Label {
                         text: Qt.formatDateTime(new Date(), "yyyy-MM-dd")
-                        color: "#2f5260"
-                        font.pointSize: 10
+                        color: Theme.textHint
+                        font.pointSize: Theme.fontSizeSmall
                         elide: Label.ElideRight
                     }
                 }
@@ -175,47 +176,47 @@ Item {
 
             
             Rectangle {
-                color: "transparent"
-                radius: 6
+                color: Qt.rgba(0, 0, 0, 0)
+                radius: Theme.radiusMedium
                 Layout.preferredWidth: parent.width > 900 ? parent.width * 0.45 : parent.width
 
                 ColumnLayout {
                     anchors.fill: parent
-                    anchors.margins: 8
-                    spacing: 12
+                    anchors.margins: Theme.spacingSmall
+                    spacing: Theme.spacingMedium
 
                     
                     Rectangle {
                         id: promo
-                        color: "#061214"
-                        radius: 8
-                        border.color: "#0f2b34"
+                        color: Theme.cardBase
+                        radius: Theme.radiusLarge
+                        border.color: Theme.border
                         border.width: 1
                         Layout.preferredHeight: 260
                         clip: true
 
                         ColumnLayout {
                             anchors.fill: parent
-                            anchors.margins: 12
-                            spacing: 8
+                            anchors.margins: Theme.spacingMedium
+                            spacing: Theme.spacingSmall
                             Label {
                                 text: "Featured"
-                                color: "#9fd9ff"
-                                font.pointSize: 12
+                                color: Theme.accent
+                                font.pointSize: Theme.fontSizeMedium
                                 Layout.fillWidth: true
                                 elide: Label.ElideRight
                             }
                             Label {
                                 text: "Skirmish Mode"
-                                color: "#eaf6ff"
-                                font.pointSize: 20
+                                color: Theme.textMain
+                                font.pointSize: Theme.fontSizeTitle
                                 font.bold: true
                                 Layout.fillWidth: true
                                 elide: Label.ElideRight
                             }
                             Text {
                                 text: "Pick a map, adjust your forces and jump into battle. Modern controls and responsive UI."
-                                color: "#7daebc"
+                                color: Theme.textSubLite
                                 wrapMode: Text.WordWrap
                                 maximumLineCount: 3           
                                 elide: Text.ElideRight
@@ -226,27 +227,27 @@ Item {
 
                     
                     Rectangle {
-                        color: "#061418"
-                        radius: 8
-                        border.color: "#0f2b34"
+                        color: Theme.cardBase
+                        radius: Theme.radiusLarge
+                        border.color: Theme.border
                         border.width: 1
                         Layout.preferredHeight: 120
                         clip: true
 
                         ColumnLayout {
                             anchors.fill: parent
-                            anchors.margins: 10
-                            spacing: 6
+                            anchors.margins: Theme.spacingSmall
+                            spacing: Theme.spacingSmall
                             Label {
                                 text: "Tips"
-                                color: "#9fd9ff"
-                                font.pointSize: 12
+                                color: Theme.accent
+                                font.pointSize: Theme.fontSizeMedium
                                 Layout.fillWidth: true
                                 elide: Label.ElideRight
                             }
                             Text {
                                 text: "Hover menu items or use Up/Down and Enter to navigate. Play opens map selection."
-                                color: "#79a6b7"
+                                color: Theme.textSubLite
                                 wrapMode: Text.WordWrap
                                 maximumLineCount: 3
                                 elide: Text.ElideRight

ui/qml/MapListPanel.qml

@@ -0,0 +1,184 @@
+
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Item {
+    id: root
+    anchors.fill: parent
+
+    property var mapsModel: []
+    property int currentIndex: 0
+    property var colors: ({})
+
+    signal mapSelected(int index)
+    signal mapDoubleClicked()
+
+    function field(obj, key) {
+        return (obj && obj[key] !== undefined) ? String(obj[key]) : ""
+    }
+
+    
+    Text {
+        id: title
+        text: "Maps"
+        color: colors.textMain
+        font.pixelSize: 18
+        font.bold: true
+        anchors {
+            top: parent.top
+            left: parent.left
+            right: parent.right
+        }
+    }
+
+    Text {
+        id: countLabel
+        text: "(" + (list.count || 0) + ")"
+        color: colors.textSubLite
+        font.pixelSize: 12
+        anchors {
+            left: title.right
+            leftMargin: 8
+            verticalCenter: title.verticalCenter
+        }
+    }
+
+    
+    Rectangle {
+        id: listFrame
+        anchors {
+            top: title.bottom
+            topMargin: 12
+            left: parent.left
+            right: parent.right
+            bottom: parent.bottom
+        }
+        color: "transparent"
+        radius: 10
+        border.color: colors.panelBr
+        border.width: 1
+        clip: true
+
+        ListView {
+            id: list
+            anchors.fill: parent
+            anchors.margins: 8
+            model: root.mapsModel
+            clip: true
+            spacing: 8
+            currentIndex: root.currentIndex
+            keyNavigationWraps: false
+            boundsBehavior: Flickable.StopAtBounds
+
+            onCurrentIndexChanged: {
+                root.currentIndex = currentIndex
+                if (currentIndex >= 0) {
+                    root.mapSelected(currentIndex)
+                }
+            }
+
+            ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+
+            highlight: Rectangle {
+                color: "transparent"
+                radius: 8
+                border.color: colors.selectedBr
+                border.width: 1
+            }
+            highlightMoveDuration: 120
+            highlightFollowsCurrentItem: true
+
+            delegate: Item {
+                width: list.width
+                height: 68
+
+                MouseArea {
+                    id: rowMouse
+                    anchors.fill: parent
+                    hoverEnabled: true
+                    acceptedButtons: Qt.LeftButton
+                    cursorShape: Qt.PointingHandCursor
+                    onEntered: list.currentIndex = index
+                    onClicked: list.currentIndex = index
+                    onDoubleClicked: root.mapDoubleClicked()
+                }
+
+                Rectangle {
+                    anchors.fill: parent
+                    radius: 8
+                    clip: true
+                    color: rowMouse.containsPress ? colors.hoverBg
+                            : (index === list.currentIndex ? colors.selectedBg : "transparent")
+                    border.width: 1
+                    border.color: (index === list.currentIndex) ? colors.selectedBr : colors.thumbBr
+                    Behavior on color { ColorAnimation { duration: 160 } }
+                    Behavior on border.color { ColorAnimation { duration: 160 } }
+
+                    Rectangle {
+                        id: thumbWrap
+                        width: 60
+                        height: 42
+                        radius: 6
+                        color: "#031314"
+                        border.color: colors.thumbBr
+                        border.width: 1
+                        anchors {
+                            left: parent.left
+                            leftMargin: 10
+                            verticalCenter: parent.verticalCenter
+                        }
+                        clip: true
+
+                        Image {
+                            anchors.fill: parent
+                            source: (typeof thumbnail !== "undefined") ? thumbnail : ""
+                            asynchronous: true
+                            fillMode: Image.PreserveAspectCrop
+                            visible: status === Image.Ready
+                        }
+                    }
+
+                    Column {
+                        anchors {
+                            left: thumbWrap.right
+                            leftMargin: 10
+                            right: parent.right
+                            rightMargin: 10
+                            verticalCenter: parent.verticalCenter
+                        }
+                        spacing: 4
+
+                        Text {
+                            text: (typeof name !== "undefined") ? String(name) : ""
+                            color: (index === list.currentIndex) ? "white" : "#dff0ff"
+                            font.pixelSize: (index === list.currentIndex) ? 15 : 14
+                            font.bold: (index === list.currentIndex)
+                            elide: Text.ElideRight
+                            width: parent.width
+                        }
+
+                        Text {
+                            text: (typeof description !== "undefined") ? String(description) : ""
+                            color: (index === list.currentIndex) ? "#d0e8ff" : colors.textSub
+                            font.pixelSize: 11
+                            elide: Text.ElideRight
+                            width: parent.width
+                        }
+                    }
+                }
+            }
+
+            
+            Item {
+                anchors.fill: parent
+                visible: list.count === 0
+                Text {
+                    text: "No maps available"
+                    color: colors.textSub
+                    font.pixelSize: 14
+                    anchors.centerIn: parent
+                }
+            }
+        }
+    }
+}

ui/qml/PlayerConfigPanel.qml

@@ -0,0 +1,241 @@
+
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Item {
+    id: root
+    anchors.fill: parent
+    
+    
+    Component {
+        id: playerListItemComponent
+        Loader {
+            source: "./PlayerListItem.qml"
+            property var itemColors: root.colors
+            property var itemPlayerData: model
+            property var itemTeamIcons: root.teamIcons
+            property bool itemCanRemove: !model.isHuman
+            
+            onLoaded: {
+                item.colors = Qt.binding(function() { return itemColors })
+                item.playerData = Qt.binding(function() { return itemPlayerData })
+                item.teamIcons = Qt.binding(function() { return itemTeamIcons })
+                item.canRemove = Qt.binding(function() { return itemCanRemove })
+                
+                item.removeClicked.connect(function() { root.removePlayerClicked(index) })
+                item.colorClicked.connect(function() { root.playerColorClicked(index) })
+                item.teamClicked.connect(function() { root.playerTeamClicked(index) })
+                item.factionClicked.connect(function() { root.playerFactionClicked(index) })
+            }
+        }
+    }
+
+    property var colors: ({})
+    property var playersModel: null
+    property var teamIcons: []
+    property var currentMapData: null
+    property string mapTitle: "Select a map"
+    property string mapPreview: ""
+
+    signal addCPUClicked()
+    signal removePlayerClicked(int index)
+    signal playerColorClicked(int index)
+    signal playerTeamClicked(int index)
+    signal playerFactionClicked(int index)
+
+    
+    Text {
+        id: title
+        text: root.mapTitle
+        color: colors.textMain
+        font.pixelSize: 20
+        font.bold: true
+        elide: Text.ElideRight
+        anchors {
+            top: parent.top
+            left: parent.left
+            right: parent.right
+        }
+    }
+
+    
+    Item {
+        id: playerSection
+        anchors {
+            top: title.bottom
+            topMargin: 16
+            left: parent.left
+            right: parent.right
+        }
+        height: Math.min(350, parent.height * 0.6)
+
+        Text {
+            id: playerSectionTitle
+            text: "Players (" + (playersModel ? playersModel.count : 0) + ")"
+            color: colors.textMain
+            font.pixelSize: 16
+            font.bold: true
+        }
+
+        Text {
+            id: playerSectionHint
+            anchors {
+                left: playerSectionTitle.right
+                leftMargin: 10
+                verticalCenter: playerSectionTitle.verticalCenter
+            }
+            text: "Click color/team to cycle"
+            color: colors.textSubLite
+            font.pixelSize: 11
+            font.italic: true
+        }
+
+        Rectangle {
+            id: playerListFrame
+            anchors {
+                top: playerSectionTitle.bottom
+                topMargin: 10
+                left: parent.left
+                right: parent.right
+                bottom: addCPUBtn.top
+                bottomMargin: 8
+            }
+            radius: 8
+            color: colors.cardBaseA
+            border.color: colors.panelBr
+            border.width: 1
+            clip: true
+
+            ListView {
+                id: playerListView
+                anchors.fill: parent
+                anchors.margins: 8
+                model: root.playersModel
+                spacing: 6
+                clip: true
+                boundsBehavior: Flickable.StopAtBounds
+
+                ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+
+                delegate: playerListItemComponent
+
+                
+                Item {
+                    anchors.fill: parent
+                    visible: !playersModel || playersModel.count === 0
+
+                    Text {
+                        anchors.centerIn: parent
+                        text: "Select a map to configure players"
+                        color: colors.textSub
+                        font.pixelSize: 13
+                    }
+                }
+            }
+        }
+
+        
+        Button {
+            id: addCPUBtn
+            text: "+ Add CPU"
+            anchors {
+                bottom: parent.bottom
+                left: parent.left
+            }
+            enabled: {
+                if (!currentMapData || !currentMapData.playerIds) return false
+                if (!playersModel) return false
+                return playersModel.count < currentMapData.playerIds.length
+            }
+            hoverEnabled: true
+
+            MouseArea {
+                id: addHover
+                anchors.fill: parent
+                hoverEnabled: true
+                acceptedButtons: Qt.NoButton
+                cursorShape: enabled ? Qt.PointingHandCursor : Qt.ArrowCursor
+            }
+
+            contentItem: Text {
+                text: addCPUBtn.text
+                font.pixelSize: 12
+                font.bold: true
+                color: enabled ? colors.addColor : colors.textSub
+                horizontalAlignment: Text.AlignHCenter
+                verticalAlignment: Text.AlignVCenter
+            }
+
+            background: Rectangle {
+                implicitWidth: 100
+                implicitHeight: 32
+                radius: 6
+                color: enabled ? (addCPUBtn.down ? Qt.darker(colors.addColor, 1.3)
+                        : (addHover.containsMouse ? Qt.darker(colors.addColor, 1.1) : colors.cardBaseA))
+                        : colors.cardBaseA
+                border.width: 1
+                border.color: enabled ? colors.addColor : colors.thumbBr
+                Behavior on color { ColorAnimation { duration: 150 } }
+            }
+
+            onClicked: root.addCPUClicked()
+
+            ToolTip {
+                visible: addHover.containsMouse && enabled
+                text: "Add AI player to the game"
+                delay: 500
+            }
+        }
+
+        Text {
+            anchors {
+                left: addCPUBtn.right
+                leftMargin: 10
+                verticalCenter: addCPUBtn.verticalCenter
+            }
+            text: {
+                if (!currentMapData || !currentMapData.playerIds) return ""
+                if (!playersModel) return ""
+                var available = currentMapData.playerIds.length - playersModel.count
+                if (available <= 0) return "Max players reached"
+                return available + " slot" + (available > 1 ? "s" : "") + " available"
+            }
+            color: colors.textSubLite
+            font.pixelSize: 11
+        }
+    }
+
+    
+    Rectangle {
+        id: preview
+        radius: 8
+        color: "#031314"
+        border.color: colors.thumbBr
+        border.width: 1
+        clip: true
+        anchors {
+            top: playerSection.bottom
+            topMargin: 16
+            left: parent.left
+            right: parent.right
+            bottom: parent.bottom
+        }
+
+        Image {
+            id: previewImage
+            anchors.fill: parent
+            source: root.mapPreview
+            asynchronous: true
+            fillMode: Image.PreserveAspectFit
+            visible: status === Image.Ready
+        }
+
+        Text {
+            anchors.centerIn: parent
+            visible: !previewImage.visible
+            text: "(map preview)"
+            color: colors.hint
+            font.pixelSize: 14
+        }
+    }
+}

ui/qml/PlayerListItem.qml

@@ -0,0 +1,189 @@
+
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Rectangle {
+    id: root
+    width: parent ? parent.width : 400
+    height: 48
+    radius: 6
+
+    property var colors: ({})
+    property var playerData: ({})
+    property var teamIcons: []
+    property bool canRemove: true
+
+    signal removeClicked()
+    signal colorClicked()
+    signal teamClicked()
+    signal factionClicked()
+
+    color: colors.cardBaseB
+    border.color: colors.thumbBr
+    border.width: 1
+
+    Row {
+        anchors.fill: parent
+        anchors.margins: 8
+        spacing: 10
+
+        
+        Item {
+            width: 80
+            height: parent.height
+            
+            Text {
+                anchors.centerIn: parent
+                text: playerData.playerName || ""
+                color: playerData.isHuman ? colors.addColor : colors.textMain
+                font.pixelSize: 14
+                font.bold: playerData.isHuman || false
+            }
+        }
+
+        
+        Rectangle {
+            width: 90
+            height: parent.height
+            radius: 4
+            color: playerData.colorHex || "#666666"
+            border.color: Qt.lighter(playerData.colorHex || "#666666", 1.3)
+            border.width: 1
+
+            Text {
+                anchors.centerIn: parent
+                text: playerData.colorName || "Color"
+                color: "white"
+                font.pixelSize: 11
+                font.bold: true
+                style: Text.Outline
+                styleColor: "black"
+            }
+
+            MouseArea {
+                anchors.fill: parent
+                cursorShape: Qt.PointingHandCursor
+                onClicked: root.colorClicked()
+            }
+
+            ToolTip {
+                visible: parent.children[1].containsMouse
+                text: "Click to change color"
+                delay: 500
+            }
+        }
+
+        
+        Rectangle {
+            width: 50
+            height: parent.height
+            radius: 4
+            color: colors.hoverBg
+            border.color: colors.thumbBr
+            border.width: 1
+
+            Column {
+                anchors.centerIn: parent
+                spacing: 2
+
+                Text {
+                    anchors.horizontalCenter: parent.horizontalCenter
+                    text: {
+                        if (!playerData.teamId || !teamIcons || teamIcons.length === 0) return "●"
+                        return teamIcons[(playerData.teamId - 1) % teamIcons.length]
+                    }
+                    color: colors.textMain
+                    font.pixelSize: 18
+                }
+
+                Text {
+                    anchors.horizontalCenter: parent.horizontalCenter
+                    text: "T" + (playerData.teamId || 1)
+                    color: colors.textSubLite
+                    font.pixelSize: 9
+                }
+            }
+
+            MouseArea {
+                anchors.fill: parent
+                cursorShape: Qt.PointingHandCursor
+                hoverEnabled: true
+                onClicked: root.teamClicked()
+            }
+
+            ToolTip {
+                visible: parent.children[1].containsMouse
+                text: "Click to change team"
+                delay: 500
+            }
+        }
+
+        
+        Rectangle {
+            width: 140
+            height: parent.height
+            radius: 4
+            color: colors.cardBaseA
+            border.color: colors.thumbBr
+            border.width: 1
+            opacity: 0.7 
+
+            Text {
+                anchors.centerIn: parent
+                text: playerData.factionName || "Standard of Iron"
+                color: colors.textSub
+                font.pixelSize: 11
+                elide: Text.ElideRight
+                width: parent.width - 8
+                horizontalAlignment: Text.AlignHCenter
+            }
+
+            MouseArea {
+                anchors.fill: parent
+                cursorShape: Qt.ArrowCursor 
+                enabled: false
+                onClicked: root.factionClicked()
+            }
+        }
+
+        
+        Item {
+            width: Math.max(10, parent.parent.width - 432)
+            height: parent.height
+        }
+
+        
+        Rectangle {
+            width: 32
+            height: parent.height
+            radius: 4
+            color: removeMouseArea.containsMouse ? colors.dangerColor : colors.cardBaseA
+            border.color: colors.dangerColor
+            border.width: 1
+            visible: root.canRemove && !playerData.isHuman
+            Behavior on color { ColorAnimation { duration: 150 } }
+
+            Text {
+                anchors.centerIn: parent
+                text: "✕"
+                color: "white"
+                font.pixelSize: 16
+                font.bold: true
+            }
+
+            MouseArea {
+                id: removeMouseArea
+                anchors.fill: parent
+                hoverEnabled: true
+                cursorShape: Qt.PointingHandCursor
+                onClicked: root.removeClicked()
+            }
+
+            ToolTip {
+                visible: removeMouseArea.containsMouse
+                text: "Remove player"
+                delay: 300
+            }
+        }
+    }
+}

ui/qml/StyleGuide.qml

@@ -0,0 +1,170 @@
+
+pragma Singleton
+import QtQuick 2.15
+
+QtObject {
+    id: root
+
+    
+    readonly property var palette: ({
+        
+        bg: "#071018",
+        bgShade: "#061214",
+        dim: Qt.rgba(0, 0, 0, 0.45),
+        
+        
+        panelBase: "#0E1C1E",
+        panelBr: "#0f2430",
+        
+        
+        cardBase: "#132526",
+        cardBaseA: "#132526AA",
+        cardBaseB: "#06141b",
+        cardBorder: "#12323a",
+        
+        
+        hover: "#184c7a",
+        hoverBg: "#184c7a",
+        selected: "#1f8bf5",
+        selectedBg: "#1f8bf5",
+        selectedBr: "#1b74d1",
+        
+        
+        thumbBr: "#2A4E56",
+        border: "#0f2b34",
+        
+        
+        textMain: "#eaf6ff",
+        textBright: "#dff0ff",
+        textSub: "#86a7b6",
+        textSubLite: "#79a6b7",
+        textDim: "#4f6a75",
+        textHint: "#2a5e6e",
+        
+        
+        accent: "#9fd9ff",
+        accentBright: "#d0e8ff",
+        
+        
+        addColor: "#3A9CA8",
+        removeColor: "#D04040",
+        dangerColor: "#D04040",
+        startColor: "#40D080"
+    })
+
+    
+    readonly property var button: ({
+        
+        primary: {
+            normalBg: palette.selectedBg,
+            hoverBg: "#2a7fe0",
+            pressBg: palette.selectedBr,
+            disabledBg: "#0a1a24",
+            
+            normalBorder: palette.selectedBr,
+            hoverBorder: palette.selectedBr,
+            disabledBorder: palette.panelBr,
+            
+            textColor: "white",
+            disabledTextColor: "#6f8793",
+            
+            radius: 9,
+            height: 40,
+            minWidth: 120,
+            fontSize: 12,
+            hoverFontSize: 13
+        },
+        
+        
+        secondary: {
+            normalBg: "transparent",
+            hoverBg: palette.cardBase,
+            pressBg: palette.hover,
+            disabledBg: "transparent",
+            
+            normalBorder: palette.cardBorder,
+            hoverBorder: palette.thumbBr,
+            disabledBorder: palette.panelBr,
+            
+            textColor: palette.textBright,
+            disabledTextColor: palette.textDim,
+            
+            radius: 8,
+            height: 38,
+            minWidth: 100,
+            fontSize: 11,
+            hoverFontSize: 12
+        },
+        
+        
+        small: {
+            normalBg: palette.addColor,
+            hoverBg: Qt.lighter(palette.addColor, 1.2),
+            pressBg: Qt.darker(palette.addColor, 1.2),
+            disabledBg: palette.cardBase,
+            
+            normalBorder: Qt.lighter(palette.addColor, 1.1),
+            hoverBorder: Qt.lighter(palette.addColor, 1.3),
+            disabledBorder: palette.thumbBr,
+            
+            textColor: "white",
+            disabledTextColor: palette.textDim,
+            
+            radius: 6,
+            height: 32,
+            minWidth: 80,
+            fontSize: 11,
+            hoverFontSize: 11
+        },
+        
+        
+        danger: {
+            normalBg: "transparent",
+            hoverBg: palette.dangerColor,
+            pressBg: Qt.darker(palette.dangerColor, 1.2),
+            disabledBg: "transparent",
+            
+            normalBorder: palette.dangerColor,
+            hoverBorder: palette.dangerColor,
+            disabledBorder: palette.thumbBr,
+            
+            textColor: palette.dangerColor,
+            hoverTextColor: "white",
+            disabledTextColor: palette.textDim,
+            
+            radius: 4,
+            height: 32,
+            minWidth: 32,
+            fontSize: 14,
+            hoverFontSize: 14
+        }
+    })
+
+    
+    readonly property var card: ({
+        radius: 8,
+        borderWidth: 1,
+        bg: palette.cardBase,
+        border: palette.cardBorder,
+        hoverBg: palette.hover,
+        selectedBg: palette.selected,
+        selectedBorder: palette.selectedBr
+    })
+
+    
+    readonly property var listItem: ({
+        height: 48,
+        radius: 6,
+        spacing: 10,
+        bg: palette.cardBaseB,
+        border: palette.thumbBr,
+        borderWidth: 1
+    })
+
+    
+    readonly property var animation: ({
+        fast: 120,
+        normal: 160,
+        slow: 200
+    })
+}

ui/qml/StyledButton.qml

@@ -0,0 +1,80 @@
+
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+Button {
+    id: control
+    
+    property string buttonStyle: "primary" 
+    property var styleConfig: {
+        if (buttonStyle === "primary") return StyleGuide.button.primary
+        if (buttonStyle === "secondary") return StyleGuide.button.secondary
+        if (buttonStyle === "small") return StyleGuide.button.small
+        if (buttonStyle === "danger") return StyleGuide.button.danger
+        return StyleGuide.button.primary
+    }
+    
+    implicitHeight: styleConfig.height
+    implicitWidth: styleConfig.minWidth
+    hoverEnabled: true
+    
+    MouseArea {
+        id: hoverArea
+        anchors.fill: parent
+        hoverEnabled: true
+        acceptedButtons: Qt.NoButton
+        cursorShape: control.enabled ? Qt.PointingHandCursor : Qt.ArrowCursor
+    }
+    
+    contentItem: Text {
+        text: control.text
+        font.pointSize: control.enabled 
+            ? (hoverArea.containsMouse ? styleConfig.hoverFontSize : styleConfig.fontSize)
+            : styleConfig.fontSize
+        font.bold: true
+        color: {
+            if (!control.enabled) return styleConfig.disabledTextColor
+            if (buttonStyle === "danger" && hoverArea.containsMouse) 
+                return styleConfig.hoverTextColor || styleConfig.textColor
+            return styleConfig.textColor
+        }
+        horizontalAlignment: Text.AlignHCenter
+        verticalAlignment: Text.AlignVCenter
+        elide: Text.ElideRight
+        
+        Behavior on font.pointSize { 
+            NumberAnimation { duration: StyleGuide.animation.fast } 
+        }
+        Behavior on color {
+            ColorAnimation { duration: StyleGuide.animation.normal }
+        }
+    }
+    
+    background: Rectangle {
+        implicitWidth: styleConfig.minWidth
+        implicitHeight: styleConfig.height
+        radius: styleConfig.radius
+        color: {
+            if (!control.enabled) return styleConfig.disabledBg
+            if (control.down) return styleConfig.pressBg
+            if (hoverArea.containsMouse) return styleConfig.hoverBg
+            return styleConfig.normalBg
+        }
+        border.width: 1
+        border.color: {
+            if (!control.enabled) return styleConfig.disabledBorder
+            if (hoverArea.containsMouse) return styleConfig.hoverBorder
+            return styleConfig.normalBorder
+        }
+        
+        Behavior on color { 
+            ColorAnimation { duration: StyleGuide.animation.normal } 
+        }
+        Behavior on border.color { 
+            ColorAnimation { duration: StyleGuide.animation.normal } 
+        }
+    }
+    
+    ToolTip.visible: control.ToolTip.text !== "" && hoverArea.containsMouse
+    ToolTip.delay: 500
+}

ui/qml/qmldir

@@ -0,0 +1,4 @@
+module StandardOfIron.UI
+singleton Constants 1.0 Constants.qml
+singleton StyleGuide 1.0 StyleGuide.qml
+StyledButton 1.0 StyledButton.qml

ui/theme.cpp

@@ -0,0 +1,18 @@
+#include "theme.h"
+
+Theme *Theme::m_instance = nullptr;
+
+Theme::Theme(QObject *parent) : QObject(parent) {}
+
+Theme *Theme::instance() {
+  if (!m_instance) {
+    m_instance = new Theme();
+  }
+  return m_instance;
+}
+
+Theme *Theme::create(QQmlEngine *engine, QJSEngine *scriptEngine) {
+  Q_UNUSED(engine)
+  Q_UNUSED(scriptEngine)
+  return instance();
+}

ui/theme.h

@@ -0,0 +1,134 @@
+#ifndef THEME_H
+#define THEME_H
+
+#include <QColor>
+#include <QObject>
+#include <QQmlEngine>
+
+class Theme : public QObject {
+  Q_OBJECT
+
+  Q_PROPERTY(QColor bg READ bg CONSTANT)
+  Q_PROPERTY(QColor bgShade READ bgShade CONSTANT)
+  Q_PROPERTY(QColor dim READ dim CONSTANT)
+
+  Q_PROPERTY(QColor panelBase READ panelBase CONSTANT)
+  Q_PROPERTY(QColor panelBr READ panelBr CONSTANT)
+  Q_PROPERTY(QColor panelBorder READ panelBorder CONSTANT)
+
+  Q_PROPERTY(QColor cardBase READ cardBase CONSTANT)
+  Q_PROPERTY(QColor cardBaseA READ cardBaseA CONSTANT)
+  Q_PROPERTY(QColor cardBaseB READ cardBaseB CONSTANT)
+  Q_PROPERTY(QColor cardBorder READ cardBorder CONSTANT)
+
+  Q_PROPERTY(QColor hover READ hover CONSTANT)
+  Q_PROPERTY(QColor hoverBg READ hoverBg CONSTANT)
+  Q_PROPERTY(QColor selected READ selected CONSTANT)
+  Q_PROPERTY(QColor selectedBg READ selectedBg CONSTANT)
+  Q_PROPERTY(QColor selectedBr READ selectedBr CONSTANT)
+
+  Q_PROPERTY(QColor thumbBr READ thumbBr CONSTANT)
+  Q_PROPERTY(QColor border READ border CONSTANT)
+
+  Q_PROPERTY(QColor textMain READ textMain CONSTANT)
+  Q_PROPERTY(QColor textBright READ textBright CONSTANT)
+  Q_PROPERTY(QColor textSub READ textSub CONSTANT)
+  Q_PROPERTY(QColor textSubLite READ textSubLite CONSTANT)
+  Q_PROPERTY(QColor textDim READ textDim CONSTANT)
+  Q_PROPERTY(QColor textHint READ textHint CONSTANT)
+
+  Q_PROPERTY(QColor accent READ accent CONSTANT)
+  Q_PROPERTY(QColor accentBright READ accentBright CONSTANT)
+
+  Q_PROPERTY(QColor addColor READ addColor CONSTANT)
+  Q_PROPERTY(QColor removeColor READ removeColor CONSTANT)
+
+  Q_PROPERTY(int spacingTiny READ spacingTiny CONSTANT)
+  Q_PROPERTY(int spacingSmall READ spacingSmall CONSTANT)
+  Q_PROPERTY(int spacingMedium READ spacingMedium CONSTANT)
+  Q_PROPERTY(int spacingLarge READ spacingLarge CONSTANT)
+  Q_PROPERTY(int spacingXLarge READ spacingXLarge CONSTANT)
+
+  Q_PROPERTY(int radiusSmall READ radiusSmall CONSTANT)
+  Q_PROPERTY(int radiusMedium READ radiusMedium CONSTANT)
+  Q_PROPERTY(int radiusLarge READ radiusLarge CONSTANT)
+  Q_PROPERTY(int radiusPanel READ radiusPanel CONSTANT)
+
+  Q_PROPERTY(int animFast READ animFast CONSTANT)
+  Q_PROPERTY(int animNormal READ animNormal CONSTANT)
+  Q_PROPERTY(int animSlow READ animSlow CONSTANT)
+
+  Q_PROPERTY(int fontSizeTiny READ fontSizeTiny CONSTANT)
+  Q_PROPERTY(int fontSizeSmall READ fontSizeSmall CONSTANT)
+  Q_PROPERTY(int fontSizeMedium READ fontSizeMedium CONSTANT)
+  Q_PROPERTY(int fontSizeLarge READ fontSizeLarge CONSTANT)
+  Q_PROPERTY(int fontSizeTitle READ fontSizeTitle CONSTANT)
+  Q_PROPERTY(int fontSizeHero READ fontSizeHero CONSTANT)
+
+public:
+  static Theme *instance();
+  static Theme *create(QQmlEngine *engine, QJSEngine *scriptEngine);
+
+  QColor bg() const { return QColor("#071018"); }
+  QColor bgShade() const { return QColor("#061214"); }
+  QColor dim() const { return QColor(0, 0, 0, 0.45 * 255); }
+
+  QColor panelBase() const { return QColor("#071018"); }
+  QColor panelBr() const { return QColor("#0f2430"); }
+  QColor panelBorder() const { return QColor("#0f2430"); }
+
+  QColor cardBase() const { return QColor("#061214"); }
+  QColor cardBaseA() const { return QColor("#061214AA"); }
+  QColor cardBaseB() const { return QColor("#061214"); }
+  QColor cardBorder() const { return QColor("#12323a"); }
+
+  QColor hover() const { return QColor("#184c7a"); }
+  QColor hoverBg() const { return QColor("#184c7a"); }
+  QColor selected() const { return QColor("#1f8bf5"); }
+  QColor selectedBg() const { return QColor("#1f8bf5"); }
+  QColor selectedBr() const { return QColor("#1b74d1"); }
+
+  QColor thumbBr() const { return QColor("#2A4E56"); }
+  QColor border() const { return QColor("#0f2b34"); }
+
+  QColor textMain() const { return QColor("#eaf6ff"); }
+  QColor textBright() const { return QColor("#dff0ff"); }
+  QColor textSub() const { return QColor("#86a7b6"); }
+  QColor textSubLite() const { return QColor("#79a6b7"); }
+  QColor textDim() const { return QColor("#4f6a75"); }
+  QColor textHint() const { return QColor("#2a5e6e"); }
+
+  QColor accent() const { return QColor("#9fd9ff"); }
+  QColor accentBright() const { return QColor("#d0e8ff"); }
+
+  QColor addColor() const { return QColor("#3A9CA8"); }
+  QColor removeColor() const { return QColor("#D04040"); }
+
+  int spacingTiny() const { return 4; }
+  int spacingSmall() const { return 8; }
+  int spacingMedium() const { return 12; }
+  int spacingLarge() const { return 16; }
+  int spacingXLarge() const { return 20; }
+
+  int radiusSmall() const { return 4; }
+  int radiusMedium() const { return 6; }
+  int radiusLarge() const { return 8; }
+  int radiusPanel() const { return 14; }
+
+  int animFast() const { return 120; }
+  int animNormal() const { return 160; }
+  int animSlow() const { return 200; }
+
+  int fontSizeTiny() const { return 11; }
+  int fontSizeSmall() const { return 12; }
+  int fontSizeMedium() const { return 14; }
+  int fontSizeLarge() const { return 16; }
+  int fontSizeTitle() const { return 18; }
+  int fontSizeHero() const { return 28; }
+
+private:
+  explicit Theme(QObject *parent = nullptr);
+  static Theme *m_instance;
+};
+
+#endif