diff --git a/config.xml b/config.xml
index d240753866aa0ca5f50957e79e65dd67cdd2b2b1..5b5b9626667a4b97f6c3e76feae3b741ef998ae3 100644
--- a/config.xml
+++ b/config.xml
@@ -397,8 +397,8 @@
                     <Damage unitId="battle_helicopter" value="105"/>
                     <Damage unitId="fighter" value="85"/>
                     <Damage unitId="bomber" value="100"/>
-                    <Damage unitId="Cruiser" value="25" />
-                    <Damage unitId="Battleship" value="5" />
+                    <Damage unitId="cruiser" value="25" />
+                    <Damage unitId="battleship" value="5" />
                 </DamageTable>
             </PrimaryWeapon>
             <SecondaryWeapon name="Anti-Air Gun">
diff --git a/src/game/Building.hpp b/src/game/Building.hpp
index 2bceaa93698658ac06cd85dc7f8fb0a22ccbb0c3..8dcb5cdf735640951bacc4b01f6c99e433520b7e 100644
--- a/src/game/Building.hpp
+++ b/src/game/Building.hpp
@@ -8,24 +8,6 @@
 namespace advanced_wars
 {
 
-enum class BuildingFaction
-{
-    URED = 0,
-    UBLUE = 1,
-    UGREEN = 2,
-    UYELLOW = 3,
-    UPURPLE = 4,
-};
-
-enum class BuildingId
-{
-    HEADQUARTER = 0,
-    CITY = 1,
-    FACTORY = 2,
-    AIRPORT = 3,
-    PORT = 4,
-};
-
 class Building
 {
     public:
diff --git a/src/game/Config.cpp b/src/game/Config.cpp
index 823a73848f96db0d1b87871c9439b53f98ae645c..b68d38f2afd7092fad6fd7e5e3bd80eab3664cb4 100644
--- a/src/game/Config.cpp
+++ b/src/game/Config.cpp
@@ -3,6 +3,7 @@
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <iostream>
+#include <optional>
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
@@ -10,7 +11,7 @@
 namespace advanced_wars
 {
 
-Config::Config(const std::string& filename)
+Config::Config(std::string filename)
 {
     namespace pt = boost::property_tree;
     pt::ptree tree;
@@ -206,7 +207,7 @@ std::string Config::getUnitPrimaryWeapon(UnitId id) const
     {
         return it->second;
     }
-    throw std::runtime_error("Primary weapon for unit ID not found");
+    return "";
 }
 
 std::string Config::getUnitSecondaryWeapon(UnitId id) const
@@ -216,36 +217,36 @@ std::string Config::getUnitSecondaryWeapon(UnitId id) const
     {
         return it->second;
     }
-    throw std::runtime_error("Secondary weapon for unit ID not found");
+    return "";
 }
 
-int Config::getUnitPrimaryWeaponDamage(UnitId attackerid, UnitId defenderid) const
+std::optional<int> Config::getUnitPrimaryWeaponDamage(UnitId attackerId, UnitId targetId) const
 {
-    auto it = m_primaryWeaponDamage.find(attackerid);
-    if (it != m_primaryWeaponDamage.end())
+    auto attackerMapIt = m_primaryWeaponDamage.find(attackerId);
+    if (attackerMapIt != m_primaryWeaponDamage.end())
     {
-        auto damageIt = it->second.find(defenderid);
-        if (damageIt != it->second.end())
+        auto damageIt = attackerMapIt->second.find(targetId);
+        if (damageIt != attackerMapIt->second.end())
         {
             return damageIt->second;
         }
     }
-    throw std::runtime_error(
-        "Primary weapon damage not found for given attacker/defender combination");
+    // Kein spezifischer Schaden vorhanden
+    return std::nullopt;
 }
 
-int Config::getUnitSecondaryWeaponDamage(UnitId attackerid, UnitId defenderid) const
+std::optional<int> Config::getUnitSecondaryWeaponDamage(UnitId attackerId, UnitId targetId) const
 {
-    auto it = m_secondaryWeaponDamage.find(attackerid);
-    if (it != m_secondaryWeaponDamage.end())
+    auto attackerMapIt = m_secondaryWeaponDamage.find(attackerId);
+    if (attackerMapIt != m_secondaryWeaponDamage.end())
     {
-        auto damageIt = it->second.find(defenderid);
-        if (damageIt != it->second.end())
+        auto damageIt = attackerMapIt->second.find(targetId);
+        if (damageIt != attackerMapIt->second.end())
         {
             return damageIt->second;
         }
     }
-    throw std::runtime_error(
-        "Secondary weapon damage not found for given attacker/defender combination");
+    // Kein spezifischer Schaden vorhanden
+    return std::nullopt;
 }
 } // namespace advanced_wars
\ No newline at end of file
diff --git a/src/game/Config.hpp b/src/game/Config.hpp
index 2b03c1be1825c036fa94201e6b24df0e7607849e..b0289ce476d641ec0fc50a97b9c2ef7ad5880888 100644
--- a/src/game/Config.hpp
+++ b/src/game/Config.hpp
@@ -1,14 +1,124 @@
 #pragma once
 
-#include "Unit.hpp" // Include for UnitId and MovementType
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
+#include <optional>
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
 
 namespace advanced_wars
 {
+/* ENUMS FOR GLOBAL USE*/
+enum class BuildingFaction
+{
+    URED = 0,
+    UBLUE = 1,
+    UGREEN = 2,
+    UYELLOW = 3,
+    UPURPLE = 4,
+};
+
+enum class BuildingId
+{
+    HEADQUARTER = 0,
+    CITY = 1,
+    FACTORY = 2,
+    AIRPORT = 3,
+    PORT = 4,
+};
+
+enum class UnitFaction
+{
+    URED = 0,
+    UBLUE = 1,
+    UGREEN = 2,
+    UYELLOW = 3,
+    UPURPLE = 4,
+};
+
+enum class UnitId
+{
+    INFANTERY = 0,
+    MECHANIZED_INFANTERY = 1,
+    RECON = 2,
+    MEDIUM_TANK = 3,
+    HEAVY_TANK = 4,
+    NEO_TANK = 5,
+    APC = 6,
+    ANTI_AIR_TANK = 7,
+    ARTILLERY = 8,
+    ROCKET_ARTILLERY = 9,
+    ANTI_AIR_MISSILE_LAUNCHER = 10,
+    FIGHTER = 11,
+    BOMBER = 12,
+    BATTLE_HELICOPTER = 13,
+    TRANSPORT_HELICOPTER = 14,
+    BATTLESHIP = 15,
+    CRUISER = 16,
+    LANDER = 17,
+    SUBMARINE = 18,
+
+    FIRST = INFANTERY,
+    LAST = SUBMARINE
+};
+
+enum class UnitState
+{
+    IDLE = 0,
+    UNAVAILABLE = 1,
+    MOVEMENTLEFT = 2,
+    MOVEMENTRIGHT = 3,
+    MOVEMENTDOWN = 4,
+    MOVEMENTUP = 5,
+};
+
+enum class MovementType
+{
+    FOOT = 0,
+    WHEELED = 1,
+    TREAD = 2,
+    AIR = 3,
+    SEA = 4,
+    LANDER = 5,
+};
+
+enum class TileId
+{
+    PLAIN = 0,
+    WATER = 1,
+    FOREST = 2,
+    MOUNTAIN = 3,
+    BRIDGE_HORIZONTAL = 4,
+    BRIDGE_VERTICAL = 5,
+    STREET_HORIZONTAL = 6,
+    STREET_VERTICAL = 7,
+    STREET_CROSSING = 8,
+    STREET_JUNCTION_RIGHT = 9,
+    STREET_JUNCTION_LEFT = 10,
+    STREET_JUNCTION_DOWN = 11,
+    STREET_JUNCTION_UP = 12,
+    STREET_CORNER_TOP_LEFT = 13,
+    STREET_CORNER_TOP_RIGHT = 14,
+    STREET_CORNER_BOTTOM_LEFT = 15,
+    STREET_CORNER_BOTTOM_RIGHT = 16,
+    RIFF = 17,
+    CLIFF_TOP = 18,
+    CLIFF_BOTTOM = 19,
+    CLIFF_LEFT = 20,
+    CLIFF_RIGHT = 21,
+    CLIFF_CORNER_TOP_LEFT = 22,
+    CLIFF_CORNER_TOP_RIGHT = 23,
+    CLIFF_CORNER_BOTTOM_LEFT = 24,
+    CLIFF_CORNER_BOTTOM_RIGHT = 25,
+    CLIFF_INVERSE_CORNER_TOP_LEFT = 26,
+    CLIFF_INVERSE_CORNER_TOP_RIGHT = 27,
+    CLIFF_INVERSE_CORNER_BOTTOM_LEFT = 28,
+    CLIFF_INVERSE_CORNER_BOTTOM_RIGHT = 29,
+};
+
+/* END OF ALL ENUMS*/
+
 /**
  * @class Config
  * @brief Parses and stores unit configuration data from an XML file.
@@ -28,7 +138,7 @@ class Config
          * @param filename Path to the XML configuration file.
          * @throws std::runtime_error if the file cannot be read or parsed.
          */
-        explicit Config(const std::string& filename);
+        Config(std::string filename);
 
         /** @brief Retrieves the cost of a given unit type. */
         int getUnitCost(UnitId id) const;
@@ -53,11 +163,11 @@ class Config
 
         /** @brief Retrieves the damage value of a unit's primary weapon against a target unit type.
          */
-        int getUnitPrimaryWeaponDamage(UnitId attackerid, UnitId defenderid) const;
+        std::optional<int> getUnitPrimaryWeaponDamage(UnitId attackerid, UnitId defenderid) const;
 
         /** @brief Retrieves the damage value of a unit's secondary weapon against a target unit
          * type. */
-        int getUnitSecondaryWeaponDamage(UnitId attackerid, UnitId defenderid) const;
+        std::optional<int> getUnitSecondaryWeaponDamage(UnitId attackerid, UnitId defenderid) const;
 
         /** @brief Retrieves the movement type of a given unit type. */
         MovementType getUnitMovementType(UnitId id) const;
diff --git a/src/game/Engine.cpp b/src/game/Engine.cpp
index 7639be52e31980ec8c331609f3adc119b7ba006f..83f03f50c1ca50daebee712d4e3b1eb5691a8714 100644
--- a/src/game/Engine.cpp
+++ b/src/game/Engine.cpp
@@ -15,7 +15,7 @@
 namespace advanced_wars
 {
 
-Engine::Engine(Window& window) : m_window(window), m_quit(false)
+Engine::Engine(Window& window) : m_window(window), m_quit(false), m_unitConfig("../config.xml")
 {
 
     this->m_SDLRenderer = SDL_CreateRenderer(
@@ -120,6 +120,11 @@ Spritesheet* Engine::getSpritesheet()
     return m_spritesheet.value();
 }
 
+Config& Engine::getUnitConfig()
+{
+    return m_unitConfig;
+}
+
 SDL_Renderer* Engine::renderer()
 {
     return this->m_SDLRenderer;
diff --git a/src/game/Engine.hpp b/src/game/Engine.hpp
index 4ecbf8bbdc98ed8ef4e4e4401c3323a3267051e6..feb8447915f1cff7d27372d1f7b7f7926ee504ea 100644
--- a/src/game/Engine.hpp
+++ b/src/game/Engine.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Config.hpp"
 #include "SDL_events.h"
 #include "Scene.hpp"
 #include "Spritesheet.hpp"
@@ -15,6 +16,7 @@ namespace advanced_wars
 
 // Forward declaration
 class Scene;
+class Config;
 
 /**
  * @brief The main window of the game
@@ -47,6 +49,8 @@ class Engine
 
         int getStage();
 
+        Config& getUnitConfig();
+
         void render();
 
         SDL_Renderer* renderer();
@@ -62,6 +66,8 @@ class Engine
 
         bool m_quit;
         int  m_stage;
+
+        Config m_unitConfig;
 };
 
 } // namespace advanced_wars
diff --git a/src/game/Level.cpp b/src/game/Level.cpp
index 9f6a4dfc3379abf5f1a7d19e0ff71af0997b5432..44f36eec9d43a8883d9dd9b01d0f732c69b1da88 100644
--- a/src/game/Level.cpp
+++ b/src/game/Level.cpp
@@ -1,5 +1,6 @@
 #include "Level.hpp"
 #include "Building.hpp"
+#include "Config.hpp"
 #include "Effect.hpp"
 #include "Engine.hpp"
 #include "Spritesheet.hpp"
@@ -12,6 +13,7 @@
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <iostream>
+#include <queue>
 #include <string>
 
 namespace advanced_wars
@@ -147,7 +149,6 @@ int Level::selectBuilding(int tileX, int tileY)
     return -1;
 }
 
-
 void Level::handleEvent(Engine& engine, SDL_Event& event)
 {
     switch (m_state)
@@ -175,6 +176,71 @@ void Level::handleEvent(Engine& engine, SDL_Event& event)
     }
 }
 
+std::vector<std::pair<int, int>> Level::calculateMovementRange(Unit& unit)
+{
+    std::vector<std::pair<int, int>>      reachableTiles;
+    std::queue<std::tuple<int, int, int>> wavefrontQueue; // x, y, remainingMovement
+
+    wavefrontQueue.push(std::make_tuple(unit.m_x, unit.m_y, unit.m_movementPoints));
+    std::unordered_map<int, std::unordered_map<int, bool>> visited;
+
+    while (!wavefrontQueue.empty())
+    {
+        auto [x, y, remainingMovement] = wavefrontQueue.front();
+        wavefrontQueue.pop();
+
+        // Check if this tile has been visited already
+        if (visited[x][y])
+            continue;
+        visited[x][y] = true;
+
+        // Check if a unit is on the current tile, skip adding it if true
+        bool isOccupied = false;
+        for (const auto& [id, otherUnit] : m_units)
+        {
+            if (otherUnit.m_x == x && otherUnit.m_y == y && id != m_selectedUnit)
+            {
+                isOccupied = true;
+                break;
+            }
+        }
+        // Add to reachable tiles only if not occupied
+        if (!isOccupied)
+        {
+            reachableTiles.emplace_back(x, y);
+        }
+
+        static const std::vector<std::pair<int, int>> directions = {
+            { 1,  0},
+            {-1,  0},
+            { 0,  1},
+            { 0, -1}
+        };
+
+        for (const auto& [dx, dy] : directions)
+        {
+            int nx = x + dx;
+            int ny = y + dy;
+
+            if (nx < 0 || nx >= m_width || ny < 0 || ny >= m_height)
+                continue; // Boundary check
+
+            int cost = getMoveCost(m_tiles[ny * m_width + nx].getType(), unit.m_movementType);
+            if (cost >= 0 && remainingMovement >= cost)
+            {
+                wavefrontQueue.push(std::make_tuple(nx, ny, remainingMovement - cost));
+            }
+        }
+    }
+
+    return reachableTiles;
+}
+
+int Level::getMoveCost(TileId tileId, MovementType movementType)
+{
+    return moveCostTable[static_cast<int>(tileId)][static_cast<int>(movementType)];
+}
+
 void Level::render(Engine& engine)
 {
     // Tiles
@@ -183,6 +249,36 @@ void Level::render(Engine& engine)
         tile.render(engine, RENDERING_SCALE);
     }
 
+    if (m_showReachableTiles)
+    {
+        SDL_SetRenderDrawColor(engine.renderer(), 255, 255, 0, 128); // Gelb mit leichtem Alpha
+
+        for (const auto& [x, y] : m_reachableTiles)
+        {
+            SDL_Rect rect = {
+                x * 16 * RENDERING_SCALE, y * 16 * RENDERING_SCALE, 16 * RENDERING_SCALE,
+                16 * RENDERING_SCALE};
+            SDL_RenderFillRect(engine.renderer(), &rect);
+        }
+
+        SDL_SetRenderDrawColor(engine.renderer(), 0, 0, 0, 255);
+    }
+
+    if (m_showAttackableTiles)
+    {
+        SDL_SetRenderDrawColor(engine.renderer(), 255, 0, 0, 128); // Rot mit leichtem Alpha
+
+        for (const auto& [x, y] : m_attackableTiles)
+        {
+            SDL_Rect rect = {
+                x * 16 * RENDERING_SCALE, y * 16 * RENDERING_SCALE, 16 * RENDERING_SCALE,
+                16 * RENDERING_SCALE};
+            SDL_RenderFillRect(engine.renderer(), &rect);
+        }
+
+        SDL_SetRenderDrawColor(engine.renderer(), 0, 0, 0, 255);
+    }
+
     // Buildings
     for (auto& [id, building] : m_buildings)
     {
@@ -275,7 +371,8 @@ Effect Level::removeEffect(int id)
     return value;
 }
 
-void Level::handleRecruitingEvent(Engine& engine, SDL_Event& event) {
+void Level::handleRecruitingEvent(Engine& engine, SDL_Event& event)
+{
 
     switch (event.type)
     {
@@ -288,21 +385,25 @@ void Level::handleRecruitingEvent(Engine& engine, SDL_Event& event) {
         {
             m_recruitingMenu.handleEvent(engine, event);
         }
-        if (event.key.keysym.sym == SDLK_RETURN) 
+        if (event.key.keysym.sym == SDLK_RETURN)
         {
-            Building& b = m_buildings.at(m_selectedBuilding);
-            UnitFaction u_faction = static_cast<UnitFaction> (b.m_faction);
-            UnitId unit_id = m_recruitingMenu.getSelectedOption();
+            Building&   b = m_buildings.at(m_selectedBuilding);
+            UnitFaction u_faction = static_cast<UnitFaction>(b.m_faction);
+            UnitId      unit_id = m_recruitingMenu.getSelectedOption();
 
-            if(b.check_money(500)) {
-                if(b.check_spawn(m_units)){
-                    addUnit(Unit(b.m_x, b.m_y, u_faction, unit_id, UnitState::IDLE));
+            if (b.check_money(500))
+            {
+                if (b.check_spawn(m_units))
+                {
+                    addUnit(Unit(
+                        b.m_x, b.m_y, u_faction, unit_id, UnitState::IDLE, engine.getUnitConfig()));
                     m_state = LevelState::SELECTING_STATE;
                     m_selectedBuilding = -1;
                 }
             }
         }
-}}
+    }
+}
 
 //*******************helper functions for event Handling*************************************
 
@@ -319,17 +420,27 @@ void Level::handleAttack(std::pair<int, int> tilePos)
 
         Unit& attacking = m_units.at(m_selectedUnit);
         Unit& defending = m_units.at(targetedUnit);
-        attacking.attack(defending);
-        if (attacking.m_health <= 0)
+
+        if (m_attackableUnitIds.find(targetedUnit) != m_attackableUnitIds.end())
         {
-            removeUnit(m_selectedUnit);
+            attacking.attack(defending);
+            if (attacking.m_health <= 0)
+            {
+                removeUnit(m_selectedUnit);
+            }
+            if (defending.m_health <= 0)
+            {
+                removeUnit(targetedUnit);
+            }
+            m_selectedUnit = -1;
+            m_showAttackableTiles = false;
+            m_showReachableTiles = false;
+            m_state = LevelState::SELECTING_STATE;
         }
-        if (defending.m_health <= 0)
+        else
         {
-            removeUnit(targetedUnit);
+            std::cout << "No target in range clicked!" << std::endl;
         }
-        m_selectedUnit = -1;
-        m_state = LevelState::SELECTING_STATE;
     }
     else
     {
@@ -348,9 +459,30 @@ void Level::handleMovement(std::pair<int, int> tilePos)
             return;
         }
     }
-    m_units.at(m_selectedUnit).updatePosition(tilePos.first, tilePos.second);
-    m_selectedUnit = -1;
-    m_state = LevelState::SELECTING_STATE;
+
+    bool isReachable = false;
+
+    for (auto& pos : m_reachableTiles)
+    {
+        if (pos == tilePos)
+        {
+            isReachable = true;
+            break;
+        }
+    }
+
+    if (isReachable)
+    {
+        m_units.at(m_selectedUnit).updatePosition(tilePos.first, tilePos.second);
+        m_selectedUnit = -1;
+        m_showAttackableTiles = false;
+        m_showReachableTiles = false;
+        m_state = LevelState::SELECTING_STATE;
+    }
+    else
+    {
+        std::cout << "Unglültige Bewegunsposition!" << std::endl;
+    }
 }
 
 void Level::handlePositionMarker(Engine& engine, SDL_Event& event)
@@ -390,6 +522,40 @@ void Level::handleSelectingEvents(Engine& engine, SDL_Event& event)
                     (tilePos.second * 16 + 15) * RENDERING_SCALE);
                 if (m_selectedUnit >= 0)
                 {
+                    m_reachableTiles = calculateMovementRange(m_units.at(m_selectedUnit));
+                    m_units.at(m_selectedUnit).on_left_click(event);
+                    m_showReachableTiles = true;
+
+                    std::vector<Unit*> allUnits;
+
+                    for (auto& [id, unit] : m_units)
+                    {
+                        allUnits.push_back(&unit);
+                    }
+
+                    std::vector<Unit*> attackableTargets =
+                        m_units.at(m_selectedUnit).getUnitsInRangeWithDamagePotential(allUnits);
+
+                    m_attackableTiles.clear();
+                    m_showAttackableTiles = true;
+                    m_attackableUnitIds.clear();
+
+                    for (Unit* target : attackableTargets)
+                    {
+                        // Füge die Position jedes angreifbaren Ziels hinzu
+                        m_attackableTiles.emplace_back(target->m_x, target->m_y);
+
+                        // Angreifbaren Einheits-ID setzen
+                        for (auto& [id, unit] : m_units)
+                        {
+                            if (&unit == target)
+                            {
+                                m_attackableUnitIds.insert(id);
+                                break;
+                            }
+                        }
+                    }
+
                     m_contextMenu.setOptions({"Move", "Attack", "Info", "Wait"});
                 }
                 else
@@ -423,6 +589,8 @@ void Level::handleSelectingEvents(Engine& engine, SDL_Event& event)
             }
             else
             {
+                m_showReachableTiles = false;
+                m_showAttackableTiles = false;
                 m_state = LevelState::SELECTING_STATE;
             }
         }
@@ -441,6 +609,8 @@ void Level::handleMenuActiveEvents(Engine& engine, SDL_Event& event)
             m_selectedUnit = -1;
             m_selectedBuilding = -1;
             m_state = LevelState::SELECTING_STATE;
+            m_showAttackableTiles = false;
+            m_showReachableTiles = false;
         }
         if (event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_DOWN)
         {
@@ -484,18 +654,11 @@ void Level::handleMenuActiveEvents(Engine& engine, SDL_Event& event)
                 m_recruitingMenu.update(
                     (tilePos.first * 16 + 15) * RENDERING_SCALE,
                     (tilePos.second * 16 + 15) * RENDERING_SCALE);
-                m_recruitingMenu.setOptions({
-            UnitId::INFANTERY,
-            UnitId::MECHANIZED_INFANTERY,
-            UnitId::RECON,
-            UnitId::APC,
-            UnitId::ARTILLERY,
-            UnitId::ANTI_AIR_TANK,
-            UnitId::ANTI_AIR_MISSILE_LAUNCHER,
-            UnitId::ROCKET_ARTILLERY,
-            UnitId::MEDIUM_TANK,
-            UnitId::NEO_TANK,
-            UnitId::HEAVY_TANK});
+                m_recruitingMenu.setOptions(
+                    {UnitId::INFANTERY, UnitId::MECHANIZED_INFANTERY, UnitId::RECON, UnitId::APC,
+                     UnitId::ARTILLERY, UnitId::ANTI_AIR_TANK, UnitId::ANTI_AIR_MISSILE_LAUNCHER,
+                     UnitId::ROCKET_ARTILLERY, UnitId::MEDIUM_TANK, UnitId::NEO_TANK,
+                     UnitId::HEAVY_TANK});
                 std::cout << "no training here" << std::endl;
             }
         }
diff --git a/src/game/Level.hpp b/src/game/Level.hpp
index fa417a22c63146f431cd0016a2b38219b0784149..c4d06287456c031e2a2bf24e9351e8de80ceb1f8 100644
--- a/src/game/Level.hpp
+++ b/src/game/Level.hpp
@@ -7,16 +7,56 @@
 #include "Tile.hpp"
 #include "Unit.hpp"
 #include "ui/Contextmenu.hpp"
-#include "ui/TileMarker.hpp"
 #include "ui/Recruitingmenu.hpp"
+#include "ui/TileMarker.hpp"
 #include <SDL.h>
+#include <array>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace advanced_wars
 {
 
+const int NUM_TILE_IDS = 30; // Aktualisieren, falls weitere IDs hinzugefügt werden
+const int NUM_MOVEMENT_TYPES = 6;
+
+const std::array<std::array<int, NUM_MOVEMENT_TYPES>, NUM_TILE_IDS> moveCostTable = {
+    {
+     // FOOT, WHEELED, TREAD, AIR, SEA, LANDER
+        {1, 2, 1, 1, 999, 999},     // PLAIN
+        {999, 999, 999, 1, 1, 1},   // WATER
+        {1, 3, 2, 1, 999, 999},     // FOREST
+        {2, 999, 999, 1, 999, 999}, // MOUNTAIN
+        {1, 1, 1, 1, 999, 999},     // BRIDGE_HORIZONTAL
+        {1, 1, 1, 1, 999, 999},     // STREET_HORIZONTAL
+        {1, 1, 1, 1, 999, 999},     // STREET_VERTICAL
+        {1, 1, 1, 1, 999, 999},     // STREET_CROSSING
+        {1, 1, 1, 1, 999, 999},     // STREET_JUNCTION_RIGHT
+        {1, 1, 1, 1, 999, 999},     // STREET_JUNCTION_LEFT
+        {1, 1, 1, 1, 999, 999},     // STREET_JUNCTION_DOWN
+        {1, 1, 1, 1, 999, 999},     // STREET_JUNCTION_UP
+        {1, 1, 1, 1, 999, 999},     // STREET_CORNER_TOP_LEFT
+        {1, 1, 1, 1, 999, 999},     // STREET_CORNER_TOP_RIGHT
+        {1, 1, 1, 1, 999, 999},     // STREET_CORNER_BOTTOM_LEFT
+        {1, 1, 1, 1, 999, 999},     // STREET_CORNER_BOTTOM_RIGHT
+        {999, 999, 999, 1, 2, 2},   // RIFF
+        {999, 999, 999, 1, 1, 1},   // CLIFF_TOP
+        {999, 999, 999, 1, 1, 1},   // CLIFF_BOTTOM
+        {999, 999, 999, 1, 1, 1},   // CLIFF_LEFT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_RIGHT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_CORNER_TOP_LEFT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_CORNER_TOP_RIGHT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_CORNER_BOTTOM_LEFT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_CORNER_BOTTOM_RIGHT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_INVERSE_CORNER_TOP_LEFT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_INVERSE_CORNER_TOP_RIGHT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_INVERSE_CORNER_BOTTOM_LEFT
+        {999, 999, 999, 1, 1, 1},   // CLIFF_INVERSE_CORNER_BOTTOM_RIGHT
+    }
+};
+
 enum class LevelState
 {
     SELECTING_STATE,
@@ -70,6 +110,14 @@ class Level : public Scene
 
         Effect removeEffect(int id);
 
+        std::vector<std::pair<int, int>> calculateMovementRange(Unit& unit);
+
+        int getMoveCost(TileId type, MovementType movementType);
+
+        std::vector<std::pair<int, int>> m_reachableTiles;
+
+        std::vector<std::pair<int, int>> m_attackableTiles;
+
     private:
         std::string                       m_name;
         int                               m_width;
@@ -98,6 +146,13 @@ class Level : public Scene
         void handleAttackingEvents(Engine& engine, SDL_Event& event);
         void handleRecruitingEvent(Engine& engine, SDL_Event& event);
 
+        bool clickCheckLeft(int mouseX, int mouseY);
+        bool clickCheckRight(int mouseX, int mouseY);
+        bool m_showReachableTiles;
+        bool m_showAttackableTiles;
+
+        std::unordered_set<int> m_attackableUnitIds;
+
         void handleAttack(std::pair<int, int> tilePos);
         void handleMovement(std::pair<int, int> tilePos);
         void handlePositionMarker(Engine& engine, SDL_Event& event);
diff --git a/src/game/Tile.cpp b/src/game/Tile.cpp
index bf393db7a961c13617e31b1f23768e330258a2bf..b7e93a427f57520304b9fc475c37b1ec5722679c 100644
--- a/src/game/Tile.cpp
+++ b/src/game/Tile.cpp
@@ -30,4 +30,8 @@ void Tile::render(Engine& engine, int scale)
         &dest, 0, NULL, SDL_FLIP_NONE);
 }
 
+TileId Tile::getType() const {
+    return m_id;  // Gibt den gespeicherten TileId zurück
+}
+
 } // namespace advanced_wars
\ No newline at end of file
diff --git a/src/game/Tile.hpp b/src/game/Tile.hpp
index 44611faab72f346c6df782e1fb4d7163834d914d..ff137b85798106d9b78442115113f24e4d5d5a32 100644
--- a/src/game/Tile.hpp
+++ b/src/game/Tile.hpp
@@ -6,40 +6,6 @@
 namespace advanced_wars
 {
 
-enum class TileId
-{
-    PLAIN = 0,
-    WATER = 1,
-    FOREST = 2,
-    MOUNTAIN = 3,
-    BRIDGE_HORIZONTAL = 4,
-    BRIDGE_VERTICAL = 5,
-    STREET_HORIZONTAL = 6,
-    STREET_VERTICAL = 7,
-    STREET_CROSSING = 8,
-    STREET_JUNCTION_RIGHT = 9,
-    STREET_JUNCTION_LEFT = 10,
-    STREET_JUNCTION_DOWN = 11,
-    STREET_JUNCTION_UP = 12,
-    STREET_CORNER_TOP_LEFT = 13,
-    STREET_CORNER_TOP_RIGHT = 14,
-    STREET_CORNER_BOTTOM_LEFT = 15,
-    STREET_CORNER_BOTTOM_RIGHT = 16,
-    RIFF = 17,
-    CLIFF_TOP = 18,
-    CLIFF_BOTTOM = 19,
-    CLIFF_LEFT = 20,
-    CLIFF_RIGHT = 21,
-    CLIFF_CORNER_TOP_LEFT = 22,
-    CLIFF_CORNER_TOP_RIGHT = 23,
-    CLIFF_CORNER_BOTTOM_LEFT = 24,
-    CLIFF_CORNER_BOTTOM_RIGHT = 25,
-    CLIFF_INVERSE_CORNER_TOP_LEFT = 26,
-    CLIFF_INVERSE_CORNER_TOP_RIGHT = 27,
-    CLIFF_INVERSE_CORNER_BOTTOM_LEFT = 28,
-    CLIFF_INVERSE_CORNER_BOTTOM_RIGHT = 29,
-};
-
 class Tile
 {
     public:
@@ -48,7 +14,8 @@ class Tile
         int    m_x;
         int    m_y;
 
-        void render(Engine& engine, int scale);
+        void   render(Engine& engine, int scale);
+        TileId getType() const;
 };
 
 } // namespace advanced_wars
\ No newline at end of file
diff --git a/src/game/Unit.cpp b/src/game/Unit.cpp
index c817aa4b02f4eeb07185e2b7169d6796a8081be1..739c75b739afd9d2a5b00451d4370fcfed211ded 100644
--- a/src/game/Unit.cpp
+++ b/src/game/Unit.cpp
@@ -1,23 +1,49 @@
 #include "Unit.hpp"
+#include "Config.hpp"
 #include <iostream>
 
 namespace advanced_wars
 {
 
-Unit::Unit(int x, int y, UnitFaction faction, UnitId id, UnitState state)
+Unit::Unit(int x, int y, UnitFaction faction, UnitId id, UnitState state, Config& config)
     : m_x(x), m_y(y), m_faction(faction), m_id(id), m_state(state), m_maxHealth(100)
 {
-    // das ist nur für Testzwecke
-    if (m_id == UnitId::INFANTERY)
+    // Allgemeine Einheiteneinstellungen aus Konfiguration holen
+    m_cost = config.getUnitCost(id);
+    m_movementPoints = config.getUnitMovementPoints(id);
+    m_ammo = config.getUnitAmmo(id);
+    m_minRange = config.getUnitMinRange(id);
+    m_maxRange = config.getUnitMaxRange(id);
+    m_health = m_maxHealth;
+
+    m_movementType = config.getUnitMovementType(id);
+
+    // Initialisieren der Primär- und Sekundärwaffe
+    std::unordered_map<UnitId, int> primaryDamage;
+    std::unordered_map<UnitId, int> secondaryDamage;
+
+    for (int targetIt = static_cast<int>(UnitId::FIRST); targetIt <= static_cast<int>(UnitId::LAST);
+         ++targetIt)
     {
-        m_secondaryWeapon = Weapon(
-            "Machine-Gun", {
-                               {UnitId::INFANTERY, 55}
-        });
+        UnitId targetId = static_cast<UnitId>(targetIt);
+
+        // Prüfen, ob ein gültiger Schadenswert vorhanden ist, und nur dann hinzufügen
+        if (auto damage = config.getUnitPrimaryWeaponDamage(id, targetId))
+        {
+            primaryDamage[targetId] = *damage;
+        }
+        if (auto damage = config.getUnitSecondaryWeaponDamage(id, targetId))
+        {
+            secondaryDamage[targetId] = *damage;
+        }
     }
-    m_health = m_maxHealth;
+
+    m_primaryWeapon = Weapon(config.getUnitPrimaryWeapon(id), primaryDamage);
+    m_secondaryWeapon = Weapon(config.getUnitSecondaryWeapon(id), secondaryDamage);
 }
 
+ 
+
 void Unit::render(Engine& engine, int scale)
 {
     Spritesheet* spritesheet = engine.getSpritesheet();
@@ -82,77 +108,86 @@ void Unit::render(Engine& engine, int scale)
 
 void Unit::attack(Unit& enemy)
 {
-    // Angenommen, primary_weapon und secondary_weapon wurden bereits korrekt
-    // initialisiert
-    auto primary_weapon_damage_it = m_primaryWeapon.m_damage.find(enemy.m_id);
-    auto secondary_weapon_damage_it = m_secondaryWeapon.m_damage.find(enemy.m_id);
+    int attacker_damage_value = calculateDamage(enemy);
 
-    int attacker_damage_value = 0;
-
-    // Die Waffe mit dem höchsten Schaden wählen
-    if (secondary_weapon_damage_it != m_secondaryWeapon.m_damage.end())
+    if (attacker_damage_value > 0)
     {
-        attacker_damage_value = secondary_weapon_damage_it->second;
-    }
+        performAttack(enemy, attacker_damage_value);
+        std::cout << "Enemy health after attack: " << enemy.m_health << std::endl;
 
-    if (primary_weapon_damage_it != m_primaryWeapon.m_damage.end())
-    {
-        if (primary_weapon_damage_it->second > attacker_damage_value)
+        // Check if the enemy is still alive for counter-attack
+        if (enemy.m_health > 0)
         {
-            // Munitionsabzug sollte hier erfolgen, falls zutreffend
-            attacker_damage_value = primary_weapon_damage_it->second;
+            // Check if the enemy is within attack range
+            int distanceX = std::abs(enemy.m_x - m_x);
+            int distanceY = std::abs(enemy.m_y - m_y);
+            int distance = distanceX + distanceY;
+
+            if (distance >= enemy.m_minRange && distance <= enemy.m_maxRange)
+            {
+                // Now, they are reversed for the counter-attack
+                int defender_damage_value = enemy.calculateDamage(*this);
+                if (defender_damage_value > 0)
+                {
+                    enemy.performAttack(*this, defender_damage_value);
+                    std::cout << "Ally health after retaliation: " << this->m_health << std::endl;
+                }
+            }
+            else
+            {
+                std::cout << "Enemy out of range for counter-attack." << std::endl;
+            }
         }
     }
-
-    if (attacker_damage_value == 0)
+    else
     {
         std::cout << "No damage value found for attack from unit " << static_cast<int>(m_id)
                   << " against unit " << static_cast<int>(enemy.m_id) << std::endl;
     }
-    else
+}
+
+int Unit::calculateDamage(Unit& target)
+{
+    // Pointers to Weapon objects
+    Weapon* primaryWeapon =  &m_primaryWeapon;
+    Weapon* secondaryWeapon = &m_secondaryWeapon;
+    
+    // Find the corresponding damage values
+    auto primary_damage_it = primaryWeapon->m_damage.find(target.m_id);
+    auto secondary_damage_it = secondaryWeapon->m_damage.find(target.m_id);
+
+    int damage_value = 0;
+
+    // Calculate damage using secondary weapon if available
+    if (secondary_damage_it != secondaryWeapon->m_damage.end())
     {
-        int off_damage = attacker_damage_value * (static_cast<float>(m_health) / m_maxHealth);
-        enemy.m_health -= off_damage;
-        enemy.m_health = std::max(
-            0,
-            enemy.m_health); // Sicherstellen, dass die Gesundheit nicht negativ wird
-        std::cout << "Enemy health after attack: " << enemy.m_health << std::endl;
+        damage_value = secondary_damage_it->second;
+    }
 
-        // Prüfen, ob der Gegner noch am Leben ist um zurückzuschlagen
-        if (enemy.m_health > 0)
+    // Calculate damage using primary weapon if higher and ammo is available
+    if (primary_damage_it != primaryWeapon->m_damage.end())
+    {
+        // Check ammo correctly
+        int& ammo = m_ammo;
+
+        if (primary_damage_it->second > damage_value && ammo > 0)
         {
-            // Weapon tables for the defender
-            auto defender_primary_weapon_damage_it = enemy.m_primaryWeapon.m_damage.find(m_id);
-            auto defender_secondary_weapon_damage_it = enemy.m_secondaryWeapon.m_damage.find(m_id);
+            ammo -= 1;
+            damage_value = primary_damage_it->second;
+            std::cout << " ammo = " << ammo << std::endl;
+        }
+    }
 
-            int defender_damage_value = 0; // Declare outside for later use
+    return damage_value;
+}
 
-            // Determine the damage value for the defender
-            if (defender_secondary_weapon_damage_it != enemy.m_secondaryWeapon.m_damage.end())
-            {
-                defender_damage_value = defender_secondary_weapon_damage_it->second;
-            }
 
-            if (defender_primary_weapon_damage_it != enemy.m_primaryWeapon.m_damage.end())
-            {
-                if (defender_primary_weapon_damage_it->second > defender_damage_value)
-                {
-                    // Munitionsabzug für primäre Waffe, falls zutreffend
-                    defender_damage_value = defender_primary_weapon_damage_it->second;
-                }
-            }
 
-            // If a valid damage value was determined for retaliation
-            if (defender_damage_value > 0)
-            {
-                int def_damage = static_cast<int>(
-                    defender_damage_value * static_cast<float>(enemy.m_health) / enemy.m_maxHealth);
-                this->m_health -= def_damage;
-                this->m_health = std::max(0, this->m_health); // Safeguard against negative health
-                std::cout << "Ally health after retaliation: " << this->m_health << std::endl;
-            }
-        }
-    }
+void Unit::performAttack(Unit& target, int damage)
+{
+    int effective_damage = damage * (static_cast<float>(m_health) / m_maxHealth);
+    target.m_health -= effective_damage;
+    target.m_health = std::max(0, target.m_health);
 }
 
 void Unit::updatePosition(int posX, int posY)
@@ -204,17 +239,50 @@ void Unit::on_left_click(SDL_Event event)
     std::cout << "Left-button pressed on unit: " << this->m_health << std::endl;
 }
 
-bool Unit::inRange(Unit& enemy)
+std::vector<Unit*> Unit::getUnitsInRangeWithDamagePotential(const std::vector<Unit*>& allUnits)
 {
-    if (this->m_x == enemy.m_x)
-    {
-        return abs(this->m_y - enemy.m_y) <= this->m_range;
-    }
-    else if (this->m_y == enemy.m_y)
-    {
-        return abs(this->m_x - enemy.m_x) <= this->m_range;
+    std::vector<Unit*> unitsInRangeWithDamage;
+
+    for (Unit* unit : allUnits)
+    { //Iterate over all units
+        // except itself
+        if (unit == this)
+        {
+            continue;
+        }
+
+        int distanceX = std::abs(unit->m_x - m_x);
+        int distanceY = std::abs(unit->m_y - m_y);
+
+        
+        int distance = distanceX + distanceY;
+        if (distance >= m_minRange && distance <= m_maxRange)
+        {
+            // Prüfen ob Schaden möglich ist
+            auto primaryDamageIt = m_primaryWeapon.m_damage.find(unit->m_id);
+            auto secondaryDamageIt = m_secondaryWeapon.m_damage.find(unit->m_id);
+
+            bool canDealDamage = false;
+
+            // Prüfen, ob Primärwaffe Schaden machen kann
+            if (primaryDamageIt != m_primaryWeapon.m_damage.end() && m_ammo > 0)
+            {
+                canDealDamage = true;
+            }
+            // Prüfen, ob Sekundärwaffe Schaden machen kann
+            if (secondaryDamageIt != m_secondaryWeapon.m_damage.end())
+            {
+                canDealDamage = true;
+            }
+
+            if (canDealDamage)
+            {
+                unitsInRangeWithDamage.push_back(unit);
+            }
+        }
     }
-    return false;
+
+    return unitsInRangeWithDamage;
 }
 
 UnitFaction Unit::getFaction()
diff --git a/src/game/Unit.hpp b/src/game/Unit.hpp
index 1d399d992024d7be86581cb754a788c01aa5f9f7..2202f9375390bbd488c381230a8013ab9d179996 100644
--- a/src/game/Unit.hpp
+++ b/src/game/Unit.hpp
@@ -1,64 +1,17 @@
 #pragma once
 
 #include "Engine.hpp"
+
 #include "Weapon.hpp"
+#include <SDL_events.h>
 #include <optional>
 #include <unordered_map>
+#include <vector>
 
 namespace advanced_wars
 {
-
-enum class UnitFaction
-{
-    URED = 0,
-    UBLUE = 1,
-    UGREEN = 2,
-    UYELLOW = 3,
-    UPURPLE = 4,
-};
-
-enum class UnitId
-{
-    INFANTERY = 0,
-    MECHANIZED_INFANTERY = 1,
-    RECON = 2,
-    MEDIUM_TANK = 3,
-    HEAVY_TANK = 4,
-    NEO_TANK = 5,
-    APC = 6,
-    ANTI_AIR_TANK = 7,
-    ARTILLERY = 8,
-    ROCKET_ARTILLERY = 9,
-    ANTI_AIR_MISSILE_LAUNCHER = 10,
-    FIGHTER = 11,
-    BOMBER = 12,
-    BATTLE_HELICOPTER = 13,
-    TRANSPORT_HELICOPTER = 14,
-    BATTLESHIP = 15,
-    CRUISER = 16,
-    LANDER = 17,
-    SUBMARINE = 18,
-};
-
-enum class UnitState
-{
-    IDLE = 0,
-    UNAVAILABLE = 1,
-    MOVEMENTLEFT = 2,
-    MOVEMENTRIGHT = 3,
-    MOVEMENTDOWN = 4,
-    MOVEMENTUP = 5,
-};
-
-enum class MovementType
-{
-    FOOT = 0,
-    WHEELED = 1,
-    TREAD = 2,
-    AIR = 3,
-    SEA = 4,
-    LANDER = 5,
-};
+class Engine;
+class Config;
 
 using MatchupTable = std::unordered_map<UnitId, std::unordered_map<UnitId, int>>;
 
@@ -67,79 +20,139 @@ class Unit
     public:
         int m_x;
         int m_y;
-        int m_health; // health equals max_health at construction
+        int m_health; // Current health of the unit, initialized to max health at construction.
         int m_price;
 
-        Unit(int x, int y, UnitFaction faction, UnitId id, UnitState state);
-        ~Unit()
-        {
-            // Assuming that the destruktion of a unit triggers events
-        }
-
+        int          m_movementPoints; // The number of tiles this unit can move per turn.
+        MovementType m_movementType;   // The type of movement this unit has (e.g., foot, wheeled).
+
+        /**
+         * Constructor for Unit.
+         * Initializes the unit's position, faction, identifier, state, and configuration settings.
+         */
+        Unit(int x, int y, UnitFaction faction, UnitId id, UnitState state, Config& config);
+
+        /**
+         * Destructor for Unit.
+         * Handles any cleanup necessary when a unit is destroyed.
+         * (Currently assumes this triggers certain game events, though not explicitly detailed
+         * here.)
+         */
+        ~Unit() {};
+
+        /**
+         * Renders the unit on the game screen.
+         * Uses the engine's rendering capabilities to draw the unit based on its state and faction.
+         *
+         * @param engine The game engine responsible for rendering.
+         * @param scale Scaling factor for rendering the unit.
+         */
         void render(Engine& engine, int scale);
 
-        /*
-        Check if attacker is in Range to initiate combat
-        TODO: This should probably tie back into rendering the units differently
-        If a unit is selected, it should call inRange on all other enemy units on the field
-        */
-
+        /**
+         * Determines if another unit (enemy) is within attack range.
+         * Checks for the range based on the unit's weapon capabilities.
+         *
+         * @param enemy The enemy unit to check range against.
+         * @return true if the enemy is in range, false otherwise.
+         */
         bool inRange(Unit& enemy);
 
-        /*
-        The attacker will move towards the defender and thus initiate combat
-        @params Takes a reference to the defender
-
-        Will Update the health for both units
-        Attacker deals damage to the defender first
-        */
-
+        /**
+         * Initiates an attack on a specified enemy unit.
+         * Calculates damage and updates health values for both the attacker and defender.
+         * Attacker damages the enemy first; if the enemy survives, a counter-attack may occur.
+         *
+         * @param enemy The unit being attacked.
+         */
         void attack(Unit& enemy);
 
-        /*
-        @params Takes the desired position of the unit and updates its values
-        This will teleport the unit, there is no smooth transition between tiles
-        */
+        /**
+         * Performs the calculated damage on a target unit, adjusting its health accordingly.
+         * Considers this unit's current health for scaling damage.
+         *
+         * @param target The target unit receiving damage.
+         * @param damage The amount of damage calculated to be applied.
+         */
+        void performAttack(Unit& target, int damage);
+
+        /**
+         * Calculates the potential damage this unit can inflict on a target.
+         * Considers primary and secondary weapons' damage tables, and checks ammunition
+         * availability.
+         *
+         * @param target The unit to calculate damage against.
+         * @return The calculated damage value.
+         */
+        int calculateDamage(Unit& target);
+
+        /**
+         * Updates this unit's position on the game field.
+         * Changes the internal position and recalculates the unit's state (e.g., direction it's
+         * facing) based on movement to a new position.
+         *
+         * @param posX The new x-coordinate for the unit.
+         * @param posY The new y-coordinate for the unit.
+         */
         void updatePosition(int posX, int posY);
 
-        /*
-        This function needs to be able to determine the possible movement-paths the unit can take
-        MUST take into consideration that different units behave differently on certain terrain
-        MUST show all movements possible
-        */
+        /**
+         * Determines potential movement paths based on the unit's movement type and current
+         * terrain. (Intended to use Dijkstra's algorithm, though implementation details are omitted
+         * here.)
+         */
         void calculateMovement();
 
+        /**
+         * Recalculates and updates the unit's state based on movement direction.
+         * Ensures that the unit faces the correct direction after a move.
+         *
+         * @param posX The x-coordinate of the desired position.
+         * @param posY The y-coordinate of the desired position.
+         */
         void calcState(int posX, int posY);
 
-        /*
-        This function will be called by an external event-handler, eventually.
-        It should start displaying standard unit information, such as UI and move_range
-        */
+        /**
+         * Processes a left-click event on this unit.
+         * Typically triggers display of unit information (e.g., UI and movement range).
+         *
+         * @param event SDL event captured, specifically mouse click event.
+         */
         void on_left_click(SDL_Event event);
 
+        /**
+         * Retrieves units within range that this unit can deal damage to.
+         * Considers all units provided in 'allUnits', excluding itself, and checks movement and
+         * weapon range.
+         *
+         * @param allUnits Vector of pointers to all units on the field to check against.
+         * @return Vector of pointers to units in range that can be engaged.
+         */
+        std::vector<Unit*> getUnitsInRangeWithDamagePotential(const std::vector<Unit*>& allUnits);
+
         UnitFaction getFaction();
 
     private:
-        UnitFaction m_faction;
-        UnitId      m_id;
-        UnitState   m_state;
+        UnitFaction m_faction; // The faction to which this unit belongs.
+        UnitId      m_id;      // The identifier for the unit type.
+        UnitState   m_state;   // The current state of the unit (idle, moving, etc.).
 
-        int m_maxHealth; // max_health required for damage_scaling
-        int m_range;
-        int m_fuel;
-        int m_maxFuel;
+        int m_maxHealth; // The maximum health of the unit.
+        int m_range;     // Possible range for future use, depending on specific unit abilities.
 
-        bool m_hasMoved;
-        bool m_hasAttacked;
-        bool m_isSelected;
-        bool m_isTargeted;
+        bool m_hasMoved;    // Indicates whether the unit has moved this turn.
+        bool m_hasAttacked; // Indicates whether the unit has attacked this turn.
+        bool m_isSelected;  // Indicates whether the unit is currently selected.
+        bool m_isTargeted;  // Indicates whether the unit is currently targeted by an enemy.
 
-        Weapon m_secondaryWeapon;
-        Weapon m_primaryWeapon;
+        Weapon m_secondaryWeapon; // The unit's secondary weapon.
+        Weapon m_primaryWeapon;   // The unit's primary weapon.
 
-        int m_ammo;
+        int m_cost;     // The cost associated with deploying this unit.
+        int m_ammo;     // The amount of available ammo for attacks.
+        int m_minRange; // The minimum range of the unit's attack capability.
+        int m_maxRange; // The maximum range of the unit's attack capability.
 
         void renderHP(Engine& engine, int scale);
 };
-
 } // namespace advanced_wars
\ No newline at end of file
diff --git a/src/game/ui/Menu.cpp b/src/game/ui/Menu.cpp
index 0ea5ba90ae60295f1942ce50242a1c23c4a70c3b..ca3cf639c8dbb5a6c141e8b71bfec58884d3e112 100644
--- a/src/game/ui/Menu.cpp
+++ b/src/game/ui/Menu.cpp
@@ -1,6 +1,7 @@
 #include "Menu.hpp"
 #include "../Building.hpp"
 #include "../Level.hpp"
+#include "../Config.hpp"
 #include "../Spritesheet.hpp"
 #include "../Tile.hpp"
 #include "../Unit.hpp"
@@ -125,6 +126,7 @@ void Menu::handleEvent(Engine& engine, SDL_Event& event)
             {
                 std::cout << "Starting game..." << std::endl;
 
+
                 // Construct a level
                 std::vector<Tile> tiles;
                 for (int y = 0; y < 20; y++)
@@ -178,6 +180,7 @@ void Menu::handleEvent(Engine& engine, SDL_Event& event)
                     }
                 }
 
+                Config config = Config("../config.xml");
                 // Units
                 std::vector<Unit> units;
 
@@ -187,7 +190,7 @@ void Menu::handleEvent(Engine& engine, SDL_Event& event)
                     {
                         units.push_back(Unit(
                             x + 9, y + 2, UnitFaction::URED, static_cast<UnitId>(y),
-                            static_cast<UnitState>(x)));
+                            static_cast<UnitState>(x), config));
                     }
                 }