diff --git a/src/unit.cpp b/src/unit.cpp
index 15078fa1b6ffcb24d949a20caef17387999f298b..1815a05c55d243c4cf4d0d63754aab1c8f855145 100644
--- a/src/unit.cpp
+++ b/src/unit.cpp
@@ -93,42 +93,74 @@ namespace advanced_wars
     void Unit::attack(Unit &enemy)
     {
 
-        
-        // Zuerst die Tabel für die primäre Waffe der angreifenden Einheit holen
+        // Zuerst die Tabel für die Waffen der angreifenden Einheit holen
         auto &attackerSecondaryWeaponTable = secWeapon[id];
+        auto &attackerPrimaryWeaponTable = primWeapon[id];
 
         // Schadenswert für die angreifende Einheit gegen die verteidigende Einheit berechnen
+        // Es wird die Waffe genommen die mehr Schaden macht
+
+        int attackerDamageValue = 0;
+
         if (attackerSecondaryWeaponTable.find(enemy.id) != attackerSecondaryWeaponTable.end())
         {
-            int attackerDamageValue = attackerSecondaryWeaponTable[enemy.id];
-            // Berechne den Schaden in Abhängigkeit der Gesundheit der angreifenden Einheit
-            int offDamage = attackerDamageValue * (static_cast<float>(health) / max_health);
+            attackerDamageValue = attackerSecondaryWeaponTable[enemy.id];
+        }
+        if (attackerPrimaryWeaponTable.find(enemy.id) != attackerPrimaryWeaponTable.end())
+        {
+            if (attackerDamageValue < attackerPrimaryWeaponTable[enemy.id])
+            {
+                // Here ammo deduction should happen if applicable
+                attackerDamageValue = attackerPrimaryWeaponTable[enemy.id];
+            }
+        }
+
+        if (attackerDamageValue == 0)
+        {
+            std::cout << "No damage value found for attack from unit " << static_cast<int>(id)
+                      << " against unit " << static_cast<int>(enemy.id) << std::endl;
+        }
+        else
+        {
 
-            // Schaden auf den Gegner anwenden
+            int offDamage = attackerDamageValue * (static_cast<float>(health) / max_health);
             enemy.health -= offDamage;
+            enemy.health = std::max(0, enemy.health); // Ensuring health is not negative
             std::cout << "Enemy health after attack: " << enemy.health << std::endl;
 
             // Prüfen, ob der Gegner noch am Leben ist um zurückzuschlagen
             if (enemy.health > 0)
             {
-                // Tabelle für die primäre Waffe der verteidigenden Einheit holen
+                // Weapon tables for the defender
                 auto &defenderSecondaryWeaponTable = secWeapon[enemy.id];
-                if (defenderSecondaryWeaponTable.find(this->id) != defenderSecondaryWeaponTable.end())
+                auto &defenderPrimaryWeaponTable = primWeapon[enemy.id];
+
+                int defenderDamageValue = 0; // Declare outside for later use
+
+                // Determine the damage value for the defender
+                if (defenderSecondaryWeaponTable.find(id) != defenderSecondaryWeaponTable.end())
                 {
-                    int defenderDamageValue = defenderSecondaryWeaponTable[this->id];
-                    int defDamage = defenderDamageValue * (static_cast<float>(enemy.health) / enemy.max_health);
+                    defenderDamageValue = defenderSecondaryWeaponTable[id];
+                }
+                if (defenderPrimaryWeaponTable.find(id) != defenderPrimaryWeaponTable.end())
+                {
+                    if (defenderDamageValue < defenderPrimaryWeaponTable[id])
+                    {
+                        // Deduct ammo for primary weapon, if applicable
+                        defenderDamageValue = defenderPrimaryWeaponTable[id];
+                    }
+                }
 
-                    // Schaden auf die angreifende Einheit anwenden
+                // If a valid damage value was determined for retaliation
+                if (defenderDamageValue > 0)
+                {
+                    int defDamage = static_cast<int>(defenderDamageValue * static_cast<float>(enemy.health) / enemy.max_health);
                     this->health -= defDamage;
+                    this->health = std::max(0, this->health); // Safeguard against negative health
                     std::cout << "Ally health after retaliation: " << this->health << std::endl;
                 }
             }
         }
-        else
-        {
-            std::cerr << "No damage value found for attack from unit " << static_cast<int>(id)
-                      << " against unit " << static_cast<int>(enemy.id) << std::endl;
-        }
     }
 
     void Unit::update_position(int posX, int posY)