From 2647c3a41e919a8c86984985036e9ddf09de6024 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Wed, 6 Feb 2019 22:46:50 +0530 Subject: [PATCH 01/11] Add interface for GoldManager, Add GoldMines - Add an interface for GoldManager. - Add forward declarations Actor and GoldManager to fix circular dependecy. - Add GoldMines for easy accessing GoldMines --- src/state/include/state/actor/actor.fwd.h | 11 +++ src/state/include/state/actor/actor.h | 3 + src/state/include/state/actor/factory.fwd.h | 2 +- .../include/state/gold_manager/gold_manager.h | 9 ++- .../include/state/gold_manager/gold_mine.h | 16 ++++ .../include/state/interfaces/i_gold_manager.h | 80 +++++++++++++++++++ 6 files changed, 119 insertions(+), 2 deletions(-) create mode 100644 src/state/include/state/actor/actor.fwd.h create mode 100644 src/state/include/state/gold_manager/gold_mine.h create mode 100644 src/state/include/state/interfaces/i_gold_manager.h diff --git a/src/state/include/state/actor/actor.fwd.h b/src/state/include/state/actor/actor.fwd.h new file mode 100644 index 0000000..2e36dac --- /dev/null +++ b/src/state/include/state/actor/actor.fwd.h @@ -0,0 +1,11 @@ +/** + * @file factory.fwd.h + * Forward declaration for the Factory class + */ + +#pragma once + +namespace state { + +class Actor; +} diff --git a/src/state/include/state/actor/actor.h b/src/state/include/state/actor/actor.h index 0f01df7..d99a0f5 100644 --- a/src/state/include/state/actor/actor.h +++ b/src/state/include/state/actor/actor.h @@ -17,6 +17,9 @@ namespace state { /** * Actor base class */ + +class GoldManager; + class STATE_EXPORT Actor : public IUpdatable { protected: /** diff --git a/src/state/include/state/actor/factory.fwd.h b/src/state/include/state/actor/factory.fwd.h index 505876f..afd58f5 100644 --- a/src/state/include/state/actor/factory.fwd.h +++ b/src/state/include/state/actor/factory.fwd.h @@ -1,5 +1,5 @@ /** - * @file soldier.fwd.h + * @file factory.fwd.h * Forward declaration for the Factory class */ diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index f4034c0..4b873c2 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -5,11 +5,13 @@ #pragma once +#include "state/interfaces/i_gold_manager.h" #include "state/state_export.h" #include "state/utilities.h" #include #include +#include namespace state { @@ -21,7 +23,7 @@ class Actor; /** * Gold Manager class that handles player gold */ -class STATE_EXPORT GoldManager { +class STATE_EXPORT GoldManager : public IGoldManager { private: /** @@ -74,6 +76,11 @@ class STATE_EXPORT GoldManager { */ int64_t mining_reward; + /** + * Vector of the gold mines + */ + std::vector gold_mines; + public: /** * Constructor for Gold Manager class diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h new file mode 100644 index 0000000..6dbbdff --- /dev/null +++ b/src/state/include/state/gold_manager/gold_mine.h @@ -0,0 +1,16 @@ +#include "physics/vector.hpp" + +class GoldMine { + public: + /** + * A vector to hold the offset where the gold mine is located + */ + Vec2D offset; + + /** + * Holds the amount of gold reserve that the gold mine has + */ + int64_t value; + + void ExtractGold(int64_t mine_rate); +}; \ No newline at end of file diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h new file mode 100644 index 0000000..c377bfc --- /dev/null +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -0,0 +1,80 @@ +#pragma once + +#include "state/actor/actor.fwd.h" +#include "state/actor/actor.h" +#include "state/gold_manager/gold_mine.h" +#include "state/state_export.h" +#include "state/utilities.h" + +namespace state { + +class STATE_EXPORT IGoldManager { + public: + /** + * Destructor + */ + virtual ~IGoldManager() {} + + /** + * Function to increase a player's gold + */ + virtual void Increase(PlayerId player_id, int64_t amount) = 0; + + /** + * Function to decrease a player's gold + */ + virtual void Decrease(PlayerId player_id, int64_t amount) = 0; + + /** + * Reward the player for killing an enemy actor + * + * @param[in] enemy_actor Pointer to the killed enemy + */ + virtual void RewardKill(Actor *enemy_actor) = 0; + + /** + * Returns the cost for creating a particular unit + * + * @param[in] actor_type ActorType to fetch cost + */ + virtual int64_t GetCreateUnitCost(ActorType unit_type) = 0; + + /** + * Decreases player's gold for creating specific actor type + * + * @param[in] actor_type Pointer to the actor which player wants to build + */ + virtual void DeductUnitCreateCost(PlayerId player_id, Actor *actor) = 0; + + /** + * Get the current balance amount of the PlayerId passed + * + * @param[in] player_id The player identifier + * + * @return The balance. + */ + virtual int64_t GetBalance(PlayerId player_id) = 0; + + /** + * Gets the maximum balance. + * + * @return The maximum possible balance. + */ + virtual int64_t GetMaxGold() = 0; + + /** + * Penalty for player triggering suicide + * + * @param[in] player_id Player who triggered the suicide + */ + virtual void DeductFactorySuicidePenalty(PlayerId player_id) = 0; + + /** + * Penalty for player triggering suicide + * + * @param[in] player_id Player who triggered the suicide + */ + virtual void RewardMineGold(PlayerId player_id) = 0; +}; + +} // namespace state \ No newline at end of file From b35701836728f8190685b5f892f90963b6efbb68 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Wed, 6 Feb 2019 23:19:18 +0530 Subject: [PATCH 02/11] Add functionality to add split gold mine rewards - Add helper functions in GoldManager and a hash map to map GoldMine to number of requests --- .../include/state/gold_manager/gold_manager.h | 42 +++++++++++++++---- .../include/state/gold_manager/gold_mine.h | 20 ++++++++- .../include/state/interfaces/i_gold_manager.h | 11 +++++ src/state/src/gold_manager/gold_manager.cpp | 6 +++ src/state/src/gold_manager/gold_mine.cpp | 20 +++++++++ 5 files changed, 88 insertions(+), 11 deletions(-) create mode 100644 src/state/src/gold_manager/gold_mine.cpp diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index 4b873c2..d25478c 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -11,6 +11,7 @@ #include #include +#include #include namespace state { @@ -81,6 +82,19 @@ class STATE_EXPORT GoldManager : public IGoldManager { */ std::vector gold_mines; + /** + * Map to manage user build requests + * It maps each gold mine to number of requests made by the player to mine + * that location + */ + std::array, 2> mine_requests; + + /** + * Function to return gold mine given the Vec2D offset + */ + + GoldMine GetGoldMine(Vec2D offset); + public: /** * Constructor for Gold Manager class @@ -105,7 +119,7 @@ class STATE_EXPORT GoldManager : public IGoldManager { * * @throw std::out_of_range If the amount is not positive */ - void Increase(PlayerId player_id, int64_t amount); + void Increase(PlayerId player_id, int64_t amount) override; /** * Method to decrease player money @@ -116,28 +130,28 @@ class STATE_EXPORT GoldManager : public IGoldManager { * @throw std::out_of_range If the amount is not positive * player has insufficuent balance */ - void Decrease(PlayerId player_id, int64_t amount); + void Decrease(PlayerId player_id, int64_t amount) override; /** * Reward the player for killing an enemy actor * * @param[in] enemy_actor Pointer to the killed enemy */ - void RewardKill(Actor *enemy_actor); + void RewardKill(Actor *enemy_actor) override; /** * Returns the cost for creating a particular unit * * @param[in] actor_type ActorType to fetch cost */ - int64_t GetCreateUnitCost(ActorType unit_type); + int64_t GetCreateUnitCost(ActorType unit_type) override; /** * Decreases player's gold for creating specific actor type * * @param[in] actor_type Pointer to the actor which player wants to build */ - void DeductUnitCreateCost(PlayerId player_id, Actor *actor); + void DeductUnitCreateCost(PlayerId player_id, Actor *actor) override; /** * Get the current balance amount of the PlayerId passed @@ -146,27 +160,37 @@ class STATE_EXPORT GoldManager : public IGoldManager { * * @return The balance. */ - int64_t GetBalance(PlayerId player_id); + int64_t GetBalance(PlayerId player_id) override; /** * Gets the maximum balance. * * @return The maximum possible balance. */ - int64_t GetMaxGold(); + int64_t GetMaxGold() override; /** * Penalty for player triggering suicide * * @param[in] player_id Player who triggered the suicide */ - void DeductFactorySuicidePenalty(PlayerId player_id); + void DeductFactorySuicidePenalty(PlayerId player_id) override; /** * Penalty for player triggering suicide * * @param[in] player_id Player who triggered the suicide */ - void RewardMineGold(PlayerId player_id); + void RewardMineGold(PlayerId player_id) override; + + /** + * Function to add build request to current requests + */ + void AddBuildRequest(PlayerId player_id, Vec2D offset) override; + + /** + * Function to assign amount of gold to be given to each player + */ + void AssignGold() override; }; } // namespace state diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h index 6dbbdff..c1f5605 100644 --- a/src/state/include/state/gold_manager/gold_mine.h +++ b/src/state/include/state/gold_manager/gold_mine.h @@ -1,5 +1,7 @@ #include "physics/vector.hpp" +namespace state { + class GoldMine { public: /** @@ -12,5 +14,19 @@ class GoldMine { */ int64_t value; - void ExtractGold(int64_t mine_rate); -}; \ No newline at end of file + /** + * Constructors + */ + + GoldMine(); + + GoldMine(Vec2D offset, int64_t value); + + /** + * Helper function to extract valid amount of gold depending on amount of + * gold left in the gold mine + */ + int64_t ExtractGold(int64_t ext_amount); +}; + +} // namespace state \ No newline at end of file diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h index c377bfc..60ecff9 100644 --- a/src/state/include/state/interfaces/i_gold_manager.h +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -75,6 +75,17 @@ class STATE_EXPORT IGoldManager { * @param[in] player_id Player who triggered the suicide */ virtual void RewardMineGold(PlayerId player_id) = 0; + + /** + * Function to add build request to current requests + */ + + virtual void AddBuildRequest(PlayerId player_id, Vec2D offset) = 0; + + /** + * Function to assign amount of gold to be given to each player + */ + virtual void AssignGold() = 0; }; } // namespace state \ No newline at end of file diff --git a/src/state/src/gold_manager/gold_manager.cpp b/src/state/src/gold_manager/gold_manager.cpp index 5063602..538c5e7 100644 --- a/src/state/src/gold_manager/gold_manager.cpp +++ b/src/state/src/gold_manager/gold_manager.cpp @@ -122,4 +122,10 @@ void GoldManager::RewardMineGold(PlayerId player_id) { Increase(player_id, reward_mining); } +void GoldManager::AddBuildRequest(PlayerId player_id, Vec2D offset) {} + +void GoldManager::AssignGold() {} + +GoldMine GoldManager::GetGoldMine(Vec2D offset) {} + } // namespace state diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp new file mode 100644 index 0000000..8921687 --- /dev/null +++ b/src/state/src/gold_manager/gold_mine.cpp @@ -0,0 +1,20 @@ +#include "state/gold_manager/gold_mine.h" + +namespace state{ + GoldMine::GoldMine() : offset(Vec2D::null), value(0) {}; + + GoldMine::GoldMine(Vec2D offset, int64_t value){ + + }; + + int64_t GoldMine::ExtractGold(int64_t ext_amount){ + if(this->value - ext_amount < 0){ + this->value = 0; + return this->value; + } + else{ + this->value -= ext_amount; + return ext_amount; + } + } +} \ No newline at end of file From 5bc1c3d5a0688672867ecbb1e6e4887e8acd5dd5 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Thu, 7 Feb 2019 12:05:32 +0530 Subject: [PATCH 03/11] Add gold assignment logic from gold mines - Add logic to create request for mining gold from a mine --- src/state/CMakeLists.txt | 1 + .../include/state/gold_manager/gold_manager.h | 11 +- .../include/state/gold_manager/gold_mine.h | 12 ++ .../include/state/interfaces/i_gold_manager.h | 3 +- .../villager_states/villager_mine_state.cpp | 3 +- src/state/src/gold_manager/gold_manager.cpp | 107 +++++++++++++++--- src/state/src/gold_manager/gold_mine.cpp | 30 ++--- src/state/src/state.cpp | 3 + 8 files changed, 135 insertions(+), 35 deletions(-) diff --git a/src/state/CMakeLists.txt b/src/state/CMakeLists.txt index d6369af..aa044f1 100644 --- a/src/state/CMakeLists.txt +++ b/src/state/CMakeLists.txt @@ -13,6 +13,7 @@ set(SOURCE_FILES src/actor/factory.cpp src/map/map.cpp src/gold_manager/gold_manager.cpp + src/gold_manager/gold_mine.cpp src/actor/soldier_states/soldier_state.cpp src/actor/soldier_states/soldier_idle_state.cpp src/actor/soldier_states/soldier_attack_state.cpp diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index d25478c..4c48fef 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -87,13 +87,13 @@ 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, 2> mine_requests; + std::array, 2> mine_requests; /** * Function to return gold mine given the Vec2D offset */ - GoldMine GetGoldMine(Vec2D offset); + const GoldMine GetGoldMine(Vec2D offset); public: /** @@ -107,7 +107,9 @@ class STATE_EXPORT GoldManager : public IGoldManager { int64_t factory_kill_reward_amount, int64_t factory_suicide_penalty_amount, int64_t villager_cost, int64_t soldier_cost, int64_t soldier_factory_cost, - int64_t mining_reward); + int64_t mining_reward, std::vector gold_mines, + std::array, 2> + mine_requests); /** * Method to increase player money @@ -181,7 +183,8 @@ class STATE_EXPORT GoldManager : public IGoldManager { * * @param[in] player_id Player who triggered the suicide */ - void RewardMineGold(PlayerId player_id) override; + void RewardMineGold(PlayerId player_id, GoldMine gold_mine, + int64_t mining_reward) override; /** * Function to add build request to current requests diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h index c1f5605..b9a853a 100644 --- a/src/state/include/state/gold_manager/gold_mine.h +++ b/src/state/include/state/gold_manager/gold_mine.h @@ -29,4 +29,16 @@ class GoldMine { int64_t ExtractGold(int64_t ext_amount); }; +/** + * Defining a way to compare 2 GoldMine objects so that is can be stored in a + * hash map + */ + +class GoldMineCompare { + public: + bool operator()(const GoldMine &lhs, const GoldMine &rhs) { + return (lhs.value - rhs.value); + } +}; + } // namespace state \ No newline at end of file diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h index 60ecff9..3cd8eeb 100644 --- a/src/state/include/state/interfaces/i_gold_manager.h +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -74,7 +74,8 @@ class STATE_EXPORT IGoldManager { * * @param[in] player_id Player who triggered the suicide */ - virtual void RewardMineGold(PlayerId player_id) = 0; + virtual void RewardMineGold(PlayerId player_id, GoldMine gold_mine, + int64_t mining_reward) = 0; /** * Function to add build request to current requests diff --git a/src/state/src/actor/villager_states/villager_mine_state.cpp b/src/state/src/actor/villager_states/villager_mine_state.cpp index 08936d2..00e8fa7 100644 --- a/src/state/src/actor/villager_states/villager_mine_state.cpp +++ b/src/state/src/actor/villager_states/villager_mine_state.cpp @@ -53,7 +53,8 @@ std::unique_ptr VillagerMineState::Update() { } // Mine gold - villager->GetGoldManager()->RewardMineGold(villager->GetPlayerId()); + villager->GetGoldManager()->AddBuildRequest(villager->GetPlayerId(), + villager->GetMineTarget()); return nullptr; } diff --git a/src/state/src/gold_manager/gold_manager.cpp b/src/state/src/gold_manager/gold_manager.cpp index 538c5e7..3ff504c 100644 --- a/src/state/src/gold_manager/gold_manager.cpp +++ b/src/state/src/gold_manager/gold_manager.cpp @@ -12,20 +12,21 @@ namespace state { GoldManager::GoldManager() {} -GoldManager::GoldManager(std::array players_gold, int64_t max_gold, - int64_t soldier_kill_reward_amount, - int64_t villager_kill_reward_amount, - int64_t factory_kill_reward_amount, - int64_t factory_suicide_penalty_amount, - int64_t villager_cost, int64_t soldier_cost, - int64_t factory_cost, int64_t mining_reward) +GoldManager::GoldManager( + std::array players_gold, int64_t max_gold, + int64_t soldier_kill_reward_amount, int64_t villager_kill_reward_amount, + int64_t factory_kill_reward_amount, int64_t factory_suicide_penalty_amount, + int64_t villager_cost, int64_t soldier_cost, int64_t factory_cost, + int64_t mining_reward, std::vector gold_mines, + std::array, 2> mine_requests) : players_gold(players_gold), max_gold(max_gold), soldier_kill_reward_amount(soldier_kill_reward_amount), villager_kill_reward_amount(villager_kill_reward_amount), factory_kill_reward_amount(factory_kill_reward_amount), factory_suicide_penalty_amount(factory_suicide_penalty_amount), villager_cost(villager_cost), soldier_cost(soldier_cost), - factory_cost(factory_cost), mining_reward(mining_reward) {} + factory_cost(factory_cost), mining_reward(mining_reward), + gold_mines(gold_mines), mine_requests(mine_requests) {} void GoldManager::Increase(PlayerId player_id, int64_t amount) { @@ -117,15 +118,93 @@ void GoldManager::DeductFactorySuicidePenalty(PlayerId player_id) { Decrease(player_id, suicide_penalty); } -void GoldManager::RewardMineGold(PlayerId player_id) { - auto reward_mining = mining_reward; - Increase(player_id, reward_mining); +void GoldManager::RewardMineGold(PlayerId player_id, GoldMine gold_mine, + int64_t mining_reward) { + // Extracting gold from the gold mine + int64_t extracted_amount = gold_mine.ExtractGold(mining_reward); + + // Increasing the player's gold + Increase(player_id, extracted_amount); } -void GoldManager::AddBuildRequest(PlayerId player_id, Vec2D offset) {} +void GoldManager::AddBuildRequest(PlayerId player_id, Vec2D offset) { + int64_t id = static_cast(player_id); + auto &player_requests = this->mine_requests[id]; + auto const gold_mine = GetGoldMine(offset); + + // If the gold mine dosen't already exist in the hash map, then we add an + // entry with count 1 + if (player_requests.empty()) { + player_requests.insert(std::pair(gold_mine, 1)); + } else if (player_requests.find(gold_mine) != player_requests.end()) { + player_requests.insert(std::pair(gold_mine, 1)); + } else { + auto request = player_requests.find(gold_mine); + request->second += 1; + } +} -void GoldManager::AssignGold() {} +void GoldManager::AssignGold() { + // Iterating through all the player's requests + for (int id = 0; id < 2; ++id) { + int64_t enemy_id = + (id + 1) % static_cast(PlayerId::PLAYER_COUNT); + auto player_requests = this->mine_requests[id]; + auto enemy_requests = this->mine_requests[enemy_id]; + for (auto const &request : player_requests) { + auto gold_mine = request.first; + auto no_player_requests = request.second; + PlayerId player_id = static_cast(id); + + // If enemy is trying to mine in the same gold mine, gold is split + if (enemy_requests.find(gold_mine) != enemy_requests.end()) { + int64_t no_enemy_requests = + enemy_requests.find(gold_mine)->second; + + // Checking if the gold mine has enough gold to accomodate both + // the users + int64_t total_gold_required = + this->mining_reward * + (no_player_requests + no_enemy_requests); + + // If the gold mine has enough gold to accomodate both the + // player's requests + if (gold_mine.value >= total_gold_required) { + // Deducting the player's requested gold + int64_t mining_reward = + this->mining_reward * no_player_requests; + RewardMineGold(player_id, gold_mine, mining_reward); + } + + // If the gold mine has lesser gold than what is asked + // NOTE: One gold coin may get lost + else { + // Finding the ratio of gold that this player will recieve + float gold_ratio = float(no_player_requests) / + (no_enemy_requests + no_enemy_requests); + int gold_recieved = gold_ratio * gold_mine.value; + RewardMineGold(player_id, gold_mine, gold_recieved); + } + } + // Gold is not split between the villagers + else { + int gold_recieved = no_player_requests * this->mining_reward; + + // Rewarding the user gold + RewardMineGold(player_id, gold_mine, gold_recieved); + } + } + } +} -GoldMine GoldManager::GetGoldMine(Vec2D offset) {} +const GoldMine GoldManager::GetGoldMine(Vec2D offset) { + for (auto gold_mine : this->gold_mines) { + if (gold_mine.offset == offset) { + return gold_mine; + } + } + // TODO : Return null value + // return null; +} } // namespace state diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp index 8921687..1581750 100644 --- a/src/state/src/gold_manager/gold_mine.cpp +++ b/src/state/src/gold_manager/gold_mine.cpp @@ -1,20 +1,20 @@ #include "state/gold_manager/gold_mine.h" -namespace state{ - GoldMine::GoldMine() : offset(Vec2D::null), value(0) {}; +namespace state { - GoldMine::GoldMine(Vec2D offset, int64_t value){ +GoldMine::GoldMine() : offset(Vec2D::null), value(0){}; - }; +GoldMine::GoldMine(Vec2D offset, int64_t value){ - int64_t GoldMine::ExtractGold(int64_t ext_amount){ - if(this->value - ext_amount < 0){ - this->value = 0; - return this->value; - } - else{ - this->value -= ext_amount; - return ext_amount; - } - } -} \ No newline at end of file +}; + +int64_t GoldMine::ExtractGold(int64_t ext_amount) { + if (this->value - ext_amount < 0) { + this->value = 0; + return this->value; + } else { + this->value -= ext_amount; + return ext_amount; + } +} +} // namespace state \ No newline at end of file diff --git a/src/state/src/state.cpp b/src/state/src/state.cpp index fef29f6..a6a4337 100644 --- a/src/state/src/state.cpp +++ b/src/state/src/state.cpp @@ -369,6 +369,9 @@ bool State::IsGameOver(PlayerId &winner) { // If no one died, is_game_over is false by default, leave winner alone return is_game_over; + + // Late gold manager update + gold_manager->AssignGold(); } } // namespace state From 642033f0132f43c81289522d2d7e1e22fc5f740b Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Thu, 7 Feb 2019 12:10:39 +0530 Subject: [PATCH 04/11] Change GoldManager constructors in tests - Change GoldManager constructors in logger_test.cpp, soldier_test.cpp, factory_test.cpp, villager_test.cpp, state_test.cpp --- src/main/main.cpp | 4 +++- test/logger/logger_test.cpp | 7 ++++++- test/state/factory_test.cpp | 6 +++++- test/state/soldier_test.cpp | 6 +++++- test/state/state_test.cpp | 6 +++++- test/state/villager_test.cpp | 6 +++++- 6 files changed, 29 insertions(+), 6 deletions(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index f819b8d..7a818fe 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -90,11 +90,13 @@ unique_ptr BuildMap() { } unique_ptr BuildGoldManager() { + std::vector gold_mines; + std::array, 2> mine_requests; return make_unique( array{GOLD_START, GOLD_START}, GOLD_MAX, SOLDIER_KILL_REWARD_AMOUNT, VILLAGER_KILL_REWARD_AMOUNT, FACTORY_KILL_REWARD_AMOUNT, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, - SOLDIER_COST, FACTORY_COST, MINING_REWARD); + SOLDIER_COST, FACTORY_COST, MINING_REWARD, gold_mines, mine_requests); } unique_ptr BuildPathPlanner(Map *map) { diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index 01c3022..a86bf7d 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -49,11 +49,16 @@ class LoggerTest : public testing::Test { player_gold[0] = 5000; player_gold[1] = 5000; max_gold = 10000; + + std::vector gold_mines; + std::array, 2> + mine_requests; + this->gold_manager = make_unique( player_gold, max_gold, SOLDIER_KILL_REWARD_AMOUNT, VILLAGER_KILL_REWARD_AMOUNT, FACTORY_KILL_REWARD_AMOUNT, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD); + MINING_REWARD, gold_mines, mine_requests); } }; diff --git a/test/state/factory_test.cpp b/test/state/factory_test.cpp index a803c92..bc65020 100644 --- a/test/state/factory_test.cpp +++ b/test/state/factory_test.cpp @@ -75,11 +75,15 @@ class FactoryTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; + std::vector gold_mines; + std::array, 2> + mine_requests; + this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD); + MINING_REWARD, gold_mines, mine_requests); villager_list = std::vector>{}; soldier_list = std::vector>{}; diff --git a/test/state/soldier_test.cpp b/test/state/soldier_test.cpp index fe643a3..706ca41 100644 --- a/test/state/soldier_test.cpp +++ b/test/state/soldier_test.cpp @@ -51,11 +51,15 @@ class SoldierTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; + std::vector gold_mines; + std::array, 2> + mine_requests; + this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD); + MINING_REWARD, gold_mines, mine_requests); this->path_planner = make_unique(map.get()); this->soldier = diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index 1c361a4..970a780 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -61,11 +61,15 @@ class StateTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; + std::vector gold_mines; + std::array, 2> + mine_requests; + this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD); + MINING_REWARD, gold_mines, mine_requests); this->path_planner = make_unique(map.get()); diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index 531b003..f8c194d 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -58,11 +58,15 @@ class VillagerTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; + std::vector gold_mines; + std::array, 2> + mine_requests; + this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD); + MINING_REWARD, gold_mines, mine_requests); this->path_planner = make_unique(map.get()); From dc91318c8c37d81c93e8ff9681d773d9aa81b07d Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Thu, 7 Feb 2019 17:01:02 +0530 Subject: [PATCH 05/11] Remove segmentation faults - Remove segmentation faults in villager tests caused due to inavailability of gold mines --- src/state/src/actor/villager.cpp | 4 +++- src/state/src/gold_manager/gold_mine.cpp | 4 +--- test/state/villager_test.cpp | 6 +++++- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/state/src/actor/villager.cpp b/src/state/src/actor/villager.cpp index c98e770..1f01dfc 100644 --- a/src/state/src/actor/villager.cpp +++ b/src/state/src/actor/villager.cpp @@ -61,7 +61,9 @@ void Villager::Build(Factory *build_target) { this->is_destination_set = false; } -void Villager::Mine(Vec2D mine_target) { this->SetMineTarget(mine_target); } +void Villager::Mine(Vec2D mine_target) { + this->SetMineTarget(mine_target); +} void Villager::SetMineTarget(Vec2D mine_target) { this->mine_target = mine_target; diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp index 1581750..da1928c 100644 --- a/src/state/src/gold_manager/gold_mine.cpp +++ b/src/state/src/gold_manager/gold_mine.cpp @@ -4,9 +4,7 @@ namespace state { GoldMine::GoldMine() : offset(Vec2D::null), value(0){}; -GoldMine::GoldMine(Vec2D offset, int64_t value){ - -}; +GoldMine::GoldMine(Vec2D offset, int64_t value) : offset(offset), value(value) {}; int64_t GoldMine::ExtractGold(int64_t ext_amount) { if (this->value - ext_amount < 0) { diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index f8c194d..09df18e 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -61,6 +61,10 @@ class VillagerTest : public Test { std::vector gold_mines; std::array, 2> mine_requests; + GoldMine gold_mine1(Vec2D(10, 10), 100); + GoldMine gold_mine2(Vec2D(20, 10), 100); + gold_mines.push_back(gold_mine1); + gold_mines.push_back(gold_mine2); this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, @@ -144,7 +148,7 @@ TEST_F(VillagerTest, TransitionToDeadState) { } TEST_F(VillagerTest, MoveToMine) { - this->villager->SetMineTarget(Vec2D(25, 30)); + this->villager->SetMineTarget(Vec2D(20, 10)); while (this->villager->GetState() != VillagerStateName::MINE) { this->villager->Update(); From e22e3eaa527dea449d4e47edfe57c4f9204a9c48 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Thu, 7 Feb 2019 23:46:42 +0530 Subject: [PATCH 06/11] Change gold mines to unique pointers - Changing gold mines in gold manager to unique pointers and changing the mine requests to type pointers for keys --- src/main/main.cpp | 5 +-- .../include/state/gold_manager/gold_manager.h | 14 +++---- .../include/state/gold_manager/gold_mine.h | 4 +- .../include/state/interfaces/i_gold_manager.h | 2 +- src/state/src/actor/villager.cpp | 4 +- src/state/src/gold_manager/gold_manager.cpp | 41 ++++++++++--------- src/state/src/gold_manager/gold_mine.cpp | 3 +- src/state/src/state.cpp | 2 +- test/logger/logger_test.cpp | 6 +-- test/state/factory_test.cpp | 6 +-- test/state/soldier_test.cpp | 6 +-- test/state/state_test.cpp | 7 ++-- test/state/villager_test.cpp | 14 +++---- 13 files changed, 52 insertions(+), 62 deletions(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index 7a818fe..39acb34 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -90,13 +90,12 @@ unique_ptr BuildMap() { } unique_ptr BuildGoldManager() { - std::vector gold_mines; - std::array, 2> mine_requests; + std::vector> gold_mines; return make_unique( array{GOLD_START, GOLD_START}, GOLD_MAX, SOLDIER_KILL_REWARD_AMOUNT, VILLAGER_KILL_REWARD_AMOUNT, FACTORY_KILL_REWARD_AMOUNT, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, - SOLDIER_COST, FACTORY_COST, MINING_REWARD, gold_mines, mine_requests); + SOLDIER_COST, FACTORY_COST, MINING_REWARD, std::move(gold_mines)); } unique_ptr BuildPathPlanner(Map *map) { diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index 4c48fef..21eb11c 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -12,6 +12,7 @@ #include #include #include +#include #include namespace state { @@ -80,20 +81,20 @@ class STATE_EXPORT GoldManager : public IGoldManager { /** * Vector of the gold mines */ - std::vector gold_mines; + std::vector> gold_mines; /** * Map to manage user build requests * It maps each gold mine to number of requests made by the player to mine * that location */ - std::array, 2> mine_requests; + std::array, 2> mine_requests; /** * Function to return gold mine given the Vec2D offset */ - const GoldMine GetGoldMine(Vec2D offset); + GoldMine *GetGoldMine(Vec2D offset); public: /** @@ -107,9 +108,8 @@ class STATE_EXPORT GoldManager : public IGoldManager { int64_t factory_kill_reward_amount, int64_t factory_suicide_penalty_amount, int64_t villager_cost, int64_t soldier_cost, int64_t soldier_factory_cost, - int64_t mining_reward, std::vector gold_mines, - std::array, 2> - mine_requests); + int64_t mining_reward, + std::vector> gold_mines); /** * Method to increase player money @@ -183,7 +183,7 @@ class STATE_EXPORT GoldManager : public IGoldManager { * * @param[in] player_id Player who triggered the suicide */ - void RewardMineGold(PlayerId player_id, GoldMine gold_mine, + void RewardMineGold(PlayerId player_id, GoldMine *gold_mine, int64_t mining_reward) override; /** diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h index b9a853a..2ba19b1 100644 --- a/src/state/include/state/gold_manager/gold_mine.h +++ b/src/state/include/state/gold_manager/gold_mine.h @@ -36,8 +36,8 @@ class GoldMine { class GoldMineCompare { public: - bool operator()(const GoldMine &lhs, const GoldMine &rhs) { - return (lhs.value - rhs.value); + bool operator()(const GoldMine *lhs, const GoldMine *rhs) { + return (lhs->value - rhs->value); } }; diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h index 3cd8eeb..c73e7ae 100644 --- a/src/state/include/state/interfaces/i_gold_manager.h +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -74,7 +74,7 @@ class STATE_EXPORT IGoldManager { * * @param[in] player_id Player who triggered the suicide */ - virtual void RewardMineGold(PlayerId player_id, GoldMine gold_mine, + virtual void RewardMineGold(PlayerId player_id, GoldMine *gold_mine, int64_t mining_reward) = 0; /** diff --git a/src/state/src/actor/villager.cpp b/src/state/src/actor/villager.cpp index 1f01dfc..c98e770 100644 --- a/src/state/src/actor/villager.cpp +++ b/src/state/src/actor/villager.cpp @@ -61,9 +61,7 @@ void Villager::Build(Factory *build_target) { this->is_destination_set = false; } -void Villager::Mine(Vec2D mine_target) { - this->SetMineTarget(mine_target); -} +void Villager::Mine(Vec2D mine_target) { this->SetMineTarget(mine_target); } void Villager::SetMineTarget(Vec2D mine_target) { this->mine_target = mine_target; diff --git a/src/state/src/gold_manager/gold_manager.cpp b/src/state/src/gold_manager/gold_manager.cpp index 3ff504c..b5f1a93 100644 --- a/src/state/src/gold_manager/gold_manager.cpp +++ b/src/state/src/gold_manager/gold_manager.cpp @@ -12,13 +12,14 @@ namespace state { GoldManager::GoldManager() {} -GoldManager::GoldManager( - std::array players_gold, int64_t max_gold, - int64_t soldier_kill_reward_amount, int64_t villager_kill_reward_amount, - int64_t factory_kill_reward_amount, int64_t factory_suicide_penalty_amount, - int64_t villager_cost, int64_t soldier_cost, int64_t factory_cost, - int64_t mining_reward, std::vector gold_mines, - std::array, 2> mine_requests) +GoldManager::GoldManager(std::array players_gold, int64_t max_gold, + int64_t soldier_kill_reward_amount, + int64_t villager_kill_reward_amount, + int64_t factory_kill_reward_amount, + int64_t factory_suicide_penalty_amount, + int64_t villager_cost, int64_t soldier_cost, + int64_t factory_cost, int64_t mining_reward, + std::vector> gold_mines) : players_gold(players_gold), max_gold(max_gold), soldier_kill_reward_amount(soldier_kill_reward_amount), villager_kill_reward_amount(villager_kill_reward_amount), @@ -26,7 +27,7 @@ GoldManager::GoldManager( factory_suicide_penalty_amount(factory_suicide_penalty_amount), villager_cost(villager_cost), soldier_cost(soldier_cost), factory_cost(factory_cost), mining_reward(mining_reward), - gold_mines(gold_mines), mine_requests(mine_requests) {} + gold_mines(std::move(gold_mines)), mine_requests({}) {} void GoldManager::Increase(PlayerId player_id, int64_t amount) { @@ -118,10 +119,10 @@ void GoldManager::DeductFactorySuicidePenalty(PlayerId player_id) { Decrease(player_id, suicide_penalty); } -void GoldManager::RewardMineGold(PlayerId player_id, GoldMine gold_mine, +void GoldManager::RewardMineGold(PlayerId player_id, GoldMine *gold_mine, int64_t mining_reward) { // Extracting gold from the gold mine - int64_t extracted_amount = gold_mine.ExtractGold(mining_reward); + int64_t extracted_amount = gold_mine->ExtractGold(mining_reward); // Increasing the player's gold Increase(player_id, extracted_amount); @@ -129,15 +130,15 @@ void GoldManager::RewardMineGold(PlayerId player_id, GoldMine gold_mine, void GoldManager::AddBuildRequest(PlayerId player_id, Vec2D offset) { int64_t id = static_cast(player_id); - auto &player_requests = this->mine_requests[id]; - auto const gold_mine = GetGoldMine(offset); + auto player_requests = this->mine_requests[id]; + auto gold_mine = GetGoldMine(offset); // If the gold mine dosen't already exist in the hash map, then we add an // entry with count 1 if (player_requests.empty()) { - player_requests.insert(std::pair(gold_mine, 1)); + player_requests.insert(std::pair(gold_mine, 1)); } else if (player_requests.find(gold_mine) != player_requests.end()) { - player_requests.insert(std::pair(gold_mine, 1)); + player_requests.insert(std::pair(gold_mine, 1)); } else { auto request = player_requests.find(gold_mine); request->second += 1; @@ -169,7 +170,7 @@ void GoldManager::AssignGold() { // If the gold mine has enough gold to accomodate both the // player's requests - if (gold_mine.value >= total_gold_required) { + if (gold_mine->value >= total_gold_required) { // Deducting the player's requested gold int64_t mining_reward = this->mining_reward * no_player_requests; @@ -182,7 +183,7 @@ void GoldManager::AssignGold() { // Finding the ratio of gold that this player will recieve float gold_ratio = float(no_player_requests) / (no_enemy_requests + no_enemy_requests); - int gold_recieved = gold_ratio * gold_mine.value; + int gold_recieved = gold_ratio * gold_mine->value; RewardMineGold(player_id, gold_mine, gold_recieved); } } @@ -197,10 +198,10 @@ void GoldManager::AssignGold() { } } -const GoldMine GoldManager::GetGoldMine(Vec2D offset) { - for (auto gold_mine : this->gold_mines) { - if (gold_mine.offset == offset) { - return gold_mine; +GoldMine *GoldManager::GetGoldMine(Vec2D offset) { + for (int i = 0; i < this->gold_mines.size(); ++i) { + if (this->gold_mines[i]->offset == offset) { + return this->gold_mines[i].get(); } } // TODO : Return null value diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp index da1928c..aa164e5 100644 --- a/src/state/src/gold_manager/gold_mine.cpp +++ b/src/state/src/gold_manager/gold_mine.cpp @@ -4,7 +4,8 @@ namespace state { GoldMine::GoldMine() : offset(Vec2D::null), value(0){}; -GoldMine::GoldMine(Vec2D offset, int64_t value) : offset(offset), value(value) {}; +GoldMine::GoldMine(Vec2D offset, int64_t value) + : offset(offset), value(value){}; int64_t GoldMine::ExtractGold(int64_t ext_amount) { if (this->value - ext_amount < 0) { diff --git a/src/state/src/state.cpp b/src/state/src/state.cpp index a6a4337..262d607 100644 --- a/src/state/src/state.cpp +++ b/src/state/src/state.cpp @@ -233,7 +233,7 @@ const std::array, 2> GetRawPtrsFromUniquePtrs( auto player_actors = std::vector{}; player_actors.reserve(actors[i].size()); - // For each actor, + // For each actor for (int j = 0; j < actors[i].size(); ++j) { player_actors.push_back(actors[i][j].get()); } diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index a86bf7d..5eb2ed6 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -50,15 +50,13 @@ class LoggerTest : public testing::Test { player_gold[1] = 5000; max_gold = 10000; - std::vector gold_mines; - std::array, 2> - mine_requests; + std::vector> gold_mines; this->gold_manager = make_unique( player_gold, max_gold, SOLDIER_KILL_REWARD_AMOUNT, VILLAGER_KILL_REWARD_AMOUNT, FACTORY_KILL_REWARD_AMOUNT, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, gold_mines, mine_requests); + MINING_REWARD, std::move(gold_mines)); } }; diff --git a/test/state/factory_test.cpp b/test/state/factory_test.cpp index bc65020..9181565 100644 --- a/test/state/factory_test.cpp +++ b/test/state/factory_test.cpp @@ -75,15 +75,13 @@ class FactoryTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector gold_mines; - std::array, 2> - mine_requests; + std::vector> gold_mines; this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, gold_mines, mine_requests); + MINING_REWARD, std::move(gold_mines)); villager_list = std::vector>{}; soldier_list = std::vector>{}; diff --git a/test/state/soldier_test.cpp b/test/state/soldier_test.cpp index 706ca41..eb6f83b 100644 --- a/test/state/soldier_test.cpp +++ b/test/state/soldier_test.cpp @@ -51,15 +51,13 @@ class SoldierTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector gold_mines; - std::array, 2> - mine_requests; + std::vector> gold_mines; this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, gold_mines, mine_requests); + MINING_REWARD, std::move(gold_mines)); this->path_planner = make_unique(map.get()); this->soldier = diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index 970a780..837b541 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -3,6 +3,7 @@ #include "gmock/gmock.h" #include "state/state.h" #include "gtest/gtest.h" +#include using namespace std; using namespace state; @@ -61,15 +62,13 @@ class StateTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector gold_mines; - std::array, 2> - mine_requests; + std::vector> gold_mines; this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, gold_mines, mine_requests); + MINING_REWARD, std::move(gold_mines)); this->path_planner = make_unique(map.get()); diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index 09df18e..5df847e 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -58,19 +58,17 @@ class VillagerTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector gold_mines; - std::array, 2> - mine_requests; - GoldMine gold_mine1(Vec2D(10, 10), 100); - GoldMine gold_mine2(Vec2D(20, 10), 100); - gold_mines.push_back(gold_mine1); - gold_mines.push_back(gold_mine2); + std::vector> gold_mines; + auto gold_mine1 = make_unique(Vec2D(10, 10), 100); + auto gold_mine2 = make_unique(Vec2D(20, 10), 100); + gold_mines.push_back(std::move(gold_mine1)); + gold_mines.push_back(std::move(gold_mine2)); this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, villager_kill_reward_gold, factory_kill_reward_gold, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, gold_mines, mine_requests); + MINING_REWARD, std::move(gold_mines)); this->path_planner = make_unique(map.get()); From 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Fri, 8 Feb 2019 17:56:07 +0530 Subject: [PATCH 07/11] Replace GoldManager with mock in all tests - Removing GoldManager dependency in all tests and adding GoldManagerMock --- src/main/main.cpp | 1 + src/state/include/state/actor/actor.h | 13 ++++--- src/state/include/state/actor/factory.h | 2 +- src/state/include/state/actor/soldier.h | 2 +- src/state/include/state/actor/unit.h | 2 +- src/state/include/state/actor/villager.h | 3 +- src/state/include/state/state.h | 6 +-- src/state/src/actor/actor.cpp | 4 +- src/state/src/actor/factory.cpp | 2 +- src/state/src/actor/soldier.cpp | 2 +- src/state/src/actor/unit.cpp | 2 +- src/state/src/actor/villager.cpp | 2 +- src/state/src/state.cpp | 2 +- test/logger/logger_test.cpp | 14 ++----- test/state/factory_test.cpp | 10 ++--- test/state/mocks/gold_manager_mock.h | 21 +++++++++++ test/state/state_syncer_test.cpp | 6 ++- test/state/state_test.cpp | 17 +++++---- test/state/villager_test.cpp | 47 ++++++++++-------------- 19 files changed, 84 insertions(+), 74 deletions(-) create mode 100644 test/state/mocks/gold_manager_mock.h diff --git a/src/main/main.cpp b/src/main/main.cpp index 39acb34..de45e11 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -10,6 +10,7 @@ #include "state/actor/soldier.h" #include "state/actor/villager.h" #include "state/command_giver.h" +#include "state/gold_manager/gold_manager.h" #include "state/map/map.h" #include "state/path_planner/path_planner.h" #include "state/player_state.h" diff --git a/src/state/include/state/actor/actor.h b/src/state/include/state/actor/actor.h index d99a0f5..845d424 100644 --- a/src/state/include/state/actor/actor.h +++ b/src/state/include/state/actor/actor.h @@ -6,7 +6,7 @@ #pragma once #include "physics/vector.hpp" -#include "state/gold_manager/gold_manager.h" +#include "state/interfaces/i_gold_manager.h" #include "state/interfaces/i_updatable.h" #include "state/state_export.h" #include "state/utilities.h" @@ -18,7 +18,10 @@ namespace state { * Actor base class */ -class GoldManager; +/** + * Forward declaration of IGoldManager + */ +class IGoldManager; class STATE_EXPORT Actor : public IUpdatable { protected: @@ -61,13 +64,13 @@ class STATE_EXPORT Actor : public IUpdatable { /** * Gold manager instance to perform transactions */ - GoldManager *gold_manager; + IGoldManager *gold_manager; public: Actor(); Actor(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager); + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager); virtual ~Actor() {} @@ -121,7 +124,7 @@ class STATE_EXPORT Actor : public IUpdatable { * * @return gold_manager Unit's GoldManager Pointer */ - GoldManager *GetGoldManager(); + IGoldManager *GetGoldManager(); /** * Get the maximum hp of the actor diff --git a/src/state/include/state/actor/factory.h b/src/state/include/state/actor/factory.h index c766e99..1f70920 100644 --- a/src/state/include/state/actor/factory.h +++ b/src/state/include/state/actor/factory.h @@ -79,7 +79,7 @@ class STATE_EXPORT Factory : public Actor { Factory(); Factory(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager, + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager, int64_t construction_complete, int64_t construction_total, ActorType production_state, int64_t villager_frequency, int64_t soldier_frequency, diff --git a/src/state/include/state/actor/soldier.h b/src/state/include/state/actor/soldier.h index 89df0b7..3749efb 100644 --- a/src/state/include/state/actor/soldier.h +++ b/src/state/include/state/actor/soldier.h @@ -29,7 +29,7 @@ class STATE_EXPORT Soldier : public Unit { Soldier(); Soldier(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager, + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage); diff --git a/src/state/include/state/actor/unit.h b/src/state/include/state/actor/unit.h index 838601e..d7cffd2 100644 --- a/src/state/include/state/actor/unit.h +++ b/src/state/include/state/actor/unit.h @@ -79,7 +79,7 @@ class STATE_EXPORT Unit : public Actor { Unit(); Unit(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager, + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage); diff --git a/src/state/include/state/actor/villager.h b/src/state/include/state/actor/villager.h index c31e9eb..4fe98ca 100644 --- a/src/state/include/state/actor/villager.h +++ b/src/state/include/state/actor/villager.h @@ -9,7 +9,6 @@ #include "state/actor/factory.fwd.h" #include "state/actor/unit.h" #include "state/actor/villager_states/villager_state.h" -#include "state/gold_manager/gold_manager.h" namespace state { @@ -62,7 +61,7 @@ class STATE_EXPORT Villager : public Unit { Villager(); Villager(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager, + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage, int64_t build_effort, int64_t build_range, int64_t mine_range); diff --git a/src/state/include/state/state.h b/src/state/include/state/state.h index 1e974c1..dabc171 100644 --- a/src/state/include/state/state.h +++ b/src/state/include/state/state.h @@ -10,8 +10,8 @@ #include "state/actor/factory.h" #include "state/actor/soldier.h" #include "state/actor/villager.h" -#include "state/gold_manager/gold_manager.h" #include "state/interfaces/i_command_taker.h" +#include "state/interfaces/i_gold_manager.h" #include "state/interfaces/i_updatable.h" #include "state/map/map.h" #include "state/path_planner/path_planner.h" @@ -34,7 +34,7 @@ class STATE_EXPORT State : public ICommandTaker { /** * Gold Manager instance to maintain player gold */ - std::unique_ptr gold_manager; + std::unique_ptr gold_manager; /** * Path Planner instance @@ -159,7 +159,7 @@ class STATE_EXPORT State : public ICommandTaker { /** * Constructor */ - State(std::unique_ptr map, std::unique_ptr gold_manager, + State(std::unique_ptr map, std::unique_ptr gold_manager, std::unique_ptr path_planner, std::array>, 2> soldiers, std::array>, 2> villagers, diff --git a/src/state/src/actor/actor.cpp b/src/state/src/actor/actor.cpp index 50cb2bb..d8ccf1c 100644 --- a/src/state/src/actor/actor.cpp +++ b/src/state/src/actor/actor.cpp @@ -14,7 +14,7 @@ Actor::Actor() { } Actor::Actor(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager) + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager) : id(id), player_id(player_id), actor_type(actor_type), hp(hp), max_hp(max_hp), position(position), gold_manager(gold_manager) {} @@ -34,7 +34,7 @@ PlayerId Actor::GetPlayerId() { return player_id; } ActorType Actor::GetActorType() { return actor_type; } -GoldManager *Actor::GetGoldManager() { return gold_manager; } +IGoldManager *Actor::GetGoldManager() { return gold_manager; } int64_t Actor::GetHp() { return hp; } diff --git a/src/state/src/actor/factory.cpp b/src/state/src/actor/factory.cpp index 3344352..36a386d 100644 --- a/src/state/src/actor/factory.cpp +++ b/src/state/src/actor/factory.cpp @@ -14,7 +14,7 @@ Factory::Factory() {} Factory::Factory(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, int64_t max_hp, DoubleVec2D position, - GoldManager *gold_manager, int64_t construction_complete, + IGoldManager *gold_manager, int64_t construction_complete, int64_t construction_total, ActorType production_state, int64_t villager_frequency, int64_t soldier_frequency, UnitProductionCallback unit_production_callback) diff --git a/src/state/src/actor/soldier.cpp b/src/state/src/actor/soldier.cpp index 0d3629a..54d4cbf 100644 --- a/src/state/src/actor/soldier.cpp +++ b/src/state/src/actor/soldier.cpp @@ -16,7 +16,7 @@ Soldier::Soldier() { } Soldier::Soldier(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, int64_t max_hp, DoubleVec2D position, - GoldManager *gold_manager, PathPlanner *path_planner, + IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage) : Unit(id, player_id, actor_type, hp, max_hp, position, gold_manager, path_planner, speed, attack_range, attack_damage), diff --git a/src/state/src/actor/unit.cpp b/src/state/src/actor/unit.cpp index 9dacc83..9942093 100644 --- a/src/state/src/actor/unit.cpp +++ b/src/state/src/actor/unit.cpp @@ -15,7 +15,7 @@ Unit::Unit() { } Unit::Unit(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, - int64_t max_hp, DoubleVec2D position, GoldManager *gold_manager, + int64_t max_hp, DoubleVec2D position, IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage) : Actor(id, player_id, actor_type, hp, max_hp, position, gold_manager), diff --git a/src/state/src/actor/villager.cpp b/src/state/src/actor/villager.cpp index c98e770..c431402 100644 --- a/src/state/src/actor/villager.cpp +++ b/src/state/src/actor/villager.cpp @@ -18,7 +18,7 @@ Villager::Villager() { } Villager::Villager(ActorId id, PlayerId player_id, ActorType actor_type, int64_t hp, int64_t max_hp, DoubleVec2D position, - GoldManager *gold_manager, PathPlanner *path_planner, + IGoldManager *gold_manager, PathPlanner *path_planner, int64_t speed, int64_t attack_range, int64_t attack_damage, int64_t build_effort, int64_t build_range, int64_t mine_range) diff --git a/src/state/src/state.cpp b/src/state/src/state.cpp index 262d607..7c8e44e 100644 --- a/src/state/src/state.cpp +++ b/src/state/src/state.cpp @@ -10,7 +10,7 @@ namespace state { State::State(std::unique_ptr map, - std::unique_ptr gold_manager, + std::unique_ptr gold_manager, std::unique_ptr path_planner, std::array>, 2> soldiers, std::array>, 2> villagers, diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index 5eb2ed6..b95ee1c 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -1,6 +1,7 @@ #include "constants/constants.h" #include "logger/logger.h" #include "state/mocks/command_taker_mock.h" +#include "state/mocks/gold_manager_mock.h" #include "state/utilities.h" #include "gtest/gtest.h" #include @@ -21,7 +22,7 @@ class LoggerTest : public testing::Test { std::unique_ptr state; std::unique_ptr logger; - std::unique_ptr gold_manager; + std::unique_ptr gold_manager; std::unique_ptr path_planner; std::array player_gold; int64_t max_gold; @@ -36,7 +37,8 @@ class LoggerTest : public testing::Test { logger(make_unique(state.get(), PLAYER_INSTRUCTION_LIMIT_TURN, PLAYER_INSTRUCTION_LIMIT_GAME, SOLDIER_MAX_HP, VILLAGER_MAX_HP, - FACTORY_MAX_HP)) { + FACTORY_MAX_HP)), + gold_manager(make_unique()) { auto map_matrix = vector>{{ {L, L, L, L, L}, {L, L, L, L, L}, @@ -49,14 +51,6 @@ class LoggerTest : public testing::Test { player_gold[0] = 5000; player_gold[1] = 5000; max_gold = 10000; - - std::vector> gold_mines; - - this->gold_manager = make_unique( - player_gold, max_gold, SOLDIER_KILL_REWARD_AMOUNT, - VILLAGER_KILL_REWARD_AMOUNT, FACTORY_KILL_REWARD_AMOUNT, - FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, std::move(gold_mines)); } }; diff --git a/test/state/factory_test.cpp b/test/state/factory_test.cpp index 9181565..a70d7ec 100644 --- a/test/state/factory_test.cpp +++ b/test/state/factory_test.cpp @@ -3,7 +3,7 @@ #include "state/actor/factory.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; @@ -22,7 +22,7 @@ class FactoryTest : public Test { Soldier model_soldier; Villager model_villager; - unique_ptr gold_manager; + unique_ptr gold_manager; unique_ptr path_planner; unique_ptr factory; @@ -77,11 +77,7 @@ class FactoryTest : public Test { std::vector> gold_mines; - this->gold_manager = make_unique( - player_gold, max_gold, soldier_kill_reward_gold, - villager_kill_reward_gold, factory_kill_reward_gold, - FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, std::move(gold_mines)); + this->gold_manager = make_unique(); villager_list = std::vector>{}; soldier_list = std::vector>{}; diff --git a/test/state/mocks/gold_manager_mock.h b/test/state/mocks/gold_manager_mock.h new file mode 100644 index 0000000..570a8b4 --- /dev/null +++ b/test/state/mocks/gold_manager_mock.h @@ -0,0 +1,21 @@ +#pragma once + +#include "gmock/gmock.h" +#include "state/interfaces/i_gold_manager.h" + +using namespace state; + +class GoldManagerMock : public IGoldManager { + public: + MOCK_METHOD2(Increase, void(PlayerId, int64_t)); + MOCK_METHOD2(Decrease, void(PlayerId, int64_t)); + MOCK_METHOD1(RewardKill, void(Actor *)); + MOCK_METHOD1(GetCreateUnitCost, int64_t(ActorType)); + MOCK_METHOD2(DeductUnitCreateCost, void(PlayerId, Actor *)); + MOCK_METHOD1(GetBalance, int64_t(PlayerId)); + MOCK_METHOD0(GetMaxGold, int64_t()); + MOCK_METHOD1(DeductFactorySuicidePenalty, void(PlayerId)); + MOCK_METHOD3(RewardMineGold, void(PlayerId, GoldMine *, int64_t)); + MOCK_METHOD2(AddBuildRequest, void(PlayerId, Vec2D)); + MOCK_METHOD0(AssignGold, void()); +}; diff --git a/test/state/state_syncer_test.cpp b/test/state/state_syncer_test.cpp index 606413f..c14e3d4 100644 --- a/test/state/state_syncer_test.cpp +++ b/test/state/state_syncer_test.cpp @@ -4,6 +4,7 @@ #include "state/interfaces/i_state_syncer.h" #include "state/mocks/command_giver_mock.h" #include "state/mocks/command_taker_mock.h" +#include "state/mocks/gold_manager_mock.h" #include "state/player_state.h" #include "state/state.h" #include "state/state_syncer.h" @@ -47,7 +48,7 @@ class StateSyncerTest : public Test { array player_states; // Creating a gold manager - unique_ptr gold_manager; + unique_ptr gold_manager; StateSyncerTest() { // Creating 2 player states @@ -57,9 +58,10 @@ class StateSyncerTest : public Test { player_states[0] = player_state1; player_states[1] = player_state2; - // Creating a mock command giver and taker + // Creating a mock command giver, command taker and gold manager auto command_taker = make_unique(); auto command_giver = make_unique(); + auto gold_manager = make_unique(); this->command_taker = command_taker.get(); this->command_giver = command_giver.get(); diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index 837b541..5392bb8 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -1,6 +1,7 @@ #include "constants/gold_manager.h" #include "constants/state.h" #include "gmock/gmock.h" +#include "state/mocks/gold_manager_mock.h" #include "state/state.h" #include "gtest/gtest.h" #include @@ -29,7 +30,7 @@ class StateTest : public Test { std::vector> temp_villager_list; std::vector> temp_soldier_list; - unique_ptr gold_manager; + unique_ptr gold_manager; unique_ptr path_planner; Villager model_villager; Soldier model_soldier; @@ -62,13 +63,7 @@ class StateTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector> gold_mines; - - this->gold_manager = make_unique( - player_gold, max_gold, soldier_kill_reward_gold, - villager_kill_reward_gold, factory_kill_reward_gold, - FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, std::move(gold_mines)); + gold_manager = make_unique(); this->path_planner = make_unique(map.get()); @@ -204,8 +199,14 @@ TEST_F(StateTest, CreateFactoryTest) { ASSERT_EQ(curr_factories[0].size(), 1); ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); +<<<<<<< e22e3eaa527dea449d4e47edfe57c4f9204a9c48 auto gold_manager = villager->GetGoldManager(); ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), 5000 - FACTORY_COST); +======= + //This is a gold manager test + // auto gold_manager = curr_villagers[0].front()->GetGoldManager(); + // ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), 5000 - FACTORY_COST); +>>>>>>> Replace GoldManager with mock in all tests } TEST_F(StateTest, BuildFactoryTest) { diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index 5df847e..9f3e4ab 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -3,7 +3,7 @@ #include "state/actor/factory.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; @@ -27,7 +27,7 @@ class VillagerTest : public Test { int64_t factory_kill_reward_gold; int64_t max_gold; - unique_ptr gold_manager; + unique_ptr gold_manager; unique_ptr path_planner; unique_ptr villager; @@ -58,17 +58,7 @@ class VillagerTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - std::vector> gold_mines; - auto gold_mine1 = make_unique(Vec2D(10, 10), 100); - auto gold_mine2 = make_unique(Vec2D(20, 10), 100); - gold_mines.push_back(std::move(gold_mine1)); - gold_mines.push_back(std::move(gold_mine2)); - - this->gold_manager = make_unique( - player_gold, max_gold, soldier_kill_reward_gold, - villager_kill_reward_gold, factory_kill_reward_gold, - FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, std::move(gold_mines)); + this->gold_manager = make_unique(); this->path_planner = make_unique(map.get()); @@ -106,6 +96,8 @@ TEST_F(VillagerTest, MoveToDestination) { } TEST_F(VillagerTest, TransitionToMineState) { + EXPECT_CALL(*this->gold_manager, + AddBuildRequest(PlayerId::PLAYER1, Vec2D(10, 10))); this->villager->Mine(Vec2D(10, 10)); this->villager->Update(); @@ -155,24 +147,25 @@ TEST_F(VillagerTest, MoveToMine) { ASSERT_EQ(this->villager->IsMineTargetInRange(), true); } +//This is a test for gold manager, not for villager +// TEST_F(VillagerTest, VillagerKillReward) { +// int64_t initial_gold = player_gold[0]; -TEST_F(VillagerTest, VillagerKillReward) { - int64_t initial_gold = player_gold[0]; +// auto target_villager = MakeTestVillager(); - auto target_villager = MakeTestVillager(); +// EXPECT_CALL(*this->gold_manager, RewardKill(target_villager.get())); +// this->villager->Attack(target_villager.get()); - this->villager->Attack(target_villager.get()); +// while (target_villager->GetHp() != 0) { +// this->villager->Update(); +// target_villager->Update(); +// this->villager->LateUpdate(); +// target_villager->LateUpdate(); +// } - while (target_villager->GetHp() != 0) { - this->villager->Update(); - target_villager->Update(); - this->villager->LateUpdate(); - target_villager->LateUpdate(); - } - - ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), - (initial_gold + villager_kill_reward_gold)); -} +// ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), +// (initial_gold + villager_kill_reward_gold)); +// } TEST_F(VillagerTest, SimultaneousKill) { auto target_villager = MakeTestVillager(); From 8d7402a77dd4b1910544206ee76d36a175b1ae5d Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Sun, 10 Feb 2019 10:07:20 +0530 Subject: [PATCH 08/11] Add expectations for GoldManager mock - Add GoldManager expectations for villager_test.cpp - Add GoldManager expectations for soldier_test.cpp - Add GoldManager expectations for logger_test.cpp - Add GoldManager expectations for factory_test.cpp - Add GoldManager expectations for state_test.cpp --- .../include/state/gold_manager/gold_manager.h | 2 +- .../include/state/interfaces/i_gold_manager.h | 3 +- .../villager_states/villager_mine_state.cpp | 4 +- src/state/src/gold_manager/gold_manager.cpp | 2 +- test/drivers/main_driver_test.cpp | 2 +- test/state/command_giver_test.cpp | 1 + test/state/factory_test.cpp | 137 +++++++++++++++--- test/state/mocks/gold_manager_mock.h | 2 +- test/state/state_test.cpp | 131 +++++++++++++---- test/state/villager_test.cpp | 43 +++--- 10 files changed, 257 insertions(+), 70 deletions(-) diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index 21eb11c..b92959c 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -189,7 +189,7 @@ class STATE_EXPORT GoldManager : public IGoldManager { /** * Function to add build request to current requests */ - void AddBuildRequest(PlayerId player_id, Vec2D offset) override; + void AddMineRequest(PlayerId player_id, Vec2D offset) override; /** * Function to assign amount of gold to be given to each player diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h index c73e7ae..284dd2e 100644 --- a/src/state/include/state/interfaces/i_gold_manager.h +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -80,8 +80,7 @@ class STATE_EXPORT IGoldManager { /** * Function to add build request to current requests */ - - virtual void AddBuildRequest(PlayerId player_id, Vec2D offset) = 0; + virtual void AddMineRequest(PlayerId player_id, Vec2D offset) = 0; /** * Function to assign amount of gold to be given to each player diff --git a/src/state/src/actor/villager_states/villager_mine_state.cpp b/src/state/src/actor/villager_states/villager_mine_state.cpp index 00e8fa7..1c7d1f6 100644 --- a/src/state/src/actor/villager_states/villager_mine_state.cpp +++ b/src/state/src/actor/villager_states/villager_mine_state.cpp @@ -53,8 +53,8 @@ std::unique_ptr VillagerMineState::Update() { } // Mine gold - villager->GetGoldManager()->AddBuildRequest(villager->GetPlayerId(), - villager->GetMineTarget()); + villager->GetGoldManager()->AddMineRequest(villager->GetPlayerId(), + villager->GetMineTarget()); return nullptr; } diff --git a/src/state/src/gold_manager/gold_manager.cpp b/src/state/src/gold_manager/gold_manager.cpp index b5f1a93..3f0e2d8 100644 --- a/src/state/src/gold_manager/gold_manager.cpp +++ b/src/state/src/gold_manager/gold_manager.cpp @@ -128,7 +128,7 @@ void GoldManager::RewardMineGold(PlayerId player_id, GoldMine *gold_mine, Increase(player_id, extracted_amount); } -void GoldManager::AddBuildRequest(PlayerId player_id, Vec2D offset) { +void GoldManager::AddMineRequest(PlayerId player_id, Vec2D offset) { int64_t id = static_cast(player_id); auto player_requests = this->mine_requests[id]; auto gold_mine = GetGoldMine(offset); diff --git a/test/drivers/main_driver_test.cpp b/test/drivers/main_driver_test.cpp index 8ac4433..c73055f 100644 --- a/test/drivers/main_driver_test.cpp +++ b/test/drivers/main_driver_test.cpp @@ -57,7 +57,7 @@ class MainDriverTest : public testing::Test { const vector MainDriverTest::shared_memory_names = {"ShmTest1", "ShmTest2"}; const int MainDriverTest::num_turns = pow(10, 4); -const int MainDriverTest::time_limit_ms = 1000; +const int MainDriverTest::time_limit_ms = 2000; const int MainDriverTest::turn_instruction_limit = 5; const int MainDriverTest::game_instruction_limit = 10; diff --git a/test/state/command_giver_test.cpp b/test/state/command_giver_test.cpp index 36390f0..d3b8075 100644 --- a/test/state/command_giver_test.cpp +++ b/test/state/command_giver_test.cpp @@ -518,6 +518,7 @@ TEST_F(CommandGiverTest, CommandExecutionTest) { EXPECT_CALL( *this->logger, LogError(PlayerId::PLAYER1, ErrorType::NO_BUILD_FACTORY_ON_WATER, _)); + // (0, 0) is a water tile this->player_states[0].villagers[0].build_position = Vec2D(0, 0); ManageActorExpectations(state_soldiers, state_villagers, state_factories, diff --git a/test/state/factory_test.cpp b/test/state/factory_test.cpp index a70d7ec..e17b4f8 100644 --- a/test/state/factory_test.cpp +++ b/test/state/factory_test.cpp @@ -98,16 +98,22 @@ class FactoryTest : public Test { TEST_F(FactoryTest, ConstructionTest) { ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); - factory->Update(); - factory->LateUpdate(); - // Build the factory factory->IncrementConstructionCompletion( factory->GetTotalConstructionCompletion()); + // Expecting calls to gold manager + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(2) + .WillRepeatedly(Return(1000)); + factory->Update(); factory->LateUpdate(); + // Factory is now in PRODUCTION state ASSERT_EQ(factory->GetState(), FactoryStateName::PRODUCTION); ASSERT_EQ(factory->GetProductionState(), ActorType::VILLAGER); } @@ -115,22 +121,47 @@ TEST_F(FactoryTest, ConstructionTest) { TEST_F(FactoryTest, UnitProductionTest) { ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); - factory->Update(); - factory->LateUpdate(); - // Build the factory factory->IncrementConstructionCompletion( factory->GetTotalConstructionCompletion()); + // Expecting gold manager calls when factory transitions from UNBUILD state + // to PRODUCTION state + EXPECT_CALL(*gold_manager, GetCreateUnitCost) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + + // Updating the factory state + factory->Update(); + factory->LateUpdate(); + + // Factory is now in PRODUCTION state + ASSERT_EQ(factory->GetState(), FactoryStateName::PRODUCTION); + + // Producing villagers now factory->SetProductionState(ActorType::VILLAGER); + // Expecting gold manager calls + EXPECT_CALL(*gold_manager, GetCreateUnitCost) + .Times(21 * villager_frequency) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(21 * villager_frequency) + .WillRepeatedly(Return(1000)); + + // The factory creates a soldier in the first tick itself + ASSERT_EQ(villager_list.size(), 1); + // After frequency no. of updates, a villager should have been produced for (int i = 0; i < villager_frequency; ++i) { factory->Update(); factory->LateUpdate(); } - ASSERT_EQ(villager_list.size(), 1); + ASSERT_EQ(villager_list.size(), 2); // After 20 x frequency updates, 20 more villagers should have been produced for (int i = 0; i < 20 * villager_frequency; ++i) { @@ -138,23 +169,43 @@ TEST_F(FactoryTest, UnitProductionTest) { factory->LateUpdate(); } - ASSERT_EQ(villager_list.size(), 1 + 20); + ASSERT_EQ(villager_list.size(), 2 + 20); } TEST_F(FactoryTest, SwitchUnitProductionTest) { ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); - factory->Update(); - factory->LateUpdate(); - // Build the factory factory->IncrementConstructionCompletion( factory->GetTotalConstructionCompletion()); factory->SetProductionState(ActorType::VILLAGER); + // Gold manager expecting calls + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(2) + .WillRepeatedly(Return(1000)); + + // Transitioning the villager from the UNBUILT state to the PRODUCTION + factory->Update(); + factory->LateUpdate(); + + ASSERT_EQ(factory->GetState(), FactoryStateName::PRODUCTION); + + // Gold manager expecting calls + // Need to check why + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(villager_frequency - 1) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(villager_frequency - 1) + .WillRepeatedly(Return(1000)); + // After frequency no. of updates, a villager should have been produced - for (int i = 0; i < villager_frequency; ++i) { + for (int i = 0; i < villager_frequency - 1; ++i) { factory->Update(); factory->LateUpdate(); } @@ -165,6 +216,13 @@ TEST_F(FactoryTest, SwitchUnitProductionTest) { factory->SetProductionState(ActorType::SOLDIER); // After 20 x frequency updates, 20 soldiers should have been produced + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(20 * soldier_frequency) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(20 * soldier_frequency) + .WillRepeatedly(Return(1000)); + for (int i = 0; i < 20 * soldier_frequency; ++i) { factory->Update(); factory->LateUpdate(); @@ -176,24 +234,49 @@ TEST_F(FactoryTest, SwitchUnitProductionTest) { TEST_F(FactoryTest, StopStartTest) { ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); - factory->Update(); - factory->LateUpdate(); + // Setting the production state to villager + factory->SetProductionState(ActorType::SOLDIER); // Build the factory and produce a unit factory->IncrementConstructionCompletion( factory->GetTotalConstructionCompletion()); + // Expecting calls to gold manager + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(2) + .WillRepeatedly(Return(1000)); + factory->Update(); factory->LateUpdate(); + // The factory has transitioned from unbuilt state to production state ASSERT_EQ(factory->GetState(), FactoryStateName::PRODUCTION); + // Expect calls to GoldManager for getting balance and unit creation cost + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(soldier_frequency - 1) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(soldier_frequency - 1) + .WillRepeatedly(Return(1000)); + // Produce a unit (- 1 since we ran 1 update just now) - for (int i = 0; i < villager_frequency - 1; ++i) { + for (int i = 0; i < soldier_frequency - 1; ++i) { factory->Update(); factory->LateUpdate(); } - ASSERT_EQ(villager_list.size(), 1); + + // Expecting 2 calls to gold manager for transisioning from the PRODUCTION + // state to the idle state + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost) + .Times(2) + .WillRepeatedly(Return(1000)); // Stop Production factory->Stop(); @@ -201,6 +284,18 @@ TEST_F(FactoryTest, StopStartTest) { factory->LateUpdate(); ASSERT_EQ(factory->GetState(), FactoryStateName::IDLE); + // NOTE: Factory is now in idle state + // Hence, it will call the GetBalance and the GetCreateUnitCost function + // every turn + + // Expecting 2 more calls to gold manager for resuming production + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost) + .Times(2) + .WillRepeatedly(Return(1000)); + // Resume Production factory->Start(); factory->Update(); @@ -214,19 +309,27 @@ TEST_F(FactoryTest, DeathTest) { factory->Update(); factory->LateUpdate(); + // The factory is now in the IDLE state // Build the factory factory->IncrementConstructionCompletion( factory->GetTotalConstructionCompletion()); + // Calls are made in the idle state to GetCreateUnitCost and GetBalance + EXPECT_CALL(*gold_manager, GetBalance(factory->GetPlayerId())) + .Times(2) + .WillRepeatedly(Return(1000)); + EXPECT_CALL(*gold_manager, GetCreateUnitCost(factory->GetProductionState())) + .Times(2) + .WillRepeatedly(Return(1000)); factory->Update(); factory->LateUpdate(); + // Factory is now in production state ASSERT_EQ(factory->GetState(), FactoryStateName::PRODUCTION); // Kill it factory->SetHp(0); factory->Update(); factory->LateUpdate(); - ASSERT_EQ(factory->GetState(), FactoryStateName::DEAD); } diff --git a/test/state/mocks/gold_manager_mock.h b/test/state/mocks/gold_manager_mock.h index 570a8b4..b1919a3 100644 --- a/test/state/mocks/gold_manager_mock.h +++ b/test/state/mocks/gold_manager_mock.h @@ -16,6 +16,6 @@ class GoldManagerMock : public IGoldManager { MOCK_METHOD0(GetMaxGold, int64_t()); MOCK_METHOD1(DeductFactorySuicidePenalty, void(PlayerId)); MOCK_METHOD3(RewardMineGold, void(PlayerId, GoldMine *, int64_t)); - MOCK_METHOD2(AddBuildRequest, void(PlayerId, Vec2D)); + MOCK_METHOD2(AddMineRequest, void(PlayerId, Vec2D)); MOCK_METHOD0(AssignGold, void()); }; diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index 5392bb8..9a7a492 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -30,7 +30,7 @@ class StateTest : public Test { std::vector> temp_villager_list; std::vector> temp_soldier_list; - unique_ptr gold_manager; + GoldManagerMock *gold_manager; unique_ptr path_planner; Villager model_villager; Soldier model_soldier; @@ -63,42 +63,41 @@ class StateTest : public Test { this->villager_kill_reward_gold = VILLAGER_KILL_REWARD_AMOUNT; this->factory_kill_reward_gold = FACTORY_KILL_REWARD_AMOUNT; - gold_manager = make_unique(); + auto unique_gold_manager = make_unique(); + this->gold_manager = unique_gold_manager.get(); this->path_planner = make_unique(map.get()); this->model_villager = Villager(1, PlayerId::PLAYER1, ActorType::VILLAGER, 100, 100, - DoubleVec2D(10, 10), gold_manager.get(), - path_planner.get(), 10, 10, 10, 10, 10, 10); + DoubleVec2D(10, 10), gold_manager, path_planner.get(), 10, + 10, 10, 10, 10, 10); - this->model_soldier = - Soldier(2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100, - DoubleVec2D(10, 10), gold_manager.get(), path_planner.get(), - 10, 10, 10); + this->model_soldier = Soldier( + 2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100, + DoubleVec2D(10, 10), gold_manager, path_planner.get(), 10, 10, 10); int64_t villager_frequency = 5; int64_t soldier_frequency = 10; - this->model_factory = - Factory(2, PlayerId::PLAYER2, ActorType::FACTORY, 1, 100, - DoubleVec2D(15, 15), gold_manager.get(), 0, 100, - ActorType::VILLAGER, villager_frequency, soldier_frequency, - UnitProductionCallback{}); + this->model_factory = Factory( + 2, PlayerId::PLAYER2, ActorType::FACTORY, 1, 100, + DoubleVec2D(15, 15), gold_manager, 0, 100, ActorType::VILLAGER, + villager_frequency, soldier_frequency, UnitProductionCallback{}); soldiers = {}; villagers = {}; factories = {}; // Player1 has 2 villagers say.. - villagers[0].push_back(make_unique( - 1, PlayerId::PLAYER1, ActorType::VILLAGER, 100, 100, - DoubleVec2D(10, 10), gold_manager.get(), path_planner.get(), 10, 10, - 10, 10, 10, 10)); - villagers[0].push_back(make_unique( - 3, PlayerId::PLAYER1, ActorType::VILLAGER, 100, 100, - DoubleVec2D(10, 10), gold_manager.get(), path_planner.get(), 10, 10, - 10, 10, 10, 10)); + villagers[0].push_back( + make_unique(1, PlayerId::PLAYER1, ActorType::VILLAGER, + 100, 100, DoubleVec2D(10, 10), gold_manager, + path_planner.get(), 10, 10, 10, 10, 10, 10)); + villagers[0].push_back( + make_unique(3, PlayerId::PLAYER1, ActorType::VILLAGER, + 100, 100, DoubleVec2D(10, 10), gold_manager, + path_planner.get(), 10, 10, 10, 10, 10, 10)); // Player 2 has 1 villager villagers[1].push_back(make_unique( @@ -107,21 +106,23 @@ class StateTest : public Test { 10, 10, 10, 10)); // Player2 has 1 soldier, say.. - soldiers[1].push_back( - make_unique(2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, - 100, DoubleVec2D(10, 10), gold_manager.get(), - path_planner.get(), 10, 10, 10)); + soldiers[1].push_back(make_unique( + 2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100, + DoubleVec2D(10, 10), gold_manager, path_planner.get(), 10, 10, 10)); Actor::SetActorIdIncrement(4); this->state = make_unique( - move(map), move(gold_manager), move(path_planner), move(soldiers), - move(villagers), move(factories), move(model_villager), - move(model_soldier), move(model_factory)); + move(map), move(unique_gold_manager), move(path_planner), + move(soldiers), move(villagers), move(factories), + move(model_villager), move(model_soldier), move(model_factory)); } }; TEST_F(StateTest, MoveUnitTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->MoveUnit(PlayerId::PLAYER1, 1, Vec2D(5, 5)); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -134,6 +135,9 @@ TEST_F(StateTest, MoveUnitTest) { } TEST_F(StateTest, MineLocationTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->MineLocation(PlayerId::PLAYER1, 1, Vec2D(25, 25)); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -147,6 +151,9 @@ TEST_F(StateTest, MineLocationTest) { } TEST_F(StateTest, VillagerAttackEnemyTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->AttackActor(PlayerId::PLAYER1, 1, 2); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -163,6 +170,9 @@ TEST_F(StateTest, VillagerAttackEnemyTest) { } TEST_F(StateTest, SoldierAttackEnemyTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->AttackActor(PlayerId::PLAYER2, 2, 1); auto curr_soldiers = state->GetSoldiers(); auto curr_soldier = curr_soldiers[1].front(); @@ -179,15 +189,23 @@ TEST_F(StateTest, SoldierAttackEnemyTest) { } TEST_F(StateTest, CreateFactoryTest) { + EXPECT_CALL(*gold_manager, DeductUnitCreateCost); state->CreateFactory(PlayerId::PLAYER1, 1, Vec2D(0, 0)); auto curr_villagers = state->GetVillagers(); auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the state and soldier while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } +======= + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + + state->Update(); +>>>>>>> Add expectations for GoldManager mock // Checking if the villager has transitioned into the BUILD state ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -197,6 +215,7 @@ TEST_F(StateTest, CreateFactoryTest) { curr_factories = state->GetFactories(); auto factory = curr_factories[0].front(); ASSERT_EQ(curr_factories[0].size(), 1); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); <<<<<<< e22e3eaa527dea449d4e47edfe57c4f9204a9c48 @@ -207,15 +226,20 @@ TEST_F(StateTest, CreateFactoryTest) { // auto gold_manager = curr_villagers[0].front()->GetGoldManager(); // ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), 5000 - FACTORY_COST); >>>>>>> Replace GoldManager with mock in all tests +======= + ASSERT_EQ(curr_factories[0].front()->GetState(), FactoryStateName::UNBUILT); +>>>>>>> Add expectations for GoldManager mock } TEST_F(StateTest, BuildFactoryTest) { // Repeat CreateFactory as above.. + EXPECT_CALL(*gold_manager, DeductUnitCreateCost); state->CreateFactory(PlayerId::PLAYER1, 1, Vec2D(0, 0)); auto curr_villagers = state->GetVillagers(); auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); @@ -226,13 +250,28 @@ TEST_F(StateTest, BuildFactoryTest) { // Getting the updated factories from state curr_factories = state->GetFactories(); auto factory = curr_factories[0].front(); +======= + EXPECT_CALL(*gold_manager, AssignGold()); + + state->Update(); + + // Adding expectation for gold manager as state is updated + + ASSERT_EQ(curr_villagers[0].front()->GetState(), VillagerStateName::BUILD); +>>>>>>> Add expectations for GoldManager mock ASSERT_EQ(curr_factories[0].size(), 1); ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); // Test BuildFactory for the same villager.. state->BuildFactory(PlayerId::PLAYER1, 1, factory->GetActorId()); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating state again +======= + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + +>>>>>>> Add expectations for GoldManager mock state->Update(); ASSERT_EQ(curr_villagers[0].front()->GetState(), VillagerStateName::BUILD); @@ -241,6 +280,9 @@ TEST_F(StateTest, BuildFactoryTest) { // Test BuildFactory for the other villager.. state->BuildFactory(PlayerId::PLAYER1, 3, factory->GetActorId()); + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->Update(); ASSERT_EQ(curr_villagers[0][1]->GetState(), VillagerStateName::BUILD); @@ -249,15 +291,23 @@ TEST_F(StateTest, BuildFactoryTest) { TEST_F(StateTest, FactoryProductionTest) { // Repeat CreateFactory as above.. + EXPECT_CALL(*gold_manager, DeductUnitCreateCost); state->CreateFactory(PlayerId::PLAYER1, 1, Vec2D(0, 0)); auto curr_villagers = state->GetVillagers(); auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } +======= + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + + state->Update(); +>>>>>>> Add expectations for GoldManager mock ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -273,6 +323,9 @@ TEST_F(StateTest, FactoryProductionTest) { state->SetFactoryProduction(PlayerId::PLAYER1, factory->GetActorId(), ActorType::SOLDIER); + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + state->Update(); ASSERT_EQ(factory->GetProductionState(), ActorType::SOLDIER); @@ -280,16 +333,24 @@ TEST_F(StateTest, FactoryProductionTest) { TEST_F(StateTest, FactoryDeathTest) { // Repeat CreateFactory as above.. + EXPECT_CALL(*gold_manager, DeductUnitCreateCost); state->CreateFactory(PlayerId::PLAYER1, 1, Vec2D(0, 0)); auto curr_villagers = state->GetVillagers(); auto curr_factories = state->GetFactories(); ASSERT_EQ(curr_factories[0].size(), 0); auto villager = curr_villagers[0].front(); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } +======= + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + + state->Update(); +>>>>>>> Add expectations for GoldManager mock ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -299,6 +360,7 @@ TEST_F(StateTest, FactoryDeathTest) { ASSERT_EQ(curr_factories[0].size(), 1); ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); +<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Killing the factory factory->SetHp(0); factory->Update(); @@ -309,6 +371,13 @@ TEST_F(StateTest, FactoryDeathTest) { ASSERT_EQ(factory->GetHp(), 0); // Updating the state +======= + // Kill factory + EXPECT_CALL(*gold_manager, AssignGold()); + + auto curr_factory = curr_factories[0].front(); + curr_factory->SetHp(0); +>>>>>>> Add expectations for GoldManager mock state->Update(); auto new_facs = state->GetFactories(); @@ -316,6 +385,9 @@ TEST_F(StateTest, FactoryDeathTest) { } TEST_F(StateTest, VillagerDeathTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + auto curr_villagers = state->GetVillagers(); ASSERT_EQ(curr_villagers[0].size(), 2); @@ -328,6 +400,9 @@ TEST_F(StateTest, VillagerDeathTest) { } TEST_F(StateTest, SoldierDeathTest) { + // Adding expectation for gold manager as state is updated + EXPECT_CALL(*gold_manager, AssignGold()); + auto curr_soldiers = state->GetSoldiers(); ASSERT_EQ(curr_soldiers[1].size(), 1); diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index 9f3e4ab..3093776 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -97,7 +97,7 @@ TEST_F(VillagerTest, MoveToDestination) { TEST_F(VillagerTest, TransitionToMineState) { EXPECT_CALL(*this->gold_manager, - AddBuildRequest(PlayerId::PLAYER1, Vec2D(10, 10))); + AddMineRequest(PlayerId::PLAYER1, Vec2D(10, 10))); this->villager->Mine(Vec2D(10, 10)); this->villager->Update(); @@ -127,6 +127,9 @@ TEST_F(VillagerTest, TransitionToDeadState) { this->villager->Attack(target_villager.get()); + // GoldManager expects call for villager killing target villager + EXPECT_CALL(*gold_manager, RewardKill(target_villager.get())); + while (target_villager->GetHp() != 0) { this->villager->Update(); target_villager->Update(); @@ -138,8 +141,13 @@ TEST_F(VillagerTest, TransitionToDeadState) { } TEST_F(VillagerTest, MoveToMine) { + ASSERT_EQ(this->villager->GetState(), VillagerStateName::IDLE); this->villager->SetMineTarget(Vec2D(20, 10)); + // A build request will be added to the gold manager when the villager tries + // to mine + EXPECT_CALL(*gold_manager, AddMineRequest); + while (this->villager->GetState() != VillagerStateName::MINE) { this->villager->Update(); this->villager->LateUpdate(); @@ -147,25 +155,21 @@ TEST_F(VillagerTest, MoveToMine) { ASSERT_EQ(this->villager->IsMineTargetInRange(), true); } -//This is a test for gold manager, not for villager -// TEST_F(VillagerTest, VillagerKillReward) { -// int64_t initial_gold = player_gold[0]; +// This is a test for gold manager, not for villager +TEST_F(VillagerTest, VillagerKillReward) { -// auto target_villager = MakeTestVillager(); - -// EXPECT_CALL(*this->gold_manager, RewardKill(target_villager.get())); -// this->villager->Attack(target_villager.get()); + auto target_villager = MakeTestVillager(); -// while (target_villager->GetHp() != 0) { -// this->villager->Update(); -// target_villager->Update(); -// this->villager->LateUpdate(); -// target_villager->LateUpdate(); -// } + EXPECT_CALL(*this->gold_manager, RewardKill(target_villager.get())); + this->villager->Attack(target_villager.get()); -// ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), -// (initial_gold + villager_kill_reward_gold)); -// } + while (target_villager->GetHp() != 0) { + this->villager->Update(); + target_villager->Update(); + this->villager->LateUpdate(); + target_villager->LateUpdate(); + } +} TEST_F(VillagerTest, SimultaneousKill) { auto target_villager = MakeTestVillager(); @@ -173,6 +177,11 @@ TEST_F(VillagerTest, SimultaneousKill) { villager->Attack(target_villager.get()); target_villager->Attack(villager.get()); + // Expecting call to gold manager for rewarding gold to both villagers for + // killing each other + EXPECT_CALL(*gold_manager, RewardKill(target_villager.get())); + EXPECT_CALL(*gold_manager, RewardKill(this->villager.get())); + while (target_villager->GetHp() != 0) { this->villager->Update(); target_villager->Update(); From 844dba43d5a7d3d71b043ac60662ed57e4f243ef Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Sun, 10 Feb 2019 23:45:55 +0530 Subject: [PATCH 09/11] Add tests for GoldManager - Add test for checking if MineRequests are added - Add test to check if gold is split in the right ratio when multiple villagers are mining the same GoldMine --- src/main/main.cpp | 4 +- src/state/include/state/actor/actor.fwd.h | 4 +- src/state/include/state/actor/actor.h | 8 - src/state/include/state/actor/factory.h | 1 + .../include/state/gold_manager/gold_manager.h | 19 +- .../include/state/gold_manager/gold_mine.h | 17 +- .../include/state/interfaces/i_gold_manager.h | 12 +- src/state/src/gold_manager/gold_manager.cpp | 48 ++-- src/state/src/gold_manager/gold_mine.cpp | 7 +- src/state/src/state.cpp | 2 +- test/CMakeLists.txt | 1 + test/state/gold_manager_test.cpp | 225 ++++++++++++++++++ test/state/mocks/gold_manager_mock.h | 3 +- test/state/soldier_test.cpp | 5 +- test/state/state_test.cpp | 30 ++- 15 files changed, 305 insertions(+), 81 deletions(-) create mode 100644 test/state/gold_manager_test.cpp diff --git a/src/main/main.cpp b/src/main/main.cpp index de45e11..3c5aaa1 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -95,8 +95,8 @@ unique_ptr BuildGoldManager() { return make_unique( array{GOLD_START, GOLD_START}, GOLD_MAX, SOLDIER_KILL_REWARD_AMOUNT, VILLAGER_KILL_REWARD_AMOUNT, - FACTORY_KILL_REWARD_AMOUNT, FACTORY_SUICIDE_PENALTY, VILLAGER_COST, - SOLDIER_COST, FACTORY_COST, MINING_REWARD, std::move(gold_mines)); + FACTORY_KILL_REWARD_AMOUNT, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, + MINING_REWARD, std::move(gold_mines)); } unique_ptr BuildPathPlanner(Map *map) { diff --git a/src/state/include/state/actor/actor.fwd.h b/src/state/include/state/actor/actor.fwd.h index 2e36dac..93ca298 100644 --- a/src/state/include/state/actor/actor.fwd.h +++ b/src/state/include/state/actor/actor.fwd.h @@ -1,6 +1,6 @@ /** - * @file factory.fwd.h - * Forward declaration for the Factory class + * @file actor.fwd.h + * Forward declaration for the Actor class */ #pragma once diff --git a/src/state/include/state/actor/actor.h b/src/state/include/state/actor/actor.h index 845d424..e01e543 100644 --- a/src/state/include/state/actor/actor.h +++ b/src/state/include/state/actor/actor.h @@ -14,14 +14,6 @@ #include namespace state { -/** - * Actor base class - */ - -/** - * Forward declaration of IGoldManager - */ -class IGoldManager; class STATE_EXPORT Actor : public IUpdatable { protected: diff --git a/src/state/include/state/actor/factory.h b/src/state/include/state/actor/factory.h index 1f70920..483ddcf 100644 --- a/src/state/include/state/actor/factory.h +++ b/src/state/include/state/actor/factory.h @@ -7,6 +7,7 @@ #include "state/actor/factory_states/factory_state.h" #include "state/actor/soldier.h" #include "state/actor/villager.h" +#include "state/interfaces/i_gold_manager.h" #include "state/state_export.h" #include "state/utilities.h" diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index b92959c..dfa3a16 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -53,11 +53,6 @@ class STATE_EXPORT GoldManager : public IGoldManager { */ int64_t factory_kill_reward_amount; - /** - * Penalty amount for a suicide of a factory - */ - int64_t factory_suicide_penalty_amount; - /** * Amount of gold to create a villager */ @@ -105,9 +100,8 @@ class STATE_EXPORT GoldManager : public IGoldManager { GoldManager(std::array player_gold, int64_t max_gold, int64_t soldier_kill_reward_amount, int64_t villager_kill_reward_amount, - int64_t factory_kill_reward_amount, - int64_t factory_suicide_penalty_amount, int64_t villager_cost, - int64_t soldier_cost, int64_t soldier_factory_cost, + int64_t factory_kill_reward_amount, int64_t villager_cost, + int64_t soldier_cost, int64_t factory_cost, int64_t mining_reward, std::vector> gold_mines); @@ -171,13 +165,6 @@ class STATE_EXPORT GoldManager : public IGoldManager { */ int64_t GetMaxGold() override; - /** - * Penalty for player triggering suicide - * - * @param[in] player_id Player who triggered the suicide - */ - void DeductFactorySuicidePenalty(PlayerId player_id) override; - /** * Penalty for player triggering suicide * @@ -194,6 +181,6 @@ class STATE_EXPORT GoldManager : public IGoldManager { /** * Function to assign amount of gold to be given to each player */ - void AssignGold() override; + void Update() override; }; } // namespace state diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h index 2ba19b1..ede581f 100644 --- a/src/state/include/state/gold_manager/gold_mine.h +++ b/src/state/include/state/gold_manager/gold_mine.h @@ -27,11 +27,22 @@ 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 a - * hash map + * Defining a way to compare 2 GoldMine objects so that is can be stored in an + * unordered hash map */ class GoldMineCompare { @@ -41,4 +52,4 @@ class GoldMineCompare { } }; -} // namespace state \ No newline at end of file +} // namespace state diff --git a/src/state/include/state/interfaces/i_gold_manager.h b/src/state/include/state/interfaces/i_gold_manager.h index 284dd2e..f7e4720 100644 --- a/src/state/include/state/interfaces/i_gold_manager.h +++ b/src/state/include/state/interfaces/i_gold_manager.h @@ -1,7 +1,6 @@ #pragma once #include "state/actor/actor.fwd.h" -#include "state/actor/actor.h" #include "state/gold_manager/gold_mine.h" #include "state/state_export.h" #include "state/utilities.h" @@ -62,13 +61,6 @@ class STATE_EXPORT IGoldManager { */ virtual int64_t GetMaxGold() = 0; - /** - * Penalty for player triggering suicide - * - * @param[in] player_id Player who triggered the suicide - */ - virtual void DeductFactorySuicidePenalty(PlayerId player_id) = 0; - /** * Penalty for player triggering suicide * @@ -85,7 +77,7 @@ class STATE_EXPORT IGoldManager { /** * Function to assign amount of gold to be given to each player */ - virtual void AssignGold() = 0; + virtual void Update() = 0; }; -} // namespace state \ No newline at end of file +} // namespace state diff --git a/src/state/src/gold_manager/gold_manager.cpp b/src/state/src/gold_manager/gold_manager.cpp index 3f0e2d8..683737e 100644 --- a/src/state/src/gold_manager/gold_manager.cpp +++ b/src/state/src/gold_manager/gold_manager.cpp @@ -16,7 +16,6 @@ GoldManager::GoldManager(std::array players_gold, int64_t max_gold, int64_t soldier_kill_reward_amount, int64_t villager_kill_reward_amount, int64_t factory_kill_reward_amount, - int64_t factory_suicide_penalty_amount, int64_t villager_cost, int64_t soldier_cost, int64_t factory_cost, int64_t mining_reward, std::vector> gold_mines) @@ -24,7 +23,6 @@ GoldManager::GoldManager(std::array players_gold, int64_t max_gold, soldier_kill_reward_amount(soldier_kill_reward_amount), villager_kill_reward_amount(villager_kill_reward_amount), factory_kill_reward_amount(factory_kill_reward_amount), - factory_suicide_penalty_amount(factory_suicide_penalty_amount), villager_cost(villager_cost), soldier_cost(soldier_cost), factory_cost(factory_cost), mining_reward(mining_reward), gold_mines(std::move(gold_mines)), mine_requests({}) {} @@ -114,11 +112,6 @@ int64_t GoldManager::GetBalance(PlayerId player_id) { int64_t GoldManager::GetMaxGold() { return max_gold; } -void GoldManager::DeductFactorySuicidePenalty(PlayerId player_id) { - auto suicide_penalty = factory_suicide_penalty_amount; - Decrease(player_id, suicide_penalty); -} - void GoldManager::RewardMineGold(PlayerId player_id, GoldMine *gold_mine, int64_t mining_reward) { // Extracting gold from the gold mine @@ -130,14 +123,12 @@ void GoldManager::RewardMineGold(PlayerId player_id, GoldMine *gold_mine, void GoldManager::AddMineRequest(PlayerId player_id, Vec2D offset) { int64_t id = static_cast(player_id); - auto player_requests = this->mine_requests[id]; + auto &player_requests = this->mine_requests[id]; auto gold_mine = GetGoldMine(offset); // If the gold mine dosen't already exist in the hash map, then we add an // entry with count 1 - if (player_requests.empty()) { - player_requests.insert(std::pair(gold_mine, 1)); - } else if (player_requests.find(gold_mine) != player_requests.end()) { + if (player_requests.find(gold_mine) == player_requests.end()) { player_requests.insert(std::pair(gold_mine, 1)); } else { auto request = player_requests.find(gold_mine); @@ -145,17 +136,19 @@ void GoldManager::AddMineRequest(PlayerId player_id, Vec2D offset) { } } -void GoldManager::AssignGold() { - // Iterating through all the player's requests +void GoldManager::Update() { + + // Assigning the player's gold based on the mine requests for (int id = 0; id < 2; ++id) { - int64_t enemy_id = + int64_t id_enemy = (id + 1) % static_cast(PlayerId::PLAYER_COUNT); - auto player_requests = this->mine_requests[id]; - auto enemy_requests = this->mine_requests[enemy_id]; + auto &player_requests = this->mine_requests[id]; + auto &enemy_requests = this->mine_requests[id_enemy]; for (auto const &request : player_requests) { auto gold_mine = request.first; auto no_player_requests = request.second; PlayerId player_id = static_cast(id); + PlayerId enemy_id = static_cast(id_enemy); // If enemy is trying to mine in the same gold mine, gold is split if (enemy_requests.find(gold_mine) != enemy_requests.end()) { @@ -171,6 +164,7 @@ void GoldManager::AssignGold() { // If the gold mine has enough gold to accomodate both the // player's requests if (gold_mine->value >= total_gold_required) { + // Deducting the player's requested gold int64_t mining_reward = this->mining_reward * no_player_requests; @@ -181,10 +175,23 @@ void GoldManager::AssignGold() { // NOTE: One gold coin may get lost else { // Finding the ratio of gold that this player will recieve - float gold_ratio = float(no_player_requests) / - (no_enemy_requests + no_enemy_requests); - int gold_recieved = gold_ratio * gold_mine->value; - RewardMineGold(player_id, gold_mine, gold_recieved); + float gold_ratio = (double)no_player_requests / + (no_player_requests + no_enemy_requests); + int player_gold_recieved = gold_ratio * gold_mine->value; + int enemy_gold_recieved = + (1 - gold_ratio) * gold_mine->value; + int residue = gold_mine->value - + (player_gold_recieved + enemy_gold_recieved); + + // Rewarding player's with their proportion of gold + RewardMineGold(player_id, gold_mine, player_gold_recieved); + RewardMineGold(enemy_id, gold_mine, enemy_gold_recieved); + + // Extracting the extra gold from the player + gold_mine->ExtractGold(residue); + + // Removing the request from the enemy's requests + enemy_requests.erase(gold_mine); } } // Gold is not split between the villagers @@ -195,6 +202,7 @@ void GoldManager::AssignGold() { RewardMineGold(player_id, gold_mine, gold_recieved); } } + this->mine_requests[id].clear(); } } diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp index aa164e5..4c93605 100644 --- a/src/state/src/gold_manager/gold_mine.cpp +++ b/src/state/src/gold_manager/gold_mine.cpp @@ -16,4 +16,9 @@ int64_t GoldMine::ExtractGold(int64_t ext_amount) { return ext_amount; } } -} // namespace state \ No newline at end of file + +int64_t GoldMine::GetGoldReserve() { return this->value; } + +void GoldMine::SetGoldReserve(int64_t gold_value) { this->value = gold_value; } + +} // namespace state diff --git a/src/state/src/state.cpp b/src/state/src/state.cpp index 7c8e44e..cfd2262 100644 --- a/src/state/src/state.cpp +++ b/src/state/src/state.cpp @@ -371,7 +371,7 @@ bool State::IsGameOver(PlayerId &winner) { return is_game_over; // Late gold manager update - gold_manager->AssignGold(); + gold_manager->Update(); } } // namespace state diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 6ebc478..8504368 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -10,6 +10,7 @@ set(SOURCE_FILES state/factory_test.cpp state/state_test.cpp state/path_planner_test.cpp + state/gold_manager_test.cpp state/state_syncer_test.cpp state/command_giver_test.cpp logger/logger_test.cpp diff --git a/test/state/gold_manager_test.cpp b/test/state/gold_manager_test.cpp new file mode 100644 index 0000000..c9c0985 --- /dev/null +++ b/test/state/gold_manager_test.cpp @@ -0,0 +1,225 @@ +#include "state/gold_manager/gold_manager.h" +#include "state/map/map.h" +#include "state/mocks/command_giver_mock.h" +#include "state/mocks/command_taker_mock.h" +#include "state/mocks/gold_manager_mock.h" +#include "state/mocks/state_syncer_mock.h" +#include "gtest/gtest.h" +#include + +using namespace std; +using namespace state; + +class GoldManagerTest : public testing::Test { + public: + // Creating a path planner + unique_ptr path_planner; + unique_ptr map; + + // Gold manager's dependencies + array player_gold; + int64_t max_gold; + int64_t soldier_kill_amount; + int64_t villager_kill_amount; + int64_t factory_kill_amount; + int64_t villager_cost; + int64_t soldier_cost; + int64_t factory_cost; + int64_t mining_reward; + vector gold_mines; + + // Creating an incrementing actor id + int64_t actor_id; + + // Creating the gold manager + unique_ptr gold_manager; + + GoldManagerTest() { + + // Assigning the GoldManager constants + this->player_gold = {1000, 1000}; + this->max_gold = 10000; + this->soldier_kill_amount = 100; + this->villager_kill_amount = 50; + this->factory_kill_amount = 200; + this->villager_cost = 100; + this->soldier_cost = 200; + this->factory_cost = 100; + this->mining_reward = 10; + int64_t map_size = 5; + int64_t ele_size = 5; + + // Creating gold mines + vector> uniq_gold_mines; + auto uniq_gold_mine = make_unique(Vec2D(2, 2), 10000); + auto gold_mine = uniq_gold_mine.get(); + uniq_gold_mines.push_back(move(uniq_gold_mine)); + this->gold_mines.push_back(gold_mine); + + // Creating a rudimentary map + vector> dummy_map = CreateMap(map_size); + this->map = make_unique(dummy_map, map_size, ele_size); + + // Assinging the path planner and the gold manager + this->path_planner = make_unique(this->map.get()); + this->gold_manager = make_unique( + player_gold, max_gold, soldier_kill_amount, villager_kill_amount, + factory_kill_amount, villager_cost, soldier_cost, factory_cost, + mining_reward, move(uniq_gold_mines)); + } + + unique_ptr MakeStateSoldier(PlayerId player_id) { + return make_unique(this->actor_id++, player_id, + ActorType::SOLDIER, 100, 100, + DoubleVec2D(0, 0), this->gold_manager.get(), + this->path_planner.get(), 5, 5, 5); + } + + unique_ptr MakeStateVillager(PlayerId player_id) { + return make_unique( + this->actor_id++, player_id, ActorType::VILLAGER, 100, 100, + DoubleVec2D(0, 0), this->gold_manager.get(), + this->path_planner.get(), 5, 5, 5, 3, 3, 3); + } + + unique_ptr MakeStateFactory(PlayerId player_id) { + return make_unique( + this->actor_id++, player_id, ActorType::FACTORY, 100, 100, + DoubleVec2D(0, 0), this->gold_manager.get(), 100, 100, + ActorType::SOLDIER, 3, 3, UnitProductionCallback{}); + } + + vector> CreateMap(int64_t map_size) { + /** + * Creating this map layout + * + * W L L L L + * L W L L L + * L L G L L + * L L L W L + * L L L L W + */ + + vector> dummy_map; + for (int i = 0; i < map_size; ++i) { + vector dummy_row; + for (int j = 0; j < map_size; ++j) { + if (i == j) { + if (i == map_size / 2) { + dummy_row.push_back(TerrainType::GOLD_MINE); + } else { + dummy_row.push_back(TerrainType::WATER); + } + } else { + dummy_row.push_back(TerrainType::LAND); + } + } + dummy_map.push_back(dummy_row); + } + return dummy_map; + } +}; + +// Starting tests + +// Gets called when a villager tries to mine a gold mine +TEST_F(GoldManagerTest, AddMineRequest) { + auto villager = MakeStateVillager(PlayerId::PLAYER1); + auto gold_mine = this->gold_mines[0]; + gold_mine->SetGoldReserve(100); + int64_t player_id = static_cast(PlayerId::PLAYER1); + villager->SetMineTarget(Vec2D(2, 2)); + + // Updating the villager's state fror IDLE to MINE + // A mine request will be sent to the GoldManager when the soldier + // transitions into MINE state + + while (villager->GetState() != VillagerStateName::MINE) { + villager->Update(); + villager->LateUpdate(); + } + + // Villager is now in the mining state + ASSERT_EQ(villager->GetState(), VillagerStateName::MINE); + + // Updating gold manager to check if player 1's gold increases + gold_manager->Update(); + + ASSERT_EQ(gold_manager->GetBalance(villager->GetPlayerId()), + this->player_gold[0] + this->mining_reward); +} + +TEST_F(GoldManagerTest, SplitGoldTest) { + // Reassigning the GoldMine gold to have 16 gold units + auto gold_mine = this->gold_mines[0]; + gold_mine->SetGoldReserve(16); + + // Making a villager each for player 1 and player 2 + // Since both villagers start at the same position, they will reach the mine + // at the same time + auto villager1 = MakeStateVillager(PlayerId::PLAYER1); + auto villager2 = MakeStateVillager(PlayerId::PLAYER2); + villager1->SetMineTarget(Vec2D(2, 2)); + villager2->SetMineTarget(Vec2D(2, 2)); + + // Making villager transition to MINE state + while (villager1->GetState() != VillagerStateName::MINE) { + villager1->Update(); + villager2->Update(); + villager1->LateUpdate(); + villager2->LateUpdate(); + } + + // Once in MINE state, call the gold manager update to check if the gold is + // divided in the right ratio + gold_manager->Update(); + + ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), + this->player_gold[0] + 8); + ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER2), + this->player_gold[1] + 8); + ASSERT_EQ(gold_mine->GetGoldReserve(), 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); + + // Creating an additional player 2 villager and resetting the first 2 + // villagers + villager1 = MakeStateVillager(PlayerId::PLAYER1); + villager2 = MakeStateVillager(PlayerId::PLAYER2); + auto villager3 = MakeStateVillager(PlayerId::PLAYER2); + + // Setting the villagers' mine targets + villager1->SetMineTarget(Vec2D(2, 2)); + villager2->SetMineTarget(Vec2D(2, 2)); + villager3->SetMineTarget(Vec2D(2, 2)); + + // Since all the villagers have been reset, they all are in the same + // position + while (villager1->GetState() != VillagerStateName::MINE) { + villager1->Update(); + villager1->LateUpdate(); + villager2->Update(); + villager2->LateUpdate(); + villager3->Update(); + villager3->LateUpdate(); + } + + // Once in MINE state, call the gold manager update to check if the gold is + // divided in the right ratio + gold_manager->Update(); + + // Checking if the players got the right ratio of gold + ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), + this->player_gold[0] + 9); + ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER2), + this->player_gold[1] + 18); + + // Checking if the extra 1 gold coin is removed + ASSERT_EQ(gold_mine->GetGoldReserve(), 0); +} diff --git a/test/state/mocks/gold_manager_mock.h b/test/state/mocks/gold_manager_mock.h index b1919a3..17d1036 100644 --- a/test/state/mocks/gold_manager_mock.h +++ b/test/state/mocks/gold_manager_mock.h @@ -14,8 +14,7 @@ class GoldManagerMock : public IGoldManager { MOCK_METHOD2(DeductUnitCreateCost, void(PlayerId, Actor *)); MOCK_METHOD1(GetBalance, int64_t(PlayerId)); MOCK_METHOD0(GetMaxGold, int64_t()); - MOCK_METHOD1(DeductFactorySuicidePenalty, void(PlayerId)); MOCK_METHOD3(RewardMineGold, void(PlayerId, GoldMine *, int64_t)); MOCK_METHOD2(AddMineRequest, void(PlayerId, Vec2D)); - MOCK_METHOD0(AssignGold, void()); + MOCK_METHOD0(Update, void()); }; diff --git a/test/state/soldier_test.cpp b/test/state/soldier_test.cpp index eb6f83b..a24bd4f 100644 --- a/test/state/soldier_test.cpp +++ b/test/state/soldier_test.cpp @@ -55,9 +55,8 @@ class SoldierTest : public Test { this->gold_manager = make_unique( player_gold, max_gold, soldier_kill_reward_gold, - villager_kill_reward_gold, factory_kill_reward_gold, - FACTORY_SUICIDE_PENALTY, VILLAGER_COST, SOLDIER_COST, FACTORY_COST, - MINING_REWARD, std::move(gold_mines)); + 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(map.get()); this->soldier = diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index 9a7a492..fd41920 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -121,7 +121,7 @@ class StateTest : public Test { TEST_F(StateTest, MoveUnitTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->MoveUnit(PlayerId::PLAYER1, 1, Vec2D(5, 5)); auto curr_villagers = state->GetVillagers(); @@ -136,7 +136,7 @@ TEST_F(StateTest, MoveUnitTest) { TEST_F(StateTest, MineLocationTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->MineLocation(PlayerId::PLAYER1, 1, Vec2D(25, 25)); auto curr_villagers = state->GetVillagers(); @@ -152,7 +152,7 @@ TEST_F(StateTest, MineLocationTest) { TEST_F(StateTest, VillagerAttackEnemyTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->AttackActor(PlayerId::PLAYER1, 1, 2); auto curr_villagers = state->GetVillagers(); @@ -171,7 +171,7 @@ TEST_F(StateTest, VillagerAttackEnemyTest) { TEST_F(StateTest, SoldierAttackEnemyTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->AttackActor(PlayerId::PLAYER2, 2, 1); auto curr_soldiers = state->GetSoldiers(); @@ -202,7 +202,7 @@ TEST_F(StateTest, CreateFactoryTest) { } ======= // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->Update(); >>>>>>> Add expectations for GoldManager mock @@ -245,6 +245,7 @@ TEST_F(StateTest, BuildFactoryTest) { state->Update(); } +<<<<<<< 8d7402a77dd4b1910544206ee76d36a175b1ae5d ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); // Getting the updated factories from state @@ -252,6 +253,9 @@ TEST_F(StateTest, BuildFactoryTest) { auto factory = curr_factories[0].front(); ======= EXPECT_CALL(*gold_manager, AssignGold()); +======= + EXPECT_CALL(*gold_manager, Update()); +>>>>>>> Add tests for GoldManager state->Update(); @@ -269,7 +273,7 @@ TEST_F(StateTest, BuildFactoryTest) { // Updating state again ======= // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); >>>>>>> Add expectations for GoldManager mock state->Update(); @@ -281,7 +285,7 @@ TEST_F(StateTest, BuildFactoryTest) { state->BuildFactory(PlayerId::PLAYER1, 3, factory->GetActorId()); // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->Update(); @@ -304,7 +308,7 @@ TEST_F(StateTest, FactoryProductionTest) { } ======= // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->Update(); >>>>>>> Add expectations for GoldManager mock @@ -324,7 +328,7 @@ TEST_F(StateTest, FactoryProductionTest) { ActorType::SOLDIER); // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->Update(); @@ -347,7 +351,7 @@ TEST_F(StateTest, FactoryDeathTest) { } ======= // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); state->Update(); >>>>>>> Add expectations for GoldManager mock @@ -373,7 +377,7 @@ TEST_F(StateTest, FactoryDeathTest) { // Updating the state ======= // Kill factory - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); auto curr_factory = curr_factories[0].front(); curr_factory->SetHp(0); @@ -386,7 +390,7 @@ TEST_F(StateTest, FactoryDeathTest) { TEST_F(StateTest, VillagerDeathTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); auto curr_villagers = state->GetVillagers(); ASSERT_EQ(curr_villagers[0].size(), 2); @@ -401,7 +405,7 @@ TEST_F(StateTest, VillagerDeathTest) { TEST_F(StateTest, SoldierDeathTest) { // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, AssignGold()); + EXPECT_CALL(*gold_manager, Update()); auto curr_soldiers = state->GetSoldiers(); ASSERT_EQ(curr_soldiers[1].size(), 1); From df080fa676dd7c2465f80321c8811e15299d906f Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Mon, 11 Feb 2019 02:59:30 +0530 Subject: [PATCH 10/11] Remove pulbic function in GoldMine - Remove getter and setter functions in GoldMine - Add gold manager mock in soldier tests --- .../include/state/gold_manager/gold_manager.h | 5 +- .../include/state/gold_manager/gold_mine.h | 24 ------- src/state/src/gold_manager/gold_mine.cpp | 5 -- test/logger/logger_test.cpp | 6 -- test/state/factory_test.cpp | 15 ----- test/state/gold_manager_test.cpp | 11 ++-- test/state/soldier_test.cpp | 63 +++++++++---------- test/state/villager_test.cpp | 15 ----- 8 files changed, 35 insertions(+), 109 deletions(-) diff --git a/src/state/include/state/gold_manager/gold_manager.h b/src/state/include/state/gold_manager/gold_manager.h index dfa3a16..4c596c1 100644 --- a/src/state/include/state/gold_manager/gold_manager.h +++ b/src/state/include/state/gold_manager/gold_manager.h @@ -11,8 +11,8 @@ #include #include -#include #include +#include #include 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, 2> mine_requests; + std::array, 2> mine_requests; /** * Function to return gold mine given the Vec2D offset */ - GoldMine *GetGoldMine(Vec2D offset); public: diff --git a/src/state/include/state/gold_manager/gold_mine.h b/src/state/include/state/gold_manager/gold_mine.h index ede581f..a51db8e 100644 --- a/src/state/include/state/gold_manager/gold_mine.h +++ b/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 diff --git a/src/state/src/gold_manager/gold_mine.cpp b/src/state/src/gold_manager/gold_mine.cpp index 4c93605..4dc278c 100644 --- a/src/state/src/gold_manager/gold_mine.cpp +++ b/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 diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index b95ee1c..55a28eb 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -24,8 +24,6 @@ class LoggerTest : public testing::Test { std::unique_ptr gold_manager; std::unique_ptr path_planner; - std::array player_gold; - int64_t max_gold; std::unique_ptr map; @@ -47,10 +45,6 @@ class LoggerTest : public testing::Test { {W, W, W, W, W}, }}; map = make_unique(map_matrix, TEST_MAP_SIZE, ELEMENT_SIZE); - - player_gold[0] = 5000; - player_gold[1] = 5000; - max_gold = 10000; } }; diff --git a/test/state/factory_test.cpp b/test/state/factory_test.cpp index e17b4f8..98a4f51 100644 --- a/test/state/factory_test.cpp +++ b/test/state/factory_test.cpp @@ -13,12 +13,6 @@ using namespace testing; class FactoryTest : public Test { protected: - array 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> gold_mines; - this->gold_manager = make_unique(); villager_list = std::vector>{}; diff --git a/test/state/gold_manager_test.cpp b/test/state/gold_manager_test.cpp index c9c0985..87ceed6 100644 --- a/test/state/gold_manager_test.cpp +++ b/test/state/gold_manager_test.cpp @@ -99,7 +99,6 @@ class GoldManagerTest : public testing::Test { * L L L W L * L L L L W */ - vector> dummy_map; for (int i = 0; i < map_size; ++i) { vector dummy_row; @@ -126,7 +125,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(PlayerId::PLAYER1); villager->SetMineTarget(Vec2D(2, 2)); @@ -152,7 +151,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,7 +177,7 @@ 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; @@ -186,7 +185,7 @@ TEST_F(GoldManagerTest, SplitGoldTest) { // 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 +220,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); } diff --git a/test/state/soldier_test.cpp b/test/state/soldier_test.cpp index a24bd4f..eb039f6 100644 --- a/test/state/soldier_test.cpp +++ b/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; - array 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 gold_manager; + unique_ptr gold_manager; unique_ptr path_planner; unique_ptr soldier; @@ -41,23 +35,7 @@ class SoldierTest : public Test { }}; map = make_unique(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> gold_mines; - - this->gold_manager = make_unique( - 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(map.get()); + gold_manager = make_unique(); this->soldier = make_unique(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( - 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(); diff --git a/test/state/villager_test.cpp b/test/state/villager_test.cpp index 3093776..f9216b6 100644 --- a/test/state/villager_test.cpp +++ b/test/state/villager_test.cpp @@ -21,12 +21,6 @@ class VillagerTest : public Test { int64_t element_size = 10; unique_ptr map; - array 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 gold_manager; unique_ptr path_planner; unique_ptr villager; @@ -49,15 +43,6 @@ class VillagerTest : public Test { }}; map = make_unique(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(); this->path_planner = make_unique(map.get()); From ac7127667f1a082f4bbe69435087c79bd92e8002 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Wed, 13 Feb 2019 03:54:16 +0530 Subject: [PATCH 11/11] Rebase against master - Fix merge conflicts in state_test.cpp, logger_test.cpp --- test/state/soldier_test.cpp | 13 +++--- test/state/state_test.cpp | 88 +++++-------------------------------- 2 files changed, 16 insertions(+), 85 deletions(-) diff --git a/test/state/soldier_test.cpp b/test/state/soldier_test.cpp index eb039f6..ae04576 100644 --- a/test/state/soldier_test.cpp +++ b/test/state/soldier_test.cpp @@ -163,19 +163,18 @@ TEST_F(SoldierTest, PursuitAndKill) { } TEST_F(SoldierTest, SimultaneousKill) { - auto *target_soldier = - new Soldier(2, PlayerId::PLAYER2, ActorType::SOLDIER, 100, 100, - DoubleVec2D(15, 15), 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); // 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 + // 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())); + EXPECT_CALL(*gold_manager, RewardKill(soldier.get())); while (target_soldier->GetHp() != 0) { this->soldier->Update(); diff --git a/test/state/state_test.cpp b/test/state/state_test.cpp index fd41920..d7cfb61 100644 --- a/test/state/state_test.cpp +++ b/test/state/state_test.cpp @@ -100,10 +100,10 @@ class StateTest : public Test { path_planner.get(), 10, 10, 10, 10, 10, 10)); // Player 2 has 1 villager - villagers[1].push_back(make_unique( - 4, PlayerId::PLAYER1, ActorType::VILLAGER, 100, 100, - DoubleVec2D(10, 10), gold_manager.get(), path_planner.get(), 10, 10, - 10, 10, 10, 10)); + villagers[1].push_back( + make_unique(4, PlayerId::PLAYER1, ActorType::VILLAGER, + 100, 100, DoubleVec2D(10, 10), gold_manager, + path_planner.get(), 10, 10, 10, 10, 10, 10)); // Player2 has 1 soldier, say.. soldiers[1].push_back(make_unique( @@ -120,9 +120,6 @@ class StateTest : public Test { }; TEST_F(StateTest, MoveUnitTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - state->MoveUnit(PlayerId::PLAYER1, 1, Vec2D(5, 5)); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -135,9 +132,6 @@ TEST_F(StateTest, MoveUnitTest) { } TEST_F(StateTest, MineLocationTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - state->MineLocation(PlayerId::PLAYER1, 1, Vec2D(25, 25)); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -151,9 +145,6 @@ TEST_F(StateTest, MineLocationTest) { } TEST_F(StateTest, VillagerAttackEnemyTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - state->AttackActor(PlayerId::PLAYER1, 1, 2); auto curr_villagers = state->GetVillagers(); auto curr_villager = curr_villagers[0].front(); @@ -170,9 +161,6 @@ TEST_F(StateTest, VillagerAttackEnemyTest) { } TEST_F(StateTest, SoldierAttackEnemyTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - state->AttackActor(PlayerId::PLAYER2, 2, 1); auto curr_soldiers = state->GetSoldiers(); auto curr_soldier = curr_soldiers[1].front(); @@ -195,17 +183,10 @@ TEST_F(StateTest, CreateFactoryTest) { auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the state and soldier while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } -======= - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - - state->Update(); ->>>>>>> Add expectations for GoldManager mock // Checking if the villager has transitioned into the BUILD state ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -215,20 +196,8 @@ TEST_F(StateTest, CreateFactoryTest) { curr_factories = state->GetFactories(); auto factory = curr_factories[0].front(); ASSERT_EQ(curr_factories[0].size(), 1); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); - -<<<<<<< e22e3eaa527dea449d4e47edfe57c4f9204a9c48 - auto gold_manager = villager->GetGoldManager(); - ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), 5000 - FACTORY_COST); -======= - //This is a gold manager test - // auto gold_manager = curr_villagers[0].front()->GetGoldManager(); - // ASSERT_EQ(gold_manager->GetBalance(PlayerId::PLAYER1), 5000 - FACTORY_COST); ->>>>>>> Replace GoldManager with mock in all tests -======= ASSERT_EQ(curr_factories[0].front()->GetState(), FactoryStateName::UNBUILT); ->>>>>>> Add expectations for GoldManager mock } TEST_F(StateTest, BuildFactoryTest) { @@ -239,43 +208,30 @@ TEST_F(StateTest, BuildFactoryTest) { auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } -<<<<<<< 8d7402a77dd4b1910544206ee76d36a175b1ae5d ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); // Getting the updated factories from state curr_factories = state->GetFactories(); auto factory = curr_factories[0].front(); -======= - EXPECT_CALL(*gold_manager, AssignGold()); -======= - EXPECT_CALL(*gold_manager, Update()); ->>>>>>> Add tests for GoldManager + // Updating state state->Update(); // Adding expectation for gold manager as state is updated ASSERT_EQ(curr_villagers[0].front()->GetState(), VillagerStateName::BUILD); ->>>>>>> Add expectations for GoldManager mock ASSERT_EQ(curr_factories[0].size(), 1); ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); // Test BuildFactory for the same villager.. state->BuildFactory(PlayerId::PLAYER1, 1, factory->GetActorId()); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 - // Updating state again -======= - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - ->>>>>>> Add expectations for GoldManager mock + // Updating state state->Update(); ASSERT_EQ(curr_villagers[0].front()->GetState(), VillagerStateName::BUILD); @@ -284,9 +240,7 @@ TEST_F(StateTest, BuildFactoryTest) { // Test BuildFactory for the other villager.. state->BuildFactory(PlayerId::PLAYER1, 3, factory->GetActorId()); - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - + // Updating state state->Update(); ASSERT_EQ(curr_villagers[0][1]->GetState(), VillagerStateName::BUILD); @@ -301,17 +255,13 @@ TEST_F(StateTest, FactoryProductionTest) { auto curr_factories = state->GetFactories(); auto villager = curr_villagers[0].front(); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } -======= - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); + // Updating state state->Update(); ->>>>>>> Add expectations for GoldManager mock ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -327,9 +277,7 @@ TEST_F(StateTest, FactoryProductionTest) { state->SetFactoryProduction(PlayerId::PLAYER1, factory->GetActorId(), ActorType::SOLDIER); - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - + // Updating state state->Update(); ASSERT_EQ(factory->GetProductionState(), ActorType::SOLDIER); @@ -344,17 +292,13 @@ TEST_F(StateTest, FactoryDeathTest) { ASSERT_EQ(curr_factories[0].size(), 0); auto villager = curr_villagers[0].front(); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Updating the villager's state while (villager->GetState() != VillagerStateName::BUILD) { state->Update(); } -======= - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); + // Updating state state->Update(); ->>>>>>> Add expectations for GoldManager mock ASSERT_EQ(villager->GetState(), VillagerStateName::BUILD); @@ -364,7 +308,6 @@ TEST_F(StateTest, FactoryDeathTest) { ASSERT_EQ(curr_factories[0].size(), 1); ASSERT_EQ(factory->GetState(), FactoryStateName::UNBUILT); -<<<<<<< 72cb5844d7321e03c15e8a78f1b3e553a1a92ca5 // Killing the factory factory->SetHp(0); factory->Update(); @@ -374,14 +317,9 @@ TEST_F(StateTest, FactoryDeathTest) { ASSERT_EQ(factory->GetState(), FactoryStateName::DEAD); ASSERT_EQ(factory->GetHp(), 0); - // Updating the state -======= // Kill factory - EXPECT_CALL(*gold_manager, Update()); - auto curr_factory = curr_factories[0].front(); curr_factory->SetHp(0); ->>>>>>> Add expectations for GoldManager mock state->Update(); auto new_facs = state->GetFactories(); @@ -389,9 +327,6 @@ TEST_F(StateTest, FactoryDeathTest) { } TEST_F(StateTest, VillagerDeathTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - auto curr_villagers = state->GetVillagers(); ASSERT_EQ(curr_villagers[0].size(), 2); @@ -404,9 +339,6 @@ TEST_F(StateTest, VillagerDeathTest) { } TEST_F(StateTest, SoldierDeathTest) { - // Adding expectation for gold manager as state is updated - EXPECT_CALL(*gold_manager, Update()); - auto curr_soldiers = state->GetSoldiers(); ASSERT_EQ(curr_soldiers[1].size(), 1);