🚀 Adjusted units interactions console printing

ArmyClasses/Army.cpp

@@ -2,17 +2,4 @@
 #include "../Game.h"
 
 Army::Army(Game* gamePtr): gamePtr(gamePtr)
-{}
-
-void Army::printFightingUnits()
-{
-	Unit* unit = nullptr;
-
-	while (currentAttackers.dequeue(unit))
-		unit->printFought();
-}
-
-int Army::getFightingUnitsCount() const
-{
-	return currentAttackers.getCount();
-}
+{}

ArmyClasses/Army.h

@@ -24,11 +24,9 @@ class Army
     virtual bool isDead() const = 0; // Check if the army is dead
 
     virtual void printArmy() const = 0; // Print the army units
-    void printFightingUnits(); // Print the fighting units of the army (current attackers)
 
     // Getters
     virtual int getUnitsCount(UnitType) const = 0; // Get the count of a specific unit type
-    int getFightingUnitsCount() const; // Get the count of fighting units
 };
 
 #endif

Game.cpp

@@ -100,11 +100,6 @@ bool Game::battleOver(bool didArmiesAttack) const
 	return currentTimestep >= 40 && (anArmyDied || noAttackTie);
 }
 
-bool Game::areUnitsFighting() const
-{
-	return earthArmy.getFightingUnitsCount() + alienArmy.getFightingUnitsCount();
-}
-
 void Game::killSaverUnits()
 {
 	Unit* saverToKill = earthAlliedArmy.removeUnit(UnitType::SU); // Remove a saver from its list
@@ -245,6 +240,13 @@ LinkedQueue<Unit*> Game::getEnemyList(ArmyType armyType, UnitType unitType, int
 	return enemyUnits;
 }
 
+void Game::registerAttack(Unit* currentAttacker, const std::string& currentAction, const std::string& currentFoughtUnits)
+{
+	attackers.enqueue(currentAttacker); // Store the current attacker
+	attackActions.enqueue(currentAction); // Store the action it made
+	foughtUnits.enqueue(currentFoughtUnits); // Store the list of units the action happened on
+}
+
 void Game::addToKilledList(Unit* unit)
 {
 	// Add the unit to the killed list
@@ -309,12 +311,17 @@ void Game::printAll()
 	std::cout << std::endl << "============== Earth Allied Army Alive Units ===================" << std::endl;
 	earthAlliedArmy.printArmy();
 
-	if (areUnitsFighting())
+	if (!attackers.isEmpty())
 	{
 		std::cout << std::endl << "============== Units fighting at current step =================" << std::endl;
-		earthArmy.printFightingUnits();
-		alienArmy.printFightingUnits();
-		earthAlliedArmy.printFightingUnits();
+		Unit* currentAttacker = nullptr;
+		std::string currentFoughtUnits, currentAction;
+
+		while (attackers.dequeue(currentAttacker) && attackActions.dequeue(currentAction) && foughtUnits.dequeue(currentFoughtUnits))
+		{
+			currentAttacker->printUnit();
+			std::cout << " " << currentAction << " [" << currentFoughtUnits << "]" << std::endl;
+		}
 	}
 	else
 		std::cout << std::endl << "============== No units fighting at current step ==============" << std::endl;

Game.h

@@ -23,14 +23,17 @@ class Game
     EarthAlliedArmy earthAlliedArmy;
     RandomGenerator randomGenerator;
 
+    LinkedQueue<Unit*> attackers; // Attackers of the current time step
+    LinkedQueue<std::string> foughtUnits; // Units attacked by each attacker in the current timestep
+    LinkedQueue<std::string> attackActions; // Action done on the unit of the opposite army
+
     LinkedQueue<Unit*> killedList;
     PriorityQueue<HealableUnit*> unitMaintenanceList;
 
 private:
     bool startAttack(); // Makes the two armies attack each other
     void setGameMode(GameMode); // Change the game mode
     bool battleOver(bool) const; // Check if the battle is over
-    bool areUnitsFighting() const; // Check if there are units fighting
     void killSaverUnits(); // Savers need to be killed once all infected units are healed
 
     void printKilledList() const; // Prints the killed list with the console formats
@@ -57,6 +60,7 @@ class Game
     void addUnit(Unit*); // Add a unit to the appropriate army and list
     Unit* removeUnit(ArmyType, UnitType); // Remove a unit from the appropriate army and list
     LinkedQueue<Unit*> getEnemyList(ArmyType, UnitType, int); // Get the enemy list for the given army type, unit type and attack capacity
+    void registerAttack(Unit*, const std::string&, const std::string&); // Store the current attacker along with its fought units
 
     void addToKilledList(Unit*); // Add a unit to the killed list
 

UnitClasses/AlienDrone.cpp

@@ -5,16 +5,9 @@ AlienDrone::AlienDrone(Game* gamePtr, double health, int power, int attackCapaci
     : Unit(gamePtr, UnitType::AD, health, power, attackCapacity)
 {}
 
-void AlienDrone::printFought()
+void AlienDrone::printUnit()
 {
-    if (!foughtUnits.isEmpty())
-    {
-        std::cout << "AD " << getId() << " shots [";
-        foughtUnits.printList();
-        std::cout << "]" << std::endl;
-
-        clearFoughtUnits(); // Clear the list after printing
-    }
+    std::cout << "AD " << id;
 }
 
 bool AlienDrone::attack()
@@ -27,6 +20,8 @@ bool AlienDrone::attack()
     LinkedQueue<Unit*> ETlist = gamePtr->getEnemyList(ArmyType::EARTH, UnitType::ET, ETnumber);
     LinkedQueue<Unit*> EGlist = gamePtr->getEnemyList(ArmyType::EARTH, UnitType::EG, EGnumber);
 
+    std::string foughtUnits = "";
+
     // Check for a successful attack
     bool attackCheck = false;
 
@@ -47,7 +42,9 @@ bool AlienDrone::attack()
             gamePtr->addUnit(enemyUnit);
 
         // Store the IDs of the fought units to be printed later
-        foughtUnits.enqueue(enemyUnit->getId());
+        if (foughtUnits != "")
+            foughtUnits += ", ";
+        foughtUnits += std::to_string(enemyUnit->getId());
 
         // Nullify the pointer
         enemyUnit = nullptr;
@@ -56,5 +53,8 @@ bool AlienDrone::attack()
         attackCheck = true;
     }
 
+    if (foughtUnits != "")
+        gamePtr->registerAttack(this, "shots", foughtUnits);
+
     return attackCheck;
 }

UnitClasses/AlienDrone.h

@@ -9,7 +9,7 @@ class AlienDrone: public Unit
 public:
 	AlienDrone(Game*, double, int, int);
 
-	void printFought(); // Print the units that the drone has fought
+	void printUnit(); // Print the unit's type along with its ID
 	bool attack(); // Attack the enemy units
 };
 

UnitClasses/AlienMonster.cpp

@@ -12,16 +12,9 @@ void AlienMonster::setInfectingProbability(int probability)
     infectingProbability = probability;
 }
 
-void AlienMonster::printFought()
+void AlienMonster::printUnit()
 {
-    if (!foughtUnits.isEmpty())
-    {
-        std::cout << "AM " << getId() << " shots [";
-        foughtUnits.printList();
-        std::cout << "]" << std::endl;
-
-        clearFoughtUnits(); // Clear the list after printing
-    }
+    std::cout << "AM " << id;
 }
 
 bool AlienMonster::attack()
@@ -36,6 +29,8 @@ bool AlienMonster::attack()
     LinkedQueue<Unit*> tanksList = gamePtr->getEnemyList(ArmyType::EARTH, UnitType::ET, tanksCapacity);
     LinkedQueue<Unit*> saversList = gamePtr->getEnemyList(ArmyType::EARTH_ALLIED, UnitType::SU, saversCapacity);
 
+    std::string foughtUnits = "", infectedSoldiers = "";
+
     // Check for a successful attack
     bool attackCheck = false;
 
@@ -51,6 +46,12 @@ bool AlienMonster::attack()
         {
             dynamic_cast<EarthSoldier*>(enemyUnit)->getInfection(); // The soldier will get infected if not infected already and not immune
             gamePtr->addUnit(enemyUnit); // The soldier will be re-enqueued to the list & infected soldiers counter will be incremented
+
+            // Store the IDs of the fought units to be printed later
+            if (infectedSoldiers != "")
+                infectedSoldiers += ", ";
+            infectedSoldiers += std::to_string(enemyUnit->getId());
+
             continue;
         }
 
@@ -66,7 +67,9 @@ bool AlienMonster::attack()
             gamePtr->addUnit(enemyUnit);
 
         // Store the IDs of the fought units to be printed later
-        foughtUnits.enqueue(enemyUnit->getId());
+        if (foughtUnits != "")
+            foughtUnits += ", ";
+        foughtUnits += std::to_string(enemyUnit->getId());
 
         // Nullify the pointer
         enemyUnit = nullptr;
@@ -75,5 +78,10 @@ bool AlienMonster::attack()
         attackCheck = true;
     }
 
+    if (foughtUnits != "")
+        gamePtr->registerAttack(this, "shots", foughtUnits);
+    if (infectedSoldiers != "")
+        gamePtr->registerAttack(this, "infects", infectedSoldiers);
+
     return attackCheck;
 }

UnitClasses/AlienMonster.h

@@ -15,7 +15,7 @@ class AlienMonster: public Unit
 	// Static functions
 	static void setInfectingProbability(int); // Set the infecting probability
 
-	void printFought(); // Print the units that the monster has fought
+	void printUnit(); // Print the unit's type along with its ID
 	bool attack(); // Attack the enemy units
 };
 

UnitClasses/AlienSoldier.cpp

@@ -5,16 +5,9 @@ AlienSoldier::AlienSoldier(Game* gamePtr, double health, int power, int attackCa
     : Unit(gamePtr, UnitType::AS, health, power, attackCapacity)
 {}
 
-void AlienSoldier::printFought()
+void AlienSoldier::printUnit()
 {
-    if (!foughtUnits.isEmpty())
-    {
-        std::cout << "AS " << getId() << " shots [";
-        foughtUnits.printList();
-        std::cout << "]" << std::endl;
-
-        clearFoughtUnits(); // Clear the list after printing
-    }
+    std::cout << "AS " << id;
 }
 
 bool AlienSoldier::attack()
@@ -27,6 +20,8 @@ bool AlienSoldier::attack()
     LinkedQueue<Unit*> soldiersList = gamePtr->getEnemyList(ArmyType::EARTH, UnitType::ES, soldiersCapacity);
     LinkedQueue<Unit*> saversList = gamePtr->getEnemyList(ArmyType::EARTH_ALLIED, UnitType::SU, saversCapacity);
 
+    std::string foughtUnits = "";
+
     // Check for a successful attack
     bool attackCheck = false;
 
@@ -47,7 +42,9 @@ bool AlienSoldier::attack()
             gamePtr->addUnit(enemyUnit);
 
         // Store the IDs of the fought units to be printed later
-        foughtUnits.enqueue(enemyUnit->getId());
+        if (foughtUnits != "")
+            foughtUnits += ", ";
+        foughtUnits += std::to_string(enemyUnit->getId());
 
         // Nullify the pointer
         enemyUnit = nullptr;
@@ -56,5 +53,8 @@ bool AlienSoldier::attack()
         attackCheck = true;
     }
 
+    if (foughtUnits != "")
+        gamePtr->registerAttack(this, "shots", foughtUnits);
+
     return attackCheck;
 }

UnitClasses/AlienSoldier.h

@@ -9,7 +9,7 @@ class AlienSoldier: public Unit
 public:
 	AlienSoldier(Game*, double, int, int);
 
-	void printFought(); // Print the units that the soldier has fought
+	void printUnit(); // Print the unit's type along with its ID
 	bool attack(); // Attack the enemy units
 };
 

UnitClasses/EarthGunnery.cpp

@@ -5,16 +5,9 @@ EarthGunnery::EarthGunnery(Game* gamePtr, double health, int power, int attackCa
     : Unit(gamePtr, UnitType::EG, health, power, attackCapacity)
 {}
 
-void EarthGunnery::printFought()
+void EarthGunnery::printUnit()
 {
-    if (!foughtUnits.isEmpty())
-    {
-        std::cout << "EG " << getId() << " shots [";
-        foughtUnits.printList();
-        std::cout << "]" << std::endl;
-
-        clearFoughtUnits(); // Clear the list after printing
-    }
+    std::cout << "EG " << id;
 }
 
 bool EarthGunnery::attack()
@@ -29,6 +22,8 @@ bool EarthGunnery::attack()
     LinkedQueue<Unit*> dronesList = gamePtr->getEnemyList(ArmyType::ALIEN, UnitType::AD, dronesCapacity);
     LinkedQueue<Unit*> monstersList = gamePtr->getEnemyList(ArmyType::ALIEN, UnitType::AM, monstersCapacity);
 
+    std::string foughtUnits = "";
+
     // Check for a successful attack
     bool attackCheck = false;
 
@@ -47,14 +42,20 @@ bool EarthGunnery::attack()
             gamePtr->addUnit(enemyUnit);
 
         // Store the IDs of the fought units to be printed later
-        foughtUnits.enqueue(enemyUnit->getId());
+        if (foughtUnits != "")
+            foughtUnits += ", ";
+        foughtUnits += std::to_string(enemyUnit->getId());
 
         // Nullify the pointer
         enemyUnit = nullptr;
 
         // If this line is reached, at least one unit was attacked
         attackCheck = true;
     }
+
+    if (foughtUnits != "")
+        gamePtr->registerAttack(this, "shots", foughtUnits);
+
     return attackCheck;
 }
 

UnitClasses/EarthGunnery.h

@@ -9,7 +9,7 @@ class EarthGunnery: public Unit
 public:
 	EarthGunnery(Game*, double, int, int);
 
-	void printFought(); // Print the units that the gunnery has fought
+	void printUnit(); // Print the unit's type along with its ID
 	bool attack(); // Attack the enemy units
 
 	// Getters