Fixed source includes

impl/game_client_lib/internal_state/internal_state_interface.cpp

@@ -1,2 +1 @@
-
 #include "internal_state_interface.hpp"

impl/game_client_lib/internal_state/internal_state_manager.cpp

@@ -1,12 +1,12 @@
 #include "internal_state_manager.hpp"
-#include "end_lose.hpp"
-#include "end_win.hpp"
-#include "place_units.hpp"
-#include "playback.hpp"
-#include "select_starting_units.hpp"
-#include "state_game.hpp"
-#include "wait_for_all_players.hpp"
-#include "wait_for_simulation_results.hpp"
+#include <internal_state/end_lose.hpp>
+#include <internal_state/end_win.hpp>
+#include <internal_state/place_units.hpp>
+#include <internal_state/playback.hpp>
+#include <internal_state/select_starting_units.hpp>
+#include <internal_state/wait_for_all_players.hpp>
+#include <internal_state/wait_for_simulation_results.hpp>
+#include <state_game.hpp>
 #include <memory>
 
 InternalStateManager::InternalStateManager()

impl/game_client_lib/internal_state/select_starting_units.cpp

@@ -1,6 +1,7 @@
 #include "select_starting_units.hpp"
-#include "state_game.hpp"
+#include <state_game.hpp>
 #include <imgui.h>
+#include <string>
 
 namespace {
 // TODO move to separate file

impl/game_client_lib/internal_state/wait_for_all_players.cpp

@@ -1,6 +1,6 @@
 #include "wait_for_all_players.hpp"
-#include "internal_state_manager.hpp"
-#include "state_game.hpp"
+#include <internal_state/internal_state_manager.hpp>
+#include <state_game.hpp>
 
 void WaitForAllPlayers::update(StateGame& state, float /*elapsed*/)
 {

impl/game_client_lib/internal_state/wait_for_simulation_results.cpp

@@ -1,6 +1,6 @@
 #include "wait_for_simulation_results.hpp"
-#include "internal_state_manager.hpp"
-#include "state_game.hpp"
+#include <internal_state/internal_state_manager.hpp>
+#include <state_game.hpp>
 
 void WaitForSimulationResults::update(StateGame& state, float /*elapsed*/)
 {

impl/game_client_lib/server_connection.cpp

@@ -4,12 +4,9 @@
 #include <json_keys.hpp>
 #include <message.hpp>
 #include <network_properties.hpp>
-#include <object_properties.hpp>
 #include <simulation_result_data.hpp>
 #include <unit_info.hpp>
-#include <mutex>
 #include <stdexcept>
-#include <string>
 
 ServerConnection::ServerConnection(jt::LoggerInterface& logger)
     : m_logger { logger }

impl/game_client_lib/server_connector.cpp

@@ -1,11 +1,9 @@
 #include "server_connector.hpp"
-#include "message.hpp"
-#include "state_game.hpp"
 #include <game_interface.hpp>
-#include "imgui.h"
-#include "misc/cpp/imgui_stdlib.h"
-#include <iostream>
-#include <memory>
+#include <message.hpp>
+#include <state_game.hpp>
+#include <imgui.h>
+#include <misc/cpp/imgui_stdlib.h>
 
 ServerConnector::ServerConnector(std::shared_ptr<CompressorInterface> compressor)
     : m_compressor { compressor }

impl/game_client_lib/state_intro.cpp

@@ -1,10 +1,11 @@
 #include "state_intro.hpp"
-#include "game_properties.hpp"
 #include <audio/sound/sound.hpp>
 #include <game_interface.hpp>
+#include <game_properties.hpp>
 #include <state_menu.hpp>
 #include <tweens/tween_alpha.hpp>
 #include <tweens/tween_position.hpp>
+#include <vector.hpp>
 
 void StateIntro::onCreate()
 {

impl/game_client_lib/state_menu.cpp

@@ -1,9 +1,8 @@
 #include "state_menu.hpp"
-#include "compression/compressor_impl.hpp"
-#include "compression/logging_compressor.hpp"
-#include "server_connector.hpp"
 #include <build_info.hpp>
 #include <color/color.hpp>
+#include <compression/compressor_impl.hpp>
+#include <compression/logging_compressor.hpp>
 #include <drawable_helpers.hpp>
 #include <game_interface.hpp>
 #include <game_properties.hpp>
@@ -23,7 +22,6 @@
 #include <tweens/tween_scale.hpp>
 #include <algorithm>
 #include <iostream>
-#include <memory>
 
 void StateMenu::onCreate()
 {

impl/game_client_lib/unit_placement/placed_unit.cpp

@@ -5,6 +5,7 @@
 #include <game_properties.hpp>
 #include <math_helper.hpp>
 #include <network_data/unit_client_to_server_data.hpp>
+#include <rect.hpp>
 #include <tweens/tween_position.hpp>
 #include <vector.hpp>
 #include <memory>
@@ -82,6 +83,7 @@ std::shared_ptr<jt::Tween> PlacedUnit::createInitialTween()
 }
 
 int PlacedUnit::getLevel() const { return 1; }
+
 int PlacedUnit::getPlayerID() const { return m_playerID; }
 
 void PlacedUnit::flash() { m_anim->flash(0.4f, jt::colors::Green); }

impl/game_common_lib/map/placement_area.cpp

@@ -1,5 +1,5 @@
+#include "placement_area.hpp"
 #include <game_properties.hpp>
-#include <map/placement_area.hpp>
 #include <map/terrain.hpp>
 
 namespace {

impl/game_common_lib/map/terrain.cpp

@@ -1,12 +1,12 @@
 #define _USE_MATH_DEFINES
 #include <cmath>
 
-#include "vector.hpp"
-#include <map/terrain.hpp>
+#include "terrain.hpp"
 #include <math_helper.hpp>
 #include <nlohmann.hpp>
+#include <vector.hpp>
 #include <fstream>
-#include <iostream>
+#include <vector>
 
 namespace {
 

impl/game_common_lib/network_data/arrow_info.cpp

@@ -1,6 +1,6 @@
 
 #include "arrow_info.hpp"
-#include "json_keys.hpp"
+#include <json_keys.hpp>
 #include <network_properties.hpp>
 
 void to_json(nlohmann::json& j, const ArrowInfo& data)
@@ -11,7 +11,7 @@ void to_json(nlohmann::json& j, const ArrowInfo& data)
         { jk::positionY, static_cast<int>(data.currentPos.y * NetworkProperties::floatPrecision()) }
         // clang-format on
     };
-    
+
     if (data.arrowScale != 1.0f) {
         j[jk::scale] = static_cast<int>(data.arrowScale * NetworkProperties::floatPrecision());
     }

impl/game_common_lib/network_helpers.cpp

@@ -2,6 +2,7 @@
 #include <asio/read.hpp>
 #include <asio/write.hpp>
 #include <iomanip>
+#include <sstream>
 
 void NetworkHelpers::freeSendString(
     std::string const& str, asio::ip::tcp::socket& socket, jt::LoggerInterface& logger)

impl/game_common_lib/receive_buffer.cpp

@@ -1,2 +1 @@
-
 #include "receive_buffer.hpp"

impl/game_common_lib/simulation_result_data.cpp

@@ -1,5 +1,5 @@
 #include "simulation_result_data.hpp"
-#include "json_keys.hpp"
+#include <json_keys.hpp>
 
 void to_json(nlohmann::json& j, const SimulationResultDataForOneFrame& data)
 {

impl/game_common_lib/unit_info.cpp

@@ -1,6 +1,5 @@
 #include "unit_info.hpp"
-#include "json_keys.hpp"
-#include <nlohmann.hpp>
+#include <json_keys.hpp>
 
 void to_json(nlohmann::json& j, AiInfo const& p)
 {

impl/game_common_lib/unit_info_collection.cpp

@@ -1,9 +1,7 @@
 #include "unit_info_collection.hpp"
 #include <json_keys.hpp>
-#include <nlohmann.hpp>
 #include <fstream>
 #include <stdexcept>
-#include <string>
 
 UnitInfoCollection::UnitInfoCollection(jt::LoggerInterface& logger, const std::string& infoFilename)
     : m_logger { logger }

impl/game_server/main.cpp

@@ -1,9 +1,10 @@
-#include "compression/compressor_impl.hpp"
-#include "compression/logging_compressor.hpp"
-#include "log/default_logging.hpp"
-#include "log/logger.hpp"
+#include <compression/compressor_impl.hpp>
+#include <compression/logging_compressor.hpp>
 #include <game_server.hpp>
+#include <log/default_logging.hpp>
+#include <log/logger.hpp>
 #include <chrono>
+#include <exception>
 #include <iostream>
 #include <memory>
 #include <string>

impl/game_server_lib/close_combat_info.cpp

@@ -1,2 +1 @@
-
 #include "close_combat_info.hpp"

impl/game_server_lib/game_server.cpp

@@ -72,7 +72,7 @@ void GameServer::performAI(std::map<int, PlayerInfo>& botDataCopy) const
             unitData.positionX -= terrainChunkSizeInPixel * 2;
             unitData.positionY -= terrainChunkSizeInPixel * 5 + 32 * (m_round - 10);
         }
-        std::vector<std::string> const possibleUnits = m_unitInfos.getTypes();
+        auto const possibleUnits = m_unitInfos.getTypes();
         auto const unitType
             = *jt::SystemHelper::select_randomly(possibleUnits.cbegin(), possibleUnits.cend());
 

impl/game_server_lib/game_simulation.cpp

@@ -215,9 +215,7 @@ void GameSimulation::handleArrows(
             }
         }
     }
-    m_arrows.erase(std::remove_if(m_arrows.begin(), m_arrows.end(),
-                       [](auto& arrow) { return arrow.age > arrow.totalTime; }),
-        m_arrows.end());
+    (void)std::erase_if(m_arrows, [](auto const& arrow) { return arrow.age > arrow.totalTime; });
 }
 
 void GameSimulation::handleArrowsToBeSpawned(float timePerUpdate)
@@ -231,9 +229,7 @@ void GameSimulation::handleArrowsToBeSpawned(float timePerUpdate)
         }
     }
 
-    m_arrowsToBeSpawned.erase(std::remove_if(m_arrowsToBeSpawned.begin(), m_arrowsToBeSpawned.end(),
-                                  [](auto& kvp) { return kvp.first <= 0; }),
-        m_arrowsToBeSpawned.end());
+    (void)std::erase_if(m_arrowsToBeSpawned, [](auto const& kvp) { return kvp.first <= 0; });
 }
 
 void GameSimulation::handleScheduledAttacks(float timePerUpdate)
@@ -256,10 +252,8 @@ void GameSimulation::handleScheduledAttacks(float timePerUpdate)
         }
     }
 
-    m_scheduledCloseCombatAttacks.erase(
-        std::remove_if(m_scheduledCloseCombatAttacks.begin(), m_scheduledCloseCombatAttacks.end(),
-            [](auto& kvp) { return kvp.first <= 0; }),
-        m_scheduledCloseCombatAttacks.end());
+    (void)std::erase_if(
+        m_scheduledCloseCombatAttacks, [](auto const& kvp) { return kvp.first <= 0; });
 }
 
 std::weak_ptr<SimulationObjectInterface> GameSimulation::getClosestTargetTo(

impl/game_server_lib/player_info.cpp

@@ -1,2 +1 @@
-
 #include "player_info.hpp"

impl/game_server_lib/server_network_connection.cpp

@@ -21,7 +21,6 @@ ServerNetworkConnection::ServerNetworkConnection(
             NetworkProperties::NetworkProtocolType(), NetworkProperties::DefaultServerPort() } }
     , m_buffer { std::make_unique<ReceiveBuffer>() }
 {
-
     awaitNextAccept();
 
     startProcessing();
@@ -83,15 +82,12 @@ void ServerNetworkConnection::update()
     std::lock_guard<std::mutex> lock { m_socketsMutex };
 
     // clean up sockets
-    m_sockets.erase(
-        std::remove_if(m_sockets.begin(), m_sockets.end(),
-            [this](auto const& s) {
-                if (!s->is_open()) {
-                    m_logger.info("remove closed socket", { "network", "ServerNetworkConnection" });
-                }
-                return !s->is_open();
-            }),
-        m_sockets.end());
+    (void)std::erase_if(m_sockets, [this](auto const& s) {
+        if (!s->is_open()) {
+            m_logger.info("remove closed socket", { "network", "ServerNetworkConnection" });
+        }
+        return !s->is_open();
+    });
 }
 
 void ServerNetworkConnection::handleReceive(

impl/game_server_lib/simulation_result_message_sender.cpp

@@ -1,7 +1,6 @@
 #include "simulation_result_message_sender.hpp"
-#include "object_properties.hpp"
-#include "simulation_result_data.hpp"
-#include <iostream>
+#include <message.hpp>
+#include <nlohmann.hpp>
 
 SimulationResultMessageSender::SimulationResultMessageSender(ServerNetworkConnection& connection)
     : m_connection { connection }

impl/game_server_lib/units/ai/ai_close_combat.cpp

@@ -1,5 +1,5 @@
 #include "ai_close_combat.hpp"
-#include "close_combat_info.hpp"
+#include <close_combat_info.hpp>
 #include <map/terrain.hpp>
 #include <math_helper.hpp>
 #include <random/random.hpp>

impl/game_server_lib/units/ai/ai_interface.cpp

@@ -1,2 +1 @@
-
 #include "ai_interface.hpp"

impl/jamtemplate/common/audio/audio/audio_impl.cpp

@@ -34,9 +34,7 @@ void jt::AudioImpl::update(float elapsed)
 
 void jt::AudioImpl::cleanUpUnusedSounds()
 {
-    m_temporarySounds.erase(std::remove_if(m_temporarySounds.begin(), m_temporarySounds.end(),
-                                [](auto wptr) { return wptr.expired(); }),
-        m_temporarySounds.end());
+    (void)std::erase_if(m_temporarySounds, [](auto const& wptr) { return wptr.expired(); });
 }
 
 std::shared_ptr<jt::SoundInterface> jt::AudioImpl::addTemporarySound(std::string const& fileName)

impl/jamtemplate/common/audio/fades/sound_fade_manager.cpp

@@ -11,17 +11,14 @@ void SoundFadeManager::volumeFade(std::weak_ptr<SoundInterface> sound, float dur
 
 void SoundFadeManager::update(float elapsed)
 {
-    m_fadeInfos.erase(std::remove_if(m_fadeInfos.begin(), m_fadeInfos.end(),
-                          [](auto const& fadeInfo) { return !fadeInfo.hasValidSound(); }),
-        m_fadeInfos.end());
+    (void)std::erase_if(
+        m_fadeInfos, [](auto const& fadeInfo) { return !fadeInfo.hasValidSound(); });
 
     for (auto& fade : m_fadeInfos) {
         fade.update(elapsed);
     }
 
-    m_fadeInfos.erase(std::remove_if(m_fadeInfos.begin(), m_fadeInfos.end(),
-                          [](auto const& fadeInfo) { return !fadeInfo.isAlive(); }),
-        m_fadeInfos.end());
+    (void)std::erase_if(m_fadeInfos, [](auto const& fadeInfo) { return !fadeInfo.isAlive(); });
 }
 std::size_t SoundFadeManager::size() const { return m_fadeInfos.size(); }
 

impl/jamtemplate/common/game_object_collection.cpp

@@ -30,15 +30,13 @@ void jt::GameObjectCollection::draw() const
 
 void jt::GameObjectCollection::cleanUpObjects()
 {
-    m_objects.erase(std::remove_if(m_objects.begin(), m_objects.end(),
-                        [](auto go) {
-                            bool const isDead = !go->isAlive();
-                            if (isDead) {
-                                go->destroy();
-                            }
-                            return isDead;
-                        }),
-        m_objects.end());
+    (void)std::erase_if(m_objects, [](auto const& go) {
+        bool const isDead = !go->isAlive();
+        if (isDead) {
+            go->destroy();
+        }
+        return isDead;
+    });
 }
 void jt::GameObjectCollection::addNewObjects()
 {

impl/jamtemplate/common/object_group.hpp

@@ -36,9 +36,7 @@ class ObjectGroup : public GameObject {
 
     void doUpdate(const float /*elapsed*/) override
     {
-        m_data.erase(std::remove_if(m_data.begin(), m_data.end(),
-                         [](std::weak_ptr<T> wptr) { return wptr.expired(); }),
-            m_data.end());
+        (void)std::erase_if(m_data, [](auto const& wptr) { return wptr.expired(); });
     }
 };
 

impl/jamtemplate/common/strutils.hpp

@@ -416,9 +416,7 @@ static inline std::string join(const std::vector<T>& tokens, const std::string&
  */
 static inline void drop_empty(std::vector<std::string>& tokens)
 {
-    auto last = std::remove_if(
-        tokens.begin(), tokens.end(), [](const std::string& s) { return s.size() == 0; });
-    tokens.erase(last, tokens.end());
+    (void)std::erase_if(tokens, [](auto const& s) { return s.empty(); });
 }
 
 /**