adjusted attack function on DamageTable in weapon

src/unit.cpp

@@ -7,6 +7,11 @@ namespace advanced_wars
     Unit::Unit(int x, int y, UnitFaction faction, UnitId id, UnitState state)
         : x(x), y(y), faction(faction), id(id), state(state), max_health(100)
     {
+        //das ist nur für Testzwecke
+        if (id == UnitId::INFANTERY)
+        {
+            secondary_weapon = Weapon("Machine-Gun", {{UnitId::INFANTERY, 55}});
+        }
         health = max_health;
     };
 
@@ -71,79 +76,68 @@ namespace advanced_wars
 
     void Unit::attack(Unit *enemy)
     {
-        secondary_weapon = fill_matchupTable(0);
-        primary_weapon = fill_matchupTable(1);
-
-        
-
-        // Zuerst die Tabel für die Waffen der angreifenden Einheit holen
-        auto &attackerSecondaryWeaponTable = secondary_weapon[this->id];
-        auto &attackerPrimaryWeaponTable = primary_weapon[this->id];
-
-        
+        // Angenommen, primary_weapon und secondary_weapon wurden bereits korrekt initialisiert
+        auto primary_weapon_damage_it = primary_weapon.damage.find(enemy->id);
+        auto secondary_weapon_damage_it = secondary_weapon.damage.find(enemy->id);
 
-        // Schadenswert für die angreifende Einheit gegen die verteidigende Einheit berechnen
-        // Es wird die Waffe genommen die mehr Schaden macht
+        int attacker_damage_value = 0;
 
-        int attackerDamageValue = 0;
-
-        if (attackerSecondaryWeaponTable.find(enemy->id) != attackerSecondaryWeaponTable.end())
+        // Die Waffe mit dem höchsten Schaden wählen
+        if (secondary_weapon_damage_it != secondary_weapon.damage.end())
         {
-            attackerDamageValue = attackerSecondaryWeaponTable[enemy->id];
+            attacker_damage_value = secondary_weapon_damage_it->second;
         }
 
-        if (attackerPrimaryWeaponTable.find(enemy->id) != attackerPrimaryWeaponTable.end())
+        if (primary_weapon_damage_it != primary_weapon.damage.end())
         {
-            if (attackerDamageValue < attackerPrimaryWeaponTable[enemy->id])
+            if (primary_weapon_damage_it->second > attacker_damage_value)
             {
-                // Here ammo deduction should happen if applicable
-                attackerDamageValue = attackerPrimaryWeaponTable[enemy->id];
+                // Munitionsabzug sollte hier erfolgen, falls zutreffend
+                attacker_damage_value = primary_weapon_damage_it->second;
             }
         }
 
-        
-
-        if (attackerDamageValue == 0)
+        if (attacker_damage_value == 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
         {
-
-            int offDamage = attackerDamageValue * (static_cast<float>(health) / max_health);
-            enemy->health -= offDamage;
-            enemy->health = std::max(0, enemy->health); // Ensuring health is not negative
+            int off_damage = attacker_damage_value * (static_cast<float>(health) / max_health);
+            enemy->health -= off_damage;
+            enemy->health = std::max(0, enemy->health); // Sicherstellen, dass die Gesundheit nicht negativ wird
             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)
             {
                 // Weapon tables for the defender
-                auto &defenderSecondaryWeaponTable = secondary_weapon[enemy->id];
-                auto &defenderPrimaryWeaponTable = primary_weapon[enemy->id];
+                auto defender_primary_weapon_damage_it = enemy->primary_weapon.damage.find(id);
+                auto defender_secondary_weapon_damage_it = enemy->secondary_weapon.damage.find(id);
 
-                int defenderDamageValue = 0; // Declare outside for later use
+                int defender_damage_value = 0; // Declare outside for later use
 
                 // Determine the damage value for the defender
-                if (defenderSecondaryWeaponTable.find(id) != defenderSecondaryWeaponTable.end())
+                if (defender_secondary_weapon_damage_it != enemy->secondary_weapon.damage.end())
                 {
-                    defenderDamageValue = defenderSecondaryWeaponTable[id];
+                    defender_damage_value = defender_secondary_weapon_damage_it->second;
                 }
-                if (defenderPrimaryWeaponTable.find(id) != defenderPrimaryWeaponTable.end())
+
+                if (defender_primary_weapon_damage_it != enemy->primary_weapon.damage.end())
                 {
-                    if (defenderDamageValue < defenderPrimaryWeaponTable[id])
+                    if (defender_primary_weapon_damage_it->second > defender_damage_value)
                     {
-                        // Deduct ammo for primary weapon, if applicable
-                        defenderDamageValue = defenderPrimaryWeaponTable[id];
+                        // 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 (defenderDamageValue > 0)
+                if (defender_damage_value > 0)
                 {
-                    int defDamage = static_cast<int>(defenderDamageValue * static_cast<float>(enemy->health) / enemy->max_health);
-                    this->health -= defDamage;
+                    int def_damage = static_cast<int>(defender_damage_value * static_cast<float>(enemy->health) / enemy->max_health);
+                    this->health -= def_damage;
                     this->health = std::max(0, this->health); // Safeguard against negative health
                     std::cout << "Ally health after retaliation: " << this->health << std::endl;
                 }
@@ -151,7 +145,8 @@ namespace advanced_wars
         }
     }
 
-    MatchupTable Unit::fill_matchupTable(int type) {
+    MatchupTable Unit::fill_matchupTable(int type)
+    {
         switch (type)
         {
         case 0:
@@ -169,7 +164,6 @@ namespace advanced_wars
         this->y = posY;
     }
 
-
     /*
     Features:
     //select unit

src/unit.hpp

@@ -131,8 +131,8 @@ private:
   bool has_attacked;
   bool is_selected;
   bool is_targeted;
-  MatchupTable secondary_weapon;
-  MatchupTable primary_weapon;
+  Weapon secondary_weapon;
+  Weapon primary_weapon;
 
   int ammo;
  

src/weapon.cpp

 #include "weapon.hpp"
 
-namespace advanced_wars {}
\ No newline at end of file
+namespace advanced_wars
+{
+    Weapon::Weapon() : name(""), damage() {}
+
+    Weapon::Weapon(const std::string &weaponName, const std::unordered_map<UnitId, int> &damageValues)
+        : name(weaponName), damage(damageValues) {}
+
+    // Funktion zum Hinzufügen von Schadenswerten
+    void Weapon::addDamageValue(UnitId unitId, int value)
+    {
+        damage[unitId] = value;
+    }
+
+    // Funktion zum Abrufen eines Schadenswertes
+    int Weapon::getDamageValue(UnitId unitId) const
+    {
+        auto it = damage.find(unitId);
+        if (it != damage.end())
+        {
+            return it->second;
+        }
+        return 0; // oder ein Fehlerwert
+    }
+
+}
\ No newline at end of file

src/weapon.hpp

 #pragma once
 
-#include "unit.hpp"
+#include <string>
 #include <unordered_map>
 
 namespace advanced_wars {
 
-// Forward Declaration
 enum class UnitId;
 
 class Weapon {
 public:
-  // Ranges
-  int min_range;
-  int max_range;
+  // Konstruktoren
+  Weapon();
+  Weapon(const std::string &weaponName, const std::unordered_map<UnitId, int> &damageValues);
 
-  // Damage
+  // Methode, um einen Schadenswert hinzuzufügen
+  void addDamageValue(UnitId unitId, int value);
+
+  // Methode, um einen Schadenswert abzurufen
+  int getDamageValue(UnitId unitId) const;
+
+  // Name der Waffe
+  std::string name;
+
+  // Schadenstabelle
   std::unordered_map<UnitId, int> damage;
 };