refactor: format all files

include/protocol/Protocol.h

@@ -445,7 +445,7 @@ public:
     virtual PacketType getType() const { return PacketType::WorldAddTower; }
 };
 
-class WorldRemoveTowerPacket : public Packet{
+class WorldRemoveTowerPacket : public Packet {
 private:
     game::TowerID m_TowerID;
 public:

include/render/VertexCache.h

@@ -11,9 +11,9 @@ namespace render {
 
 class VertexCache {
 
-typedef std::vector<float> Vector;
+    typedef std::vector<float> Vector;
-typedef std::pair<Vector::iterator, Vector::iterator> ElementsIndex;
+    typedef std::pair<Vector::iterator, Vector::iterator> ElementsIndex;
-typedef std::pair<ElementsIndex, ElementsIndex> DataIndex;
+    typedef std::pair<ElementsIndex, ElementsIndex> DataIndex;
 
 private:
     Vector m_Positions;

include/render/loader/WorldLoader.h

@@ -8,7 +8,7 @@ namespace render {
 
 namespace WorldLoader {
 
-struct RenderData{
+struct RenderData {
     std::vector<float> positions;
     std::vector<float> colors;
 };

src/game/Mobs.cpp

@@ -18,9 +18,9 @@ void Mob::addEffect(EffectType effectType, float durationSec) {
     if (isImmuneTo(effectType))
         return;
     if (hasEffect(effectType)) {
-        auto it = std::find_if(m_Effects.begin(), m_Effects.end(), [&effectType](EffectDuration effect){ return effect.first == effectType;});
+        auto it = std::find_if(m_Effects.begin(), m_Effects.end(), [&effectType](EffectDuration effect) { return effect.first == effectType;});
         EffectDuration& effect = *it;
-        if(effect.second < durationSec)
+        if (effect.second < durationSec)
             effect.second = durationSec;    // setting new duration if it's greater then the actual
     } else {
         m_Effects.push_back({ effectType, durationSec });
@@ -42,7 +42,7 @@ void Mob::updateEffects(std::uint64_t delta) {
 }
 
 bool Mob::hasEffect(EffectType type) {
-    return std::find_if(m_Effects.begin(), m_Effects.end(), [&type](EffectDuration effect){ return effect.first == type;}) != m_Effects.end();
+    return std::find_if(m_Effects.begin(), m_Effects.end(), [&type](EffectDuration effect) { return effect.first == type;}) != m_Effects.end();
 }
 
 

src/game/client/ClientGame.cpp

@@ -70,9 +70,9 @@ void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) {
     game::Player* player = &m_Players[packet->getPlayerID()];
     if (player->getTeamColor() == game::TeamColor::None) { //join a team
         getTeam(packet->getSelectedTeam()).addPlayer(player);
-    }     else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team
+    } else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team
         getTeam(player->getTeamColor()).removePlayer(player);
-    }     else { // change team
+    } else { // change team
         getTeam(player->getTeamColor()).removePlayer(player);
         getTeam(packet->getSelectedTeam()).addPlayer(player);
     }
@@ -117,7 +117,7 @@ void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position) {
     m_Client->getConnexion().sendPacket(&packet);
 }
 
-void ClientGame::HandlePacket(protocol::WorldAddTowerPacket* packet){
+void ClientGame::HandlePacket(protocol::WorldAddTowerPacket* packet) {
     m_WorldRenderer.addTower(m_WorldClient.placeTowerAt(packet->getTowerID(), packet->getTowerType(), packet->getTowerX(), packet->getTowerY(), packet->getBuilder()));
 }
 

src/game/client/WorldClient.cpp

@@ -25,7 +25,7 @@ void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) {
         packet->getMobX(), packet->getMobY(), packet->getMobDirection());
 }
 
-void WorldClient::OnArrowShot(game::MobPtr target, game::Tower* tower){
+void WorldClient::OnArrowShot(game::MobPtr target, game::Tower* tower) {
     World::OnArrowShot(target, tower);
 }
 

src/game/server/ServerWorld.cpp

@@ -46,13 +46,13 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
     }
 }
 
-game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder){
+game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder) {
     game::TowerPtr tower = World::placeTowerAt(m_CurrentTowerID, type, x, y, builder);
     m_CurrentTowerID++;
     return tower;
 }
 
-void ServerWorld::OnArrowShot(game::MobPtr target, game::Tower* shooter){
+void ServerWorld::OnArrowShot(game::MobPtr target, game::Tower* shooter) {
     World::OnArrowShot(target, shooter);
 }
 

src/misc/Time.cpp

@@ -29,7 +29,7 @@ void AutoTimer::reset() {
     m_LastTime = getTime();
 }
 
-bool Timer::update(std::uint64_t delta){
+bool Timer::update(std::uint64_t delta) {
     m_InternalTime += delta;
     if (m_InternalTime >= m_Interval) {
         m_InternalTime %= m_Interval;
@@ -38,7 +38,7 @@ bool Timer::update(std::uint64_t delta){
     return false;
 }
 
-void Timer::reset(){
+void Timer::reset() {
     m_InternalTime = 0;
 }
 

src/network/TCPSocket.cpp

@@ -23,7 +23,7 @@ bool TCPSocket::Connect(const IPAddress& address, unsigned short port) {
     if (this->GetStatus() == Connected)
         return true;
 
-    struct addrinfo hints{};
+    struct addrinfo hints {};
     memset(&hints, 0, sizeof(addrinfo));
 
     struct addrinfo* result = nullptr;

src/protocol/Protocol.cpp

@@ -298,7 +298,7 @@ void WorldDataPacket::Deserialize(DataBuffer& data) {
             game::ChunkData::value_type value;
             if (startLong == endLong) {
                 value = (chunkData[startLong] >> startOffset);
-            }             else {
+            } else {
                 int endOffset = BITS_IN_LONG - startOffset;
                 value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset);
             }

src/render/VertexCache.cpp

@@ -4,7 +4,7 @@
 namespace td {
 namespace render {
 
-void VertexCache::addData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors){
+void VertexCache::addData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors) {
     ElementsIndex positionsIndexes;
     positionsIndexes.first = m_Positions.end();
     m_Positions.insert(m_Positions.end(), positions.begin(), positions.end());
@@ -15,12 +15,12 @@ void VertexCache::addData(std::uint64_t index, std::vector<float> positions, std
     m_Colors.insert(m_Colors.end(), colors.begin(), colors.end());
     colorsIndexes.second = m_Colors.end() - 1;
 
-    m_Indexes.insert({index, {positionsIndexes, colorsIndexes}});
+    m_Indexes.insert({ index, {positionsIndexes, colorsIndexes} });
 }
 
-void VertexCache::removeData(std::uint64_t index){
+void VertexCache::removeData(std::uint64_t index) {
     auto it = m_Indexes.find(index);
-    if(it != m_Indexes.end()){
+    if (it != m_Indexes.end()) {
         DataIndex indexes = it->second;
         ElementsIndex positionsIndexes = indexes.first;
         ElementsIndex colorsIndexes = indexes.second;
@@ -32,13 +32,13 @@ void VertexCache::removeData(std::uint64_t index){
     }
 }
 
-void VertexCache::clear(){
+void VertexCache::clear() {
     m_Positions.clear();
     m_Colors.clear();
     m_Indexes.clear();
 }
 
-void VertexCache::updateVertexArray(){
+void VertexCache::updateVertexArray() {
     m_VertexArray = std::make_unique<GL::VertexArray>(m_Colors.size()); // one color per vertex
 
     GL::VertexBuffer positionsBuffer(m_Positions, 2);

src/render/WorldRenderer.cpp

@@ -62,7 +62,7 @@ void WorldRenderer::renderMobs() const {
 }
 
 void WorldRenderer::renderTowers() const {
-    if(!m_TowersCache.isEmpty())
+    if (!m_TowersCache.isEmpty())
         m_Renderer->renderVAO(m_TowersCache.getVertexArray());
 }
 
@@ -152,13 +152,13 @@ void WorldRenderer::detectClick() {
     }
 }
 
-void WorldRenderer::addTower(game::TowerPtr tower){
+void WorldRenderer::addTower(game::TowerPtr tower) {
     const WorldLoader::RenderData& renderData = WorldLoader::loadTowerModel(tower);
     m_TowersCache.addData(tower->getID(), renderData.positions, renderData.colors);
     m_TowersCache.updateVertexArray();
 }
 
-void WorldRenderer::removeTower(game::TowerPtr tower){
+void WorldRenderer::removeTower(game::TowerPtr tower) {
     m_TowersCache.removeData(tower->getID());
     m_TowersCache.updateVertexArray();
 }

src/render/gui/TowerGui.cpp

@@ -231,7 +231,7 @@ void capValues(int* values, int& value) {
     for (int j = 0; j < 16; j++) {
         total += values[j];
     }
-    if(total == 13)
+    if (total == 13)
         value--;
 }
 
@@ -278,7 +278,7 @@ void renderSummonMenu() {
             ImGui::PopID();
         }
         ImGui::PopItemWidth();
-        if(ImGui::Button("Send")){
+        if (ImGui::Button("Send")) {
             std::cout << "Sending Troops ...\n";
         }
         ImGui::End();

src/render/loader/WorldLoader.cpp

@@ -188,7 +188,7 @@ GL::VertexArray loadTileSelectModel() {
     return tileSelectVao;
 }
 
-RenderData loadTowerModel(game::TowerPtr tower){
+RenderData loadTowerModel(game::TowerPtr tower) {
     RenderData renderData;
 
     float towerX = tower->getX() - 1;