From 0c1aca414de7dcb472d3e2bb1ed9f423068db78c Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Tue, 3 Mar 2020 01:41:43 +0530 Subject: [PATCH 1/4] Fix flag offsets not being set in player state --- src/logger/proto | 2 +- src/player_code/src/player_code.cpp | 81 ++++++++++++++++++- .../include/player_wrapper/transfer_state.h | 3 +- src/state/src/state_syncer.cpp | 2 +- 4 files changed, 83 insertions(+), 5 deletions(-) diff --git a/src/logger/proto b/src/logger/proto index c681c2ec..f5e44402 160000 --- a/src/logger/proto +++ b/src/logger/proto @@ -1 +1 @@ -Subproject commit c681c2ec597acd79c4b08e8385a24896626628ce +Subproject commit f5e44402736c123572df3015d5048bec1a450fa3 diff --git a/src/player_code/src/player_code.cpp b/src/player_code/src/player_code.cpp index efffbe5d..98ec257e 100644 --- a/src/player_code/src/player_code.cpp +++ b/src/player_code/src/player_code.cpp @@ -9,6 +9,85 @@ namespace player_code { using namespace player_state; -State PlayerCode::update(State state) { return state; } +State PlayerCode::update(State state) { + static int64_t num_turn = 0; + ++num_turn; + uint64_t num_state_bots = state.bots.size(), num_flags = state.flag_offsets.size(); + uint64_t bot_count = 0, flag_count = 0; + + // Assigning a quarter of them to move into the center flag + for(; bot_count < num_state_bots / 4; ++bot_count){ + auto &bot = state.bots[bot_count]; + auto flag_position = state.flag_offsets[flag_count++]; + flag_count %= num_flags; + bot.move(flag_position); + } + + // Assinging another quarter to move ahead of the flag locations and create towers + if(num_turn % 100 == 0){ + for(; bot_count < num_state_bots / 2; ++bot_count){ + auto &bot = state.bots[bot_count]; + auto flag_position = state.flag_offsets[(flag_count++) % num_flags]; + auto nearest_buildable_position = findNearestFreePosition(state, flag_position); + // logr << "Transforming bot\n"; + bot.transform(nearest_buildable_position); + } + }else{ + // Going to enemy base and blasting + for(; bot_count < num_state_bots / 2; ++bot_count){ + auto &bot = state.bots[bot_count]; + bot.blast(Constants::Map::PLAYER2_BASE_POSITION); + } + } + + // Assigning half of the bots to create towers near enemy base location + if(num_turn % 100 == 0){ + for(; bot_count < num_state_bots; ++bot_count){ + auto &bot = state.bots[bot_count]; + auto enemy_base = Constants::Map::PLAYER2_BASE_POSITION; + auto nearest_buildable_position = findNearestFreePosition(state, enemy_base); + bot.transform(nearest_buildable_position); + } + }else{ + // Try to transform in any flag + for(; bot_count < num_state_bots; ++bot_count){ + auto &bot = state.bots[bot_count]; + auto flag_position = state.flag_offsets[flag_count++]; + flag_count %= num_flags; + bot.move(flag_position); + } + } + + // Checking if enemy bots are in range and blasting + uint64_t tower_count = state.towers.size(); + + for(uint64_t tower_index = 0; tower_index < tower_count; ++tower_index){ + // Finding total number of enemy units in range + uint64_t enemy_actors = 0; + auto &tower = state.towers[tower_index]; + uint64_t tower_range = tower.impact_radius; + + for(int64_t enemy_bot_index = 0; enemy_bot_index < state.enemy_bots.size(); ++enemy_bot_index){ + auto &bot = state.enemy_bots[enemy_bot_index]; + if(tower.position.distance(bot.position) <= tower_range){ + ++enemy_actors; + } + } + + for(int64_t enemy_tower_index = 0; enemy_tower_index < state.enemy_towers.size(); ++enemy_tower_index){ + auto &enemy_tower = state.enemy_towers[enemy_tower_index]; + if(tower.position.distance(enemy_tower.position) <= tower_range){ + ++enemy_actors; + } + } + + if(enemy_actors >= 0){ + // logr << "Tower is blasting\n"; + tower.blast(); + } + } + + return state; +} } // namespace player_code diff --git a/src/player_wrapper/include/player_wrapper/transfer_state.h b/src/player_wrapper/include/player_wrapper/transfer_state.h index a5a9e048..cf4a5cc4 100644 --- a/src/player_wrapper/include/player_wrapper/transfer_state.h +++ b/src/player_wrapper/include/player_wrapper/transfer_state.h @@ -102,8 +102,7 @@ ConvertToTransferState(const player_state::State &ps) { ts.enemy_towers = vectorToArray(ps.enemy_towers); // Copy flag offsets - ts.flag_offsets = - vectorToArray(ps.flag_offsets); + ts.flag_offsets = vectorToArray(ps.flag_offsets); // Copy score std::copy(ps.scores.begin(), ps.scores.end(), ts.scores.begin()); diff --git a/src/state/src/state_syncer.cpp b/src/state/src/state_syncer.cpp index b5cba69e..38a7b267 100644 --- a/src/state/src/state_syncer.cpp +++ b/src/state/src/state_syncer.cpp @@ -134,7 +134,7 @@ void StateSyncer::updatePlayerStates( if (static_cast(player_id) == PlayerId::PLAYER1) { std::copy(flag_offsets.begin(), flag_offsets.end(), - player_states[player_id].flag_offsets.begin()); + player_states[player_id].flag_offsets.begin()); } else { // Flipping all the map positions and moving it into PLAYER2's // flag_offset positions as they won't be asked for again From 779139e5c465b581d6023202517f6c95444caf37 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Tue, 3 Mar 2020 01:49:47 +0530 Subject: [PATCH 2/4] Clang format fix --- src/player_code/src/player_code.cpp | 59 +++++++++++-------- .../include/player_wrapper/transfer_state.h | 3 +- src/state/src/state_syncer.cpp | 2 +- 3 files changed, 36 insertions(+), 28 deletions(-) diff --git a/src/player_code/src/player_code.cpp b/src/player_code/src/player_code.cpp index 98ec257e..27e579c4 100644 --- a/src/player_code/src/player_code.cpp +++ b/src/player_code/src/player_code.cpp @@ -12,82 +12,89 @@ using namespace player_state; State PlayerCode::update(State state) { static int64_t num_turn = 0; ++num_turn; - uint64_t num_state_bots = state.bots.size(), num_flags = state.flag_offsets.size(); - uint64_t bot_count = 0, flag_count = 0; + uint64_t num_state_bots = state.bots.size(), + num_flags = state.flag_offsets.size(); + uint64_t bot_count = 0, flag_count = 0; // Assigning a quarter of them to move into the center flag - for(; bot_count < num_state_bots / 4; ++bot_count){ + for (; bot_count < num_state_bots / 4; ++bot_count) { auto &bot = state.bots[bot_count]; auto flag_position = state.flag_offsets[flag_count++]; flag_count %= num_flags; bot.move(flag_position); } - // Assinging another quarter to move ahead of the flag locations and create towers - if(num_turn % 100 == 0){ - for(; bot_count < num_state_bots / 2; ++bot_count){ + // Assinging another quarter to move ahead of the flag locations and create + // towers + if (num_turn % 100 == 0) { + for (; bot_count < num_state_bots / 2; ++bot_count) { auto &bot = state.bots[bot_count]; auto flag_position = state.flag_offsets[(flag_count++) % num_flags]; - auto nearest_buildable_position = findNearestFreePosition(state, flag_position); + auto nearest_buildable_position = + findNearestFreePosition(state, flag_position); // logr << "Transforming bot\n"; bot.transform(nearest_buildable_position); } - }else{ + } else { // Going to enemy base and blasting - for(; bot_count < num_state_bots / 2; ++bot_count){ + for (; bot_count < num_state_bots / 2; ++bot_count) { auto &bot = state.bots[bot_count]; bot.blast(Constants::Map::PLAYER2_BASE_POSITION); } } // Assigning half of the bots to create towers near enemy base location - if(num_turn % 100 == 0){ - for(; bot_count < num_state_bots; ++bot_count){ + if (num_turn % 100 == 0) { + for (; bot_count < num_state_bots; ++bot_count) { auto &bot = state.bots[bot_count]; auto enemy_base = Constants::Map::PLAYER2_BASE_POSITION; - auto nearest_buildable_position = findNearestFreePosition(state, enemy_base); + auto nearest_buildable_position = + findNearestFreePosition(state, enemy_base); bot.transform(nearest_buildable_position); } - }else{ + } else { // Try to transform in any flag - for(; bot_count < num_state_bots; ++bot_count){ + for (; bot_count < num_state_bots; ++bot_count) { auto &bot = state.bots[bot_count]; auto flag_position = state.flag_offsets[flag_count++]; flag_count %= num_flags; bot.move(flag_position); } } - + // Checking if enemy bots are in range and blasting uint64_t tower_count = state.towers.size(); - - for(uint64_t tower_index = 0; tower_index < tower_count; ++tower_index){ + + for (uint64_t tower_index = 0; tower_index < tower_count; ++tower_index) { // Finding total number of enemy units in range uint64_t enemy_actors = 0; auto &tower = state.towers[tower_index]; uint64_t tower_range = tower.impact_radius; - - for(int64_t enemy_bot_index = 0; enemy_bot_index < state.enemy_bots.size(); ++enemy_bot_index){ - auto &bot = state.enemy_bots[enemy_bot_index]; - if(tower.position.distance(bot.position) <= tower_range){ + + for (int64_t enemy_bot_index = 0; + enemy_bot_index < state.enemy_bots.size(); ++enemy_bot_index) { + auto &bot = state.enemy_bots[enemy_bot_index]; + if (tower.position.distance(bot.position) <= tower_range) { ++enemy_actors; } } - for(int64_t enemy_tower_index = 0; enemy_tower_index < state.enemy_towers.size(); ++enemy_tower_index){ - auto &enemy_tower = state.enemy_towers[enemy_tower_index]; - if(tower.position.distance(enemy_tower.position) <= tower_range){ + for (int64_t enemy_tower_index = 0; + enemy_tower_index < state.enemy_towers.size(); + ++enemy_tower_index) { + auto &enemy_tower = state.enemy_towers[enemy_tower_index]; + if (tower.position.distance(enemy_tower.position) <= tower_range) { ++enemy_actors; } } - if(enemy_actors >= 0){ + if (enemy_actors >= 0) { // logr << "Tower is blasting\n"; tower.blast(); } } - return state; + return state; } } // namespace player_code diff --git a/src/player_wrapper/include/player_wrapper/transfer_state.h b/src/player_wrapper/include/player_wrapper/transfer_state.h index cf4a5cc4..a5a9e048 100644 --- a/src/player_wrapper/include/player_wrapper/transfer_state.h +++ b/src/player_wrapper/include/player_wrapper/transfer_state.h @@ -102,7 +102,8 @@ ConvertToTransferState(const player_state::State &ps) { ts.enemy_towers = vectorToArray(ps.enemy_towers); // Copy flag offsets - ts.flag_offsets = vectorToArray(ps.flag_offsets); + ts.flag_offsets = + vectorToArray(ps.flag_offsets); // Copy score std::copy(ps.scores.begin(), ps.scores.end(), ts.scores.begin()); diff --git a/src/state/src/state_syncer.cpp b/src/state/src/state_syncer.cpp index 38a7b267..b5cba69e 100644 --- a/src/state/src/state_syncer.cpp +++ b/src/state/src/state_syncer.cpp @@ -134,7 +134,7 @@ void StateSyncer::updatePlayerStates( if (static_cast(player_id) == PlayerId::PLAYER1) { std::copy(flag_offsets.begin(), flag_offsets.end(), - player_states[player_id].flag_offsets.begin()); + player_states[player_id].flag_offsets.begin()); } else { // Flipping all the map positions and moving it into PLAYER2's // flag_offset positions as they won't be asked for again From 29b987bd56768b7ae567181140e81586f74f2125 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Tue, 3 Mar 2020 02:48:16 +0530 Subject: [PATCH 3/4] Add turn winner for renderer --- src/logger/src/logger.cpp | 15 +++++++++++++++ .../include/state/score_manager/score_manager.h | 12 ++++++++++++ src/state/src/score_manager/score_manager.cpp | 16 +++++++++++----- test/logger/logger_test.cpp | 3 +++ 4 files changed, 41 insertions(+), 5 deletions(-) diff --git a/src/logger/src/logger.cpp b/src/logger/src/logger.cpp index e59c9ddf..5b59388f 100644 --- a/src/logger/src/logger.cpp +++ b/src/logger/src/logger.cpp @@ -103,6 +103,7 @@ void Logger::logState() { auto bots = state->getBots(); auto towers = state->getTowers(); auto scores = state->getScores(); + auto score_manager = state->getScoreManager(); // Things logged only in first turn if (turn_count == 1) { @@ -188,6 +189,20 @@ void Logger::logState() { inst_count = 0; } + // Log turn winners + auto turn_winner = score_manager->getTurnWinner(); + switch(turn_winner){ + case PlayerId::PLAYER1: + game_state->set_turn_winner(proto::Winner::PLAYER1); + break; + case PlayerId::PLAYER2: + game_state->set_turn_winner(proto::Winner::PLAYER2); + break; + case PlayerId::PLAYER_NULL: + game_state->set_turn_winner(proto::Winner::TIE); + break; + } + // Log the errors, clear the error vectors for (auto &player_errors : errors) { auto player_error_struct = game_state->add_player_errors(); diff --git a/src/state/include/state/score_manager/score_manager.h b/src/state/include/state/score_manager/score_manager.h index 0df19f1f..6958de5f 100644 --- a/src/state/include/state/score_manager/score_manager.h +++ b/src/state/include/state/score_manager/score_manager.h @@ -33,6 +33,11 @@ class STATE_EXPORT ScoreManager { */ std::array num_towers; + /** + * Stores the player with more actor value in a given turn + */ + PlayerId turn_winner; + /** * Get points based on number of bots and towers owned by the player * @@ -95,5 +100,12 @@ class STATE_EXPORT ScoreManager { * @return std::array */ std::array getBotCounts() const; + + /** + * Returns the winner of the turn + * + * @return PlayerId + */ + PlayerId getTurnWinner() const; }; } // namespace state diff --git a/src/state/src/score_manager/score_manager.cpp b/src/state/src/score_manager/score_manager.cpp index faf1510c..a56698f2 100644 --- a/src/state/src/score_manager/score_manager.cpp +++ b/src/state/src/score_manager/score_manager.cpp @@ -9,10 +9,10 @@ namespace state { ScoreManager::ScoreManager() - : scores({0, 0}), num_bots({0, 0}), num_towers({0, 0}) {} + : scores({0, 0}), num_bots({0, 0}), num_towers({0, 0}), turn_winner(PlayerId::PLAYER_NULL) {} ScoreManager::ScoreManager(std::array scores) - : scores(scores), num_bots({0, 0}), num_towers({0, 0}) {} + : scores(scores), num_bots({0, 0}), num_towers({0, 0}), turn_winner(PlayerId::PLAYER_NULL) {} double ScoreManager::getPlayerPoints(PlayerId player_id) const { using namespace Constants::Score; @@ -61,11 +61,17 @@ void ScoreManager::updateScores() { auto points_1 = getPlayerPoints(PlayerId::PLAYER1); auto points_2 = getPlayerPoints(PlayerId::PLAYER2); - if (points_1 == points_2) + if (points_1 == points_2){ + turn_winner = PlayerId::PLAYER_NULL; return; - auto dominant_player_id = + } + turn_winner = points_1 > points_2 ? PlayerId::PLAYER1 : PlayerId::PLAYER2; - scores[static_cast(dominant_player_id)]++; + scores[static_cast(turn_winner)]++; +} + +PlayerId ScoreManager::getTurnWinner() const{ + return turn_winner; } std::array ScoreManager::getScores() const { return scores; } diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index 584dd2de..874a7bcd 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -141,10 +141,12 @@ TEST_F(LoggerTest, WriteReadTest) { std::array scores1 = {100, 100}; std::array scores2 = {300, 200}; + EXPECT_CALL(*state, getScoreManager()).Times(4).WillRepeatedly(Return(score_manager.get())); EXPECT_CALL(*state, getScores()) .WillOnce(Return(scores1)) .WillRepeatedly(Return(scores2)); + vector inst_counts = {123456, 654321}; logger->logInstructionCount(PlayerId::PLAYER1, inst_counts[0]); logger->logInstructionCount(PlayerId::PLAYER2, inst_counts[1]); @@ -208,6 +210,7 @@ TEST_F(LoggerTest, WriteReadTest) { ASSERT_EQ(game->states(0).player_errors(1).errors_size(), 2); ASSERT_EQ(game->states(0).player_errors(1).errors(0), 2); ASSERT_EQ(game->states(0).player_errors(1).errors(1), 3); + ASSERT_EQ(game->states[0].player) // Check if the mapping got set and the message string matches auto error_map = *game->mutable_error_map(); From b3e1f3f5cc0dc90db0113f52c1d13d1578a1c316 Mon Sep 17 00:00:00 2001 From: Hrishikesh Shekhar Date: Tue, 3 Mar 2020 03:02:18 +0530 Subject: [PATCH 4/4] Fix logger tests with new expectations --- src/logger/src/logger.cpp | 16 ++++++++-------- .../include/state/score_manager/score_manager.h | 4 ++-- src/state/src/score_manager/score_manager.cpp | 15 +++++++-------- test/logger/logger_test.cpp | 8 +++++--- 4 files changed, 22 insertions(+), 21 deletions(-) diff --git a/src/logger/src/logger.cpp b/src/logger/src/logger.cpp index 5b59388f..149a9045 100644 --- a/src/logger/src/logger.cpp +++ b/src/logger/src/logger.cpp @@ -191,18 +191,18 @@ void Logger::logState() { // Log turn winners auto turn_winner = score_manager->getTurnWinner(); - switch(turn_winner){ - case PlayerId::PLAYER1: - game_state->set_turn_winner(proto::Winner::PLAYER1); + switch (turn_winner) { + case PlayerId::PLAYER1: + game_state->set_turn_winner(proto::Winner::PLAYER1); break; - case PlayerId::PLAYER2: - game_state->set_turn_winner(proto::Winner::PLAYER2); + case PlayerId::PLAYER2: + game_state->set_turn_winner(proto::Winner::PLAYER2); break; - case PlayerId::PLAYER_NULL: - game_state->set_turn_winner(proto::Winner::TIE); + case PlayerId::PLAYER_NULL: + game_state->set_turn_winner(proto::Winner::TIE); break; } - + // Log the errors, clear the error vectors for (auto &player_errors : errors) { auto player_error_struct = game_state->add_player_errors(); diff --git a/src/state/include/state/score_manager/score_manager.h b/src/state/include/state/score_manager/score_manager.h index 6958de5f..b5539819 100644 --- a/src/state/include/state/score_manager/score_manager.h +++ b/src/state/include/state/score_manager/score_manager.h @@ -103,8 +103,8 @@ class STATE_EXPORT ScoreManager { /** * Returns the winner of the turn - * - * @return PlayerId + * + * @return PlayerId */ PlayerId getTurnWinner() const; }; diff --git a/src/state/src/score_manager/score_manager.cpp b/src/state/src/score_manager/score_manager.cpp index a56698f2..d54347aa 100644 --- a/src/state/src/score_manager/score_manager.cpp +++ b/src/state/src/score_manager/score_manager.cpp @@ -9,10 +9,12 @@ namespace state { ScoreManager::ScoreManager() - : scores({0, 0}), num_bots({0, 0}), num_towers({0, 0}), turn_winner(PlayerId::PLAYER_NULL) {} + : scores({0, 0}), num_bots({0, 0}), num_towers({0, 0}), + turn_winner(PlayerId::PLAYER_NULL) {} ScoreManager::ScoreManager(std::array scores) - : scores(scores), num_bots({0, 0}), num_towers({0, 0}), turn_winner(PlayerId::PLAYER_NULL) {} + : scores(scores), num_bots({0, 0}), num_towers({0, 0}), + turn_winner(PlayerId::PLAYER_NULL) {} double ScoreManager::getPlayerPoints(PlayerId player_id) const { using namespace Constants::Score; @@ -61,18 +63,15 @@ void ScoreManager::updateScores() { auto points_1 = getPlayerPoints(PlayerId::PLAYER1); auto points_2 = getPlayerPoints(PlayerId::PLAYER2); - if (points_1 == points_2){ + if (points_1 == points_2) { turn_winner = PlayerId::PLAYER_NULL; return; } - turn_winner = - points_1 > points_2 ? PlayerId::PLAYER1 : PlayerId::PLAYER2; + turn_winner = points_1 > points_2 ? PlayerId::PLAYER1 : PlayerId::PLAYER2; scores[static_cast(turn_winner)]++; } -PlayerId ScoreManager::getTurnWinner() const{ - return turn_winner; -} +PlayerId ScoreManager::getTurnWinner() const { return turn_winner; } std::array ScoreManager::getScores() const { return scores; } } // namespace state diff --git a/test/logger/logger_test.cpp b/test/logger/logger_test.cpp index 874a7bcd..59d9c316 100644 --- a/test/logger/logger_test.cpp +++ b/test/logger/logger_test.cpp @@ -141,12 +141,13 @@ TEST_F(LoggerTest, WriteReadTest) { std::array scores1 = {100, 100}; std::array scores2 = {300, 200}; - EXPECT_CALL(*state, getScoreManager()).Times(4).WillRepeatedly(Return(score_manager.get())); + EXPECT_CALL(*state, getScoreManager()) + .Times(4) + .WillRepeatedly(Return(score_manager.get())); EXPECT_CALL(*state, getScores()) .WillOnce(Return(scores1)) .WillRepeatedly(Return(scores2)); - vector inst_counts = {123456, 654321}; logger->logInstructionCount(PlayerId::PLAYER1, inst_counts[0]); logger->logInstructionCount(PlayerId::PLAYER2, inst_counts[1]); @@ -210,7 +211,8 @@ TEST_F(LoggerTest, WriteReadTest) { ASSERT_EQ(game->states(0).player_errors(1).errors_size(), 2); ASSERT_EQ(game->states(0).player_errors(1).errors(0), 2); ASSERT_EQ(game->states(0).player_errors(1).errors(1), 3); - ASSERT_EQ(game->states[0].player) + + EXPECT_EQ(game->states(0).turn_winner(), proto::Winner::TIE); // Check if the mapping got set and the message string matches auto error_map = *game->mutable_error_map();