From 0856ca47ca96233c4162089dca675f5ebfe5a5d1 Mon Sep 17 00:00:00 2001 From: Persson-dev Date: Sun, 19 Sep 2021 17:33:16 +0200 Subject: [PATCH] refactor: format code --- include/game/BaseGame.h | 30 +-- include/game/Connexion.h | 4 +- include/game/GameManager.h | 2 +- include/game/Mobs.h | 74 +++---- include/game/Player.h | 26 +-- include/game/Team.h | 16 +- include/game/Towers.h | 126 ++++++------ include/game/Types.h | 2 +- include/game/World.h | 66 +++--- include/game/client/Client.h | 16 +- include/game/client/ClientConnexion.h | 8 +- include/game/client/ClientGame.h | 8 +- include/game/client/WorldClient.h | 2 +- include/game/server/Lobby.h | 2 +- include/game/server/Server.h | 34 ++-- include/game/server/ServerConnexion.h | 12 +- include/game/server/ServerGame.h | 6 +- include/game/server/ServerWorld.h | 2 +- include/misc/Easing.h | 2 +- include/misc/Time.h | 16 +- include/network/DataBuffer.h | 52 ++--- include/network/TCPListener.h | 10 +- include/protocol/PacketHandler.h | 46 ++--- include/protocol/Protocol.h | 272 ++++++++++++------------- include/render/WorldRenderer.h | 6 +- include/render/loader/GLLoader.h | 80 ++++---- include/render/loader/TextureLoader.h | 2 +- include/render/shaders/EntityShader.h | 6 +- include/render/shaders/ShaderProgram.h | 8 +- include/render/shaders/WorldShader.h | 4 +- include/window/Display.h | 2 +- src/Tower Defense.cpp | 4 +- src/game/BaseGame.cpp | 8 +- src/game/Connexion.cpp | 24 +-- src/game/Mobs.cpp | 16 +- src/game/Team.cpp | 14 +- src/game/Towers.cpp | 26 +-- src/game/World.cpp | 152 +++++++------- src/game/client/Client.cpp | 22 +- src/game/client/ClientConnexion.cpp | 16 +- src/game/client/ClientGame.cpp | 80 ++++---- src/game/client/TowersInfo.cpp | 2 +- src/game/client/WorldClient.cpp | 18 +- src/game/server/Lobby.cpp | 24 +-- src/game/server/Server.cpp | 44 ++-- src/game/server/ServerConnexion.cpp | 63 +++--- src/game/server/ServerGame.cpp | 24 +-- src/game/server/ServerWorld.cpp | 16 +- src/misc/Compression.cpp | 2 +- src/misc/Easing.cpp | 72 +++---- src/misc/Random.cpp | 4 +- src/misc/Time.cpp | 16 +- src/network/DataBuffer.cpp | 14 +- src/network/IPAddress.cpp | 12 +- src/network/Network.cpp | 4 +- src/network/Socket.cpp | 8 +- src/network/TCPListener.cpp | 22 +- src/network/TCPSocket.cpp | 14 +- src/protocol/PacketDispatcher.cpp | 10 +- src/protocol/PacketFactory.cpp | 6 +- src/protocol/Protocol.cpp | 139 +++++++------ src/render/Renderer.cpp | 46 ++--- src/render/WorldRenderer.cpp | 4 +- src/render/gui/TowerGui.cpp | 110 +++++----- src/render/loader/GLLoader.cpp | 96 ++++----- src/render/loader/TextureLoader.cpp | 10 +- src/render/loader/WorldLoader.cpp | 20 +- src/render/shaders/EntityShader.cpp | 16 +- src/render/shaders/ShaderProgram.cpp | 46 ++--- src/render/shaders/WorldShader.cpp | 14 +- src/window/Display.cpp | 32 +-- 71 files changed, 1102 insertions(+), 1110 deletions(-) diff --git a/include/game/BaseGame.h b/include/game/BaseGame.h index a2c7a99..660d218 100644 --- a/include/game/BaseGame.h +++ b/include/game/BaseGame.h @@ -7,7 +7,7 @@ namespace td { namespace game { -enum class GameState : std::uint8_t{ +enum class GameState : std::uint8_t { Lobby, Game, EndGame, @@ -16,10 +16,10 @@ enum class GameState : std::uint8_t{ typedef std::map PlayerList; -class Game{ +class Game { protected: World* m_World; - std::array m_Teams = {Team{TeamColor::Red}, Team{TeamColor::Blue}}; + std::array m_Teams = { Team{TeamColor::Red}, Team{TeamColor::Blue} }; GameState m_GameState = GameState::Lobby; PlayerList m_Players; public: @@ -28,23 +28,23 @@ public: virtual void tick(std::uint64_t delta); - Team& getRedTeam(){ return m_Teams[(std::uint8_t)TeamColor::Red]; } - const Team& getRedTeam() const{ return m_Teams[(std::uint8_t)TeamColor::Red]; } + Team& getRedTeam() { return m_Teams[(std::uint8_t)TeamColor::Red]; } + const Team& getRedTeam() const { return m_Teams[(std::uint8_t)TeamColor::Red]; } - Team& getBlueTeam(){ return m_Teams[(std::uint8_t)TeamColor::Blue]; } - const Team& getBlueTeam() const{ return m_Teams[(std::uint8_t)TeamColor::Blue]; } + Team& getBlueTeam() { return m_Teams[(std::uint8_t)TeamColor::Blue]; } + const Team& getBlueTeam() const { return m_Teams[(std::uint8_t)TeamColor::Blue]; } - Team& getTeam(TeamColor team){ return m_Teams[(std::uint8_t)team]; } - const Team& getTeam(TeamColor team) const{ return m_Teams[(std::uint8_t)team]; } + Team& getTeam(TeamColor team) { return m_Teams[(std::uint8_t)team]; } + const Team& getTeam(TeamColor team) const { return m_Teams[(std::uint8_t)team]; } - GameState getGameState() const{ return m_GameState; } - void setGameState(GameState gameState){ m_GameState = gameState; }; + GameState getGameState() const { return m_GameState; } + void setGameState(GameState gameState) { m_GameState = gameState; }; - const World* getWorld() const{ return m_World; } - World* getWorld(){ return m_World; } + const World* getWorld() const { return m_World; } + World* getWorld() { return m_World; } - const PlayerList& getPlayers() const{ return m_Players; } - PlayerList& getPlayers(){ return m_Players; } + const PlayerList& getPlayers() const { return m_Players; } + PlayerList& getPlayers() { return m_Players; } }; diff --git a/include/game/Connexion.h b/include/game/Connexion.h index 4ed8146..7578b49 100644 --- a/include/game/Connexion.h +++ b/include/game/Connexion.h @@ -8,7 +8,7 @@ namespace td { namespace protocol { -class Connexion : public protocol::PacketHandler{ +class Connexion : public protocol::PacketHandler { protected: protocol::PacketDispatcher m_Dispatcher; private: @@ -25,7 +25,7 @@ public: bool connect(const std::string& address, std::uint16_t port); - network::Socket::Status getSocketStatus() const{return m_Socket.GetStatus();} + network::Socket::Status getSocketStatus() const { return m_Socket.GetStatus(); } void sendPacket(protocol::Packet* packet); diff --git a/include/game/GameManager.h b/include/game/GameManager.h index 0f90815..00dc5be 100644 --- a/include/game/GameManager.h +++ b/include/game/GameManager.h @@ -8,7 +8,7 @@ #ifndef GAME_GAMEMANAGER_H_ #define GAME_GAMEMANAGER_H_ -namespace GameManager{ +namespace GameManager { void render(); void init(); diff --git a/include/game/Mobs.h b/include/game/Mobs.h index c84c2a8..f916479 100644 --- a/include/game/Mobs.h +++ b/include/game/Mobs.h @@ -9,7 +9,7 @@ namespace td { namespace game { -enum class EffectType : std::uint8_t{ +enum class EffectType : std::uint8_t { Slowness = 0, Stun, Fire, @@ -17,7 +17,7 @@ enum class EffectType : std::uint8_t{ Heal, }; -enum class MobType : std::uint8_t{ +enum class MobType : std::uint8_t { Zombie = 0, Spider, Skeleton, @@ -36,7 +36,7 @@ typedef std::uint8_t MobLevel; typedef std::vector TowerImmunities; typedef std::vector EffectImmunities; -class MobStats{ +class MobStats { private: float m_Damage; float m_Speed; @@ -47,24 +47,24 @@ private: public: MobStats(float damage, float speed, std::uint16_t moneyCost, std::uint16_t expCost, std::uint16_t maxLife, - std::uint16_t expReward): m_Damage(damage), m_Speed(speed), + std::uint16_t expReward) : m_Damage(damage), m_Speed(speed), m_MoneyCost(moneyCost), m_ExpCost(expCost), m_MaxLife(maxLife), - m_ExpReward(expReward){ + m_ExpReward(expReward) { } - float getDamage() const{ return m_Damage; } - float getMovementSpeed() const{ return m_Speed; } - std::uint16_t getMoneyCost() const{ return m_MoneyCost; } - std::uint16_t getExpCost() const{ return m_ExpCost; } - std::uint16_t getExpReward() const{ return m_ExpReward; } - std::uint16_t getMaxLife() const{ return m_MaxLife; } + float getDamage() const { return m_Damage; } + float getMovementSpeed() const { return m_Speed; } + std::uint16_t getMoneyCost() const { return m_MoneyCost; } + std::uint16_t getExpCost() const { return m_ExpCost; } + std::uint16_t getExpReward() const { return m_ExpReward; } + std::uint16_t getMaxLife() const { return m_MaxLife; } }; const MobStats* getMobStats(MobType type, std::uint8_t level); const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level); const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level); -class Mob{ +class Mob { protected: float m_Health; private: @@ -75,54 +75,54 @@ private: float m_X = 0, m_Y = 0; public: - Mob(MobID id, MobLevel level, PlayerID sender): m_Sender(sender), m_Level(level){ + Mob(MobID id, MobLevel level, PlayerID sender) : m_Sender(sender), m_Level(level) { } virtual MobType getType() const = 0; - virtual void tick(std::uint64_t delta){} + virtual void tick(std::uint64_t delta) {} - const TowerImmunities& getTowerImmunities() const{ return getMobTowerImmunities(getType(), m_Level); } - const EffectImmunities& getEffectImmunities() const{ return getMobEffectImmunities(getType(), m_Level); } - PlayerID getSender() const{ return m_Sender; } - MobLevel getLevel() const{ return m_Level; } - const MobStats* getStats() const{ return getMobStats(getType(), m_Level); } - float getHealth() const{ return m_Health; } - bool isAlive() const{ return m_Health > 0; } + const TowerImmunities& getTowerImmunities() const { return getMobTowerImmunities(getType(), m_Level); } + const EffectImmunities& getEffectImmunities() const { return getMobEffectImmunities(getType(), m_Level); } + PlayerID getSender() const { return m_Sender; } + MobLevel getLevel() const { return m_Level; } + const MobStats* getStats() const { return getMobStats(getType(), m_Level); } + float getHealth() const { return m_Health; } + bool isAlive() const { return m_Health > 0; } - void damage(float dmg){ m_Health -= dmg; } - void heal(float heal){ m_Health = std::min((float)getStats()->getMaxLife(), m_Health + heal); } + void damage(float dmg) { m_Health -= dmg; } + void heal(float heal) { m_Health = std::min((float)getStats()->getMaxLife(), m_Health + heal); } - float getX() const{ return m_X; } - void setX(float x){ m_X = x; } + float getX() const { return m_X; } + void setX(float x) { m_X = x; } - float getY() const{ return m_Y; } - void setY(float y){ m_Y = y; } + float getY() const { return m_Y; } + void setY(float y) { m_Y = y; } - Direction getDirection() const{ return m_Direction; } - void setDirection(Direction dir){ m_Direction = dir; } + Direction getDirection() const { return m_Direction; } + void setDirection(Direction dir) { m_Direction = dir; } protected: - void initHealth(){m_Health = (float)getStats()->getMaxLife();} + void initHealth() { m_Health = (float)getStats()->getMaxLife(); } }; typedef std::shared_ptr MobPtr; -class Zombie : public Mob{ +class Zombie : public Mob { public: - Zombie(MobID id, std::uint8_t level, PlayerID sender): Mob(id, level, sender){initHealth();} + Zombie(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); } - virtual MobType getType() const{ return MobType::Zombie; } + virtual MobType getType() const { return MobType::Zombie; } }; -class Spider : public Mob{ +class Spider : public Mob { public: - Spider(MobID id, std::uint8_t level, PlayerID sender): Mob(id, level, sender){initHealth();} + Spider(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); } - virtual MobType getType() const{ return MobType::Spider; } + virtual MobType getType() const { return MobType::Spider; } }; -namespace MobFactory{ +namespace MobFactory { MobPtr createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender); } diff --git a/include/game/Player.h b/include/game/Player.h index 990aa64..d22702c 100644 --- a/include/game/Player.h +++ b/include/game/Player.h @@ -5,10 +5,10 @@ #include "game/Team.h" -namespace td{ -namespace game{ +namespace td { +namespace game { -class Player{ +class Player { private: game::TeamColor m_TeamColor = game::TeamColor::None; @@ -19,21 +19,21 @@ private: std::uint8_t m_GoldPerSecond = 5; public: - Player(std::uint8_t id = 0) : m_ID(id){} + Player(std::uint8_t id = 0) : m_ID(id) {} - const std::string& getName() const{return m_Name;} - void setName(const std::string& name){m_Name = name;} + const std::string& getName() const { return m_Name; } + void setName(const std::string& name) { m_Name = name; } - game::TeamColor getTeamColor() const{return m_TeamColor;} - void setTeamColor(game::TeamColor teamColor){m_TeamColor = teamColor;} + game::TeamColor getTeamColor() const { return m_TeamColor; } + void setTeamColor(game::TeamColor teamColor) { m_TeamColor = teamColor; } - std::uint8_t getGoldPerSecond() const{ return m_GoldPerSecond;} - void setGoldPerSecond(std::uint8_t goldPerSecond){m_GoldPerSecond = goldPerSecond;} + std::uint8_t getGoldPerSecond() const { return m_GoldPerSecond; } + void setGoldPerSecond(std::uint8_t goldPerSecond) { m_GoldPerSecond = goldPerSecond; } - std::uint32_t getGold() const{ return m_Gold;} - void setGold(std::uint32_t gold){m_Gold = gold;} + std::uint32_t getGold() const { return m_Gold; } + void setGold(std::uint32_t gold) { m_Gold = gold; } - std::uint8_t getID() const{return m_ID;} + std::uint8_t getID() const { return m_ID; } }; } // namespace game diff --git a/include/game/Team.h b/include/game/Team.h index cf38d36..f2aafbb 100644 --- a/include/game/Team.h +++ b/include/game/Team.h @@ -11,23 +11,23 @@ namespace game { class Player; -enum class TeamColor : std::int8_t{ +enum class TeamColor : std::int8_t { None = -1, Red, Blue }; -struct Spawn{ +struct Spawn { Direction direction; std::int32_t x, y; }; -struct TeamCastle{ +struct TeamCastle { std::int32_t x, y; std::uint16_t life = 1000; }; -class Team{ +class Team { private: std::vector m_Players; TeamColor m_Color; @@ -41,11 +41,11 @@ public: TeamColor getColor() const; - const Spawn& getSpawn() const {return m_Spawn;} - Spawn& getSpawn() {return m_Spawn;} + const Spawn& getSpawn() const { return m_Spawn; } + Spawn& getSpawn() { return m_Spawn; } - const TeamCastle& getCastle() const {return m_TeamCastle;} - TeamCastle& getCastle() {return m_TeamCastle;} + const TeamCastle& getCastle() const { return m_TeamCastle; } + TeamCastle& getCastle() { return m_TeamCastle; } std::uint8_t getPlayerCount() const; }; diff --git a/include/game/Towers.h b/include/game/Towers.h index 7e9f9a6..d28a5cd 100644 --- a/include/game/Towers.h +++ b/include/game/Towers.h @@ -6,7 +6,7 @@ namespace td { namespace game { -enum class TowerType : std::uint8_t{ +enum class TowerType : std::uint8_t { Archer = 0, Ice, Sorcerer, @@ -23,49 +23,49 @@ enum class TowerType : std::uint8_t{ TowerCount }; -enum class TowerSize : bool{ +enum class TowerSize : bool { Little = 0, // 3x3 Big, // 5x5 }; -enum class TowerPath : std::uint8_t{ +enum class TowerPath : std::uint8_t { Top = 0, // Base path Bottom }; -class TowerStats{ +class TowerStats { private: float m_Rate; float m_Damage; std::uint8_t m_Range; public: - TowerStats(float rate, float damage, std::uint8_t range): m_Rate(rate), m_Damage(damage), - m_Range(range){ + TowerStats(float rate, float damage, std::uint8_t range) : m_Rate(rate), m_Damage(damage), + m_Range(range) { } - float getDamageRate() const{ return m_Rate; } - float getDamage() const{ return m_Damage; } - std::uint8_t getRange() const{ return m_Range; } + float getDamageRate() const { return m_Rate; } + float getDamage() const { return m_Damage; } + std::uint8_t getRange() const { return m_Range; } }; -class TowerLevel{ +class TowerLevel { private: // 1, 2, 3, 4 std::uint8_t m_Level : 3; // 0 : base path 1 : top path (if there is bottom path) 2 : bottom path (if there is top path) TowerPath m_Path : 1; public: - TowerLevel(): m_Level(1), m_Path(TowerPath::Top){} - TowerLevel(std::uint8_t level, TowerPath path): m_Level(level), m_Path(path){} + TowerLevel() : m_Level(1), m_Path(TowerPath::Top) {} + TowerLevel(std::uint8_t level, TowerPath path) : m_Level(level), m_Path(path) {} - std::uint8_t getLevel() const{ return m_Level; } - TowerPath getPath() const{ return m_Path; } + std::uint8_t getLevel() const { return m_Level; } + TowerPath getPath() const { return m_Path; } - void setLevel(std::uint8_t level){ m_Level = level; } - void setPath(TowerPath path){ m_Path = path; } + void setLevel(std::uint8_t level) { m_Level = level; } + void setPath(TowerPath path) { m_Path = path; } // operator to sort maps - friend bool operator<(const TowerLevel& level, const TowerLevel& other){ + friend bool operator<(const TowerLevel& level, const TowerLevel& other) { return level.getLevel() * static_cast(level.getPath()) < other.getLevel() * static_cast(other.getPath()); } @@ -73,140 +73,140 @@ public: const TowerStats* getTowerStats(TowerType type, TowerLevel level); -class Tower{ +class Tower { private: std::uint16_t m_X, m_Y; TowerLevel m_Level{}; protected: utils::Timer m_Timer; public: // converting seconds to millis - Tower(std::uint16_t x, std::uint16_t y): m_X(x), m_Y(y), m_Timer(getStats()->getDamageRate() * 1000){} + Tower(std::uint16_t x, std::uint16_t y) : m_X(x), m_Y(y), m_Timer(getStats()->getDamageRate() * 1000) {} virtual TowerType getType() const = 0; virtual TowerSize getSize() const = 0; virtual void tick(std::uint64_t delta) = 0; - void upgrade(std::uint8_t level, TowerPath path){ + void upgrade(std::uint8_t level, TowerPath path) { m_Level.setLevel(level); m_Level.setPath(path); } - std::uint16_t getX() const{ return m_X; } - std::uint16_t getY() const{ return m_Y; } - const TowerLevel& getLevel() const{ return m_Level; } - const TowerStats* getStats() const{ return getTowerStats(getType(), m_Level); } + std::uint16_t getX() const { return m_X; } + std::uint16_t getY() const { return m_Y; } + const TowerLevel& getLevel() const { return m_Level; } + const TowerStats* getStats() const { return getTowerStats(getType(), m_Level); } }; // ---------- Little Towers ---------- -class LittleTower : public Tower{ +class LittleTower : public Tower { public: - LittleTower(std::uint16_t x, std::uint16_t y): Tower(x, y){} + LittleTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {} - virtual TowerSize getSize() const{ return TowerSize::Little; } + virtual TowerSize getSize() const { return TowerSize::Little; } virtual TowerType getType() const = 0; virtual void tick(std::uint64_t delta) = 0; }; -class ArcherTower : public LittleTower{ +class ArcherTower : public LittleTower { public: - ArcherTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + ArcherTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Archer; } + virtual TowerType getType() const { return TowerType::Archer; } virtual void tick(std::uint64_t delta); }; -class IceTower : public LittleTower{ +class IceTower : public LittleTower { public: - IceTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + IceTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Ice; } + virtual TowerType getType() const { return TowerType::Ice; } virtual void tick(std::uint64_t delta); }; -class MageTower : public LittleTower{ +class MageTower : public LittleTower { public: - MageTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + MageTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Mage; } + virtual TowerType getType() const { return TowerType::Mage; } virtual void tick(std::uint64_t delta); }; -class PoisonTower : public LittleTower{ +class PoisonTower : public LittleTower { public: - PoisonTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + PoisonTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Poison; } + virtual TowerType getType() const { return TowerType::Poison; } virtual void tick(std::uint64_t delta); }; -class QuakeTower : public LittleTower{ +class QuakeTower : public LittleTower { public: - QuakeTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + QuakeTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Quake; } + virtual TowerType getType() const { return TowerType::Quake; } virtual void tick(std::uint64_t delta); }; -class ArtilleryTower : public LittleTower{ +class ArtilleryTower : public LittleTower { public: - ArtilleryTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + ArtilleryTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Artillery; } + virtual TowerType getType() const { return TowerType::Artillery; } virtual void tick(std::uint64_t delta); }; -class SorcererTower : public LittleTower{ +class SorcererTower : public LittleTower { public: - SorcererTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + SorcererTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Sorcerer; } + virtual TowerType getType() const { return TowerType::Sorcerer; } virtual void tick(std::uint64_t delta); }; -class ZeusTower : public LittleTower{ +class ZeusTower : public LittleTower { public: - ZeusTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} + ZeusTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Zeus; } + virtual TowerType getType() const { return TowerType::Zeus; } virtual void tick(std::uint64_t delta); }; // ---------- Big Towers ---------- -class BigTower : public Tower{ +class BigTower : public Tower { public: - BigTower(std::uint16_t x, std::uint16_t y): Tower(x, y){} + BigTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {} - virtual TowerSize getSize() const{ return TowerSize::Big; } + virtual TowerSize getSize() const { return TowerSize::Big; } virtual TowerType getType() const = 0; virtual void tick(std::uint64_t delta) = 0; }; -class TurretTower : public BigTower{ +class TurretTower : public BigTower { public: - TurretTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} + TurretTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Turret; } + virtual TowerType getType() const { return TowerType::Turret; } virtual void tick(std::uint64_t delta); }; -class NecromancerTower : public BigTower{ +class NecromancerTower : public BigTower { public: - NecromancerTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} + NecromancerTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Necromancer; } + virtual TowerType getType() const { return TowerType::Necromancer; } virtual void tick(std::uint64_t delta); }; -class LeachTower : public BigTower{ +class LeachTower : public BigTower { public: - LeachTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} + LeachTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {} - virtual TowerType getType() const{ return TowerType::Leach; } + virtual TowerType getType() const { return TowerType::Leach; } virtual void tick(std::uint64_t delta); }; diff --git a/include/game/Types.h b/include/game/Types.h index dea29b7..88f70c2 100644 --- a/include/game/Types.h +++ b/include/game/Types.h @@ -5,7 +5,7 @@ namespace td { namespace game { -enum class Direction : std::uint8_t{ +enum class Direction : std::uint8_t { PositiveX = 1 << 0, NegativeX = 1 << 1, PositiveY = 1 << 2, diff --git a/include/game/World.h b/include/game/World.h index 1578f4b..316afa9 100644 --- a/include/game/World.h +++ b/include/game/World.h @@ -7,15 +7,15 @@ #include "Mobs.h" #include "Team.h" -namespace td{ -namespace game{ - typedef std::pair ChunkCoord; +namespace td { +namespace game { +typedef std::pair ChunkCoord; } } -namespace std{ +namespace std { template <> -struct hash{ - std::size_t operator()(const td::game::ChunkCoord& key) const{ +struct hash { + std::size_t operator()(const td::game::ChunkCoord& key) const { // Compute individual hash values for first, // second and third and combine them using XOR // and bit shifting: @@ -37,7 +37,7 @@ namespace game { class Game; -enum class TileType : std::uint8_t{ +enum class TileType : std::uint8_t { None = 0, Tower, Walk, @@ -49,31 +49,31 @@ enum class TileType : std::uint8_t{ Ice,*/ }; -struct Color{ +struct Color { std::uint8_t r, g, b; }; -struct Tile{ +struct Tile { virtual TileType getType() const = 0; }; -struct TowerTile : Tile{ +struct TowerTile : Tile { std::uint8_t color_palette_ref; TeamColor team_owner; - virtual TileType getType() const{ return TileType::Tower; } + virtual TileType getType() const { return TileType::Tower; } }; -struct WalkableTile : Tile{ +struct WalkableTile : Tile { Direction direction; - virtual TileType getType() const{ return TileType::Walk; } + virtual TileType getType() const { return TileType::Walk; } }; -struct DecorationTile : Tile{ +struct DecorationTile : Tile { std::uint16_t color_palette_ref; - virtual TileType getType() const{ return TileType::Decoration; } + virtual TileType getType() const { return TileType::Decoration; } }; typedef std::shared_ptr TilePtr; @@ -85,15 +85,15 @@ typedef std::array ChunkData; typedef std::uint32_t TileIndex; //32 x 32 area -struct Chunk{ - enum{ ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight }; +struct Chunk { + enum { ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight }; // stores index of tile palette - ChunkData tiles{0}; + ChunkData tiles{ 0 }; ChunkPalette palette; - TileIndex getTileIndex(std::uint16_t tileNumber) const{ + TileIndex getTileIndex(std::uint16_t tileNumber) const { TileIndex chunkPaletteIndex = tiles.at(tileNumber); - if(chunkPaletteIndex == 0) // index 0 means empty tile index 1 = first tile + if (chunkPaletteIndex == 0) // index 0 means empty tile index 1 = first tile return 0; return palette.at(chunkPaletteIndex); } @@ -110,7 +110,7 @@ typedef std::vector MobList; typedef std::array SpawnColorPalette; -class World{ +class World { protected: TowerTileColorPalette m_TowerPlacePalette; Color m_WalkablePalette; @@ -123,7 +123,7 @@ protected: TilePalette m_TilePalette; MobList m_Mobs; - + Game* m_Game; public: World(Game* game); @@ -140,25 +140,25 @@ public: TilePtr getTile(std::int32_t x, std::int32_t y); - const TowerTileColorPalette& getTowerTileColorPalette() const{ return m_TowerPlacePalette; } - const Color& getWalkableTileColor() const{ return m_WalkablePalette; } - const std::vector& getDecorationPalette() const{ return m_DecorationPalette; } + const TowerTileColorPalette& getTowerTileColorPalette() const { return m_TowerPlacePalette; } + const Color& getWalkableTileColor() const { return m_WalkablePalette; } + const std::vector& getDecorationPalette() const { return m_DecorationPalette; } - const TilePalette& getTilePalette() const{ return m_TilePalette; } + const TilePalette& getTilePalette() const { return m_TilePalette; } - TilePtr getTilePtr(TileIndex index) const{ - if(index == 0) + TilePtr getTilePtr(TileIndex index) const { + if (index == 0) return nullptr; return m_TilePalette.at(index - 1); } - const std::unordered_map& getChunks() const{ return m_Chunks; } + const std::unordered_map& getChunks() const { return m_Chunks; } - const Color& getSpawnColor(TeamColor color) const{ return m_SpawnColorPalette[(std::size_t) color]; } - const SpawnColorPalette& getSpawnColors() const{ return m_SpawnColorPalette; } + const Color& getSpawnColor(TeamColor color) const { return m_SpawnColorPalette[(std::size_t)color]; } + const SpawnColorPalette& getSpawnColors() const { return m_SpawnColorPalette; } - const MobList& getMobList() const{ return m_Mobs; } - MobList& getMobList(){ return m_Mobs; } + const MobList& getMobList() const { return m_Mobs; } + MobList& getMobList() { return m_Mobs; } const Color* getTileColor(TilePtr tile) const; diff --git a/include/game/client/Client.h b/include/game/client/Client.h index d456df2..703d3b6 100644 --- a/include/game/client/Client.h +++ b/include/game/client/Client.h @@ -11,21 +11,21 @@ namespace td { namespace client { -class Client{ +class Client { private: render::Renderer* m_Renderer; ClientConnexion m_Connexion; ClientGame m_Game; bool m_Connected; public: - Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(this), m_Connected(false){} + Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(this), m_Connected(false) {} - const ClientGame& getGame() const{ return m_Game; } - const ClientConnexion& getConnexion() const{ return m_Connexion; } - render::Renderer* getRenderer() const {return m_Renderer;} + const ClientGame& getGame() const { return m_Game; } + const ClientConnexion& getConnexion() const { return m_Connexion; } + render::Renderer* getRenderer() const { return m_Renderer; } - ClientGame& getGame(){ return m_Game; } - ClientConnexion& getConnexion(){ return m_Connexion; } + ClientGame& getGame() { return m_Game; } + ClientConnexion& getConnexion() { return m_Connexion; } void tick(std::uint64_t delta); @@ -34,7 +34,7 @@ public: void connect(const std::string& address, std::uint16_t port); void closeConnection(); - bool isConnected() const{ return m_Connexion.getSocketStatus() == network::Socket::Connected; } + bool isConnected() const { return m_Connexion.getSocketStatus() == network::Socket::Connected; } void selectTeam(game::TeamColor team); }; diff --git a/include/game/client/ClientConnexion.h b/include/game/client/ClientConnexion.h index 5c1f985..a7e1869 100644 --- a/include/game/client/ClientConnexion.h +++ b/include/game/client/ClientConnexion.h @@ -7,7 +7,7 @@ namespace td { namespace client { -class ClientConnexion : public protocol::Connexion{ +class ClientConnexion : public protocol::Connexion { private: std::uint8_t m_ConnectionID; std::string m_DisconnectReason; @@ -23,9 +23,9 @@ public: virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(protocol::ServerTpsPacket* packet); - const std::string& getDisconnectReason() const{ return m_DisconnectReason; } - float getServerTPS() const{ return m_ServerTPS; } - int getServerPing() const {return m_Ping;} + const std::string& getDisconnectReason() const { return m_DisconnectReason; } + float getServerTPS() const { return m_ServerTPS; } + int getServerPing() const { return m_Ping; } REMOVE_COPY(ClientConnexion); private: diff --git a/include/game/client/ClientGame.h b/include/game/client/ClientGame.h index 3cab147..cffaa9e 100644 --- a/include/game/client/ClientGame.h +++ b/include/game/client/ClientGame.h @@ -14,7 +14,7 @@ namespace client { class Client; -class ClientGame : public protocol::PacketHandler, public game::Game{ +class ClientGame : public protocol::PacketHandler, public game::Game { private: Client* m_Client; std::uint8_t m_ConnexionID; @@ -31,10 +31,10 @@ public: void renderWorld(); - std::uint32_t getLobbyTime() const{return m_LobbyTime;} - const game::Player* getPlayer() const{return m_Player;} + std::uint32_t getLobbyTime() const { return m_LobbyTime; } + const game::Player* getPlayer() const { return m_Player; } - render::Renderer* getRenderer() const {return m_Renderer;} + render::Renderer* getRenderer() const { return m_Renderer; } void PlaceTower(game::TowerType type, const glm::vec2& position); diff --git a/include/game/client/WorldClient.h b/include/game/client/WorldClient.h index fef9edc..eb23691 100644 --- a/include/game/client/WorldClient.h +++ b/include/game/client/WorldClient.h @@ -8,7 +8,7 @@ namespace client { class ClientGame; -class WorldClient : public game::World, public protocol::PacketHandler{ +class WorldClient : public game::World, public protocol::PacketHandler { private: ClientGame* m_Game; public: diff --git a/include/game/server/Lobby.h b/include/game/server/Lobby.h index bfccb07..eab34e6 100644 --- a/include/game/server/Lobby.h +++ b/include/game/server/Lobby.h @@ -9,7 +9,7 @@ namespace server { class Server; -class Lobby{ +class Lobby { private: Server* m_Server; bool m_GameStarted = false; diff --git a/include/game/server/Server.h b/include/game/server/Server.h index 03aecb3..cfc2a02 100644 --- a/include/game/server/Server.h +++ b/include/game/server/Server.h @@ -22,23 +22,23 @@ namespace server { typedef std::map ConnexionMap; -class TickCounter{ +class TickCounter { private: float m_TPS; std::uint64_t m_LastTPSTime; std::uint8_t m_TickCount; public: - TickCounter(){} + TickCounter() {} - void reset(){ + void reset() { m_TPS = SERVER_TPS; m_LastTPSTime = utils::getTime(); m_TickCount = 0; } - bool update(){ // return true when tps is updated + bool update() { // return true when tps is updated m_TickCount++; - if (m_TickCount >= SERVER_TPS){ + if (m_TickCount >= SERVER_TPS) { std::uint64_t timeElapsedSinceLast20Ticks = td::utils::getTime() - m_LastTPSTime; m_TPS = (float)SERVER_TPS / (float)(timeElapsedSinceLast20Ticks / 1000.0f); m_TickCount = 0; @@ -48,19 +48,19 @@ public: return false; } - float getTPS() const{ return m_TPS; } + float getTPS() const { return m_TPS; } }; -class Server{ +class Server { private: network::TCPListener m_Listener; ConnexionMap m_Connections; - ServerGame m_Game{this}; - Lobby m_Lobby{this}; + ServerGame m_Game{ this }; + Lobby m_Lobby{ this }; TickCounter m_TickCounter; public: Server(const std::string& worldFilePath); - virtual ~Server(){} + virtual ~Server() {} bool start(std::uint16_t port); void tick(std::uint64_t delta); @@ -72,17 +72,17 @@ public: void broadcastPacket(protocol::Packet* packet); - float getTPS() const{ return m_TickCounter.getTPS(); } + float getTPS() const { return m_TickCounter.getTPS(); } - const ServerGame& getGame() const{ return m_Game; } + const ServerGame& getGame() const { return m_Game; } ServerGame& getGame() { return m_Game; } - const Lobby& getLobby() const{ return m_Lobby; } - const ConnexionMap& getConnexions() const{ return m_Connections; } - ConnexionMap& getConnexions(){ return m_Connections; } + const Lobby& getLobby() const { return m_Lobby; } + const ConnexionMap& getConnexions() const { return m_Connections; } + ConnexionMap& getConnexions() { return m_Connections; } - const game::PlayerList& getPlayers() const{ return m_Game.getPlayers(); } - game::PlayerList& getPlayers(){ return m_Game.getPlayers(); } + const game::PlayerList& getPlayers() const { return m_Game.getPlayers(); } + game::PlayerList& getPlayers() { return m_Game.getPlayers(); } private: void accept(); diff --git a/include/game/server/ServerConnexion.h b/include/game/server/ServerConnexion.h index 72de88f..841be8e 100644 --- a/include/game/server/ServerConnexion.h +++ b/include/game/server/ServerConnexion.h @@ -6,8 +6,8 @@ #include "game/Player.h" #include "game/Connexion.h" -namespace td{ -namespace server{ +namespace td { +namespace server { class Server; @@ -19,7 +19,7 @@ struct KeepAlive }; -class ServerConnexion : public protocol::Connexion{ +class ServerConnexion : public protocol::Connexion { private: Server* m_Server = nullptr; std::uint8_t m_ID; @@ -39,9 +39,9 @@ public: virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(protocol::PlaceTowerPacket* packet); - std::uint8_t getID() const{return m_ID;} - const game::Player* getPlayer() const{return m_Player;} - game::Player* getPlayer() {return m_Player;} + std::uint8_t getID() const { return m_ID; } + const game::Player* getPlayer() const { return m_Player; } + game::Player* getPlayer() { return m_Player; } virtual bool updateSocket(); diff --git a/include/game/server/ServerGame.h b/include/game/server/ServerGame.h index 0b84bd9..f32cc1a 100644 --- a/include/game/server/ServerGame.h +++ b/include/game/server/ServerGame.h @@ -9,14 +9,14 @@ namespace server { class Server; -class ServerGame : public game::Game{ +class ServerGame : public game::Game { private: Server* m_Server; ServerWorld m_ServerWorld; - utils::Timer m_GoldMineTimer{1000, std::bind(&ServerGame::updateGoldMines, this)}; + utils::Timer m_GoldMineTimer{ 1000, std::bind(&ServerGame::updateGoldMines, this) }; public: ServerGame(Server* server); - ~ServerGame(){} + ~ServerGame() {} virtual void tick(std::uint64_t delta); void startGame(); diff --git a/include/game/server/ServerWorld.h b/include/game/server/ServerWorld.h index 5ae17b4..f3e9094 100644 --- a/include/game/server/ServerWorld.h +++ b/include/game/server/ServerWorld.h @@ -8,7 +8,7 @@ namespace server { class Server; class ServerGame; -class ServerWorld : public game::World{ +class ServerWorld : public game::World { private: game::MobID m_CurrentMobID; Server* m_Server; diff --git a/include/misc/Easing.h b/include/misc/Easing.h index 2ceb70b..ec63577 100644 --- a/include/misc/Easing.h +++ b/include/misc/Easing.h @@ -1,7 +1,7 @@ #pragma once namespace td { -namespace utils{ +namespace utils { constexpr float PI = 3.14159274101257324219; diff --git a/include/misc/Time.h b/include/misc/Time.h index 9b38b74..8c02c0c 100644 --- a/include/misc/Time.h +++ b/include/misc/Time.h @@ -12,7 +12,7 @@ std::uint64_t getTime(); typedef std::function TimerExecFunction; // utililty class to call function at regular period of time -class Timer{ +class Timer { private: std::uint64_t m_Interval; TimerExecFunction m_Function; @@ -20,20 +20,20 @@ private: std::uint64_t m_LastTime = getTime(); std::uint64_t m_InternalTime = 0; public: - Timer() : m_Interval(0), m_Function(nullptr){} - Timer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr){} - Timer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback){} + Timer() : m_Interval(0), m_Function(nullptr) {} + Timer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr) {} + Timer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback) {} void update(); void update(std::uint64_t delta); void reset(); - void setInterval(std::uint64_t newInterval){m_Interval = newInterval;} - std::uint64_t getInterval() const{return m_Interval;} + void setInterval(std::uint64_t newInterval) { m_Interval = newInterval; } + std::uint64_t getInterval() const { return m_Interval; } - void setCallbackFunction(TimerExecFunction newCallback){m_Function = newCallback;} - TimerExecFunction getCallbackFunction() const{return m_Function;} + void setCallbackFunction(TimerExecFunction newCallback) { m_Function = newCallback; } + TimerExecFunction getCallbackFunction() const { return m_Function; } }; diff --git a/include/network/DataBuffer.h b/include/network/DataBuffer.h index 7160d14..a40cfda 100644 --- a/include/network/DataBuffer.h +++ b/include/network/DataBuffer.h @@ -7,9 +7,9 @@ #include #include -namespace td{ +namespace td { -class DataBuffer{ +class DataBuffer { private: typedef std::vector Data; Data m_Buffer; @@ -31,7 +31,7 @@ public: DataBuffer& operator=(DataBuffer&& other); template - void Append(T data){ + void Append(T data) { std::size_t size = sizeof(data); std::size_t end_pos = m_Buffer.size(); m_Buffer.resize(m_Buffer.size() + size); @@ -39,30 +39,30 @@ public: } template - DataBuffer& operator<<(T data){ + DataBuffer& operator<<(T data) { // Switch to big endian //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T)); Append(data); return *this; } - DataBuffer& operator<<(std::string str){ - m_Buffer.insert(m_Buffer.end(), str.begin(), str.end()); + DataBuffer& operator<<(std::string str) { + m_Buffer.insert(m_Buffer.end(), str.begin(), str.end()); return *this; } - DataBuffer& operator<<(DataBuffer& data){ + DataBuffer& operator<<(DataBuffer& data) { m_Buffer.insert(m_Buffer.end(), data.begin(), data.end()); return *this; } - DataBuffer& operator<<(const DataBuffer& data){ + DataBuffer& operator<<(const DataBuffer& data) { m_Buffer.insert(m_Buffer.end(), data.begin(), data.end()); return *this; } template - DataBuffer& operator>>(T& data){ + DataBuffer& operator>>(T& data) { assert(m_ReadOffset + sizeof(T) <= GetSize()); data = *(T*)&m_Buffer[m_ReadOffset]; //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T)); @@ -70,77 +70,77 @@ public: return *this; } - DataBuffer& operator>>(DataBuffer& data){ + DataBuffer& operator>>(DataBuffer& data) { data.Resize(GetSize() - m_ReadOffset); std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.end(), data.begin()); m_ReadOffset = m_Buffer.size(); return *this; } - DataBuffer& operator>>(std::string& str){ - std::size_t stringSize = strlen((const char*) m_Buffer.data() + m_ReadOffset) + 1; // including null character + DataBuffer& operator>>(std::string& str) { + std::size_t stringSize = strlen((const char*)m_Buffer.data() + m_ReadOffset) + 1; // including null character str.resize(stringSize); std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.begin() + m_ReadOffset + stringSize, str.begin()); m_ReadOffset += stringSize; return *this; } - void ReadSome(char* buffer, std::size_t amount){ + void ReadSome(char* buffer, std::size_t amount) { assert(m_ReadOffset + amount <= GetSize()); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer); m_ReadOffset += amount; } - void ReadSome(std::uint8_t* buffer, std::size_t amount){ + void ReadSome(std::uint8_t* buffer, std::size_t amount) { assert(m_ReadOffset + amount <= GetSize()); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer); m_ReadOffset += amount; } - void ReadSome(DataBuffer& buffer, std::size_t amount){ + void ReadSome(DataBuffer& buffer, std::size_t amount) { assert(m_ReadOffset + amount <= GetSize()); buffer.Resize(amount); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin()); m_ReadOffset += amount; } - void ReadSome(std::string& buffer, std::size_t amount){ + void ReadSome(std::string& buffer, std::size_t amount) { assert(m_ReadOffset + amount <= GetSize()); buffer.resize(amount); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin()); m_ReadOffset += amount; } - void Resize(std::size_t size){ + void Resize(std::size_t size) { m_Buffer.resize(size); } - void Reserve(std::size_t amount){ + void Reserve(std::size_t amount) { m_Buffer.reserve(amount); } - void erase(iterator it){ + void erase(iterator it) { m_Buffer.erase(it); } - void Clear(){ + void Clear() { m_Buffer.clear(); m_ReadOffset = 0; } - bool IsFinished() const{ + bool IsFinished() const { return m_ReadOffset >= m_Buffer.size(); } - std::uint8_t* data(){ + std::uint8_t* data() { return m_Buffer.data(); } - const std::uint8_t* data() const{ + const std::uint8_t* data() const { return m_Buffer.data(); } - std::size_t GetReadOffset() const{ return m_ReadOffset; } + std::size_t GetReadOffset() const { return m_ReadOffset; } void SetReadOffset(std::size_t pos); std::string ToString() const; @@ -153,8 +153,8 @@ public: const_iterator begin() const; const_iterator end() const; - reference operator[](Data::size_type i){ return m_Buffer[i]; } - const_reference operator[](Data::size_type i) const{ return m_Buffer[i]; } + reference operator[](Data::size_type i) { return m_Buffer[i]; } + const_reference operator[](Data::size_type i) const { return m_Buffer[i]; } bool ReadFile(const std::string& fileName); bool WriteFile(const std::string& fileName); diff --git a/include/network/TCPListener.h b/include/network/TCPListener.h index 0b6cf9c..f9c91d8 100644 --- a/include/network/TCPListener.h +++ b/include/network/TCPListener.h @@ -1,10 +1,10 @@ #pragma once #include "TCPSocket.h" -namespace td{ -namespace network{ +namespace td { +namespace network { -class TCPListener{ +class TCPListener { int m_Handle; std::uint16_t m_Port; int m_MaxConnections; @@ -20,10 +20,10 @@ public: bool close(); bool setBlocking(bool blocking); - std::uint16_t getListeningPort() const{ + std::uint16_t getListeningPort() const { return m_Port; } - int getMaximumConnections() const{ + int getMaximumConnections() const { return m_MaxConnections; } diff --git a/include/protocol/PacketHandler.h b/include/protocol/PacketHandler.h index b890f1e..2d12deb 100644 --- a/include/protocol/PacketHandler.h +++ b/include/protocol/PacketHandler.h @@ -7,34 +7,34 @@ namespace protocol { class PacketDispatcher; -class PacketHandler{ +class PacketHandler { private: PacketDispatcher* m_Dispatcher; public: - PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher){} - virtual ~PacketHandler(){} + PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher) {} + virtual ~PacketHandler() {} - PacketDispatcher* GetDispatcher(){return m_Dispatcher;} + PacketDispatcher* GetDispatcher() { return m_Dispatcher; } - virtual void HandlePacket(PlayerLoginPacket* packet){} - virtual void HandlePacket(WorldBeginDataPacket* packet){} - virtual void HandlePacket(WorldDataPacket* packet){} - virtual void HandlePacket(KeepAlivePacket* packet){} - virtual void HandlePacket(UpdateMoneyPacket* packet){} - virtual void HandlePacket(UpdateExpPacket* packet){} - virtual void HandlePacket(UpdateLobbyTimePacket* packet){} - virtual void HandlePacket(UpdateGameStatePacket* packet){} - virtual void HandlePacket(PlayerListPacket* packet){} - virtual void HandlePacket(PlayerJoinPacket* packet){} - virtual void HandlePacket(PlayerLeavePacket* packet){} - virtual void HandlePacket(ConnexionInfoPacket* packet){} - virtual void HandlePacket(SelectTeamPacket* packet){} - virtual void HandlePacket(UpdatePlayerTeamPacket* packet){} - virtual void HandlePacket(DisconnectPacket* packet){} - virtual void HandlePacket(ServerTpsPacket* packet){} - virtual void HandlePacket(SpawnMobPacket* packet){} - virtual void HandlePacket(PlaceTowerPacket* packet){} - virtual void HandlePacket(WorldAddTowerPacket* packet){} + virtual void HandlePacket(PlayerLoginPacket* packet) {} + virtual void HandlePacket(WorldBeginDataPacket* packet) {} + virtual void HandlePacket(WorldDataPacket* packet) {} + virtual void HandlePacket(KeepAlivePacket* packet) {} + virtual void HandlePacket(UpdateMoneyPacket* packet) {} + virtual void HandlePacket(UpdateExpPacket* packet) {} + virtual void HandlePacket(UpdateLobbyTimePacket* packet) {} + virtual void HandlePacket(UpdateGameStatePacket* packet) {} + virtual void HandlePacket(PlayerListPacket* packet) {} + virtual void HandlePacket(PlayerJoinPacket* packet) {} + virtual void HandlePacket(PlayerLeavePacket* packet) {} + virtual void HandlePacket(ConnexionInfoPacket* packet) {} + virtual void HandlePacket(SelectTeamPacket* packet) {} + virtual void HandlePacket(UpdatePlayerTeamPacket* packet) {} + virtual void HandlePacket(DisconnectPacket* packet) {} + virtual void HandlePacket(ServerTpsPacket* packet) {} + virtual void HandlePacket(SpawnMobPacket* packet) {} + virtual void HandlePacket(PlaceTowerPacket* packet) {} + virtual void HandlePacket(WorldAddTowerPacket* packet) {} }; } // namespace protocol diff --git a/include/protocol/Protocol.h b/include/protocol/Protocol.h index b6bab4b..da181ca 100644 --- a/include/protocol/Protocol.h +++ b/include/protocol/Protocol.h @@ -9,7 +9,7 @@ namespace protocol { class PacketHandler; -enum class PacketType : std::uint8_t{ +enum class PacketType : std::uint8_t { PlayerLogin = 0, PlayerJoin, PlayerLeave, @@ -32,55 +32,55 @@ enum class PacketType : std::uint8_t{ WorldAddTower }; -class Packet{ +class Packet { public: - Packet(){} - virtual ~Packet(){} + Packet() {} + virtual ~Packet() {} virtual DataBuffer Serialize() const = 0; virtual void Deserialize(DataBuffer& data) = 0; virtual void Dispatch(PacketHandler* handler) = 0; virtual PacketType getType() const = 0; - std::uint8_t getID() const{ return (std::uint8_t)getType(); } + std::uint8_t getID() const { return (std::uint8_t)getType(); } }; -class KeepAlivePacket : public Packet{ +class KeepAlivePacket : public Packet { private: std::uint64_t m_AliveID; public: - KeepAlivePacket(){} - KeepAlivePacket(std::uint64_t aliveID): m_AliveID(aliveID){} - virtual ~KeepAlivePacket(){} + KeepAlivePacket() {} + KeepAlivePacket(std::uint64_t aliveID) : m_AliveID(aliveID) {} + virtual ~KeepAlivePacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - std::uint64_t getAliveID(){ return m_AliveID; } + std::uint64_t getAliveID() { return m_AliveID; } - virtual PacketType getType() const{ return PacketType::KeepAlive; } + virtual PacketType getType() const { return PacketType::KeepAlive; } }; -class PlayerLoginPacket : public Packet{ +class PlayerLoginPacket : public Packet { private: std::string m_PlayerName; public: - PlayerLoginPacket(){} - PlayerLoginPacket(std::string playerName): m_PlayerName(playerName){} - virtual ~PlayerLoginPacket(){} + PlayerLoginPacket() {} + PlayerLoginPacket(std::string playerName) : m_PlayerName(playerName) {} + virtual ~PlayerLoginPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - virtual PacketType getType() const{ return PacketType::PlayerLogin; } + virtual PacketType getType() const { return PacketType::PlayerLogin; } - const std::string& getPlayerName(){ return m_PlayerName; } + const std::string& getPlayerName() { return m_PlayerName; } }; -class WorldBeginDataPacket : public Packet{ +class WorldBeginDataPacket : public Packet { private: game::TowerTileColorPalette m_TowerPlacePalette; game::Color m_WalkablePalette; @@ -95,264 +95,264 @@ private: const game::World* m_World; public: - WorldBeginDataPacket(){} - WorldBeginDataPacket(const game::World* world): m_World(world){} - virtual ~WorldBeginDataPacket(){} + WorldBeginDataPacket() {} + WorldBeginDataPacket(const game::World* world) : m_World(world) {} + virtual ~WorldBeginDataPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - virtual PacketType getType() const{ return PacketType::WorldBeginData; } + virtual PacketType getType() const { return PacketType::WorldBeginData; } - const game::TowerTileColorPalette& getTowerTilePalette() const{ return m_TowerPlacePalette; } - const game::Color& getWalkableTileColor() const{ return m_WalkablePalette; } - const std::vector& getDecorationPalette() const{ return m_DecorationPalette; } + const game::TowerTileColorPalette& getTowerTilePalette() const { return m_TowerPlacePalette; } + const game::Color& getWalkableTileColor() const { return m_WalkablePalette; } + const std::vector& getDecorationPalette() const { return m_DecorationPalette; } - const game::Spawn& getRedSpawn() const{ return m_RedSpawn; } - const game::Spawn& getBlueSpawn() const{ return m_BlueSpawn; } + const game::Spawn& getRedSpawn() const { return m_RedSpawn; } + const game::Spawn& getBlueSpawn() const { return m_BlueSpawn; } - const game::SpawnColorPalette& getSpawnPalette() const{ return m_SpawnColorPalette; } + const game::SpawnColorPalette& getSpawnPalette() const { return m_SpawnColorPalette; } - const game::TeamCastle& getRedCastle() const{ return m_RedTower; } - const game::TeamCastle& getBlueCastle() const{ return m_BlueTower; } + const game::TeamCastle& getRedCastle() const { return m_RedTower; } + const game::TeamCastle& getBlueCastle() const { return m_BlueTower; } - const game::TilePalette getTilePalette() const{ return m_TilePalette; } + const game::TilePalette getTilePalette() const { return m_TilePalette; } }; -class WorldDataPacket : public Packet{ +class WorldDataPacket : public Packet { private: std::unordered_map m_Chunks; const game::World* m_World; public: - WorldDataPacket(){} - WorldDataPacket(const game::World* world): m_World(world){} - virtual ~WorldDataPacket(){} + WorldDataPacket() {} + WorldDataPacket(const game::World* world) : m_World(world) {} + virtual ~WorldDataPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - virtual PacketType getType() const{ return PacketType::WorldData; } + virtual PacketType getType() const { return PacketType::WorldData; } - const std::unordered_map& getChunks() const{ return m_Chunks; } + const std::unordered_map& getChunks() const { return m_Chunks; } }; -class UpdateMoneyPacket : public Packet{ +class UpdateMoneyPacket : public Packet { private: std::uint32_t m_NewAmount; public: - UpdateMoneyPacket(){} - UpdateMoneyPacket(std::uint32_t newAmount): m_NewAmount(newAmount){} - virtual ~UpdateMoneyPacket(){} + UpdateMoneyPacket() {} + UpdateMoneyPacket(std::uint32_t newAmount) : m_NewAmount(newAmount) {} + virtual ~UpdateMoneyPacket() {} - std::uint32_t getGold() const{ return m_NewAmount; } + std::uint32_t getGold() const { return m_NewAmount; } virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - virtual PacketType getType() const{ return PacketType::UpdateMoney; } + virtual PacketType getType() const { return PacketType::UpdateMoney; } }; -class UpdateExpPacket : public Packet{ +class UpdateExpPacket : public Packet { private: std::uint32_t m_NewAmount; public: - UpdateExpPacket(){} - UpdateExpPacket(std::uint32_t newAmount): m_NewAmount(newAmount){} - virtual ~UpdateExpPacket(){} + UpdateExpPacket() {} + UpdateExpPacket(std::uint32_t newAmount) : m_NewAmount(newAmount) {} + virtual ~UpdateExpPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - virtual PacketType getType() const{ return PacketType::UpdateEXP; } + virtual PacketType getType() const { return PacketType::UpdateEXP; } }; -class UpdateLobbyTimePacket : public Packet{ +class UpdateLobbyTimePacket : public Packet { private: std::uint32_t m_RemainingTime; public: - UpdateLobbyTimePacket(){} - UpdateLobbyTimePacket(std::uint32_t remainingTime): m_RemainingTime(remainingTime){} - virtual ~UpdateLobbyTimePacket(){} + UpdateLobbyTimePacket() {} + UpdateLobbyTimePacket(std::uint32_t remainingTime) : m_RemainingTime(remainingTime) {} + virtual ~UpdateLobbyTimePacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - std::uint32_t getRemainingTime() const{ return m_RemainingTime; } + std::uint32_t getRemainingTime() const { return m_RemainingTime; } - virtual PacketType getType() const{ return PacketType::UpdateLobbyTime; } + virtual PacketType getType() const { return PacketType::UpdateLobbyTime; } }; -class UpdateGameStatePacket : public Packet{ +class UpdateGameStatePacket : public Packet { private: game::GameState m_GameState; public: - UpdateGameStatePacket(){} - UpdateGameStatePacket(game::GameState gameState): m_GameState(gameState){} - virtual ~UpdateGameStatePacket(){} + UpdateGameStatePacket() {} + UpdateGameStatePacket(game::GameState gameState) : m_GameState(gameState) {} + virtual ~UpdateGameStatePacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - game::GameState getGameState() const{ return m_GameState; } + game::GameState getGameState() const { return m_GameState; } - virtual PacketType getType() const{ return PacketType::UpdateGameState; } + virtual PacketType getType() const { return PacketType::UpdateGameState; } }; -struct PlayerInfo{ +struct PlayerInfo { std::string name; game::TeamColor team; }; -class PlayerListPacket : public Packet{ +class PlayerListPacket : public Packet { private: std::map m_Players; public: - PlayerListPacket(){} - PlayerListPacket(std::map players): m_Players(players){} - virtual ~PlayerListPacket(){} + PlayerListPacket() {} + PlayerListPacket(std::map players) : m_Players(players) {} + virtual ~PlayerListPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - const std::map& getPlayers() const{ return m_Players; } + const std::map& getPlayers() const { return m_Players; } - virtual PacketType getType() const{ return PacketType::PlayerList; } + virtual PacketType getType() const { return PacketType::PlayerList; } }; -class PlayerJoinPacket : public Packet{ +class PlayerJoinPacket : public Packet { private: std::uint8_t m_PlayerID; std::string m_PlayerName; public: - PlayerJoinPacket(){} - PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName): m_PlayerID(playerID), m_PlayerName(playerName){} - virtual ~PlayerJoinPacket(){} + PlayerJoinPacket() {} + PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName) : m_PlayerID(playerID), m_PlayerName(playerName) {} + virtual ~PlayerJoinPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - std::uint8_t getPlayerID() const{ return m_PlayerID; } - const std::string& getPlayerName() const{ return m_PlayerName; } + std::uint8_t getPlayerID() const { return m_PlayerID; } + const std::string& getPlayerName() const { return m_PlayerName; } - virtual PacketType getType() const{ return PacketType::PlayerJoin; } + virtual PacketType getType() const { return PacketType::PlayerJoin; } }; -class PlayerLeavePacket : public Packet{ +class PlayerLeavePacket : public Packet { private: std::uint8_t m_PlayerID; public: - PlayerLeavePacket(){} - PlayerLeavePacket(std::uint8_t playerID): m_PlayerID(playerID){} - virtual ~PlayerLeavePacket(){} + PlayerLeavePacket() {} + PlayerLeavePacket(std::uint8_t playerID) : m_PlayerID(playerID) {} + virtual ~PlayerLeavePacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - std::uint8_t getPlayerID() const{ return m_PlayerID; } + std::uint8_t getPlayerID() const { return m_PlayerID; } - virtual PacketType getType() const{ return PacketType::PlayerLeave; } + virtual PacketType getType() const { return PacketType::PlayerLeave; } }; -class ConnexionInfoPacket : public Packet{ +class ConnexionInfoPacket : public Packet { private: std::uint8_t m_ConnectionID; public: - ConnexionInfoPacket(){} - ConnexionInfoPacket(std::uint8_t connectionID): m_ConnectionID(connectionID){} - virtual ~ConnexionInfoPacket(){} + ConnexionInfoPacket() {} + ConnexionInfoPacket(std::uint8_t connectionID) : m_ConnectionID(connectionID) {} + virtual ~ConnexionInfoPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - std::uint8_t getConnectionID() const{ return m_ConnectionID; } + std::uint8_t getConnectionID() const { return m_ConnectionID; } - virtual PacketType getType() const{ return PacketType::ConnectionInfo; } + virtual PacketType getType() const { return PacketType::ConnectionInfo; } }; -class SelectTeamPacket : public Packet{ +class SelectTeamPacket : public Packet { private: game::TeamColor m_SelectedTeam; public: - SelectTeamPacket(){} - SelectTeamPacket(game::TeamColor selectedTeam): m_SelectedTeam(selectedTeam){} - virtual ~SelectTeamPacket(){} + SelectTeamPacket() {} + SelectTeamPacket(game::TeamColor selectedTeam) : m_SelectedTeam(selectedTeam) {} + virtual ~SelectTeamPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; } + game::TeamColor getSelectedTeam() const { return m_SelectedTeam; } - virtual PacketType getType() const{ return PacketType::SelectTeam; } + virtual PacketType getType() const { return PacketType::SelectTeam; } }; -class UpdatePlayerTeamPacket : public Packet{ +class UpdatePlayerTeamPacket : public Packet { private: std::uint8_t m_PlayerID; game::TeamColor m_SelectedTeam; public: - UpdatePlayerTeamPacket(){} - UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam): m_PlayerID(playerID), m_SelectedTeam(selectedTeam){} - virtual ~UpdatePlayerTeamPacket(){} + UpdatePlayerTeamPacket() {} + UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam) : m_PlayerID(playerID), m_SelectedTeam(selectedTeam) {} + virtual ~UpdatePlayerTeamPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; } - std::uint8_t getPlayerID() const{ return m_PlayerID; } + game::TeamColor getSelectedTeam() const { return m_SelectedTeam; } + std::uint8_t getPlayerID() const { return m_PlayerID; } - virtual PacketType getType() const{ return PacketType::UpdatePlayerTeam; } + virtual PacketType getType() const { return PacketType::UpdatePlayerTeam; } }; -class DisconnectPacket : public Packet{ +class DisconnectPacket : public Packet { private: std::string m_Reason; // only when sent from server public: - DisconnectPacket(){} - DisconnectPacket(std::string reason): m_Reason(reason){} - virtual ~DisconnectPacket(){} + DisconnectPacket() {} + DisconnectPacket(std::string reason) : m_Reason(reason) {} + virtual ~DisconnectPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - const std::string& getReason() const{ return m_Reason; } + const std::string& getReason() const { return m_Reason; } - virtual PacketType getType() const{ return PacketType::Disconnect; } + virtual PacketType getType() const { return PacketType::Disconnect; } }; -class ServerTpsPacket : public Packet{ +class ServerTpsPacket : public Packet { private: float m_TPS; std::uint64_t m_PacketSendTime; // used to calculate ping public: - ServerTpsPacket(){} - ServerTpsPacket(float tps, std::uint64_t sendTime): m_TPS(tps), m_PacketSendTime(sendTime){} - virtual ~ServerTpsPacket(){} + ServerTpsPacket() {} + ServerTpsPacket(float tps, std::uint64_t sendTime) : m_TPS(tps), m_PacketSendTime(sendTime) {} + virtual ~ServerTpsPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - float getTPS() const{ return m_TPS; } - std::uint64_t getPacketSendTime() const {return m_PacketSendTime;} + float getTPS() const { return m_TPS; } + std::uint64_t getPacketSendTime() const { return m_PacketSendTime; } - virtual PacketType getType() const{ return PacketType::ServerTps; } + virtual PacketType getType() const { return PacketType::ServerTps; } }; -class SpawnMobPacket : public Packet{ +class SpawnMobPacket : public Packet { private: game::MobID m_MobID; game::MobType m_MobType; @@ -361,36 +361,36 @@ private: game::PlayerID m_Sender; float m_MobX, m_MobY; public: - SpawnMobPacket(){} - SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender, + SpawnMobPacket() {} + SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender, float x, float y, game::Direction dir) : m_MobID(id), m_MobType(type), m_MobLevel(level), - m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y){} - virtual ~SpawnMobPacket(){} + m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y) {} + virtual ~SpawnMobPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); virtual void Dispatch(PacketHandler* handler); - game::MobID getMobID() const{ return m_MobID; } - game::MobType getMobType() const{ return m_MobType; } - game::MobLevel getMobLevel() const{ return m_MobLevel; } - game::Direction getMobDirection() const{ return m_MobDirection; } - game::PlayerID getSender() const{ return m_Sender; } - float getMobX() const{ return m_MobX; } - float getMobY() const{ return m_MobY; } + game::MobID getMobID() const { return m_MobID; } + game::MobType getMobType() const { return m_MobType; } + game::MobLevel getMobLevel() const { return m_MobLevel; } + game::Direction getMobDirection() const { return m_MobDirection; } + game::PlayerID getSender() const { return m_Sender; } + float getMobX() const { return m_MobX; } + float getMobY() const { return m_MobY; } - virtual PacketType getType() const{ return PacketType::SpawnMob; } + virtual PacketType getType() const { return PacketType::SpawnMob; } }; -class PlaceTowerPacket : public Packet{ +class PlaceTowerPacket : public Packet { private: std::int32_t m_TowerX, m_TowerY; game::TowerType m_TowerType; public: - PlaceTowerPacket(){} + PlaceTowerPacket() {} PlaceTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type) : - m_TowerX(x), m_TowerY(y), m_TowerType(type){} - virtual ~PlaceTowerPacket(){} + m_TowerX(x), m_TowerY(y), m_TowerType(type) {} + virtual ~PlaceTowerPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); @@ -400,19 +400,19 @@ public: std::int32_t getTowerY() const { return m_TowerY; } game::TowerType getTowerType() const { return m_TowerType; } - virtual PacketType getType() const{ return PacketType::PlaceTower; } + virtual PacketType getType() const { return PacketType::PlaceTower; } }; -class WorldAddTowerPacket : public Packet{ +class WorldAddTowerPacket : public Packet { private: std::int32_t m_TowerX, m_TowerY; game::TowerType m_TowerType; game::PlayerID m_Builder; public: - WorldAddTowerPacket(){} + WorldAddTowerPacket() {} WorldAddTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type, game::PlayerID player) : - m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player){} - virtual ~WorldAddTowerPacket(){} + m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player) {} + virtual ~WorldAddTowerPacket() {} virtual DataBuffer Serialize() const; virtual void Deserialize(DataBuffer& data); @@ -421,9 +421,9 @@ public: std::int32_t getTowerX() const { return m_TowerX; } std::int32_t getTowerY() const { return m_TowerY; } game::TowerType getTowerType() const { return m_TowerType; } - game::PlayerID getBuilder() const {return m_Builder;} + game::PlayerID getBuilder() const { return m_Builder; } - virtual PacketType getType() const{ return PacketType::WorldAddTower; } + virtual PacketType getType() const { return PacketType::WorldAddTower; } }; } diff --git a/include/render/WorldRenderer.h b/include/render/WorldRenderer.h index 1d2e325..e34e80d 100644 --- a/include/render/WorldRenderer.h +++ b/include/render/WorldRenderer.h @@ -8,16 +8,16 @@ namespace td { -namespace client{ +namespace client { class ClientGame; - + } // namespace client namespace render { -class WorldRenderer{ +class WorldRenderer { private: client::ClientGame* m_Client; Renderer* m_Renderer; diff --git a/include/render/loader/GLLoader.h b/include/render/loader/GLLoader.h index c7bdde2..519b863 100644 --- a/include/render/loader/GLLoader.h +++ b/include/render/loader/GLLoader.h @@ -14,53 +14,53 @@ className& operator=(const className &) = delete -namespace GL{ +namespace GL { -struct VertexAttribPointer{ +struct VertexAttribPointer { unsigned int m_Index, m_Size; int m_Offset; }; -class VertexBuffer{ - private: - unsigned int m_ID, m_DataStride; - std::vector m_VertexAttribs; - public: - REMOVE_COPY(VertexBuffer); - VertexBuffer(VertexBuffer&& other){ - m_VertexAttribs = std::move(other.m_VertexAttribs); - m_ID = other.m_ID; - m_DataStride = other.m_DataStride; - other.m_ID = 0; - other.m_DataStride = 0; - } - VertexBuffer(const std::vector& data, unsigned int stride); - ~VertexBuffer(); - void bind() const; - void unbind() const; - void addVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset); - void bindVertexAttribs() const; +class VertexBuffer { +private: + unsigned int m_ID, m_DataStride; + std::vector m_VertexAttribs; +public: + REMOVE_COPY(VertexBuffer); + VertexBuffer(VertexBuffer&& other) { + m_VertexAttribs = std::move(other.m_VertexAttribs); + m_ID = other.m_ID; + m_DataStride = other.m_DataStride; + other.m_ID = 0; + other.m_DataStride = 0; + } + VertexBuffer(const std::vector& data, unsigned int stride); + ~VertexBuffer(); + void bind() const; + void unbind() const; + void addVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset); + void bindVertexAttribs() const; }; -class VertexArray{ - private: - unsigned int m_ID, m_VertexCount; - std::vector m_VertexBuffers; //use to destroy vbos when become unused - public: - REMOVE_COPY(VertexArray); - VertexArray(VertexArray&& other){ - m_ID = other.m_ID; - m_VertexCount = other.m_VertexCount; - m_VertexBuffers = std::move(other.m_VertexBuffers); - other.m_VertexCount = 0; - other.m_ID = 0; - } - VertexArray(unsigned int vertexCount); - ~VertexArray(); - unsigned int getVertexCount() const {return m_VertexCount;} - void bindVertexBuffer(VertexBuffer& vbo); - void bind() const; - void unbind() const; +class VertexArray { +private: + unsigned int m_ID, m_VertexCount; + std::vector m_VertexBuffers; //use to destroy vbos when become unused +public: + REMOVE_COPY(VertexArray); + VertexArray(VertexArray&& other) { + m_ID = other.m_ID; + m_VertexCount = other.m_VertexCount; + m_VertexBuffers = std::move(other.m_VertexBuffers); + other.m_VertexCount = 0; + other.m_ID = 0; + } + VertexArray(unsigned int vertexCount); + ~VertexArray(); + unsigned int getVertexCount() const { return m_VertexCount; } + void bindVertexBuffer(VertexBuffer& vbo); + void bind() const; + void unbind() const; }; } diff --git a/include/render/loader/TextureLoader.h b/include/render/loader/TextureLoader.h index 82d8323..fdb59ca 100644 --- a/include/render/loader/TextureLoader.h +++ b/include/render/loader/TextureLoader.h @@ -8,7 +8,7 @@ #ifndef RENDER_LOADER_TEXTURELOADER_H_ #define RENDER_LOADER_TEXTURELOADER_H_ -namespace TextureLoader{ +namespace TextureLoader { const unsigned int loadGLTexture(const char* fileName); } diff --git a/include/render/shaders/EntityShader.h b/include/render/shaders/EntityShader.h index 15422e5..cf482f7 100644 --- a/include/render/shaders/EntityShader.h +++ b/include/render/shaders/EntityShader.h @@ -2,7 +2,7 @@ #include "ShaderProgram.h" -class EntityShader : public ShaderProgram{ +class EntityShader : public ShaderProgram { private: unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_translation = 0, location_viewtype = 0; protected: @@ -13,6 +13,6 @@ public: void setCamPos(const glm::vec2& camPos); void setZoom(float zoom); void setAspectRatio(float aspectRatio); - void setModelPos(const glm::vec2& modelPos); - void setIsometricView(float isometric); + void setModelPos(const glm::vec2& modelPos); + void setIsometricView(float isometric); }; diff --git a/include/render/shaders/ShaderProgram.h b/include/render/shaders/ShaderProgram.h index d391b3d..72de021 100755 --- a/include/render/shaders/ShaderProgram.h +++ b/include/render/shaders/ShaderProgram.h @@ -11,8 +11,8 @@ #include #include -namespace gl{ - enum class GLenum : unsigned int; +namespace gl { +enum class GLenum : unsigned int; } class ShaderProgram { @@ -22,7 +22,7 @@ public: void start() const; void stop() const; void loadProgramFile(const std::string& vertexFile, const std::string& fragmentFile); - void loadProgram(const std::string& vertexSource, const std::string& fragmentSource); + void loadProgram(const std::string& vertexSource, const std::string& fragmentSource); protected: virtual void getAllUniformLocation() = 0; @@ -41,7 +41,7 @@ private: unsigned int vertexShaderID; unsigned int fragmentShaderID; int loadShaderFromFile(const std::string& file, gl::GLenum type); - int loadShader(const std::string& source, gl::GLenum type); + int loadShader(const std::string& source, gl::GLenum type); }; #endif /* RENDER_SHADERS_SHADERPROGRAM_H_ */ diff --git a/include/render/shaders/WorldShader.h b/include/render/shaders/WorldShader.h index 5b6ae1f..1209edf 100644 --- a/include/render/shaders/WorldShader.h +++ b/include/render/shaders/WorldShader.h @@ -10,7 +10,7 @@ #include "ShaderProgram.h" -class WorldShader : public ShaderProgram{ +class WorldShader : public ShaderProgram { private: unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_viewtype = 0; protected: @@ -21,7 +21,7 @@ public: void setCamPos(const glm::vec2& camPos); void setZoom(float zoom); void setAspectRatio(float aspectRatio); - void setIsometricView(float isometric); + void setIsometricView(float isometric); }; #endif /* RENDER_SHADERS_GAMESHADER_H_ */ diff --git a/include/window/Display.h b/include/window/Display.h index 8310d5a..dbc681f 100644 --- a/include/window/Display.h +++ b/include/window/Display.h @@ -9,7 +9,7 @@ #define WINDOW_DISPLAY_H_ -namespace Display{ +namespace Display { void create(); void render(); diff --git a/src/Tower Defense.cpp b/src/Tower Defense.cpp index dee0c8c..fa0ac1b 100644 --- a/src/Tower Defense.cpp +++ b/src/Tower Defense.cpp @@ -9,10 +9,10 @@ #include "window/Display.h" #include "misc/Random.h" -int main(int argc, const char* args[]){ +int main(int argc, const char* args[]) { td::utils::initRandomizer(); Display::create(); - while (!Display::isCloseRequested()){ + while (!Display::isCloseRequested()) { Display::pollEvents(); Display::render(); Display::update(); diff --git a/src/game/BaseGame.cpp b/src/game/BaseGame.cpp index 97c8fca..1d2b610 100644 --- a/src/game/BaseGame.cpp +++ b/src/game/BaseGame.cpp @@ -3,16 +3,16 @@ namespace td { namespace game { -Game::Game(World* world) : m_World(world){ +Game::Game(World* world) : m_World(world) { } -Game::~Game(){ +Game::~Game() { } -void Game::tick(std::uint64_t delta){ - if(m_GameState == GameState::Game){ +void Game::tick(std::uint64_t delta) { + if (m_GameState == GameState::Game) { m_World->tick(delta); } } diff --git a/src/game/Connexion.cpp b/src/game/Connexion.cpp index 72f9fc4..5a1c0d2 100644 --- a/src/game/Connexion.cpp +++ b/src/game/Connexion.cpp @@ -12,15 +12,15 @@ namespace td { namespace protocol { -Connexion::Connexion() : protocol::PacketHandler(nullptr){ +Connexion::Connexion() : protocol::PacketHandler(nullptr) { } -Connexion::Connexion(Connexion&& move) : protocol::PacketHandler(&m_Dispatcher), m_Socket(std::move(move.m_Socket)){ +Connexion::Connexion(Connexion&& move) : protocol::PacketHandler(&m_Dispatcher), m_Socket(std::move(move.m_Socket)) { } -Connexion::Connexion(protocol::PacketDispatcher* dispatcher) : protocol::PacketHandler(dispatcher){ +Connexion::Connexion(protocol::PacketDispatcher* dispatcher) : protocol::PacketHandler(dispatcher) { } @@ -28,13 +28,13 @@ Connexion::Connexion(protocol::PacketDispatcher* dispatcher, network::TCPSocket& } -bool Connexion::updateSocket(){ - if(m_Socket.GetStatus() != network::Socket::Connected) +bool Connexion::updateSocket() { + if (m_Socket.GetStatus() != network::Socket::Connected) return false; DataBuffer buffer; m_Socket.Receive(buffer, sizeof(std::uint64_t)); - if (buffer.GetSize() > 0){ + if (buffer.GetSize() > 0) { std::uint64_t packetLenght; buffer >> packetLenght; @@ -52,24 +52,24 @@ bool Connexion::updateSocket(){ return true; } -bool Connexion::connect(const std::string& address, std::uint16_t port){ - if(!m_Socket.Connect(address, port)){ +bool Connexion::connect(const std::string& address, std::uint16_t port) { + if (!m_Socket.Connect(address, port)) { return false; } m_Socket.SetBlocking(false); return true; } -void Connexion::sendPacket(protocol::Packet* packet){ +void Connexion::sendPacket(protocol::Packet* packet) { network::SendPacket(packet->Serialize(), m_Socket); } -void Connexion::closeConnection(){ +void Connexion::closeConnection() { m_Socket.Disconnect(); } -Connexion::~Connexion(){ - +Connexion::~Connexion() { + } } // namespace server diff --git a/src/game/Mobs.cpp b/src/game/Mobs.cpp index 966e42d..21a182d 100644 --- a/src/game/Mobs.cpp +++ b/src/game/Mobs.cpp @@ -69,8 +69,8 @@ const std::map MobConstants = { {{MobType::Giant, 5},{MobStats{0, 0, 0, 0, 0, 0}}}, }; -const MobStats* getMobStats(MobType type, std::uint8_t level){ - return &MobConstants.at(MobKey{type, level}); +const MobStats* getMobStats(MobType type, std::uint8_t level) { + return &MobConstants.at(MobKey{ type, level }); } const std::map MobsTowerImmunities = { @@ -135,8 +135,8 @@ const std::map MobsTowerImmunities = { {{MobType::Giant, 5},{}}, }; -const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level){ - return MobsTowerImmunities.at({type, level}); +const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level) { + return MobsTowerImmunities.at({ type, level }); } const std::map MobsEffectImmunities = { @@ -201,11 +201,11 @@ const std::map MobsEffectImmunities = { {{MobType::Giant, 5},{EffectType::Stun}}, }; -const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level){ - return MobsEffectImmunities.at({type, level}); +const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level) { + return MobsEffectImmunities.at({ type, level }); } -MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender){ +MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender) { using MobCreator = std::function(MobID, std::uint8_t, PlayerID)>; static std::map mobFactory = { @@ -215,6 +215,6 @@ MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerI return mobFactory[type](id, level, sender); } - + } // namespace game } // namespace td diff --git a/src/game/Team.cpp b/src/game/Team.cpp index eaf7888..702fb49 100644 --- a/src/game/Team.cpp +++ b/src/game/Team.cpp @@ -3,23 +3,23 @@ namespace td { namespace game { -Team::Team(TeamColor color): m_Color(color){} +Team::Team(TeamColor color) : m_Color(color) {} -void Team::addPlayer(Player* newPlayer){ +void Team::addPlayer(Player* newPlayer) { m_Players.push_back(newPlayer); newPlayer->setTeamColor(m_Color); } -void Team::removePlayer(const Player* player){ - m_Players.erase(std::find(m_Players.begin(), m_Players.end(), player)); +void Team::removePlayer(const Player* player) { + m_Players.erase(std::find(m_Players.begin(), m_Players.end(), player)); } -TeamColor Team::getColor() const{ +TeamColor Team::getColor() const { return m_Color; } -std::uint8_t Team::getPlayerCount() const{ - return m_Players.size(); +std::uint8_t Team::getPlayerCount() const { + return m_Players.size(); } diff --git a/src/game/Towers.cpp b/src/game/Towers.cpp index 860ac9b..afb6000 100644 --- a/src/game/Towers.cpp +++ b/src/game/Towers.cpp @@ -103,57 +103,57 @@ const std::map, TowerStats> TowerConstants = { {{TowerType::Necromancer, {4, TowerPath::Bottom}}, {0, 0, 0}}, }; -const TowerStats* getTowerStats(TowerType type, TowerLevel level){ - return &TowerConstants.at({type, level}); +const TowerStats* getTowerStats(TowerType type, TowerLevel level) { + return &TowerConstants.at({ type, level }); } -void ArcherTower::tick(std::uint64_t delta){ +void ArcherTower::tick(std::uint64_t delta) { } -void IceTower::tick(std::uint64_t delta){ +void IceTower::tick(std::uint64_t delta) { } -void MageTower::tick(std::uint64_t delta){ +void MageTower::tick(std::uint64_t delta) { } -void PoisonTower::tick(std::uint64_t delta){ +void PoisonTower::tick(std::uint64_t delta) { } -void QuakeTower::tick(std::uint64_t delta){ +void QuakeTower::tick(std::uint64_t delta) { } -void ZeusTower::tick(std::uint64_t delta){ +void ZeusTower::tick(std::uint64_t delta) { } -void ArtilleryTower::tick(std::uint64_t delta){ +void ArtilleryTower::tick(std::uint64_t delta) { } -void SorcererTower::tick(std::uint64_t delta){ +void SorcererTower::tick(std::uint64_t delta) { } -void LeachTower::tick(std::uint64_t delta){ +void LeachTower::tick(std::uint64_t delta) { } -void TurretTower::tick(std::uint64_t delta){ +void TurretTower::tick(std::uint64_t delta) { } -void NecromancerTower::tick(std::uint64_t delta){ +void NecromancerTower::tick(std::uint64_t delta) { } diff --git a/src/game/World.cpp b/src/game/World.cpp index 0a76e88..297bff4 100644 --- a/src/game/World.cpp +++ b/src/game/World.cpp @@ -14,21 +14,21 @@ namespace td { namespace game { -World::World(Game* game) : m_Game(game){ - #if WRITE_MAP +World::World(Game* game) : m_Game(game) { +#if WRITE_MAP loadMapFromFile(""); - #endif +#endif } -TilePtr World::getTile(std::int32_t x, std::int32_t y){ +TilePtr World::getTile(std::int32_t x, std::int32_t y) { std::int16_t chunkX = x / Chunk::ChunkWidth; std::int16_t chunkY = y / Chunk::ChunkHeight; std::uint16_t subChunkX = x % Chunk::ChunkWidth; std::uint16_t subChunkY = y % Chunk::ChunkHeight; - auto chunkIt = m_Chunks.find({chunkX, chunkY}); - if(chunkIt == m_Chunks.end()) + auto chunkIt = m_Chunks.find({ chunkX, chunkY }); + if (chunkIt == m_Chunks.end()) return nullptr; ChunkPtr chunk = chunkIt->second; @@ -36,7 +36,7 @@ TilePtr World::getTile(std::int32_t x, std::int32_t y){ return getTilePtr(chunk->getTileIndex(subChunkY * Chunk::ChunkWidth + subChunkX)); } -bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader){ +bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader) { m_TowerPlacePalette = worldHeader->getTowerTilePalette(); m_WalkablePalette = worldHeader->getWalkableTileColor(); m_DecorationPalette = worldHeader->getDecorationPalette(); @@ -54,15 +54,15 @@ bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader){ return true; } -bool World::loadMap(const protocol::WorldDataPacket* worldData){ +bool World::loadMap(const protocol::WorldDataPacket* worldData) { m_Chunks = worldData->getChunks(); return true; } -bool World::loadMapFromFile(const std::string& fileName){ +bool World::loadMapFromFile(const std::string& fileName) { #if !WRITE_MAP DataBuffer buffer; - if(!buffer.ReadFile(fileName)){ + if (!buffer.ReadFile(fileName)) { std::cerr << "Failed to load map from file " << fileName << " !\n"; } @@ -89,10 +89,10 @@ bool World::loadMapFromFile(const std::string& fileName){ return true; #else - m_WalkablePalette = {102, 102, 153}; + m_WalkablePalette = { 102, 102, 153 }; - m_TowerPlacePalette[0] = {204, 51, 0}; - m_TowerPlacePalette[1] = {255, 153, 0}; + m_TowerPlacePalette[0] = { 204, 51, 0 }; + m_TowerPlacePalette[1] = { 255, 153, 0 }; WalkableTile walkableTileDown; // 1 walkableTileDown.direction = Direction::PositiveY; @@ -137,12 +137,12 @@ bool World::loadMapFromFile(const std::string& fileName){ getRedTeam().getSpawn().y = 13; getRedTeam().getSpawn().direction = Direction::PositiveY; - m_SpawnColorPalette[(uint) TeamColor::Red] = {255, 0, 0}; + m_SpawnColorPalette[(uint)TeamColor::Red] = { 255, 0, 0 }; //Chunks Chunk chunk0; - for (int i = 0; i <= 6; i++){ + for (int i = 0; i <= 6; i++) { chunk0.palette.push_back(i); } chunk0.tiles = { @@ -182,7 +182,7 @@ bool World::loadMapFromFile(const std::string& fileName){ Chunk chunk1; - for (int i = 0; i <= 6; i++){ + for (int i = 0; i <= 6; i++) { chunk1.palette.push_back(i); } @@ -223,7 +223,7 @@ bool World::loadMapFromFile(const std::string& fileName){ Chunk chunk2; - for (int i = 0; i <= 6; i++){ + for (int i = 0; i <= 6; i++) { chunk2.palette.push_back(i); } @@ -262,9 +262,9 @@ bool World::loadMapFromFile(const std::string& fileName){ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }; - m_Chunks.insert({{0, 0}, std::make_shared(chunk0)}); - m_Chunks.insert({{1, 0}, std::make_shared(chunk1)}); - m_Chunks.insert({{1, 1}, std::make_shared(chunk2)}); + m_Chunks.insert({ {0, 0}, std::make_shared(chunk0) }); + m_Chunks.insert({ {1, 0}, std::make_shared(chunk1) }); + m_Chunks.insert({ {1, 1}, std::make_shared(chunk2) }); // blue map = same but with offset of 64 (in x coordinate) @@ -276,35 +276,35 @@ bool World::loadMapFromFile(const std::string& fileName){ getBlueTeam().getSpawn().y = 13; getBlueTeam().getSpawn().direction = Direction::PositiveY; - m_SpawnColorPalette[(uint) TeamColor::Blue] = {0, 0, 255}; + m_SpawnColorPalette[(uint)TeamColor::Blue] = { 0, 0, 255 }; Chunk chunk01; - chunk01.palette = {0, 1, 2, 3, 4, 7, 8}; + chunk01.palette = { 0, 1, 2, 3, 4, 7, 8 }; chunk01.tiles = chunk0.tiles; // the tiles indicies are the same, only the palette has changed Chunk chunk11; - chunk11.palette = {0, 1, 2, 3, 4, 7, 8}; + chunk11.palette = { 0, 1, 2, 3, 4, 7, 8 }; chunk11.tiles = chunk1.tiles; // the tiles indicies are the same, only the palette has changed Chunk chunk21; - chunk21.palette = {0, 1, 2, 3, 4, 7, 8}; + chunk21.palette = { 0, 1, 2, 3, 4, 7, 8 }; chunk21.tiles = chunk2.tiles; // the tiles indicies are the same, only the palette has changed - m_Chunks.insert({{2, 0}, std::make_shared(chunk01)}); - m_Chunks.insert({{3, 0}, std::make_shared(chunk11)}); - m_Chunks.insert({{3, 1}, std::make_shared(chunk21)}); - + m_Chunks.insert({ {2, 0}, std::make_shared(chunk01) }); + m_Chunks.insert({ {3, 0}, std::make_shared(chunk11) }); + m_Chunks.insert({ {3, 1}, std::make_shared(chunk21) }); + saveMap("tdmap.tdmap"); #endif } -bool World::saveMap(const std::string& fileName) const{ +bool World::saveMap(const std::string& fileName) const { protocol::WorldBeginDataPacket headerPacket(this); protocol::WorldDataPacket dataPacket(this); @@ -319,11 +319,11 @@ bool World::saveMap(const std::string& fileName) const{ return buffer.WriteFile(fileName); } -void World::tick(std::uint64_t delta){ +void World::tick(std::uint64_t delta) { moveMobs(delta); } -void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir){ +void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir) { MobPtr mob = MobFactory::createMob(id, type, level, sender); mob->setX(x); mob->setY(y); @@ -331,82 +331,82 @@ void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID send m_Mobs.push_back(mob); } -void World::moveMobs(std::uint64_t delta){ - for(MobPtr mob : m_Mobs){ +void World::moveMobs(std::uint64_t delta) { + for (MobPtr mob : m_Mobs) { TilePtr tile = getTile(mob->getX(), mob->getY()); - if(tile != nullptr && tile->getType() == TileType::Walk){ + if (tile != nullptr && tile->getType() == TileType::Walk) { WalkableTile* walkTile = dynamic_cast(tile.get()); mob->setDirection(walkTile->direction); } float mobWalkSpeed = mob->getStats()->getMovementSpeed(); - float walkAmount = mobWalkSpeed * ((float) delta / 1000.0f); - - switch(mob->getDirection()){ - case Direction::NegativeX:{ - mob->setX(mob->getX() - walkAmount); - break; - } - case Direction::PositiveX:{ - mob->setX(mob->getX() + walkAmount); - break; - } - case Direction::NegativeY:{ - mob->setY(mob->getY() - walkAmount); - break; - } - case Direction::PositiveY:{ - mob->setY(mob->getY() + walkAmount); - break; - } + float walkAmount = mobWalkSpeed * ((float)delta / 1000.0f); + + switch (mob->getDirection()) { + case Direction::NegativeX: { + mob->setX(mob->getX() - walkAmount); + break; + } + case Direction::PositiveX: { + mob->setX(mob->getX() + walkAmount); + break; + } + case Direction::NegativeY: { + mob->setY(mob->getY() - walkAmount); + break; + } + case Direction::PositiveY: { + mob->setY(mob->getY() + walkAmount); + break; + } } } } -const Color* World::getTileColor(TilePtr tile) const{ - switch(tile->getType()){ - case TileType::Tower:{ - TowerTile* towerTile = (TowerTile*) tile.get(); - return &m_TowerPlacePalette[towerTile->color_palette_ref]; - } - case TileType::Walk:{ - return &m_WalkablePalette; - } - case TileType::Decoration:{ - DecorationTile* towerTile = (DecorationTile*) tile.get(); - return &m_DecorationPalette[towerTile->color_palette_ref]; - break; - } - case TileType::None:{ - return nullptr; - } +const Color* World::getTileColor(TilePtr tile) const { + switch (tile->getType()) { + case TileType::Tower: { + TowerTile* towerTile = (TowerTile*)tile.get(); + return &m_TowerPlacePalette[towerTile->color_palette_ref]; + } + case TileType::Walk: { + return &m_WalkablePalette; + } + case TileType::Decoration: { + DecorationTile* towerTile = (DecorationTile*)tile.get(); + return &m_DecorationPalette[towerTile->color_palette_ref]; + break; + } + case TileType::None: { + return nullptr; + } } return nullptr; } -Team& World::getRedTeam(){ +Team& World::getRedTeam() { return m_Game->getRedTeam(); } -const Team& World::getRedTeam() const{ +const Team& World::getRedTeam() const { return m_Game->getRedTeam(); } -Team& World::getBlueTeam(){ +Team& World::getBlueTeam() { return m_Game->getBlueTeam(); } -const Team& World::getBlueTeam() const{ +const Team& World::getBlueTeam() const { return m_Game->getBlueTeam(); } -Team& World::getTeam(TeamColor team){ +Team& World::getTeam(TeamColor team) { return m_Game->getTeam(team); } -const Team& World::getTeam(TeamColor team) const{ +const Team& World::getTeam(TeamColor team) const { return m_Game->getTeam(team); } diff --git a/src/game/client/Client.cpp b/src/game/client/Client.cpp index 9b1aab0..13b5686 100644 --- a/src/game/client/Client.cpp +++ b/src/game/client/Client.cpp @@ -5,24 +5,24 @@ namespace td { namespace client { -void Client::connect(const std::string& address, std::uint16_t port){ - if(!m_Connexion.connect(address, port)){ +void Client::connect(const std::string& address, std::uint16_t port) { + if (!m_Connexion.connect(address, port)) { std::cout << "Failed to connect !\n"; return; } m_Connected = true; } -void Client::selectTeam(game::TeamColor team){ - if(!m_Connected) +void Client::selectTeam(game::TeamColor team) { + if (!m_Connected) return; protocol::SelectTeamPacket packet(team); m_Connexion.sendPacket(&packet); } -void Client::closeConnection(){ - if(!m_Connected) +void Client::closeConnection() { + if (!m_Connected) return; m_Connected = false; @@ -31,18 +31,18 @@ void Client::closeConnection(){ m_Connexion.sendPacket(&packet); } -void Client::tick(std::uint64_t delta){ - if(!m_Connected) +void Client::tick(std::uint64_t delta) { + if (!m_Connected) return; m_Connected = m_Connexion.updateSocket(); - if(!m_Connected){ + if (!m_Connected) { std::cout << "Disconnected ! (Reason : " << m_Connexion.getDisconnectReason() << ")\n"; - }else{ + } else { m_Game.tick(delta); } } -void Client::render(){ +void Client::render() { m_Game.renderWorld(); } diff --git a/src/game/client/ClientConnexion.cpp b/src/game/client/ClientConnexion.cpp index b5045a5..a6820d5 100644 --- a/src/game/client/ClientConnexion.cpp +++ b/src/game/client/ClientConnexion.cpp @@ -4,42 +4,42 @@ namespace td { namespace client { -ClientConnexion::ClientConnexion(): Connexion(&m_Dispatcher){ +ClientConnexion::ClientConnexion() : Connexion(&m_Dispatcher) { registerHandlers(); } -void ClientConnexion::registerHandlers(){ +void ClientConnexion::registerHandlers() { GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this); GetDispatcher()->RegisterHandler(protocol::PacketType::Disconnect, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this); } -void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet){ +void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet) { protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID()); sendPacket(&keepAlivePacket); } -void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet){ +void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet) { m_ConnectionID = packet->getConnectionID(); login(); } -void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet){ +void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet) { m_ServerTPS = packet->getTPS(); m_Ping = utils::getTime() - packet->getPacketSendTime(); } -void ClientConnexion::login(){ +void ClientConnexion::login() { td::protocol::PlayerLoginPacket loginPacket("Persson" + std::to_string(m_ConnectionID)); sendPacket(&loginPacket); } -bool ClientConnexion::updateSocket(){ +bool ClientConnexion::updateSocket() { return Connexion::updateSocket(); } -void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet){ +void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet) { m_DisconnectReason = packet->getReason(); closeConnection(); } diff --git a/src/game/client/ClientGame.cpp b/src/game/client/ClientGame.cpp index 993df5f..d904e60 100644 --- a/src/game/client/ClientGame.cpp +++ b/src/game/client/ClientGame.cpp @@ -8,9 +8,9 @@ namespace td { namespace client { -ClientGame::ClientGame(Client* client): protocol::PacketHandler(client->getConnexion().GetDispatcher()), - game::Game(&m_WorldClient), m_Client(client), m_Renderer(client->getRenderer()), m_WorldClient(this), - m_WorldRenderer(&m_WorldClient, this){ +ClientGame::ClientGame(Client* client) : protocol::PacketHandler(client->getConnexion().GetDispatcher()), +game::Game(&m_WorldClient), m_Client(client), m_Renderer(client->getRenderer()), m_WorldClient(this), +m_WorldRenderer(&m_WorldClient, this) { GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerJoin, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerList, this); @@ -23,113 +23,111 @@ ClientGame::ClientGame(Client* client): protocol::PacketHandler(client->getConne GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this); } -ClientGame::~ClientGame(){ +ClientGame::~ClientGame() { GetDispatcher()->UnregisterHandler(this); } -void ClientGame::tick(std::uint64_t delta){ +void ClientGame::tick(std::uint64_t delta) { game::Game::tick(delta); m_WorldRenderer.update(); - if (m_GameState == game::GameState::Lobby && m_LobbyTime > 0){ + if (m_GameState == game::GameState::Lobby && m_LobbyTime > 0) { m_LobbyTime -= delta; } } -void ClientGame::HandlePacket(protocol::PlayerJoinPacket* packet){ +void ClientGame::HandlePacket(protocol::PlayerJoinPacket* packet) { game::Player player(packet->getPlayerID()); player.setName(packet->getPlayerName()); - m_Players.insert({player.getID(), player}); + m_Players.insert({ player.getID(), player }); } -void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet){ +void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet) { game::Player* player = &m_Players[packet->getPlayerID()]; - if (player->getTeamColor() != game::TeamColor::None){ + if (player->getTeamColor() != game::TeamColor::None) { m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player); } m_Players.erase(player->getID()); } -void ClientGame::HandlePacket(protocol::PlayerListPacket* packet){ - for (auto pair : packet->getPlayers()){ +void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) { + for (auto pair : packet->getPlayers()) { std::uint8_t playerID = pair.first; protocol::PlayerInfo playerInfo = pair.second; game::Player player(playerID); player.setName(playerInfo.name); player.setTeamColor(playerInfo.team); - m_Players.insert({playerID, player}); - if (player.getTeamColor() != game::TeamColor::None){ + m_Players.insert({ playerID, player }); + if (player.getTeamColor() != game::TeamColor::None) { m_Teams[(std::size_t)player.getTeamColor()].addPlayer(&m_Players[playerID]); } } m_Player = &m_Players[m_ConnexionID]; } -void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet){ +void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) { game::Player* player = &m_Players[packet->getPlayerID()]; - if (player->getTeamColor() == game::TeamColor::None){ //join a team + 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); player->setTeamColor(game::TeamColor::None); - } - else{ // change team + } else { // change team getTeam(player->getTeamColor()).removePlayer(player); getTeam(packet->getSelectedTeam()).addPlayer(player); } } -void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet){ +void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet) { setGameState(packet->getGameState()); } -void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet){ +void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet) { m_ConnexionID = packet->getConnectionID(); } -void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet){ +void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet) { m_LobbyTime = packet->getRemainingTime(); } -void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet){ +void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet) { m_Player->setGold(packet->getGold()); } -void ClientGame::HandlePacket(protocol::DisconnectPacket* packet){ +void ClientGame::HandlePacket(protocol::DisconnectPacket* packet) { m_GameState = game::GameState::Disconnected; } -void ClientGame::HandlePacket(protocol::WorldDataPacket* packet){ +void ClientGame::HandlePacket(protocol::WorldDataPacket* packet) { m_WorldRenderer.loadModels(); // set cam pos to player spawn const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn(); m_WorldRenderer.setCamPos(spawn.x + 0.5, spawn.y + 0.5); } -void ClientGame::renderWorld(){ - if(m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame){ +void ClientGame::renderWorld() { + if (m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame) { m_WorldRenderer.render(); } } -void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position){ +void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position) { protocol::PlaceTowerPacket packet(position.x, position.y, type); m_Client->getConnexion().sendPacket(&packet); } -bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos){ +bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos) { game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y); - if(tile == nullptr){ + if (tile == nullptr) { return false; } - if(tile->getType() == game::TileType::Tower){ - for(int x = -1; x < 2; x++){ - for(int y = -1; y < 2; y++){ + if (tile->getType() == game::TileType::Tower) { + for (int x = -1; x < 2; x++) { + for (int y = -1; y < 2; y++) { game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y); - if(adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower){ + if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower) { return false; } } @@ -140,18 +138,18 @@ bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos){ return false; } -bool ClientGame::CanPlaceBigTower(const glm::vec2& worldPos){ +bool ClientGame::CanPlaceBigTower(const glm::vec2& worldPos) { game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y); - if(tile == nullptr){ + if (tile == nullptr) { return false; } - if(tile->getType() == game::TileType::Tower){ - for(int x = -2; x < 3; x++){ - for(int y = -2; y < 3; y++){ + if (tile->getType() == game::TileType::Tower) { + for (int x = -2; x < 3; x++) { + for (int y = -2; y < 3; y++) { game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y); - if(adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower){ + if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower) { return false; } } diff --git a/src/game/client/TowersInfo.cpp b/src/game/client/TowersInfo.cpp index b3178a1..2e5e314 100644 --- a/src/game/client/TowersInfo.cpp +++ b/src/game/client/TowersInfo.cpp @@ -19,7 +19,7 @@ static const std::map TowerInfoConstants = { {TowerType::Zeus, {"Zeus", "Strike lightning", false}}, }; -const TowerInfo& getTowerInfo(TowerType type){ +const TowerInfo& getTowerInfo(TowerType type) { return TowerInfoConstants.at(type); } diff --git a/src/game/client/WorldClient.cpp b/src/game/client/WorldClient.cpp index 3dd3426..4d33539 100644 --- a/src/game/client/WorldClient.cpp +++ b/src/game/client/WorldClient.cpp @@ -3,30 +3,30 @@ #include "game/client/ClientGame.h" #include "render/WorldRenderer.h" -namespace td{ -namespace client{ +namespace td { +namespace client { -WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::PacketHandler(game->GetDispatcher()), m_Game(game){ +WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::PacketHandler(game->GetDispatcher()), m_Game(game) { GetDispatcher()->RegisterHandler(protocol::PacketType::WorldBeginData, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldAddTower, this); GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this); } -void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet){ +void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet) { loadMap(packet); } -void WorldClient::HandlePacket(protocol::WorldDataPacket* packet){ +void WorldClient::HandlePacket(protocol::WorldDataPacket* packet) { loadMap(packet); } -void WorldClient::HandlePacket(protocol::WorldAddTowerPacket* packet){ - +void WorldClient::HandlePacket(protocol::WorldAddTowerPacket* packet) { + } -void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet){ - spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(), +void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) { + spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(), packet->getMobX(), packet->getMobY(), packet->getMobDirection()); } diff --git a/src/game/server/Lobby.cpp b/src/game/server/Lobby.cpp index bac381a..addf36a 100644 --- a/src/game/server/Lobby.cpp +++ b/src/game/server/Lobby.cpp @@ -22,51 +22,51 @@ namespace server { 1, // 1 s };*/ -Lobby::Lobby(Server* server) : m_Server(server), m_Timer(1000, std::bind(&Lobby::sendTimeRemaining, this)){ - +Lobby::Lobby(Server* server) : m_Server(server), m_Timer(1000, std::bind(&Lobby::sendTimeRemaining, this)) { + } -void Lobby::tick(){ +void Lobby::tick() { if (m_GameStarted || m_StartTimerTime == 0) return; - if(utils::getTime() - m_StartTimerTime >= LOBBY_WAITING_TIME){ + if (utils::getTime() - m_StartTimerTime >= LOBBY_WAITING_TIME) { protocol::UpdateGameStatePacket packet(game::GameState::Game); m_Server->broadcastPacket(&packet); m_GameStarted = true; m_Server->lauchGame(); return; } - + m_Timer.update(); } -void Lobby::sendTimeRemaining(){ +void Lobby::sendTimeRemaining() { protocol::UpdateLobbyTimePacket packet(LOBBY_WAITING_TIME - (utils::getTime() - m_StartTimerTime)); // converting second to millis m_Server->broadcastPacket(&packet); } -void Lobby::OnPlayerJoin(std::uint8_t playerID){ - if(m_GameStarted) +void Lobby::OnPlayerJoin(std::uint8_t playerID) { + if (m_GameStarted) return; std::cout << "(Server) Player Joined Lobby !\n"; m_Players.push_back(playerID); - if (m_Players.size() == 2){ // start timer if a second player join the match + if (m_Players.size() == 2) { // start timer if a second player join the match m_StartTimerTime = utils::getTime(); m_Timer.reset(); sendTimeRemaining(); } } -void Lobby::OnPlayerLeave(std::uint8_t playerID){ - if(m_GameStarted) +void Lobby::OnPlayerLeave(std::uint8_t playerID) { + if (m_GameStarted) return; std::cout << "(Server) Player Leaved Lobby !\n"; auto it = std::find(m_Players.begin(), m_Players.end(), playerID); if (it == m_Players.end()) return; m_Players.erase(it); - if (m_Players.size() == 1){ + if (m_Players.size() == 1) { protocol::UpdateLobbyTimePacket packet(0); m_Server->broadcastPacket(&packet); m_StartTimerTime = 0; // reset timer if there is only one player left diff --git a/src/game/server/Server.cpp b/src/game/server/Server.cpp index acadd76..848132e 100644 --- a/src/game/server/Server.cpp +++ b/src/game/server/Server.cpp @@ -5,20 +5,20 @@ namespace td { namespace server { -Server::Server(const std::string& worldFilePath){ +Server::Server(const std::string& worldFilePath) { m_Game.getWorld()->loadMapFromFile(worldFilePath); } -void Server::lauchGame(){ +void Server::lauchGame() { m_Game.startGame(); } -bool Server::start(std::uint16_t port){ - if(!m_Listener.listen(port, 10)){ +bool Server::start(std::uint16_t port) { + if (!m_Listener.listen(port, 10)) { std::cout << "Failed to bind port " << port << " !\n"; return false; } - if(!m_Listener.setBlocking(false)){ + if (!m_Listener.setBlocking(false)) { std::cout << "Failed to block server socket !\n"; return false; } @@ -27,7 +27,7 @@ bool Server::start(std::uint16_t port){ return true; } -void Server::stop(){ +void Server::stop() { protocol::DisconnectPacket packet("Server closed"); broadcastPacket(&packet); @@ -38,65 +38,65 @@ void Server::stop(){ getPlayers().clear(); } -void Server::tick(std::uint64_t delta){ +void Server::tick(std::uint64_t delta) { accept(); updateSockets(); m_Lobby.tick(); m_Game.tick(delta); - if(m_TickCounter.update()){ + if (m_TickCounter.update()) { protocol::ServerTpsPacket packet(m_TickCounter.getTPS(), utils::getTime()); broadcastPacket(&packet); } } -void Server::accept(){ +void Server::accept() { static std::uint8_t newPlayerID = 0; network::TCPSocket newSocket; - if (m_Listener.accept(newSocket)){ + if (m_Listener.accept(newSocket)) { ServerConnexion con(newSocket, newPlayerID); - m_Connections.insert(std::move(ConnexionMap::value_type{newPlayerID, std::move(con)})); + m_Connections.insert(std::move(ConnexionMap::value_type{ newPlayerID, std::move(con) })); OnPlayerJoin(newPlayerID); m_Connections[newPlayerID].setServer(this); newPlayerID++; } } -void Server::updateSockets(){ +void Server::updateSockets() { std::int16_t closedConnexionID = -1; - for (auto& connection : m_Connections){ + for (auto& connection : m_Connections) { ServerConnexion& con = connection.second; - if(con.getSocketStatus() != network::Socket::Status::Connected){ + if (con.getSocketStatus() != network::Socket::Status::Connected) { closedConnexionID = connection.first; - }else{ + } else { con.updateSocket(); } } - if(closedConnexionID != -1){ + if (closedConnexionID != -1) { removeConnexion(closedConnexionID); } } -void Server::broadcastPacket(protocol::Packet* packet){ - for (auto& connection : m_Connections){ +void Server::broadcastPacket(protocol::Packet* packet) { + for (auto& connection : m_Connections) { ServerConnexion& con = connection.second; con.sendPacket(packet); } } -void Server::removeConnexion(std::uint8_t connexionID){ +void Server::removeConnexion(std::uint8_t connexionID) { getPlayers().erase(getPlayers().find(connexionID)); m_Connections.erase(connexionID); m_Lobby.OnPlayerLeave(connexionID); OnPlayerLeave(connexionID); } -void Server::OnPlayerJoin(std::uint8_t id){ +void Server::OnPlayerJoin(std::uint8_t id) { m_Lobby.OnPlayerJoin(id); - getPlayers().insert({id, game::Player{id}}); + getPlayers().insert({ id, game::Player{id} }); } -void Server::OnPlayerLeave(std::uint8_t id){ +void Server::OnPlayerLeave(std::uint8_t id) { protocol::PlayerLeavePacket packet(id); broadcastPacket(&packet); } diff --git a/src/game/server/ServerConnexion.cpp b/src/game/server/ServerConnexion.cpp index 2aed84e..38b84ab 100644 --- a/src/game/server/ServerConnexion.cpp +++ b/src/game/server/ServerConnexion.cpp @@ -10,30 +10,30 @@ #define KEEP_ALIVE_TIMEOUT 10 * 1000 // 10s -namespace td{ -namespace server{ +namespace td { +namespace server { /* NEVER TRUST USER INPUT */ -ServerConnexion::ServerConnexion(): m_Player(0){ +ServerConnexion::ServerConnexion() : m_Player(0) { } -ServerConnexion::ServerConnexion(network::TCPSocket& socket, std::uint8_t id) : Connexion::Connexion(&m_Dispatcher, socket), m_ID(id), m_Player(0){ +ServerConnexion::ServerConnexion(network::TCPSocket& socket, std::uint8_t id) : Connexion::Connexion(&m_Dispatcher, socket), m_ID(id), m_Player(0) { Connexion::updateSocket(); } ServerConnexion::ServerConnexion(ServerConnexion&& move) : Connexion::Connexion(std::move(move)), m_Server(move.m_Server), -m_ID(move.m_ID), m_KeepAlive(move.m_KeepAlive), m_Player(move.m_Player){ +m_ID(move.m_ID), m_KeepAlive(move.m_KeepAlive), m_Player(move.m_Player) { move.m_Server = nullptr; registerHandlers(); } -void ServerConnexion::registerHandlers(){ +void ServerConnexion::registerHandlers() { GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerLogin, this); GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this); GetDispatcher()->RegisterHandler(protocol::PacketType::SelectTeam, this); @@ -41,18 +41,17 @@ void ServerConnexion::registerHandlers(){ GetDispatcher()->RegisterHandler(protocol::PacketType::PlaceTower, this); } -bool ServerConnexion::updateSocket(){ +bool ServerConnexion::updateSocket() { checkKeepAlive(); return Connexion::updateSocket(); } -void ServerConnexion::checkKeepAlive(){ +void ServerConnexion::checkKeepAlive() { std::uint64_t time = utils::getTime(); - if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT){ - if (m_KeepAlive.recievedResponse){ + if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT) { + if (m_KeepAlive.recievedResponse) { sendKeepAlive(); - } - else{ + } else { protocol::DisconnectPacket packet("Time out"); sendPacket(&packet); closeConnection(); @@ -60,7 +59,7 @@ void ServerConnexion::checkKeepAlive(){ } } -void ServerConnexion::sendKeepAlive(){ +void ServerConnexion::sendKeepAlive() { m_KeepAlive.keepAliveID = utils::getRandomNumber(RAND_MAX); m_KeepAlive.recievedResponse = false; @@ -71,21 +70,21 @@ void ServerConnexion::sendKeepAlive(){ m_KeepAlive.sendTime = time; } -void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet){ - if (m_Player->getName().empty() && !packet->getPlayerName().empty()){ +void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet) { + if (m_Player->getName().empty() && !packet->getPlayerName().empty()) { m_Player->setName(packet->getPlayerName()); protocol::PlayerJoinPacket joinPacket(m_ID, m_Player->getName()); m_Server->broadcastPacket(&joinPacket); std::map playerNames; - for (const auto& pair : m_Server->getPlayers()){ + for (const auto& pair : m_Server->getPlayers()) { const game::Player& player = pair.second; - if (!player.getName().empty()){ + if (!player.getName().empty()) { protocol::PlayerInfo playerInfo; playerInfo.name = player.getName(); playerInfo.team = player.getTeamColor(); - playerNames.insert({player.getID(), playerInfo}); + playerNames.insert({ player.getID(), playerInfo }); } } @@ -94,17 +93,17 @@ void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet){ } } -void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet){ - if(m_Server->getGame().getGameState() != game::GameState::Lobby) +void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet) { + if (m_Server->getGame().getGameState() != game::GameState::Lobby) return; - if((std::int8_t) packet->getSelectedTeam() >= -1 || (std::int8_t) packet->getSelectedTeam() <= 1){ + if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) { //m_Player->setTeamColor(packet->getSelectedTeam()); - if(m_Player->getTeamColor() == game::TeamColor::None){ //join a team + if (m_Player->getTeamColor() == game::TeamColor::None) { //join a team m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player); - }else if(packet->getSelectedTeam() == game::TeamColor::None){ // leave a team + } else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player); m_Player->setTeamColor(game::TeamColor::None); - }else{ // change team + } else { // change team m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player); m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player); } @@ -113,30 +112,30 @@ void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet){ } } -void ServerConnexion::HandlePacket(protocol::KeepAlivePacket* packet){ - if(packet->getAliveID() == m_KeepAlive.keepAliveID) +void ServerConnexion::HandlePacket(protocol::KeepAlivePacket* packet) { + if (packet->getAliveID() == m_KeepAlive.keepAliveID) m_KeepAlive.recievedResponse = true; } -void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet){ +void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet) { closeConnection(); } -void ServerConnexion::setServer(Server* server){ +void ServerConnexion::setServer(Server* server) { m_Server = server; m_Player = &m_Server->getPlayers().at(m_ID); initConnection(); sendKeepAlive(); } -void ServerConnexion::initConnection(){ +void ServerConnexion::initConnection() { protocol::UpdateGameStatePacket statePacket(m_Server->getGame().getGameState()); sendPacket(&statePacket); protocol::ConnexionInfoPacket conPacket(m_ID); sendPacket(&conPacket); - if (m_Server->getGame().getGameState() == game::GameState::Game){ + if (m_Server->getGame().getGameState() == game::GameState::Game) { protocol::WorldBeginDataPacket headerDataPacket(m_Server->getGame().getWorld()); protocol::WorldBeginDataPacket dataPacket(m_Server->getGame().getWorld()); sendPacket(&headerDataPacket); @@ -144,13 +143,13 @@ void ServerConnexion::initConnection(){ } } -void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet){ +void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) { // process packet protocol::WorldAddTowerPacket addTowerPacket(packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID); m_Server->broadcastPacket(&addTowerPacket); } -ServerConnexion::~ServerConnexion(){ +ServerConnexion::~ServerConnexion() { if (GetDispatcher() != nullptr) GetDispatcher()->UnregisterHandler(this); } diff --git a/src/game/server/ServerGame.cpp b/src/game/server/ServerGame.cpp index 2529aca..52b1f82 100644 --- a/src/game/server/ServerGame.cpp +++ b/src/game/server/ServerGame.cpp @@ -4,21 +4,21 @@ namespace td { namespace server { -ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this){ - +ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this) { + } -void ServerGame::tick(std::uint64_t delta){ +void ServerGame::tick(std::uint64_t delta) { Game::tick(delta); m_GoldMineTimer.update(); } -void ServerGame::startGame(){ +void ServerGame::startGame() { balanceTeams(); protocol::WorldBeginDataPacket headerMapData(m_World); m_Server->broadcastPacket(&headerMapData); - + protocol::WorldDataPacket mapData(m_World); m_Server->broadcastPacket(&mapData); @@ -27,8 +27,8 @@ void ServerGame::startGame(){ m_ServerWorld.spawnMobs(game::MobType::Zombie, 1, 0, 12); } -void ServerGame::updateGoldMines(){ - for(auto& pair : m_Server->getPlayers()){ +void ServerGame::updateGoldMines() { + for (auto& pair : m_Server->getPlayers()) { game::Player* player = &pair.second; player->setGold(player->getGold() + player->getGoldPerSecond()); protocol::UpdateMoneyPacket packet(player->getGold()); @@ -36,15 +36,15 @@ void ServerGame::updateGoldMines(){ } } -void ServerGame::balanceTeams(){ - for(auto playerInfo : m_Players){ +void ServerGame::balanceTeams() { + for (auto playerInfo : m_Players) { game::Player& player = playerInfo.second; - if(player.getTeamColor() == game::TeamColor::None){ + if (player.getTeamColor() == game::TeamColor::None) { game::Team& redTeam = getRedTeam(); game::Team& blueTeam = getBlueTeam(); - if(blueTeam.getPlayerCount() > redTeam.getPlayerCount()){ + if (blueTeam.getPlayerCount() > redTeam.getPlayerCount()) { redTeam.addPlayer(&player); - }else{ + } else { blueTeam.addPlayer(&player); } protocol::UpdatePlayerTeamPacket packet(player.getID(), player.getTeamColor()); diff --git a/src/game/server/ServerWorld.cpp b/src/game/server/ServerWorld.cpp index 28de2af..22f10a6 100644 --- a/src/game/server/ServerWorld.cpp +++ b/src/game/server/ServerWorld.cpp @@ -7,21 +7,21 @@ namespace td { namespace server { -ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game), m_CurrentMobID(0), m_Server(server){ +ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game), m_CurrentMobID(0), m_Server(server) { } -void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count){ - for (int i = 0; i < count; i++){ +void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count) { + for (int i = 0; i < count; i++) { game::TeamColor senderTeam = m_Game->getPlayers().at(sender).getTeamColor(); game::Spawn* enemyMobSpawn; - if(senderTeam == game::TeamColor::Red){ + if (senderTeam == game::TeamColor::Red) { enemyMobSpawn = &getTeam(game::TeamColor::Blue).getSpawn(); - }else{ + } else { enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn(); } - + std::int32_t spawnCenterX = enemyMobSpawn->x; std::int32_t spawnCenterY = enemyMobSpawn->y; @@ -32,10 +32,10 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player std::int32_t maxSpawnX = spawnCenterX + 2; std::uint64_t randomX = utils::getRandomNumber(std::abs(minSpawnX - maxSpawnX) * MOB_SPAWN_PRECISION); - float mobX = (float) randomX / MOB_SPAWN_PRECISION + (float) minSpawnX; + float mobX = (float)randomX / MOB_SPAWN_PRECISION + (float)minSpawnX; std::uint64_t randomY = utils::getRandomNumber(std::abs(minSpawnY - maxSpawnY) * MOB_SPAWN_PRECISION); - float mobY = (float) randomY / MOB_SPAWN_PRECISION + (float) minSpawnY; + float mobY = (float)randomY / MOB_SPAWN_PRECISION + (float)minSpawnY; spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->direction); diff --git a/src/misc/Compression.cpp b/src/misc/Compression.cpp index ff031dd..2cb4c86 100644 --- a/src/misc/Compression.cpp +++ b/src/misc/Compression.cpp @@ -49,7 +49,7 @@ DataBuffer Compress(const DataBuffer& buffer) { return packet; } -DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength){ +DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) { std::uint64_t uncompressedLength; buffer >> uncompressedLength; diff --git a/src/misc/Easing.cpp b/src/misc/Easing.cpp index 781bb38..353f6a4 100644 --- a/src/misc/Easing.cpp +++ b/src/misc/Easing.cpp @@ -2,70 +2,70 @@ #include -namespace td{ -namespace utils{ +namespace td { +namespace utils { /* Sine functions */ -float easeInSine(float x){ +float easeInSine(float x) { return 1.0f - std::cos((x * PI) / 2.0f); } -float easeOutSine(float x){ +float easeOutSine(float x) { return std::sin((x * PI) / 2.0f); } -float easeInOutSine(float x){ +float easeInOutSine(float x) { return -(std::cos(PI * x) - 1.0f) / 2.0f; } /* Cubic functions */ -float easeInCubic(float x){ +float easeInCubic(float x) { return x * easeInQuad(x); } -float easeOutCubic(float x){ +float easeOutCubic(float x) { return 1 - std::pow(1 - x, 3); } -float easeInOutCubic(float x){ +float easeInOutCubic(float x) { return x < 0.5 ? 4 * easeInCubic(x) : 1 - std::pow(-2 * x + 2, 3) / 2.0f; } /* Quint functions */ -float easeInQuint(float x){ +float easeInQuint(float x) { return x * easeInQuart(x); } -float easeOutQuint(float x){ +float easeOutQuint(float x) { return 1 - std::pow(1 - x, 5); } -float easeInOutQuint(float x){ +float easeInOutQuint(float x) { return x < 0.5 ? 16 * easeInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0f; } /* Circ functions */ -float easeInCirc(float x){ +float easeInCirc(float x) { return 1 - std::sqrt(1 - std::pow(x, 2)); } -float easeOutCirc(float x){ +float easeOutCirc(float x) { return std::sqrt(1 - std::pow(x - 1, 2)); } -float easeInOutCirc(float x){ +float easeInOutCirc(float x) { return x < 0.5 - ? (1 - std::sqrt(1 - std::pow(2 * x, 2))) / 2.0f - : (std::sqrt(1 - std::pow(-2 * x + 2, 2)) + 1) / 2.0f; + ? (1 - std::sqrt(1 - std::pow(2 * x, 2))) / 2.0f + : (std::sqrt(1 - std::pow(-2 * x + 2, 2)) + 1) / 2.0f; } /* Elastic functions */ -float easeInElastic(float x){ +float easeInElastic(float x) { const float c4 = (2 * PI) / 3.0f; return x == 0 @@ -75,7 +75,7 @@ float easeInElastic(float x){ : -std::pow(2, 10 * x - 10) * std::sin((x * 10 - 10.75) * c4); } -float easeOutElastic(float x){ +float easeOutElastic(float x) { const float c4 = (2 * PI) / 3.0f; return x == 0 @@ -85,7 +85,7 @@ float easeOutElastic(float x){ : std::pow(2, -10 * x) * std::sin((x * 10 - 0.75) * c4) + 1; } -float easeInOutElastic(float x){ +float easeInOutElastic(float x) { const float c5 = (2 * PI) / 4.5; return x == 0 @@ -99,43 +99,43 @@ float easeInOutElastic(float x){ /* Quad functions */ -float easeInQuad(float x){ +float easeInQuad(float x) { return x * x; } -float easeOutQuad(float x){ +float easeOutQuad(float x) { return 1 - (1 - x) * (1 - x); } -float easeInOutQuad(float x){ +float easeInOutQuad(float x) { return x < 0.5 ? 2 * x * x : 1 - std::pow(-2 * x + 2, 2) / 2.0f; } /* Quart functions */ -float easeInQuart(float x){ +float easeInQuart(float x) { return x * easeInCubic(x); } -float easeOutQuart(float x){ +float easeOutQuart(float x) { return 1 - std::pow(1 - x, 4); } -float easeInOutQuart(float x){ +float easeInOutQuart(float x) { return x < 0.5 ? 8 * easeInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0f; } /* Expo functions */ -float easeInExpo(float x){ +float easeInExpo(float x) { return x == 0 ? 0 : std::pow(2, 10 * x - 10); } -float easeOutExpo(float x){ +float easeOutExpo(float x) { return x == 1 ? 1 : 1 - std::pow(2, -10 * x); } -float easeInOutExpo(float x){ +float easeInOutExpo(float x) { return x == 0 ? 0 : x == 1 @@ -146,21 +146,21 @@ float easeInOutExpo(float x){ /* Back functions */ -float easeInBack(float x){ +float easeInBack(float x) { const float c1 = 1.70158; const float c3 = c1 + 1; return c3 * easeInCubic(x) - c1 * easeInQuad(x); } -float easeOutBack(float x){ +float easeOutBack(float x) { const float c1 = 1.70158; const float c3 = c1 + 1; return 1 + c3 * std::pow(x - 1, 3) + c1 * std::pow(x - 1, 2); } -float easeInOutBack(float x){ +float easeInOutBack(float x) { const float c1 = 1.70158; const float c2 = c1 * 1.525; @@ -171,18 +171,18 @@ float easeInOutBack(float x){ /* Bounce functions */ -float easeInBounce(float x){ +float easeInBounce(float x) { return 1 - easeOutBounce(1 - x); } -float easeOutBounce(float x){ +float easeOutBounce(float x) { const float n1 = 7.5625; const float d1 = 2.75; if (x < 1 / d1) { return n1 * easeInQuad(x); } else if (x < 2 / d1) { - x-= 1.5; + x -= 1.5; return n1 * (x / d1) * x + 0.75; } else if (x < 2.5 / d1) { x -= 2.25; @@ -193,11 +193,11 @@ float easeOutBounce(float x){ } } -float easeInOutBounce(float x){ +float easeInOutBounce(float x) { return x < 0.5 ? (1 - easeOutBounce(1 - 2 * x)) / 2.0f : (1 + easeOutBounce(2 * x - 1)) / 2.0f; } - + } // namespace utils } // namespace td diff --git a/src/misc/Random.cpp b/src/misc/Random.cpp index 7c1c882..5b44ee8 100644 --- a/src/misc/Random.cpp +++ b/src/misc/Random.cpp @@ -5,11 +5,11 @@ namespace td { namespace utils { -void initRandomizer(){ +void initRandomizer() { srand(time(0)); } -std::uint64_t getRandomNumber(std::uint64_t max){ +std::uint64_t getRandomNumber(std::uint64_t max) { return rand() % max; } diff --git a/src/misc/Time.cpp b/src/misc/Time.cpp index ca172c5..b2b0c4b 100644 --- a/src/misc/Time.cpp +++ b/src/misc/Time.cpp @@ -4,32 +4,32 @@ namespace td { namespace utils { -void Timer::update(){ +void Timer::update() { m_InternalTime += getTime() - m_LastTime; - if(m_InternalTime >= m_Interval){ - if(m_Function != nullptr) + if (m_InternalTime >= m_Interval) { + if (m_Function != nullptr) m_Function(); m_InternalTime %= m_Interval; } m_LastTime = getTime(); } -void Timer::update(std::uint64_t delta){ +void Timer::update(std::uint64_t delta) { m_InternalTime += delta; - if(m_InternalTime >= m_Interval){ - if(m_Function != nullptr) + if (m_InternalTime >= m_Interval) { + if (m_Function != nullptr) m_Function(); m_InternalTime %= m_Interval; } m_LastTime = getTime(); } -void Timer::reset(){ +void Timer::reset() { m_InternalTime = 0; m_LastTime = getTime(); } -std::uint64_t getTime(){ +std::uint64_t getTime() { return std::chrono::duration_cast(std::chrono::system_clock().now().time_since_epoch()).count(); } diff --git a/src/network/DataBuffer.cpp b/src/network/DataBuffer.cpp index c2e7336..475c491 100644 --- a/src/network/DataBuffer.cpp +++ b/src/network/DataBuffer.cpp @@ -62,27 +62,27 @@ std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer) { return os; } -bool DataBuffer::ReadFile(const std::string& fileName){ - try{ +bool DataBuffer::ReadFile(const std::string& fileName) { + try { std::ifstream file(fileName); std::ostringstream ss; ss << file.rdbuf(); const std::string& s = ss.str(); m_Buffer = DataBuffer::Data(s.begin(), s.end()); m_ReadOffset = 0; - }catch(std::exception& e){ + } catch (std::exception& e) { std::cerr << "Failed to read file \"" << fileName << "\" reason : " << e.what() << std::endl; return false; } return m_Buffer.size() > 0; } -bool DataBuffer::WriteFile(const std::string& fileName){ - try{ +bool DataBuffer::WriteFile(const std::string& fileName) { + try { std::ofstream file(fileName); - file.write((const char*) m_Buffer.data(), m_Buffer.size()); + file.write((const char*)m_Buffer.data(), m_Buffer.size()); file.flush(); - }catch(std::exception& e){ + } catch (std::exception& e) { std::cerr << "Failed to write file \"" << fileName << "\" reason : " << e.what() << std::endl; return false; } diff --git a/src/network/IPAddress.cpp b/src/network/IPAddress.cpp index 6acea74..63a4d4f 100644 --- a/src/network/IPAddress.cpp +++ b/src/network/IPAddress.cpp @@ -16,13 +16,13 @@ namespace network { /* Create an invalid address */ IPAddress::IPAddress() noexcept - : m_Address(0), m_Valid(false){ - - } + : m_Address(0), m_Valid(false) { + +} /* Initialize by string IP */ IPAddress::IPAddress(const std::string& ip) - : m_Address(0), m_Valid(false){ + : m_Address(0), m_Valid(false) { std::sregex_iterator begin(ip.begin(), ip.end(), IPRegex); std::sregex_iterator end; @@ -41,7 +41,7 @@ IPAddress::IPAddress(const std::string& ip) } IPAddress::IPAddress(const std::wstring& ip) - : m_Address(0), m_Valid(false){ + : m_Address(0), m_Valid(false) { std::wsregex_iterator begin(ip.begin(), ip.end(), IPRegexW); std::wsregex_iterator end; @@ -61,7 +61,7 @@ IPAddress::IPAddress(const std::wstring& ip) /* Initialize by octets */ IPAddress::IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) noexcept - : m_Valid(true){ + : m_Valid(true) { m_Address = (octet1 << 24) | (octet2 << 16) | (octet3 << 8) | octet4; } diff --git a/src/network/Network.cpp b/src/network/Network.cpp index 161bb38..f667678 100644 --- a/src/network/Network.cpp +++ b/src/network/Network.cpp @@ -33,7 +33,7 @@ NetworkInitializer initializer; IPAddresses Dns::Resolve(const std::string& host) { IPAddresses list; - addrinfo hints = { 0 }, *addresses; + addrinfo hints = { 0 }, * addresses; //hints.ai_family = AF_UNSPEC; hints.ai_family = AF_INET; @@ -42,7 +42,7 @@ IPAddresses Dns::Resolve(const std::string& host) { getaddrinfo(host.c_str(), NULL, &hints, &addresses); - for (addrinfo *p = addresses; p != NULL; p = p->ai_next) { + for (addrinfo* p = addresses; p != NULL; p = p->ai_next) { #ifdef _WIN32 //wchar_t straddr[35]; //char straddr[512]; diff --git a/src/network/Socket.cpp b/src/network/Socket.cpp index 3971261..b047c1d 100644 --- a/src/network/Socket.cpp +++ b/src/network/Socket.cpp @@ -13,10 +13,10 @@ namespace td { namespace network { Socket::Socket(Type type) - : m_Blocking(false), + : m_Blocking(false), m_Type(type), m_Status(Disconnected), - m_Handle((SocketHandle) INVALID_SOCKET) + m_Handle((SocketHandle)INVALID_SOCKET) { } @@ -28,9 +28,9 @@ Socket::~Socket() { bool Socket::SetBlocking(bool block) { unsigned long mode = block ? 0 : 1; - if(ioctl(m_Handle, FIONBIO, &mode) < 0){ + if (ioctl(m_Handle, FIONBIO, &mode) < 0) { return false; - } + } m_Blocking = block; diff --git a/src/network/TCPListener.cpp b/src/network/TCPListener.cpp index 8b535be..d9a5462 100644 --- a/src/network/TCPListener.cpp +++ b/src/network/TCPListener.cpp @@ -8,16 +8,16 @@ #define ioctlsocket ioctl #endif -namespace td{ -namespace network{ +namespace td { +namespace network { -TCPListener::TCPListener(){} +TCPListener::TCPListener() {} -TCPListener::~TCPListener(){ +TCPListener::~TCPListener() { destroy(); } -bool TCPListener::listen(uint16_t port, int maxConnections){ +bool TCPListener::listen(uint16_t port, int maxConnections) { if ((m_Handle = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) return false; @@ -38,7 +38,7 @@ bool TCPListener::listen(uint16_t port, int maxConnections){ return true; } -bool TCPListener::accept(TCPSocket& newSocket){ +bool TCPListener::accept(TCPSocket& newSocket) { int addrlen = sizeof(newSocket.m_RemoteAddr); if ((newSocket.m_Handle = ::accept(m_Handle, reinterpret_cast(&newSocket.m_RemoteAddr), reinterpret_cast(&addrlen))) < 0) @@ -48,21 +48,21 @@ bool TCPListener::accept(TCPSocket& newSocket){ return true; } -void TCPListener::destroy(){ - if(m_Handle < 0) +void TCPListener::destroy() { + if (m_Handle < 0) ::closesocket(m_Handle); } -bool TCPListener::close(){ +bool TCPListener::close() { if (::shutdown(m_Handle, SD_BOTH) == 0) return true; return false; } -bool TCPListener::setBlocking(bool blocking){ +bool TCPListener::setBlocking(bool blocking) { unsigned long mode = blocking ? 0 : 1; - if(ioctlsocket(m_Handle, FIONBIO, &mode) < 0){ + if (ioctlsocket(m_Handle, FIONBIO, &mode) < 0) { return false; } return true; diff --git a/src/network/TCPSocket.cpp b/src/network/TCPSocket.cpp index ffba21c..28c9050 100644 --- a/src/network/TCPSocket.cpp +++ b/src/network/TCPSocket.cpp @@ -16,14 +16,14 @@ namespace network { TCPSocket::TCPSocket() : Socket(Socket::TCP), m_Port(0) { - m_Handle = (SocketHandle) INVALID_SOCKET; + m_Handle = (SocketHandle)INVALID_SOCKET; } bool TCPSocket::Connect(const IPAddress& address, unsigned short port) { if (this->GetStatus() == Connected) return true; - struct addrinfo hints = { 0 }, *result = nullptr; + struct addrinfo hints = { 0 }, * result = nullptr; if ((m_Handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) return false; @@ -55,7 +55,7 @@ bool TCPSocket::Connect(const IPAddress& address, unsigned short port) { return true; } -size_t TCPSocket::Send(const unsigned char* data, size_t size){ +size_t TCPSocket::Send(const unsigned char* data, size_t size) { if (this->GetStatus() != Connected) return 0; @@ -118,19 +118,19 @@ DataBuffer TCPSocket::Receive(std::size_t amount) { return DataBuffer(std::string(buf.get(), received)); } -TCPSocket::TCPSocket(TCPSocket&& other) : Socket(TCP){ +TCPSocket::TCPSocket(TCPSocket&& other) : Socket(TCP) { m_Handle = other.m_Handle; m_Port = other.m_Port; m_RemoteAddr = other.m_RemoteAddr; m_RemoteIP = other.m_RemoteIP; SetStatus(other.GetStatus()); SetBlocking(other.IsBlocking()); - other.m_Handle = (SocketHandle) INVALID_SOCKET; + other.m_Handle = (SocketHandle)INVALID_SOCKET; } -void SendPacket(const DataBuffer& data, network::TCPSocket& socket){ +void SendPacket(const DataBuffer& data, network::TCPSocket& socket) { DataBuffer compressed = utils::Compress(data); - socket.Send((const std::uint8_t*) compressed.ToString().data(), compressed.GetSize()); + socket.Send((const std::uint8_t*)compressed.ToString().data(), compressed.GetSize()); } diff --git a/src/protocol/PacketDispatcher.cpp b/src/protocol/PacketDispatcher.cpp index 6a187e2..fbcb073 100644 --- a/src/protocol/PacketDispatcher.cpp +++ b/src/protocol/PacketDispatcher.cpp @@ -3,20 +3,20 @@ namespace td { namespace protocol { -void PacketDispatcher::RegisterHandler(PacketType type, PacketHandler* handler){ +void PacketDispatcher::RegisterHandler(PacketType type, PacketHandler* handler) { auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler); if (found == m_Handlers[type].end()) m_Handlers[type].push_back(handler); } -void PacketDispatcher::UnregisterHandler(PacketType type, PacketHandler* handler){ +void PacketDispatcher::UnregisterHandler(PacketType type, PacketHandler* handler) { auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler); if (found != m_Handlers[type].end()) m_Handlers[type].erase(found); } -void PacketDispatcher::UnregisterHandler(PacketHandler* handler){ - for (auto& pair : m_Handlers){ +void PacketDispatcher::UnregisterHandler(PacketHandler* handler) { + for (auto& pair : m_Handlers) { if (pair.second.empty()) continue; PacketType type = pair.first; @@ -25,7 +25,7 @@ void PacketDispatcher::UnregisterHandler(PacketHandler* handler){ } } -void PacketDispatcher::Dispatch(Packet* packet){ +void PacketDispatcher::Dispatch(Packet* packet) { if (!packet) return; PacketType type = packet->getType(); diff --git a/src/protocol/PacketFactory.cpp b/src/protocol/PacketFactory.cpp index 6410ae4..5dbd180 100644 --- a/src/protocol/PacketFactory.cpp +++ b/src/protocol/PacketFactory.cpp @@ -4,9 +4,9 @@ namespace td { namespace protocol { -namespace PacketFactory{ +namespace PacketFactory { -using PacketCreator = std::function; +using PacketCreator = std::function; static std::map packets = { {PacketType::PlayerLogin, []() -> Packet* {return new PlayerLoginPacket();} }, @@ -30,7 +30,7 @@ static std::map packets = { {PacketType::WorldAddTower, []() -> Packet* {return new WorldAddTowerPacket(); } }, }; -Packet* createPacket(PacketType type, DataBuffer& buffer){ +Packet* createPacket(PacketType type, DataBuffer& buffer) { Packet* packet = packets[type](); packet->Deserialize(buffer); return packet; diff --git a/src/protocol/Protocol.cpp b/src/protocol/Protocol.cpp index 08972a0..aed7a23 100644 --- a/src/protocol/Protocol.cpp +++ b/src/protocol/Protocol.cpp @@ -9,27 +9,27 @@ namespace protocol { const int BITS_IN_BYTE = 8; const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t); -unsigned int countBits(unsigned int number){ +unsigned int countBits(unsigned int number) { // log function in base 2 // take only integer part return (int)std::log2(number) + 1; } -DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile){ +DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile) { buffer << tile->getType(); - switch (tile->getType()){ - case game::TileType::Tower:{ - const game::TowerTile* towerTile = (const game::TowerTile*) tile.get(); + switch (tile->getType()) { + case game::TileType::Tower: { + const game::TowerTile* towerTile = (const game::TowerTile*)tile.get(); buffer << towerTile->color_palette_ref << towerTile->team_owner; break; } - case game::TileType::Walk:{ - const game::WalkableTile* walkTile = (const game::WalkableTile*) tile.get(); + case game::TileType::Walk: { + const game::WalkableTile* walkTile = (const game::WalkableTile*)tile.get(); buffer << walkTile->direction; break; } - case game::TileType::Decoration:{ - const game::DecorationTile* decoTile = (const game::DecorationTile*) tile.get(); + case game::TileType::Decoration: { + const game::DecorationTile* decoTile = (const game::DecorationTile*)tile.get(); buffer << decoTile->color_palette_ref; break; } @@ -39,23 +39,23 @@ DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile){ return buffer; } -DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile){ +DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile) { game::TileType tileType; buffer >> tileType; - switch (tileType){ - case game::TileType::Tower:{ + switch (tileType) { + case game::TileType::Tower: { std::shared_ptr tilePtr = std::make_shared(); buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner; tile = tilePtr; break; } - case game::TileType::Walk:{ + case game::TileType::Walk: { std::shared_ptr tilePtr = std::make_shared(); buffer >> tilePtr->direction; tile = tilePtr; break; } - case game::TileType::Decoration:{ + case game::TileType::Decoration: { std::shared_ptr tilePtr = std::make_shared(); buffer >> tilePtr->color_palette_ref; tile = tilePtr; @@ -67,17 +67,17 @@ DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile){ return buffer; } -DataBuffer PlayerLoginPacket::Serialize() const{ +DataBuffer PlayerLoginPacket::Serialize() const { DataBuffer data; data << getID() << m_PlayerName; return data; } -void PlayerLoginPacket::Deserialize(DataBuffer& data){ +void PlayerLoginPacket::Deserialize(DataBuffer& data) { data >> m_PlayerName; } -DataBuffer WorldBeginDataPacket::Serialize() const{ +DataBuffer WorldBeginDataPacket::Serialize() const { DataBuffer data; const game::TowerTileColorPalette towerTilePalette = m_World->getTowerTileColorPalette(); const std::vector& decoTilePalette = m_World->getDecorationPalette(); @@ -100,7 +100,7 @@ DataBuffer WorldBeginDataPacket::Serialize() const{ // tile palette data << m_World->getTilePalette().size(); - for (game::TilePtr tile : m_World->getTilePalette()){ + for (game::TilePtr tile : m_World->getTilePalette()) { data << tile; } @@ -109,7 +109,7 @@ DataBuffer WorldBeginDataPacket::Serialize() const{ return data; } -void WorldBeginDataPacket::Deserialize(DataBuffer& data){ +void WorldBeginDataPacket::Deserialize(DataBuffer& data) { data >> m_TowerPlacePalette >> m_WalkablePalette; std::uint16_t decoPaletteSize; @@ -131,7 +131,7 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data){ m_TilePalette.reserve(tilePaletteSize); - for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++){ + for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++) { game::TilePtr tile; data >> tile; m_TilePalette.push_back(tile); @@ -142,14 +142,14 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data){ typedef std::vector ChunkPackedData; -DataBuffer WorldDataPacket::Serialize() const{ +DataBuffer WorldDataPacket::Serialize() const { DataBuffer data; data << getID() << m_World->getChunks().size(); - for (const auto& pair : m_World->getChunks()){ + for (const auto& pair : m_World->getChunks()) { game::ChunkCoord coords = pair.first; game::ChunkPtr chunk = pair.second; - data << coords.first << coords.second << (std::uint64_t) chunk->palette.size(); + data << coords.first << coords.second << (std::uint64_t)chunk->palette.size(); std::size_t bufferSize = data.GetSize(); data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type)); @@ -160,8 +160,8 @@ DataBuffer WorldDataPacket::Serialize() const{ game::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1); ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0); - - for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++){ + + for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) { int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG; int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG; int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG; @@ -173,7 +173,7 @@ DataBuffer WorldDataPacket::Serialize() const{ chunkData[startLong] |= (value << startOffset); - if (startLong != endLong){ + if (startLong != endLong) { chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset)); } } @@ -185,11 +185,11 @@ DataBuffer WorldDataPacket::Serialize() const{ return data; } -void WorldDataPacket::Deserialize(DataBuffer& data){ +void WorldDataPacket::Deserialize(DataBuffer& data) { std::uint64_t chunkCount; data >> chunkCount; - for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++){ + for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++) { game::ChunkPtr chunk = std::make_shared(); game::ChunkCoord::first_type chunkX, chunkY; @@ -215,16 +215,15 @@ void WorldDataPacket::Deserialize(DataBuffer& data){ memcpy((void*)chunkData.data(), data.data() + data.GetReadOffset(), chunkData.size() * sizeof(ChunkPackedData::value_type)); data.SetReadOffset(data.GetReadOffset() + chunkData.size() * sizeof(ChunkPackedData::value_type)); - for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++){ + for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) { int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG; int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG; int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG; game::ChunkData::value_type value; - if (startLong == endLong){ + if (startLong == endLong) { value = (chunkData[startLong] >> startOffset); - } - else{ + } else { int endOffset = BITS_IN_LONG - startOffset; value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset); } @@ -234,180 +233,180 @@ void WorldDataPacket::Deserialize(DataBuffer& data){ } - m_Chunks.insert({{chunkX, chunkY}, chunk}); + m_Chunks.insert({ {chunkX, chunkY}, chunk }); } } -DataBuffer KeepAlivePacket::Serialize() const{ +DataBuffer KeepAlivePacket::Serialize() const { DataBuffer data; data << getID() << m_AliveID; return data; } -void KeepAlivePacket::Deserialize(DataBuffer& data){ +void KeepAlivePacket::Deserialize(DataBuffer& data) { data >> m_AliveID; } -DataBuffer UpdateMoneyPacket::Serialize() const{ +DataBuffer UpdateMoneyPacket::Serialize() const { DataBuffer data; data << getID() << m_NewAmount; return data; } -void UpdateMoneyPacket::Deserialize(DataBuffer& data){ +void UpdateMoneyPacket::Deserialize(DataBuffer& data) { data >> m_NewAmount; } -DataBuffer UpdateExpPacket::Serialize() const{ +DataBuffer UpdateExpPacket::Serialize() const { DataBuffer data; data << getID() << m_NewAmount; return data; } -void UpdateExpPacket::Deserialize(DataBuffer& data){ +void UpdateExpPacket::Deserialize(DataBuffer& data) { data >> m_NewAmount; } -DataBuffer UpdateLobbyTimePacket::Serialize() const{ +DataBuffer UpdateLobbyTimePacket::Serialize() const { DataBuffer data; data << getID() << m_RemainingTime; return data; } -void UpdateLobbyTimePacket::Deserialize(DataBuffer& data){ +void UpdateLobbyTimePacket::Deserialize(DataBuffer& data) { data >> m_RemainingTime; } -DataBuffer UpdateGameStatePacket::Serialize() const{ +DataBuffer UpdateGameStatePacket::Serialize() const { DataBuffer data; data << getID() << m_GameState; return data; } -void UpdateGameStatePacket::Deserialize(DataBuffer& data){ +void UpdateGameStatePacket::Deserialize(DataBuffer& data) { data >> m_GameState; } -DataBuffer PlayerListPacket::Serialize() const{ +DataBuffer PlayerListPacket::Serialize() const { DataBuffer data; data << getID() << (std::uint8_t)m_Players.size(); - for (auto pair : m_Players){ + for (auto pair : m_Players) { data << pair.first << pair.second.name << pair.second.team; } return data; } -void PlayerListPacket::Deserialize(DataBuffer& data){ +void PlayerListPacket::Deserialize(DataBuffer& data) { std::uint8_t playerCount; data >> playerCount; - for (int i = 0; i < playerCount; i++){ + for (int i = 0; i < playerCount; i++) { std::uint8_t playerID; PlayerInfo playerInfo; data >> playerID >> playerInfo.name >> playerInfo.team; - m_Players.insert({playerID, playerInfo}); + m_Players.insert({ playerID, playerInfo }); } } -DataBuffer PlayerJoinPacket::Serialize() const{ +DataBuffer PlayerJoinPacket::Serialize() const { DataBuffer data; data << getID() << m_PlayerID << m_PlayerName; return data; } -void PlayerJoinPacket::Deserialize(DataBuffer& data){ +void PlayerJoinPacket::Deserialize(DataBuffer& data) { data >> m_PlayerID >> m_PlayerName; } -DataBuffer PlayerLeavePacket::Serialize() const{ +DataBuffer PlayerLeavePacket::Serialize() const { DataBuffer data; data << getID() << m_PlayerID; return data; } -void PlayerLeavePacket::Deserialize(DataBuffer& data){ +void PlayerLeavePacket::Deserialize(DataBuffer& data) { data >> m_PlayerID; } -DataBuffer ConnexionInfoPacket::Serialize() const{ +DataBuffer ConnexionInfoPacket::Serialize() const { DataBuffer data; data << getID() << m_ConnectionID; return data; } -void ConnexionInfoPacket::Deserialize(DataBuffer& data){ +void ConnexionInfoPacket::Deserialize(DataBuffer& data) { data >> m_ConnectionID; } -DataBuffer SelectTeamPacket::Serialize() const{ +DataBuffer SelectTeamPacket::Serialize() const { DataBuffer data; data << getID() << m_SelectedTeam; return data; } -void SelectTeamPacket::Deserialize(DataBuffer& data){ +void SelectTeamPacket::Deserialize(DataBuffer& data) { data >> m_SelectedTeam; } -DataBuffer UpdatePlayerTeamPacket::Serialize() const{ +DataBuffer UpdatePlayerTeamPacket::Serialize() const { DataBuffer data; data << getID() << m_PlayerID << m_SelectedTeam; return data; } -void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data){ +void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data) { data >> m_PlayerID >> m_SelectedTeam; } -DataBuffer DisconnectPacket::Serialize() const{ +DataBuffer DisconnectPacket::Serialize() const { DataBuffer data; data << getID() << m_Reason; return data; } -void DisconnectPacket::Deserialize(DataBuffer& data){ +void DisconnectPacket::Deserialize(DataBuffer& data) { data >> m_Reason; } -DataBuffer ServerTpsPacket::Serialize() const{ +DataBuffer ServerTpsPacket::Serialize() const { DataBuffer data; data << getID() << m_TPS << m_PacketSendTime; return data; } -void ServerTpsPacket::Deserialize(DataBuffer& data){ +void ServerTpsPacket::Deserialize(DataBuffer& data) { data >> m_TPS >> m_PacketSendTime; } -DataBuffer SpawnMobPacket::Serialize() const{ +DataBuffer SpawnMobPacket::Serialize() const { DataBuffer data; - data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection + data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection << m_Sender << m_MobX << m_MobY; return data; } -void SpawnMobPacket::Deserialize(DataBuffer& data){ - data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection +void SpawnMobPacket::Deserialize(DataBuffer& data) { + data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection >> m_Sender >> m_MobX >> m_MobY; } -DataBuffer PlaceTowerPacket::Serialize() const{ +DataBuffer PlaceTowerPacket::Serialize() const { DataBuffer data; data << getID() << m_TowerX << m_TowerY << m_TowerType; return data; } -void PlaceTowerPacket::Deserialize(DataBuffer& data){ +void PlaceTowerPacket::Deserialize(DataBuffer& data) { data >> m_TowerX >> m_TowerY >> m_TowerType; } -DataBuffer WorldAddTowerPacket::Serialize() const{ +DataBuffer WorldAddTowerPacket::Serialize() const { DataBuffer data; data << getID() << m_TowerX << m_TowerY << m_TowerType << m_Builder; return data; } -void WorldAddTowerPacket::Deserialize(DataBuffer& data){ +void WorldAddTowerPacket::Deserialize(DataBuffer& data) { data >> m_TowerX >> m_TowerY >> m_TowerType >> m_Builder; } diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp index 4bf91fb..0284665 100644 --- a/src/render/Renderer.cpp +++ b/src/render/Renderer.cpp @@ -14,18 +14,18 @@ using namespace gl; -namespace td{ -namespace render{ +namespace td { +namespace render { -Renderer::Renderer(){ +Renderer::Renderer() { } -Renderer::~Renderer(){ +Renderer::~Renderer() { } -void Renderer::updateIsometricView(){ +void Renderer::updateIsometricView() { float isometricEased = utils::easeInOutExpo(m_IsometricShade); m_WorldShader->start(); m_WorldShader->setIsometricView(isometricEased); @@ -33,7 +33,7 @@ void Renderer::updateIsometricView(){ m_EntityShader->setIsometricView(isometricEased); } -void Renderer::initShader(){ +void Renderer::initShader() { m_WorldShader = std::make_unique(); m_WorldShader->loadShader(); m_EntityShader = std::make_unique(); @@ -42,23 +42,23 @@ void Renderer::initShader(){ updateIsometricView(); } -bool Renderer::init(){ +bool Renderer::init() { glbinding::Binding::initialize(); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); initShader(); return true; } -void Renderer::renderVAO(const GL::VertexArray& vao){ +void Renderer::renderVAO(const GL::VertexArray& vao) { m_WorldShader->start(); vao.bind(); glDrawArrays(GL_TRIANGLES, 0, vao.getVertexCount()); vao.unbind(); } -void Renderer::renderModel(const Model& model){ +void Renderer::renderModel(const Model& model) { m_EntityShader->start(); m_EntityShader->setModelPos(model.positon); model.vao->bind(); @@ -66,13 +66,13 @@ void Renderer::renderModel(const Model& model){ model.vao->unbind(); } -void Renderer::updateIsometricFade(){ +void Renderer::updateIsometricFade() { static std::uint64_t lastTime = utils::getTime(); - if(m_IsometricShade != (float) m_IsometricView){ - float step = (float) (utils::getTime() - lastTime) / 1000.0f * m_AnimationSpeed; - if(m_IsometricShade < m_IsometricView){ + if (m_IsometricShade != (float)m_IsometricView) { + float step = (float)(utils::getTime() - lastTime) / 1000.0f * m_AnimationSpeed; + if (m_IsometricShade < m_IsometricView) { m_IsometricShade += step; - }else{ + } else { m_IsometricShade -= step; } m_IsometricShade = std::min(m_IsometricShade, 1.0f); @@ -82,13 +82,13 @@ void Renderer::updateIsometricFade(){ lastTime = utils::getTime(); } -void Renderer::prepare(){ +void Renderer::prepare() { glClear(GL_COLOR_BUFFER_BIT); glClearColor(0, 0, 0, 0); updateIsometricFade(); } -void Renderer::resize(int width, int height){ +void Renderer::resize(int width, int height) { m_WorldShader->start(); m_WorldShader->setAspectRatio((float)width / height); m_EntityShader->start(); @@ -96,20 +96,20 @@ void Renderer::resize(int width, int height){ glViewport(0, 0, width, height); } -void Renderer::setZoom(float zoom){ +void Renderer::setZoom(float zoom) { m_WorldShader->start(); m_WorldShader->setZoom(zoom); m_EntityShader->start(); m_EntityShader->setZoom(zoom); } -void Renderer::setCamMovement(const glm::vec2& mov){ +void Renderer::setCamMovement(const glm::vec2& mov) { m_CamPos.x += mov.x * (1 - m_IsometricView) + (0.5 * mov.x - mov.y) * m_IsometricView; m_CamPos.y += -mov.y * (1 - m_IsometricView) + (-0.5 * mov.x - mov.y) * m_IsometricView; setCamPos(m_CamPos); } -void Renderer::setCamPos(const glm::vec2& newPos){ +void Renderer::setCamPos(const glm::vec2& newPos) { m_CamPos = newPos; m_WorldShader->start(); m_WorldShader->setCamPos(newPos); @@ -117,11 +117,11 @@ void Renderer::setCamPos(const glm::vec2& newPos){ m_EntityShader->setCamPos(newPos); } -void Renderer::setIsometricView(bool isometric){ +void Renderer::setIsometricView(bool isometric) { m_IsometricView = isometric; } -glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight){ +glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight) { float isometricEased = utils::easeInOutExpo(m_IsometricShade); float relativeX = (cursorPos.x / windowWidth * 2) - 1; @@ -133,7 +133,7 @@ glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRa float worldX = m_CamPos.x + deltaX * (1 - isometricEased) + (0.5 * deltaX + deltaY) * isometricEased; float worldY = m_CamPos.y + deltaY * (1 - isometricEased) + (-0.5 * deltaX + deltaY) * isometricEased; - return {worldX, worldY}; + return { worldX, worldY }; } diff --git a/src/render/WorldRenderer.cpp b/src/render/WorldRenderer.cpp index e016fe9..a1e1a72 100644 --- a/src/render/WorldRenderer.cpp +++ b/src/render/WorldRenderer.cpp @@ -103,7 +103,7 @@ void WorldRenderer::changeZoom(float zoomStep) { static float sensibility = 1.5f; if (zoomStep < 0) { m_Zoom /= -zoomStep * sensibility; - } else { + } else { m_Zoom *= zoomStep * sensibility; } m_Renderer->setZoom(m_Zoom); @@ -157,7 +157,7 @@ glm::vec2 WorldRenderer::getCursorWorldPos() const { return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight()); } -glm::vec2 WorldRenderer::getClickWorldPos() const{ +glm::vec2 WorldRenderer::getClickWorldPos() const { return m_Renderer->getCursorWorldPos(m_HoldCursorPos, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight()); } diff --git a/src/render/gui/TowerGui.cpp b/src/render/gui/TowerGui.cpp index 2654838..767c194 100644 --- a/src/render/gui/TowerGui.cpp +++ b/src/render/gui/TowerGui.cpp @@ -20,7 +20,7 @@ #include #include -namespace TowerGui{ +namespace TowerGui { static GLFWwindow* window; static std::unique_ptr client; @@ -29,7 +29,7 @@ static td::render::Renderer* renderer; bool serverShouldStop = false; -void init(GLFWwindow* glfw_window, td::render::Renderer* render){ +void init(GLFWwindow* glfw_window, td::render::Renderer* render) { window = glfw_window; IMGUI_CHECKVERSION(); ImGui::CreateContext(); @@ -44,47 +44,47 @@ void init(GLFWwindow* glfw_window, td::render::Renderer* render){ client = std::make_unique(render); } -void beginFrame(){ +void beginFrame() { ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame(); } -void endFrame(){ +void endFrame() { ImGui::EndFrame(); ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); } -void renderFPSCounter(){ +void renderFPSCounter() { ImGui::Begin("FPS Counter"); ImGui::Text("FPS : %i", (int)ImGui::GetIO().Framerate); static bool vsync = true; - if (ImGui::Checkbox("V-Sync", &vsync)){ + if (ImGui::Checkbox("V-Sync", &vsync)) { glfwSwapInterval(vsync); } static bool isometric = true; - if (ImGui::Checkbox("Vue Isometrique ?", &isometric)){ + if (ImGui::Checkbox("Vue Isometrique ?", &isometric)) { renderer->setIsometricView(isometric); } ImGui::End(); } -bool startServer(int port, const std::string& worldFilePath){ +bool startServer(int port, const std::string& worldFilePath) { if (worldFilePath.empty()) return false; std::shared_ptr server = std::make_shared(worldFilePath); - if (!server->start(port)){ + if (!server->start(port)) { return false; } - serverThread = new std::thread([server](){ - while (!serverShouldStop){ + serverThread = new std::thread([server]() { + while (!serverShouldStop) { static std::uint64_t lastTime = td::utils::getTime(); std::uint64_t time = td::utils::getTime(); std::uint64_t delta = time - lastTime; - if (delta >= SERVER_TICK){ + if (delta >= SERVER_TICK) { server->tick(delta); lastTime = td::utils::getTime(); std::uint64_t sleepTime = SERVER_TICK - (delta - SERVER_TICK); @@ -97,38 +97,37 @@ bool startServer(int port, const std::string& worldFilePath){ return true; } -void renderMainMenu(){ +void renderMainMenu() { ImGui::Begin("Main Menu"); - if (ImGui::Button("Rejoindre une partie##join")){ + if (ImGui::Button("Rejoindre une partie##join")) { ImGui::OpenPopup("Rejoindre une partie##join_popup"); } - if (ImGui::Button("Créer une partie")){ + if (ImGui::Button("Créer une partie")) { ImGui::OpenPopup("Créer une partie##create_popup"); } - if (ImGui::Button("Options")){ + if (ImGui::Button("Options")) { } static bool triedToConnect = false; - if (ImGui::BeginPopup("Rejoindre une partie##join_popup")){ + if (ImGui::BeginPopup("Rejoindre une partie##join_popup")) { static char buffer[512] = "localhost"; static int port = 25565; ImGui::InputText("Server Adress", buffer, sizeof(buffer)); ImGui::InputInt("Port", &port, -1); - if (ImGui::Button("Rejoindre")){ + if (ImGui::Button("Rejoindre")) { client->connect(buffer, port); triedToConnect = true; } - if (triedToConnect){ + if (triedToConnect) { ImGui::Text("Impossible de se connecter"); } ImGui::EndPopup(); - } - else{ + } else { triedToConnect = false; } static bool triedToCreate = false; - if (ImGui::BeginPopup("Créer une partie##create_popup")){ + if (ImGui::BeginPopup("Créer une partie##create_popup")) { static imgui_addons::ImGuiFileBrowser file_dialog; static int port = 25565; static std::string worldFilePath; @@ -136,33 +135,31 @@ void renderMainMenu(){ ImGui::InputInt("Server Port", &port, -1); ImGui::Text(std::string("Fichier de monde sélectionné : " + (worldFilePath.empty() ? std::string("Aucun") : worldFilePath)).c_str()); ImGui::SameLine(); - if (ImGui::Button("Ouvrir un fichier")){ + if (ImGui::Button("Ouvrir un fichier")) { ImGui::OpenPopup("WorldFileDialog"); } - if (file_dialog.showFileDialog("WorldFileDialog", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(600, 300), ".tdmap")){ + if (file_dialog.showFileDialog("WorldFileDialog", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(600, 300), ".tdmap")) { worldFilePath = file_dialog.selected_path; } - if (ImGui::Button("Créer")){ - if (!startServer(port, worldFilePath)){ + if (ImGui::Button("Créer")) { + if (!startServer(port, worldFilePath)) { triedToCreate = true; - } - else{ + } else { client->connect("localhost", port); } } if (triedToCreate) ImGui::Text("Failed to launch server"); ImGui::EndPopup(); - } - else{ + } else { triedToCreate = false; } ImGui::End(); } -ImVec4 getImGuiTeamColor(td::game::TeamColor color){ - switch (color){ +ImVec4 getImGuiTeamColor(td::game::TeamColor color) { + switch (color) { case td::game::TeamColor::None: break; case td::game::TeamColor::Red: @@ -173,9 +170,9 @@ ImVec4 getImGuiTeamColor(td::game::TeamColor color){ return ImVec4(1, 1, 1, 1); } -void showPlayers(){ - if (ImGui::TreeNode(std::string("Players (" + std::to_string(client->getGame().getPlayers().size()) + ")##player_list").c_str())){ - for (auto pair : client->getGame().getPlayers()){ +void showPlayers() { + if (ImGui::TreeNode(std::string("Players (" + std::to_string(client->getGame().getPlayers().size()) + ")##player_list").c_str())) { + for (auto pair : client->getGame().getPlayers()) { const td::game::Player& player = pair.second; ImGui::PushStyleColor(ImGuiCol_Text, getImGuiTeamColor(player.getTeamColor())); ImGui::Text(player.getName().c_str()); @@ -185,19 +182,19 @@ void showPlayers(){ } } -void showTeamSelection(){ +void showTeamSelection() { if (client->getGame().getPlayer() == nullptr) return; td::game::TeamColor playerTeam = client->getGame().getPlayer()->getTeamColor(); - if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Red ? "Leave" : "Join") + std::string(" Red Team")).c_str())){ + if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Red ? "Leave" : "Join") + std::string(" Red Team")).c_str())) { if (playerTeam == td::game::TeamColor::Red) client->selectTeam(td::game::TeamColor::None); else client->selectTeam(td::game::TeamColor::Red); } ImGui::SameLine(); - if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Blue ? "Leave" : "Join") + std::string(" Blue Team")).c_str())){ + if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Blue ? "Leave" : "Join") + std::string(" Blue Team")).c_str())) { if (playerTeam == td::game::TeamColor::Blue) client->selectTeam(td::game::TeamColor::None); else @@ -205,36 +202,35 @@ void showTeamSelection(){ } } -void showLobbyProgress(){ +void showLobbyProgress() { const int timePassed = LOBBY_WAITING_TIME - client->getGame().getLobbyTime(); const float progress = (float)timePassed / (float)(LOBBY_WAITING_TIME); - if (progress > 0 && progress < 1){ + if (progress > 0 && progress < 1) { ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f), std::string(std::to_string(client->getGame().getLobbyTime() / 1000) + "s").c_str()); ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x); ImGui::Text("Time Remaining"); - } - else{ + } else { ImGui::Text("Waiting for players ...\n"); } } -void showTPS(){ +void showTPS() { ImGui::Text("Server TPS : %.1f", client->getConnexion().getServerTPS()); ImGui::Text("Server Ping : %i", client->getConnexion().getServerPing()); } -void showStats(){ +void showStats() { ImGui::Text("Gold : %i", client->getGame().getPlayer()->getGold()); } -void renderSummonMenu(){ +void renderSummonMenu() { static bool menu_open = false; - if (menu_open){ + if (menu_open) { ImGui::Begin("Summon", &menu_open); static int width = 100; ImTextureID my_tex_id = ImGui::GetIO().Fonts->TexID; - for (int i = 0; i < 8; i++){ + for (int i = 0; i < 8; i++) { ImGui::SameLine(); ImGui::PushID(i); ImGui::Image(my_tex_id, ImVec2(100, 100)); @@ -243,7 +239,7 @@ void renderSummonMenu(){ ImGui::Separator(); static int values[16]; ImGui::PushItemWidth(width); - for (int i = 0; i < 8; i++){ + for (int i = 0; i < 8; i++) { ImGui::SameLine(); ImGui::PushID(i); ImGui::InputInt("", values + i, 1, 10); @@ -251,7 +247,7 @@ void renderSummonMenu(){ } ImGui::PopItemWidth(); ImGui::Separator(); - for (int i = 0; i < 8; i++){ + for (int i = 0; i < 8; i++) { ImGui::SameLine(); ImGui::PushID(i); ImGui::Image(my_tex_id, ImVec2(100, 100)); @@ -259,7 +255,7 @@ void renderSummonMenu(){ } ImGui::Separator(); ImGui::PushItemWidth(width); - for (int i = 8; i < 16; i++){ + for (int i = 8; i < 16; i++) { ImGui::SameLine(); ImGui::PushID(i); ImGui::InputInt("", values + i, 1, 10); @@ -270,8 +266,8 @@ void renderSummonMenu(){ } } -void renderGame(){ - if (client->getGame().getGameState() == td::game::GameState::Lobby){ +void renderGame() { + if (client->getGame().getGameState() == td::game::GameState::Lobby) { ImGui::Begin("Lobby"); showTPS(); @@ -281,7 +277,7 @@ void renderGame(){ ImGui::End(); } - if (client->getGame().getGameState() == td::game::GameState::Game){ + if (client->getGame().getGameState() == td::game::GameState::Game) { ImGui::Begin("Game"); showTPS(); @@ -292,7 +288,7 @@ void renderGame(){ } } -void tick(){ +void tick() { static std::uint64_t lastTime = td::utils::getTime(); std::uint64_t time = td::utils::getTime(); @@ -303,7 +299,7 @@ void tick(){ lastTime = td::utils::getTime(); } -void render(){ +void render() { tick(); beginFrame(); client->render(); @@ -319,11 +315,11 @@ void render(){ endFrame(); } -void destroy(){ +void destroy() { client->closeConnection(); client.reset(); serverShouldStop = true; - if (serverThread != nullptr){ + if (serverThread != nullptr) { serverThread->join(); delete serverThread; } diff --git a/src/render/loader/GLLoader.cpp b/src/render/loader/GLLoader.cpp index 867b63f..202ebf8 100644 --- a/src/render/loader/GLLoader.cpp +++ b/src/render/loader/GLLoader.cpp @@ -11,64 +11,64 @@ using namespace gl; -namespace GL{ +namespace GL { - VertexArray::~VertexArray(){ - if(m_ID != 0) - glDeleteVertexArrays(1, &m_ID); - } +VertexArray::~VertexArray() { + if (m_ID != 0) + glDeleteVertexArrays(1, &m_ID); +} - VertexArray::VertexArray(unsigned int vertexCount) : m_VertexCount(vertexCount){ - glGenVertexArrays(1, &m_ID); - } +VertexArray::VertexArray(unsigned int vertexCount) : m_VertexCount(vertexCount) { + glGenVertexArrays(1, &m_ID); +} - void VertexArray::bind() const{ - glBindVertexArray(m_ID); - } +void VertexArray::bind() const { + glBindVertexArray(m_ID); +} - void VertexArray::unbind() const{ - glBindVertexArray(0); - } +void VertexArray::unbind() const { + glBindVertexArray(0); +} - void VertexArray::bindVertexBuffer(VertexBuffer& VertexBuffer){ - VertexBuffer.bind(); - VertexBuffer.bindVertexAttribs(); - m_VertexBuffers.push_back(std::move(VertexBuffer)); - } +void VertexArray::bindVertexBuffer(VertexBuffer& VertexBuffer) { + VertexBuffer.bind(); + VertexBuffer.bindVertexAttribs(); + m_VertexBuffers.push_back(std::move(VertexBuffer)); +} - VertexBuffer::~VertexBuffer(){ - if(m_ID != 0) - glDeleteBuffers(1, &m_ID); - } +VertexBuffer::~VertexBuffer() { + if (m_ID != 0) + glDeleteBuffers(1, &m_ID); +} - VertexBuffer::VertexBuffer(const std::vector& data, unsigned int stride) : m_DataStride(stride){ - glGenBuffers(1, &m_ID); - bind(); - glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), nullptr, GL_STATIC_DRAW); - glBufferSubData(GL_ARRAY_BUFFER, 0, data.size() * sizeof(float), data.data()); - unbind(); - } +VertexBuffer::VertexBuffer(const std::vector& data, unsigned int stride) : m_DataStride(stride) { + glGenBuffers(1, &m_ID); + bind(); + glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), nullptr, GL_STATIC_DRAW); + glBufferSubData(GL_ARRAY_BUFFER, 0, data.size() * sizeof(float), data.data()); + unbind(); +} - void VertexBuffer::bind() const{ - glBindBuffer(GL_ARRAY_BUFFER, m_ID); - } +void VertexBuffer::bind() const { + glBindBuffer(GL_ARRAY_BUFFER, m_ID); +} - void VertexBuffer::unbind() const{ - glBindBuffer(GL_ARRAY_BUFFER, 0); - } +void VertexBuffer::unbind() const { + glBindBuffer(GL_ARRAY_BUFFER, 0); +} - void VertexBuffer::addVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset){ - VertexAttribPointer pointer; - pointer.m_Index = index; - pointer.m_Size = coordinateSize; - pointer.m_Offset = offset; - m_VertexAttribs.push_back(pointer); - } +void VertexBuffer::addVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset) { + VertexAttribPointer pointer; + pointer.m_Index = index; + pointer.m_Size = coordinateSize; + pointer.m_Offset = offset; + m_VertexAttribs.push_back(pointer); +} - void VertexBuffer::bindVertexAttribs() const{ - for(const VertexAttribPointer& pointer : m_VertexAttribs){ - glEnableVertexAttribArray(pointer.m_Index); - glVertexAttribPointer(pointer.m_Index, pointer.m_Size, GL_FLOAT, false, m_DataStride * sizeof(float), (void*)(intptr_t) pointer.m_Offset); - } +void VertexBuffer::bindVertexAttribs() const { + for (const VertexAttribPointer& pointer : m_VertexAttribs) { + glEnableVertexAttribArray(pointer.m_Index); + glVertexAttribPointer(pointer.m_Index, pointer.m_Size, GL_FLOAT, false, m_DataStride * sizeof(float), (void*)(intptr_t)pointer.m_Offset); } +} } \ No newline at end of file diff --git a/src/render/loader/TextureLoader.cpp b/src/render/loader/TextureLoader.cpp index eb9e001..b738358 100644 --- a/src/render/loader/TextureLoader.cpp +++ b/src/render/loader/TextureLoader.cpp @@ -21,8 +21,8 @@ const unsigned int loadGLTexture(const char* fileName) { const unsigned char* image = stbi_load(fileName, &width, &height, &comp, STBI_rgb_alpha); if (image == nullptr) { - std::cerr << "Erreur lors du chargement de la texture !" << std::endl; - throw(std::runtime_error("Failed to load texture")); + std::cerr << "Erreur lors du chargement de la texture !" << std::endl; + throw(std::runtime_error("Failed to load texture")); } GLuint textureID; @@ -34,13 +34,13 @@ const unsigned int loadGLTexture(const char* fileName) { if (comp == 3) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, - GL_UNSIGNED_BYTE, image); + GL_UNSIGNED_BYTE, image); else if (comp == 4) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, - GL_UNSIGNED_BYTE, image); + GL_UNSIGNED_BYTE, image); glBindTexture(GL_TEXTURE_2D, 0); - stbi_image_free((void*) image); + stbi_image_free((void*)image); return textureID; } } diff --git a/src/render/loader/WorldLoader.cpp b/src/render/loader/WorldLoader.cpp index 52cbb39..7216cda 100644 --- a/src/render/loader/WorldLoader.cpp +++ b/src/render/loader/WorldLoader.cpp @@ -10,7 +10,7 @@ namespace render { namespace WorldLoader { -GL::VertexArray loadMobModel(){ +GL::VertexArray loadMobModel() { std::vector positions = { -0.5, -0.5, 0.5, -0.5, @@ -48,19 +48,19 @@ GL::VertexArray loadMobModel(){ return mobVao; } -GL::VertexArray loadWorldModel(const td::game::World* world){ +GL::VertexArray loadWorldModel(const td::game::World* world) { std::vector positions; std::vector colors; - for (const auto& chunkInfo : world->getChunks()){ + for (const auto& chunkInfo : world->getChunks()) { const td::game::ChunkCoord& coords = chunkInfo.first; td::game::ChunkPtr chunk = chunkInfo.second; std::int32_t chunkX = coords.first * td::game::Chunk::ChunkWidth; std::int32_t chunkY = coords.second * td::game::Chunk::ChunkHeight; - for (int tileY = 0; tileY < td::game::Chunk::ChunkHeight; tileY++){ - for (int tileX = 0; tileX < td::game::Chunk::ChunkWidth; tileX++){ + for (int tileY = 0; tileY < td::game::Chunk::ChunkHeight; tileY++) { + for (int tileX = 0; tileX < td::game::Chunk::ChunkWidth; tileX++) { int tileNumber = tileY * td::game::Chunk::ChunkWidth + tileX; td::game::TileIndex tileIndex = chunk->getTileIndex(tileNumber); td::game::TilePtr tile = world->getTilePtr(tileIndex); @@ -100,7 +100,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){ const td::game::Color* tileColor = world->getTileColor(tile); - for (int i = 0; i < 6; i++){ + for (int i = 0; i < 6; i++) { int color = 255; color |= tileColor->r << 24; color |= tileColor->g << 16; @@ -115,7 +115,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){ } } - for (int spawnColor = 0; spawnColor < 2; spawnColor++){ + for (int spawnColor = 0; spawnColor < 2; spawnColor++) { const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn(); float fromX = spawn.x - 2, toX = spawn.x + 3; float fromY = spawn.y - 2, toY = spawn.y + 3; @@ -130,7 +130,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){ toX, fromY, }); - for (int i = 0; i < 6; i++){ + for (int i = 0; i < 6; i++) { int color = 255; color |= world->getSpawnColor(game::TeamColor(spawnColor)).r << 24; color |= world->getSpawnColor(game::TeamColor(spawnColor)).g << 16; @@ -156,7 +156,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){ return worldVao; } -GL::VertexArray loadTileSelectModel(){ +GL::VertexArray loadTileSelectModel() { std::vector positions = { 0, 0, 1, 0, @@ -170,7 +170,7 @@ GL::VertexArray loadTileSelectModel(){ int color = 255 << 24 | 255 << 16 | 255 << 8 | 150; float colorFloat; - memcpy((std::uint8_t*) &colorFloat, &color, sizeof(float)); + memcpy((std::uint8_t*)&colorFloat, &color, sizeof(float)); std::vector colors(6, colorFloat); diff --git a/src/render/shaders/EntityShader.cpp b/src/render/shaders/EntityShader.cpp index 213c535..3029b09 100644 --- a/src/render/shaders/EntityShader.cpp +++ b/src/render/shaders/EntityShader.cpp @@ -49,13 +49,13 @@ void main(void){ } )"; -EntityShader::EntityShader(): ShaderProgram(){} +EntityShader::EntityShader() : ShaderProgram() {} -void EntityShader::loadShader(){ +void EntityShader::loadShader() { ShaderProgram::loadProgram(vertexSource, fragmentSource); } -void EntityShader::getAllUniformLocation(){ +void EntityShader::getAllUniformLocation() { location_aspect_ratio = getUniformLocation("aspectRatio"); location_zoom = getUniformLocation("zoom"); location_cam = getUniformLocation("camPos"); @@ -63,18 +63,18 @@ void EntityShader::getAllUniformLocation(){ location_viewtype = getUniformLocation("isometricView"); } -void EntityShader::setCamPos(const glm::vec2& camPos){ +void EntityShader::setCamPos(const glm::vec2& camPos) { loadVector(location_cam, camPos); } -void EntityShader::setZoom(float zoom){ +void EntityShader::setZoom(float zoom) { loadFloat(location_zoom, zoom); } -void EntityShader::setAspectRatio(float aspectRatio){ +void EntityShader::setAspectRatio(float aspectRatio) { loadFloat(location_aspect_ratio, aspectRatio); } -void EntityShader::setModelPos(const glm::vec2& modelPos){ +void EntityShader::setModelPos(const glm::vec2& modelPos) { loadVector(location_translation, modelPos); } -void EntityShader::setIsometricView(float isometric){ +void EntityShader::setIsometricView(float isometric) { loadFloat(location_viewtype, isometric); } diff --git a/src/render/shaders/ShaderProgram.cpp b/src/render/shaders/ShaderProgram.cpp index 011537a..192881f 100755 --- a/src/render/shaders/ShaderProgram.cpp +++ b/src/render/shaders/ShaderProgram.cpp @@ -15,58 +15,58 @@ using namespace gl; -ShaderProgram::ShaderProgram(): - programID(0), vertexShaderID(0), fragmentShaderID(0){ +ShaderProgram::ShaderProgram() : + programID(0), vertexShaderID(0), fragmentShaderID(0) { } -ShaderProgram::~ShaderProgram(){ +ShaderProgram::~ShaderProgram() { cleanUp(); } -void ShaderProgram::start() const{ +void ShaderProgram::start() const { glUseProgram(programID); } -void ShaderProgram::stop() const{ +void ShaderProgram::stop() const { glUseProgram(0); } -int ShaderProgram::getUniformLocation(const std::string& uniformName) const{ +int ShaderProgram::getUniformLocation(const std::string& uniformName) const { const int location = glGetUniformLocation(programID, uniformName.c_str()); - if (location == -1){ + if (location == -1) { std::cout << "Warning ! Uniform variable " << uniformName << " not found !\n"; } return location; } -void ShaderProgram::loadFloat(const int location, const float value) const{ +void ShaderProgram::loadFloat(const int location, const float value) const { glUniform1f(location, value); } -void ShaderProgram::loadInt(const int& location, const int& value) const{ +void ShaderProgram::loadInt(const int& location, const int& value) const { glUniform1i(location, value); } void ShaderProgram::loadVector(const int& location, - const glm::vec2& vector) const{ + const glm::vec2& vector) const { glUniform2f(location, vector.x, vector.y); } void ShaderProgram::loadVector(const int& location, - const glm::vec3& vector) const{ + const glm::vec3& vector) const { glUniform3f(location, vector.x, vector.y, vector.z); } void ShaderProgram::loadVector(const int& location, - const glm::vec4& vector) const{ + const glm::vec4& vector) const { glUniform4f(location, vector.x, vector.y, vector.z, vector.w); } -void ShaderProgram::loadBoolean(const int& location, const bool& value) const{ +void ShaderProgram::loadBoolean(const int& location, const bool& value) const { glUniform1i(location, value); } -void ShaderProgram::cleanUp() const{ +void ShaderProgram::cleanUp() const { stop(); glDetachShader(programID, vertexShaderID); glDetachShader(programID, fragmentShaderID); @@ -76,7 +76,7 @@ void ShaderProgram::cleanUp() const{ } void ShaderProgram::loadProgramFile(const std::string& vertexFile, - const std::string& fragmentFile){ + const std::string& fragmentFile) { vertexShaderID = loadShaderFromFile(vertexFile, GL_VERTEX_SHADER); fragmentShaderID = loadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER); programID = glCreateProgram(); @@ -88,7 +88,7 @@ void ShaderProgram::loadProgramFile(const std::string& vertexFile, } void ShaderProgram::loadProgram(const std::string& vertexSource, - const std::string& fragmentSource){ + const std::string& fragmentSource) { vertexShaderID = loadShader(vertexSource, GL_VERTEX_SHADER); fragmentShaderID = loadShader(fragmentSource, GL_FRAGMENT_SHADER); programID = glCreateProgram(); @@ -99,7 +99,7 @@ void ShaderProgram::loadProgram(const std::string& vertexSource, getAllUniformLocation(); } -int ShaderProgram::loadShader(const std::string& source, GLenum type){ +int ShaderProgram::loadShader(const std::string& source, GLenum type) { unsigned int shaderID = glCreateShader(type); const char* c_str = source.c_str(); @@ -108,7 +108,7 @@ int ShaderProgram::loadShader(const std::string& source, GLenum type){ glCompileShader(shaderID); GLint compilesuccessful; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful); - if (compilesuccessful == false){ + if (compilesuccessful == false) { std::cout << "Could not compile shader !\n"; GLsizei size; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size); @@ -119,12 +119,12 @@ int ShaderProgram::loadShader(const std::string& source, GLenum type){ return shaderID; } -int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){ +int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type) { std::string shaderSource = ""; std::ifstream fileStream(file); - if (fileStream.is_open()){ + if (fileStream.is_open()) { std::string line; - while (getline(fileStream, line)){ + while (getline(fileStream, line)) { shaderSource += line + "\n"; } fileStream.close(); @@ -137,7 +137,7 @@ int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){ glCompileShader(shaderID); GLint compilesuccessful; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful); - if (compilesuccessful == false){ + if (compilesuccessful == false) { std::cout << "Could not compile shader !\n"; GLsizei size; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size); @@ -148,6 +148,6 @@ int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){ return shaderID; } -void ShaderProgram::loadMatrix(const int& location, const glm::mat4& matrix){ +void ShaderProgram::loadMatrix(const int& location, const glm::mat4& matrix) { glUniformMatrix4fv(location, 1, false, glm::value_ptr(matrix)); } diff --git a/src/render/shaders/WorldShader.cpp b/src/render/shaders/WorldShader.cpp index 5187cb1..a1814d0 100644 --- a/src/render/shaders/WorldShader.cpp +++ b/src/render/shaders/WorldShader.cpp @@ -46,28 +46,28 @@ void main(void){ } )"; -WorldShader::WorldShader(): ShaderProgram(){} +WorldShader::WorldShader() : ShaderProgram() {} -void WorldShader::loadShader(){ +void WorldShader::loadShader() { ShaderProgram::loadProgram(vertexSource, fragmentSource); } -void WorldShader::getAllUniformLocation(){ +void WorldShader::getAllUniformLocation() { location_aspect_ratio = getUniformLocation("aspectRatio"); location_zoom = getUniformLocation("zoom"); location_cam = getUniformLocation("camPos"); location_viewtype = getUniformLocation("isometricView"); } -void WorldShader::setCamPos(const glm::vec2& camPos){ +void WorldShader::setCamPos(const glm::vec2& camPos) { loadVector(location_cam, camPos); } -void WorldShader::setZoom(float zoom){ +void WorldShader::setZoom(float zoom) { loadFloat(location_zoom, zoom); } -void WorldShader::setAspectRatio(float aspectRatio){ +void WorldShader::setAspectRatio(float aspectRatio) { loadFloat(location_aspect_ratio, aspectRatio); } -void WorldShader::setIsometricView(float isometric){ +void WorldShader::setIsometricView(float isometric) { loadFloat(location_viewtype, isometric); } diff --git a/src/window/Display.cpp b/src/window/Display.cpp index 6415946..65fdfd2 100644 --- a/src/window/Display.cpp +++ b/src/window/Display.cpp @@ -26,19 +26,19 @@ std::unique_ptr renderer = std::make_uniqueresize(width, height); lastWidth = width; lastHeight = height; } void create() { - glfwSetErrorCallback(&error_callback); + glfwSetErrorCallback(&error_callback); glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); @@ -46,15 +46,15 @@ void create() { glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, nullptr, nullptr); glfwMakeContextCurrent(window); - if(!renderer->init()){ - exit(1); - } - TowerGui::init(window, renderer.get()); + if (!renderer->init()) { + exit(1); + } + TowerGui::init(window, renderer.get()); windowResizeEvent(window, WINDOW_WIDTH, WINDOW_HEIGHT); } void render() { - renderer->prepare(); + renderer->prepare(); TowerGui::render(); } @@ -62,7 +62,7 @@ void update() { glfwSwapBuffers(window); int windowWidth, windowHeight; glfwGetWindowSize(window, &windowWidth, &windowHeight); - if(windowWidth != lastWidth || windowHeight != lastHeight){ + if (windowWidth != lastWidth || windowHeight != lastHeight) { windowResizeEvent(window, windowWidth, windowHeight); } } @@ -71,7 +71,7 @@ void destroy() { renderer.reset(0); TowerGui::destroy(); glfwDestroyWindow(window); - window = NULL; + window = NULL; glfwTerminate(); } @@ -80,21 +80,21 @@ void pollEvents() { } bool isCloseRequested() { - return glfwWindowShouldClose(window); + return glfwWindowShouldClose(window); } bool isMouseDown(int button) { - return glfwGetMouseButton(window, button); + return glfwGetMouseButton(window, button); } -float getAspectRatio(){ +float getAspectRatio() { return aspectRatio; } -int getWindowWidth(){ +int getWindowWidth() { return lastWidth; } -int getWindowHeight(){ +int getWindowHeight() { return lastHeight; }