Remove pulbic function in GoldMine

- Remove getter and setter functions in GoldMine
- Add gold manager mock in soldier tests

Author: hrishikeshshekhar

src/state/include/state/gold_manager/gold_manager.h

@@ -11,8 +11,8 @@
 
 #include <array>
 #include <cstdint>
-#include <map>
 #include <memory>
+#include <unordered_map>
 #include <vector>
 
 namespace state {
@@ -83,12 +83,11 @@ class STATE_EXPORT GoldManager : public IGoldManager {
 	 * It maps each gold mine to number of requests made by the player to mine
 	 * that location
 	 */
-	std::array<std::map<GoldMine *, int64_t, GoldMineCompare>, 2> mine_requests;
+	std::array<std::unordered_map<GoldMine *, int64_t>, 2> mine_requests;
 
 	/**
 	 * Function to return gold mine given the Vec2D offset
 	 */
-
 	GoldMine *GetGoldMine(Vec2D offset);
 
   public:

src/state/include/state/gold_manager/gold_mine.h

@@ -27,29 +27,5 @@ class GoldMine {
 	 * gold left in the gold mine
 	 */
 	int64_t ExtractGold(int64_t ext_amount);
-
-	/**
-	 * Helper function to get the amount of gold in the GoldMine
-	 */
-
-	int64_t GetGoldReserve();
-
-	/**
-	 * Helper function to set the amount of gold reserve in a GoldMine
-	 */
-	void SetGoldReserve(int64_t gold_value);
-};
-
-/**
- * Defining a way to compare 2 GoldMine objects so that is can be stored in an
- * unordered hash map
- */
-
-class GoldMineCompare {
-  public:
-	bool operator()(const GoldMine *lhs, const GoldMine *rhs) {
-		return (lhs->value - rhs->value);
-	}
 };
-
 } // namespace state

src/state/src/gold_manager/gold_mine.cpp

@@ -16,9 +16,4 @@ int64_t GoldMine::ExtractGold(int64_t ext_amount) {
 		return ext_amount;
 	}
 }
-
-int64_t GoldMine::GetGoldReserve() { return this->value; }
-
-void GoldMine::SetGoldReserve(int64_t gold_value) { this->value = gold_value; }
-
 } // namespace state

test/logger/logger_test.cpp

@@ -24,8 +24,6 @@ class LoggerTest : public testing::Test {
 
 	std::unique_ptr<GoldManagerMock> gold_manager;
 	std::unique_ptr<PathPlanner> path_planner;
-	std::array<int64_t, 2> player_gold;
-	int64_t max_gold;
 
 	std::unique_ptr<Map> map;
 
@@ -47,10 +45,6 @@ class LoggerTest : public testing::Test {
 		    {W, W, W, W, W},
 		}};
 		map = make_unique<Map>(map_matrix, TEST_MAP_SIZE, ELEMENT_SIZE);
-
-		player_gold[0] = 5000;
-		player_gold[1] = 5000;
-		max_gold = 10000;
 	}
 };
 

test/state/factory_test.cpp

@@ -13,12 +13,6 @@ using namespace testing;
 
 class FactoryTest : public Test {
   protected:
-	array<int64_t, 2> player_gold;
-	int64_t soldier_kill_reward_gold;
-	int64_t villager_kill_reward_gold;
-	int64_t factory_kill_reward_gold;
-	int64_t max_gold;
-
 	Soldier model_soldier;
 	Villager model_villager;
 
@@ -59,8 +53,6 @@ class FactoryTest : public Test {
 
 	FactoryTest() {
 
-		player_gold[0] = player_gold[1] = 5000;
-
 		model_villager =
 		    Villager(2, PlayerId::PLAYER2, ActorType::VILLAGER, 100, 100,
 		             DoubleVec2D(15, 15), gold_manager.get(),
@@ -70,13 +62,6 @@ class FactoryTest : public Test {
 		                        100, DoubleVec2D(10, 10), gold_manager.get(),
 		                        path_planner.get(), 10, 10, 10);
 
-		this->max_gold = 10000;
-		this->soldier_kill_reward_gold = SOLDIER_KILL_REWARD_AMOUNT;
-		this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT;
-		this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT;
-
-		std::vector<std::unique_ptr<GoldMine>> gold_mines;
-
 		this->gold_manager = make_unique<GoldManagerMock>();
 
 		villager_list = std::vector<std::unique_ptr<Villager>>{};

test/state/gold_manager_test.cpp

@@ -126,7 +126,7 @@ class GoldManagerTest : public testing::Test {
 TEST_F(GoldManagerTest, AddMineRequest) {
 	auto villager = MakeStateVillager(PlayerId::PLAYER1);
 	auto gold_mine = this->gold_mines[0];
-	gold_mine->SetGoldReserve(100);
+	gold_mine->value = 100;
 	int64_t player_id = static_cast<int64_t>(PlayerId::PLAYER1);
 	villager->SetMineTarget(Vec2D(2, 2));
 
@@ -152,7 +152,7 @@ TEST_F(GoldManagerTest, AddMineRequest) {
 TEST_F(GoldManagerTest, SplitGoldTest) {
 	// Reassigning the GoldMine gold to have 16 gold units
 	auto gold_mine = this->gold_mines[0];
-	gold_mine->SetGoldReserve(16);
+	gold_mine->value = 16;
 
 	// Making a villager each for player 1 and player 2
 	// Since both villagers start at the same position, they will reach the mine
@@ -178,15 +178,15 @@ TEST_F(GoldManagerTest, SplitGoldTest) {
 	          this->player_gold[0] + 8);
 	ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER2),
 	          this->player_gold[1] + 8);
-	ASSERT_EQ(gold_mine->GetGoldReserve(), 0);
+	ASSERT_EQ(gold_mine->value, 0);
 
 	// Updating the player gold in the test
 	this->player_gold[0] += 8;
 	this->player_gold[1] += 8;
 
 	// Reassigning gold manager to have an odd number and checking if the
 	// remaining gold is removed
-	gold_mine->SetGoldReserve(28);
+	gold_mine->value = 28;
 
 	// Creating an additional player 2 villager and resetting the first 2
 	// villagers
@@ -221,5 +221,5 @@ TEST_F(GoldManagerTest, SplitGoldTest) {
 	          this->player_gold[1] + 18);
 
 	// Checking if the extra 1 gold coin is removed
-	ASSERT_EQ(gold_mine->GetGoldReserve(), 0);
+	ASSERT_EQ(gold_mine->value, 0);
 }

test/state/soldier_test.cpp

@@ -2,7 +2,7 @@
 #include "gmock/gmock.h"
 #include "state/actor/soldier.h"
 #include "state/actor/villager.h"
-#include "state/gold_manager/gold_manager.h"
+#include "state/mocks/gold_manager_mock.h"
 #include "gtest/gtest.h"
 
 using namespace std;
@@ -20,13 +20,7 @@ class SoldierTest : public Test {
 	int64_t element_size = 10;
 	unique_ptr<Map> map;
 
-	array<int64_t, 2> player_gold;
-	int64_t soldier_kill_reward_gold;
-	int64_t villager_kill_reward_gold;
-	int64_t factory_kill_reward_gold;
-	int64_t max_gold;
-
-	unique_ptr<GoldManager> gold_manager;
+	unique_ptr<GoldManagerMock> gold_manager;
 	unique_ptr<PathPlanner> path_planner;
 	unique_ptr<Soldier> soldier;
 
@@ -41,23 +35,7 @@ class SoldierTest : public Test {
 		}};
 
 		map = make_unique<Map>(map_matrix, map_size, element_size);
-
-		for (int i = 0; i < (int)PlayerId::PLAYER_COUNT; ++i) {
-			player_gold[i] = 5000; // Start balance
-		}
-
-		this->max_gold = 10000;
-		this->soldier_kill_reward_gold = SOLDIER_KILL_REWARD_AMOUNT;
-		this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT;
-		this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT;
-
-		std::vector<std::unique_ptr<GoldMine>> gold_mines;
-
-		this->gold_manager = make_unique<GoldManager>(
-		    player_gold, max_gold, soldier_kill_reward_gold,
-		    villager_kill_reward_gold, factory_kill_reward_gold, VILLAGER_COST,
-		    SOLDIER_COST, FACTORY_COST, MINING_REWARD, std::move(gold_mines));
-		this->path_planner = make_unique<PathPlanner>(map.get());
+		gold_manager = make_unique<GoldManagerMock>();
 
 		this->soldier =
 		    make_unique<Soldier>(1, PlayerId::PLAYER1, ActorType::SOLDIER, 100,
@@ -120,8 +98,13 @@ TEST_F(SoldierTest, MoveToDeadState) {
 	                DoubleVec2D(15, 15), gold_manager.get(), path_planner.get(),
 	                10, 10, attack_damage);
 
+	// Making soldier attack the other soldier
 	this->soldier->Attack(target_soldier);
 
+	// Expect calls to GoldManager for killing unit
+	EXPECT_CALL(*gold_manager, RewardKill(target_soldier));
+
+	// Soldier continuously attacking the other soldier until he dies
 	while (target_soldier->GetHp() != 0) {
 		this->soldier->Update();
 		target_soldier->Update();
@@ -135,7 +118,7 @@ TEST_F(SoldierTest, MoveToDeadState) {
 TEST_F(SoldierTest, SoldierKillReward) {
 	int64_t initial_hp = 100;
 	int64_t attack_damage = 10;
-	int64_t initial_gold = player_gold[0];
+	int64_t initial_gold = 100;
 
 	auto *target_soldier =
 	    new Soldier(2, PlayerId::PLAYER2, ActorType::SOLDIER, initial_hp, 100,
@@ -144,28 +127,31 @@ TEST_F(SoldierTest, SoldierKillReward) {
 
 	this->soldier->Attack(target_soldier);
 
+	// Expecting call to gold manager to reward kill of soldier
+	EXPECT_CALL(*gold_manager, RewardKill(target_soldier));
+
 	while (target_soldier->GetHp() != 0) {
 		this->soldier->Update();
 		target_soldier->Update();
 		this->soldier->LateUpdate();
 		target_soldier->LateUpdate();
 	}
-
-	ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1),
-	          (initial_gold + soldier_kill_reward_gold));
 }
 
 TEST_F(SoldierTest, PursuitAndKill) {
 	int64_t initial_hp = 100;
 	int64_t attack_damage = 10;
-
 	auto *target_soldier =
 	    new Soldier(2, PlayerId::PLAYER2, ActorType::SOLDIER, initial_hp, 100,
-	                DoubleVec2D(10, 40), gold_manager.get(), path_planner.get(),
+	                DoubleVec2D(15, 15), gold_manager.get(), path_planner.get(),
 	                10, 10, attack_damage);
 
 	this->soldier->SetAttackTarget(target_soldier);
 
+	// Expecting call to gold manager to reward the soldier for killing target
+	// soldier
+	EXPECT_CALL(*gold_manager, RewardKill(target_soldier));
+
 	while (target_soldier->GetHp() != 0) {
 		this->soldier->Update();
 		target_soldier->Update();
@@ -177,13 +163,20 @@ TEST_F(SoldierTest, PursuitAndKill) {
 }
 
 TEST_F(SoldierTest, SimultaneousKill) {
-	auto target_soldier = make_unique<Soldier>(
-	    2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100, DoubleVec2D(35, 45),
-	    gold_manager.get(), path_planner.get(), 10, 10, 10);
+	auto *target_soldier =
+	    new Soldier(2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100,
+	                DoubleVec2D(15, 15), gold_manager.get(), path_planner.get(),
+	                10, 10, 10);
 
-	soldier->Attack(target_soldier.get());
+	// Both soldiers attacking each other
+	soldier->Attack(target_soldier);
 	target_soldier->Attack(soldier.get());
 
+
+	// Expecting call to gold manager to reward gold to each soldier for killing the other
+	EXPECT_CALL(*gold_manager, RewardKill(target_soldier));
+	EXPECT_CALL(*gold_manager, RewardKill(soldier.get())); 
+
 	while (target_soldier->GetHp() != 0) {
 		this->soldier->Update();
 		target_soldier->Update();

test/state/villager_test.cpp

@@ -21,12 +21,6 @@ class VillagerTest : public Test {
 	int64_t element_size = 10;
 	unique_ptr<Map> map;
 
-	array<int64_t, 2> player_gold;
-	int64_t soldier_kill_reward_gold;
-	int64_t villager_kill_reward_gold;
-	int64_t factory_kill_reward_gold;
-	int64_t max_gold;
-
 	unique_ptr<GoldManagerMock> gold_manager;
 	unique_ptr<PathPlanner> path_planner;
 	unique_ptr<Villager> villager;
@@ -49,15 +43,6 @@ class VillagerTest : public Test {
 		}};
 
 		map = make_unique<Map>(map_matrix, map_size, element_size);
-		for (int i = 0; i < (int)PlayerId::PLAYER_COUNT; ++i) {
-			player_gold[i] = 5000; // Start balance
-		}
-
-		this->max_gold = 10000;
-		this->soldier_kill_reward_gold = SOLDIER_KILL_REWARD_AMOUNT;
-		this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT;
-		this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT;
-
 		this->gold_manager = make_unique<GoldManagerMock>();
 
 		this->path_planner = make_unique<PathPlanner>(map.get());