Persson-dev/Tower-Defense
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

GIGA REFACTOR

Browse Source
This commit is contained in:
Simon Pribylski
2022-03-02 18:51:42 +01:00
parent 553b2f6aad
commit 6df59b1487
92 changed files with 1807 additions and 1785 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
include/game/BaseGame.h
View File

@@ -40,30 +40,30 @@ public:
Game(World* world);
virtual ~Game();
virtual void tick(std::uint64_t delta);
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; }
const Player* getPlayerById(PlayerID id) const;
Player* getPlayerById(PlayerID id);
const Player* GetPlayerById(PlayerID id) const;
Player* GetPlayerById(PlayerID id);
const TeamList& getTeams() const { return m_Teams; }
const TeamList& GetTeams() const { return m_Teams; }
};

10
include/game/Connexion.h
View File

@@ -20,14 +20,14 @@ public:
Connexion(protocol::PacketDispatcher* dispatcher, network::TCPSocket& socket);
virtual ~Connexion();
virtual bool updateSocket();
void closeConnection();
virtual bool UpdateSocket();
void CloseConnection();
bool connect(const std::string& address, std::uint16_t port);
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(const protocol::Packet* packet);
void SendPacket(const protocol::Packet* packet);
REMOVE_COPY(Connexion);
};

10
include/game/GameManager.h
View File

@@ -10,12 +10,12 @@
namespace GameManager {
void render();
void init();
void destroy();
void tick();
void Render();
void Init();
void Destroy();
void Tick();
void startServer();
void StartServer();
}

138
include/game/Mobs.h
View File

@@ -61,13 +61,13 @@ public:
m_MaxLife(maxLife), m_ExpReward(expReward) {
}
float getDamage() const { return m_Damage; }
float getMovementSpeed() const { return m_Speed; }
const glm::vec2& getSize() const { return m_Size; }
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; }
const glm::vec2& GetSize() const { return m_Size; }
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; }
};
struct EffectDuration {
@@ -76,9 +76,9 @@ struct EffectDuration {
Tower* tower; // the tower that gived the effect
};
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);
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 : public utils::shape::Rectangle {
protected:
@@ -105,131 +105,133 @@ public:
}
virtual MobType getType() const = 0;
virtual MobType GetType() const = 0;
virtual void tick(std::uint64_t delta, World* world);
virtual void Tick(std::uint64_t delta, World* world);
virtual bool OnDeath(World* world) { return true; }
MobID getMobID() const { return m_ID; }
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); }
void setHealth(float newHealth) { m_Health = newHealth; }
float getHealth() const { return m_Health; }
bool isDead() const { return m_Health <= 0; }
bool isAlive() const { return m_Health > 0; }
const Tower* getLastDamageTower() { return m_LastDamage; }
bool hasReachedEnemyCastle() { return m_CastleTarget != nullptr; }
MobID GetMobID() const { return m_ID; }
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); }
void SetHealth(float newHealth) { m_Health = newHealth; }
float GetHealth() const { return m_Health; }
bool IsDead() const { return m_Health <= 0; }
bool IsAlive() const { return m_Health > 0; }
const Tower* GetLastDamageTower() { return m_LastDamage; }
bool HasReachedEnemyCastle() { return m_CastleTarget != nullptr; }
void damage(float dmg, const Tower* damager) { m_Health = std::max(0.0f, m_Health - dmg); m_LastDamage = damager; }
void heal(float heal) { m_Health = std::min(static_cast<float>(getStats()->getMaxLife()), m_Health + heal); }
void setMobReachedCastle(TeamCastle* castle) { m_CastleTarget = castle; } // used when mob is in front of the castle
void Damage(float dmg, const Tower* damager) { m_Health = std::max(0.0f, m_Health - dmg); m_LastDamage = damager; }
void Heal(float heal) { m_Health = std::min(static_cast<float>(GetStats()->GetMaxLife()), m_Health + heal); }
void SetMobReachedCastle(TeamCastle* castle) { m_CastleTarget = castle; } // used when mob is in front of the castle
bool isImmuneTo(TowerType type);
bool IsImmuneTo(TowerType type);
bool isImmuneTo(EffectType type);
void addEffect(EffectType type, float durationSec, Tower* tower);
bool hasEffect(EffectType type);
bool IsImmuneTo(EffectType type);
void AddEffect(EffectType type, float durationSec, Tower* tower);
bool HasEffect(EffectType type);
float getTileX() { return getCenterX() - static_cast<float>(static_cast<std::int32_t>(getCenterX())); } // returns a float between 0 and 1 excluded
float getTileY() { return getCenterY() - static_cast<float>(static_cast<std::int32_t>(getCenterY())); } // returns a float between 0 and 1 excluded
float GetTileX() { return GetCenterX() - static_cast<float>(static_cast<std::int32_t>(GetCenterX())); } // returns a float between 0 and 1 excluded
float GetTileY() { return GetCenterY() - static_cast<float>(static_cast<std::int32_t>(GetCenterY())); } // returns a float between 0 and 1 excluded
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 initMob() {
m_Health = static_cast<float>(getStats()->getMaxLife());
setSize(getStats()->getSize().x, getStats()->getSize().y);
void InitMob() {
m_Health = static_cast<float>(GetStats()->GetMaxLife());
SetSize(GetStats()->GetSize().x, GetStats()->GetSize().y);
}
private:
void updateEffects(std::uint64_t delta, World* world);
void attackCastle(std::uint64_t delta, World* world);
void move(std::uint64_t delta, World* world);
void walk(std::uint64_t delta, World* world);
void moveBack(const TeamCastle& castle, World* world);
void changeDirection(const WalkableTile& tile, World* world);
bool isTouchingCastle(const TeamCastle& castle) const;
EffectDuration& getEffect(EffectType type);
void UpdateEffects(std::uint64_t delta, World* world);
void AttackCastle(std::uint64_t delta, World* world);
void Move(std::uint64_t delta, World* world);
void Walk(std::uint64_t delta, World* world);
void MoveBack(const TeamCastle& castle, World* world);
void ChangeDirection(const WalkableTile& tile, World* world);
bool IsTouchingCastle(const TeamCastle& castle) const;
EffectDuration& GetEffect(EffectType type);
};
typedef std::shared_ptr<Mob> MobPtr;
class Zombie : public Mob {
public:
Zombie(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Zombie(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Zombie; }
virtual MobType GetType() const { return MobType::Zombie; }
};
class Spider : public Mob {
public:
Spider(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Spider(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Spider; }
virtual MobType GetType() const { return MobType::Spider; }
};
class Skeleton : public Mob {
public:
Skeleton(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Skeleton(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Skeleton; }
virtual MobType GetType() const { return MobType::Skeleton; }
};
class PigMan : public Mob {
public:
PigMan(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
PigMan(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Pigman; }
virtual MobType GetType() const { return MobType::Pigman; }
};
class Creeper : public Mob {
public:
Creeper(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Creeper(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Creeper; }
virtual MobType GetType() const { return MobType::Creeper; }
};
class Silverfish : public Mob {
public:
Silverfish(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Silverfish(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Silverfish; }
virtual MobType GetType() const { return MobType::Silverfish; }
};
class Blaze : public Mob {
public:
Blaze(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Blaze(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Blaze; }
virtual MobType GetType() const { return MobType::Blaze; }
};
class Witch : public Mob {
public:
Witch(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Witch(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Witch; }
virtual MobType GetType() const { return MobType::Witch; }
};
class Slime : public Mob {
public:
Slime(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Slime(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Slime; }
virtual MobType GetType() const { return MobType::Slime; }
};
class Giant : public Mob {
public:
Giant(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initMob(); }
Giant(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
virtual MobType getType() const { return MobType::Giant; }
virtual MobType GetType() const { return MobType::Giant; }
};
namespace MobFactory {
MobPtr createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender);
std::string getMobName(MobType type);
MobPtr CreateMob(MobID id, MobType type, std::uint8_t level, PlayerID sender);
std::string GetMobName(MobType type);
}
class MobListener {

30
include/game/Player.h
View File

@@ -23,26 +23,26 @@ public:
Player(std::uint8_t id = 0) : m_TeamColor(game::TeamColor::None), m_Gold(0), m_Exp(0), m_ID(id), m_GoldPerSecond(5) {}
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; }
void addGold(std::uint32_t gold) { m_Gold += gold; }
void removeGold(std::uint32_t gold) { m_Gold -= gold; }
std::uint32_t GetGold() const { return m_Gold; }
void SetGold(std::uint32_t gold) { m_Gold = gold; }
void AddGold(std::uint32_t gold) { m_Gold += gold; }
void RemoveGold(std::uint32_t gold) { m_Gold -= gold; }
std::uint32_t getExp() const { return m_Exp; }
void setExp(std::uint32_t exp) { m_Exp = exp; }
void addExp(std::uint32_t exp) { m_Exp += exp; }
void removeExp(std::uint32_t exp) { m_Exp -= exp; }
std::uint32_t GetExp() const { return m_Exp; }
void SetExp(std::uint32_t exp) { m_Exp = exp; }
void AddExp(std::uint32_t exp) { m_Exp += exp; }
void RemoveExp(std::uint32_t exp) { m_Exp -= exp; }
PlayerID getID() const { return m_ID; }
PlayerID GetID() const { return m_ID; }
};
} // namespace game

44
include/game/Team.h
View File

@@ -24,13 +24,13 @@ private:
Direction m_Direction;
public:
Spawn() {
setWidth(5);
setHeight(5);
SetWidth(5);
SetHeight(5);
}
Direction getDirection() const { return m_Direction; }
Direction GetDirection() const { return m_Direction; }
void setDirection(Direction direction) { m_Direction = direction; }
void SetDirection(Direction direction) { m_Direction = direction; }
};
class Team;
@@ -43,23 +43,23 @@ public:
static constexpr int CastleMaxLife = 1000;
TeamCastle(const Team* team) : m_Team(team), m_Life(CastleMaxLife) {
setWidth(5);
setHeight(5);
SetWidth(5);
SetHeight(5);
}
TeamCastle() : TeamCastle(nullptr) {}
float getLife() const { return m_Life; }
float GetLife() const { return m_Life; }
const Team* getTeam() const { return m_Team; }
void setTeam(const Team* team) { m_Team = team; }
const Team* GetTeam() const { return m_Team; }
void SetTeam(const Team* team) { m_Team = team; }
void setLife(float life) { m_Life = life; }
void damage(float damage) { m_Life = std::max(0.0f, m_Life - damage); }
void SetLife(float life) { m_Life = life; }
void Damage(float damage) { m_Life = std::max(0.0f, m_Life - damage); }
void setShape(utils::shape::Rectangle rect) {
setCenter(rect.getCenter());
setSize(rect.getSize());
void SetShape(utils::shape::Rectangle rect) {
SetCenter(rect.GetCenter());
SetSize(rect.GetSize());
}
};
@@ -72,18 +72,18 @@ private:
public:
Team(TeamColor color);
void addPlayer(Player* newPlayer);
void removePlayer(const Player* player);
void AddPlayer(Player* newPlayer);
void RemovePlayer(const Player* player);
TeamColor getColor() const;
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;
std::uint8_t GetPlayerCount() const;
};
typedef std::array<Team, 2> TeamList;

142
include/game/Towers.h
View File

@@ -55,9 +55,9 @@ public:
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 {
@@ -70,20 +70,20 @@ public:
TowerLevel() : m_Level(1), m_Path(TowerPath::Base) {}
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) {
return level.getLevel() + static_cast<std::uint8_t>(level.getPath()) * 4 <
other.getLevel() + static_cast<std::uint8_t>(other.getPath()) * 4;
return level.GetLevel() + static_cast<std::uint8_t>(level.GetPath()) * 4 <
other.GetLevel() + static_cast<std::uint8_t>(other.GetPath()) * 4;
}
};
const TowerStats* getTowerStats(TowerType type, TowerLevel level);
const TowerStats* GetTowerStats(TowerType type, TowerLevel level);
typedef std::uint16_t TowerID;
@@ -97,36 +97,36 @@ protected:
utils::CooldownTimer m_Timer;
public:
Tower(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) : utils::shape::Circle(x + 0.5f, y + 0.5f, 0), m_ID(id), m_Type(type), m_Builder(builder),
m_Timer(getStats()->getDamageRate() * 1000) { // converting seconds to millis
setRadius(getStats()->getRange());
m_Timer(GetStats()->GetDamageRate() * 1000) { // converting seconds to millis
SetRadius(GetStats()->GetRange());
}
virtual TowerType getType() const = 0;
virtual TowerSize getSize() const = 0;
virtual void tick(std::uint64_t delta, World* world) = 0;
virtual TowerType GetType() const = 0;
virtual TowerSize GetSize() const = 0;
virtual void Tick(std::uint64_t delta, World* world) = 0;
void upgrade(std::uint8_t level, TowerPath path) {
m_Level.setLevel(level);
m_Level.setPath(path);
m_Timer.setCooldown(getStats()->getDamageRate() * 1000); // converting seconds to millis
m_Timer.reset();
setRadius(getStats()->getRange());
void Upgrade(std::uint8_t level, TowerPath path) {
m_Level.SetLevel(level);
m_Level.SetPath(path);
m_Timer.SetCooldown(GetStats()->GetDamageRate() * 1000); // converting seconds to millis
m_Timer.Reset();
SetRadius(GetStats()->GetRange());
}
std::uint16_t getID() const { return m_ID; }
const TowerLevel& getLevel() const { return m_Level; }
const TowerStats* getStats() const { return getTowerStats(m_Type, m_Level); }
PlayerID getBuilder() const { return m_Builder; }
std::uint16_t GetID() const { return m_ID; }
const TowerLevel& GetLevel() const { return m_Level; }
const TowerStats* GetStats() const { return GetTowerStats(m_Type, m_Level); }
PlayerID GetBuilder() const { return m_Builder; }
bool isMobInRange(MobPtr mob);
bool IsMobInRange(MobPtr mob);
};
typedef std::shared_ptr<Tower> TowerPtr;
namespace TowerFactory {
TowerPtr createTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder);
std::string getTowerName(TowerType type);
TowerPtr CreateTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder);
std::string GetTowerName(TowerType type);
} // namespace TowerFactory
@@ -139,13 +139,13 @@ public:
TowerInfo(std::string&& name, std::string&& description, bool big) : m_Name(std::move(name)),
m_Description(std::move(description)), m_IsBigTower(big) {}
const std::string& getName() const { return m_Name; }
const std::string& getDescription() const { return m_Description; }
const std::string& GetName() const { return m_Name; }
const std::string& GetDescription() const { return m_Description; }
bool isBigTower() const { return m_IsBigTower; }
bool IsBigTower() const { return m_IsBigTower; }
};
const TowerInfo& getTowerInfo(TowerType type);
const TowerInfo& GetTowerInfo(TowerType type);
// ---------- Little Towers ----------
@@ -153,77 +153,77 @@ class LittleTower : public Tower {
public:
LittleTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}
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, World* world) = 0;
virtual TowerType GetType() const = 0;
virtual void Tick(std::uint64_t delta, World* world) = 0;
};
class ArcherTower : public LittleTower {
public:
ArcherTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
ArcherTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
constexpr static float ExplosionRadius = 1.5f;
constexpr static float FireDurationSec = 10.0f;
virtual TowerType getType() const { return TowerType::Archer; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Archer; }
virtual void Tick(std::uint64_t delta, World* world);
};
class IceTower : public LittleTower {
public:
IceTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
IceTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Ice; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Ice; }
virtual void Tick(std::uint64_t delta, World* world);
};
class MageTower : public LittleTower {
public:
MageTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
MageTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Mage; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Mage; }
virtual void Tick(std::uint64_t delta, World* world);
};
class PoisonTower : public LittleTower {
public:
PoisonTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
PoisonTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Poison; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Poison; }
virtual void Tick(std::uint64_t delta, World* world);
};
class QuakeTower : public LittleTower {
public:
QuakeTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
QuakeTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Quake; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Quake; }
virtual void Tick(std::uint64_t delta, World* world);
};
class ArtilleryTower : public LittleTower {
public:
ArtilleryTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
ArtilleryTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Artillery; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Artillery; }
virtual void Tick(std::uint64_t delta, World* world);
};
class SorcererTower : public LittleTower {
public:
SorcererTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
SorcererTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Sorcerer; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Sorcerer; }
virtual void Tick(std::uint64_t delta, World* world);
};
class ZeusTower : public LittleTower {
public:
ZeusTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, getType(), x, y, builder) {}
ZeusTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Zeus; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Zeus; }
virtual void Tick(std::uint64_t delta, World* world);
};
// ---------- Big Towers ----------
@@ -232,34 +232,34 @@ class BigTower : public Tower {
public:
BigTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}
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, World* world) = 0;
virtual TowerType GetType() const = 0;
virtual void Tick(std::uint64_t delta, World* world) = 0;
};
class TurretTower : public BigTower {
public:
TurretTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}
TurretTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Turret; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Turret; }
virtual void Tick(std::uint64_t delta, World* world);
};
class NecromancerTower : public BigTower {
public:
NecromancerTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}
NecromancerTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Necromancer; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Necromancer; }
virtual void Tick(std::uint64_t delta, World* world);
};
class LeachTower : public BigTower {
public:
LeachTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, getType(), x, y, builder) {}
LeachTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
virtual TowerType getType() const { return TowerType::Leach; }
virtual void tick(std::uint64_t delta, World* world);
virtual TowerType GetType() const { return TowerType::Leach; }
virtual void Tick(std::uint64_t delta, World* world);
};
} // namespace game

82
include/game/World.h
View File

@@ -71,26 +71,26 @@ static constexpr Color GREEN{ 0, 255, 0 };
static constexpr Color BLUE{ 0, 0, 255 };
struct Tile {
virtual TileType getType() const = 0;
virtual TileType GetType() const = 0;
};
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 {
Direction direction;
virtual TileType getType() const { return TileType::Walk; }
virtual TileType GetType() const { return TileType::Walk; }
};
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<Tile> TilePtr;
@@ -109,7 +109,7 @@ struct Chunk {
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
return 0;
@@ -168,29 +168,29 @@ protected:
public:
World(Game* game);
bool loadMap(const protocol::WorldBeginDataPacket* worldHeader);
bool loadMap(const protocol::WorldDataPacket* worldData);
bool LoadMap(const protocol::WorldBeginDataPacket* worldHeader);
bool LoadMap(const protocol::WorldDataPacket* worldData);
bool loadMapFromFile(const std::string& fileName);
bool saveMap(const std::string& fileName) const;
bool LoadMapFromFile(const std::string& fileName);
bool SaveMap(const std::string& fileName) const;
void tick(std::uint64_t delta);
void Tick(std::uint64_t delta);
void spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir);
void SpawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir);
TowerPtr placeTowerAt(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder);
TowerPtr removeTower(TowerID id);
TowerPtr PlaceTowerAt(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder);
TowerPtr RemoveTower(TowerID id);
TilePtr getTile(std::int32_t x, std::int32_t y) const;
TilePtr GetTile(std::int32_t x, std::int32_t y) const;
const TowerTileColorPalette& getTowerTileColorPalette() const { return m_TowerPlacePalette; }
const Color& getWalkableTileColor() const { return m_WalkablePalette; }
const std::vector<Color>& getDecorationPalette() const { return m_DecorationPalette; }
const Color& getBackgroundColor() const { return m_Background; }
const TowerTileColorPalette& GetTowerTileColorPalette() const { return m_TowerPlacePalette; }
const Color& GetWalkableTileColor() const { return m_WalkablePalette; }
const std::vector<Color>& GetDecorationPalette() const { return m_DecorationPalette; }
const Color& GetBackgroundColor() const { return m_Background; }
const TilePalette& getTilePalette() const { return m_TilePalette; }
const TilePalette& GetTilePalette() const { return m_TilePalette; }
TilePtr getTilePtr(TileIndex index) const {
TilePtr GetTilePtr(TileIndex index) const {
if (index == 0)
return nullptr;
return m_TilePalette.at(index - 1);
@@ -199,36 +199,36 @@ public:
bool CanPlaceLittleTower(const glm::vec2& worldPos, PlayerID player) const;
bool CanPlaceBigTower(const glm::vec2& worldPos, PlayerID player) const;
TowerPtr getTower(const glm::vec2& position) const; // returns null if no tower is here
TowerPtr GetTower(const glm::vec2& position) const; // returns null if no tower is here
const std::unordered_map<ChunkCoord, ChunkPtr>& getChunks() const { return m_Chunks; }
const std::unordered_map<ChunkCoord, ChunkPtr>& 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;
const Color* GetTileColor(TilePtr tile) const;
Team& getRedTeam();
const Team& getRedTeam() const;
Team& GetRedTeam();
const Team& GetRedTeam() const;
Team& getBlueTeam();
const Team& getBlueTeam() const;
Team& GetBlueTeam();
const Team& GetBlueTeam() const;
Team& getTeam(TeamColor team);
const Team& getTeam(TeamColor team) const;
Team& GetTeam(TeamColor team);
const Team& GetTeam(TeamColor team) const;
const TeamList& getTeams() const;
const TeamList& GetTeams() const;
const TowerList& getTowers() const { return m_Towers; };
TowerPtr getTowerById(TowerID tower);
const TowerList& GetTowers() const { return m_Towers; };
TowerPtr GetTowerById(TowerID tower);
const Player* getPlayerById(PlayerID id) const;
const Player* GetPlayerById(PlayerID id) const;
WorldNotifier& getWorldNotifier() { return m_WorldNotifier; }
MobNotifier& getMobNotifier() { return m_MobNotifier; }
WorldNotifier& GetWorldNotifier() { return m_WorldNotifier; }
MobNotifier& GetMobNotifier() { return m_MobNotifier; }
// WorldListener
@@ -243,8 +243,8 @@ public:
virtual void OnMobCastleDamage(Mob* damager, TeamCastle* enemyCastle, float damage);
private:
void tickMobs(std::uint64_t delta);
void cleanDeadMobs();
void TickMobs(std::uint64_t delta);
void CleanDeadMobs();
};
} // namespace game

32
include/game/client/Client.h
View File

@@ -24,29 +24,29 @@ private:
public:
Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(std::make_unique<ClientGame>(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);
void Tick(std::uint64_t delta);
void render();
void Render();
bool connect(const network::IPAddresses& addresses, std::uint16_t port);
void closeConnection();
bool Connect(const network::IPAddresses& addresses, 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);
void sendMobs(const std::vector<protocol::MobSend>& mobSends);
void placeTower(game::TowerType type, const glm::vec2& position);
void upgradeTower(game::TowerID tower, game::TowerLevel level);
void removeTower(game::TowerID tower);
void SelectTeam(game::TeamColor team);
void SendMobs(const std::vector<protocol::MobSend>& mobSends);
void PlaceTower(game::TowerType type, const glm::vec2& position);
void UpgradeTower(game::TowerID tower, game::TowerLevel level);
void RemoveTower(game::TowerID tower);
private:
void reset();
void Reset();
};
} // namespace client

12
include/game/client/ClientConnexion.h
View File

@@ -16,21 +16,21 @@ private:
public:
ClientConnexion();
virtual bool updateSocket();
virtual bool UpdateSocket();
virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
virtual void HandlePacket(const protocol::DisconnectPacket* packet);
virtual void HandlePacket(const 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:
void registerHandlers();
void login();
void RegisterHandlers();
void Login();
};
} // namespace client

16
include/game/client/ClientGame.h
View File

@@ -27,17 +27,17 @@ public:
ClientGame(Client* client);
virtual ~ClientGame();
virtual void tick(std::uint64_t delta);
virtual void Tick(std::uint64_t delta);
void renderWorld();
void RenderWorld();
std::uint32_t getLobbyTime() const { return m_LobbyTime; }
const game::Player* getPlayer() const { return m_Player; }
const WorldClient& getWorld() const { return m_WorldClient; }
Client* getClient() const { return m_Client; }
std::uint32_t GetLobbyTime() const { return m_LobbyTime; }
const game::Player* GetPlayer() const { return m_Player; }
const WorldClient& GetWorld() const { return m_WorldClient; }
Client* GetClient() const { return m_Client; }
render::Renderer* getRenderer() const { return m_Renderer; }
WorldClient& getWorldClient() { return m_WorldClient; }
render::Renderer* GetRenderer() const { return m_Renderer; }
WorldClient& GetWorldClient() { return m_WorldClient; }
virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
virtual void HandlePacket(const protocol::PlayerJoinPacket* packet);

4
include/game/server/Lobby.h
View File

@@ -22,9 +22,9 @@ public:
void OnPlayerJoin(std::uint8_t playerID);
void OnPlayerLeave(std::uint8_t playerID);
void sendTimeRemaining();
void SendTimeRemaining();
void tick();
void Tick();
//static constexpr int LobbyWaitingTime = 2 * 60 * 1000; // in millis
static constexpr int LobbyWaitingTime = 5 * 1000; // in millis

52
include/game/server/Server.h
View File

@@ -28,25 +28,25 @@ private:
public:
TickCounter() {}
void reset() {
void Reset() {
m_TPS = SERVER_TPS;
m_LastTPSTime = utils::getTime();
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) {
std::uint64_t timeElapsedSinceLast20Ticks = td::utils::getTime() - m_LastTPSTime;
std::uint64_t timeElapsedSinceLast20Ticks = td::utils::GetTime() - m_LastTPSTime;
m_TPS = (float)SERVER_TPS / (float)(timeElapsedSinceLast20Ticks / 1000.0f);
m_TickCount = 0;
m_LastTPSTime = td::utils::getTime();
m_LastTPSTime = td::utils::GetTime();
return true;
}
return false;
}
float getTPS() const { return m_TPS; }
float GetTPS() const { return m_TPS; }
};
class Server {
@@ -63,36 +63,36 @@ public:
Server(const std::string& worldFilePath);
virtual ~Server();
bool start(std::uint16_t port);
void stop(); // force the server to stop
void close(); // at the end of a game
bool Start(std::uint16_t port);
void Stop(); // force the server to stop
void Close(); // at the end of a game
void removeConnexion(std::uint8_t connexionID);
void RemoveConnexion(std::uint8_t connexionID);
void broadcastPacket(const protocol::Packet* packet);
void BroadcastPacket(const protocol::Packet* packet);
float getTPS() const { return m_TickCounter.getTPS(); }
float GetTPS() const { return m_TickCounter.GetTPS(); }
bool isRunning() { return m_ServerRunning; }
bool IsRunning() { return m_ServerRunning; }
const ServerGame& getGame() const { return m_Game; }
ServerGame& getGame() { 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();
void updateSockets();
void Accept();
void UpdateSockets();
void clean();
void startThread();
void stopThread();
void tick(std::uint64_t delta);
void Clean();
void StartThread();
void StopThread();
void Tick(std::uint64_t delta);
void OnPlayerJoin(std::uint8_t id);
void OnPlayerLeave(std::uint8_t id);

18
include/game/server/ServerConnexion.h
View File

@@ -31,7 +31,7 @@ public:
ServerConnexion(ServerConnexion&& move);
virtual ~ServerConnexion();
void setServer(Server* server);
void SetServer(Server* server);
virtual void HandlePacket(const protocol::PlayerLoginPacket* packet);
virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
@@ -42,18 +42,18 @@ public:
virtual void HandlePacket(const protocol::UpgradeTowerPacket* packet);
virtual void HandlePacket(const protocol::RemoveTowerPacket* 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();
virtual bool UpdateSocket();
REMOVE_COPY(ServerConnexion);
private:
void registerHandlers();
void checkKeepAlive();
void sendKeepAlive();
void initConnection();
void RegisterHandlers();
void CheckKeepAlive();
void SendKeepAlive();
void InitConnection();
};
} // namespace server

14
include/game/server/ServerGame.h
View File

@@ -20,10 +20,10 @@ public:
ServerGame(Server* server);
~ServerGame() {}
ServerWorld* getServerWorld() { return &m_ServerWorld; }
ServerWorld* GetServerWorld() { return &m_ServerWorld; }
virtual void tick(std::uint64_t delta);
void startGame();
virtual void Tick(std::uint64_t delta);
void StartGame();
// GameListener
@@ -32,10 +32,10 @@ public:
virtual void OnGameEnd();
virtual void OnGameClose();
private:
void balanceTeams();
void updateMobStates();
void updateGoldMines();
void updatePlayerStats();
void BalanceTeams();
void UpdateMobStates();
void UpdateGoldMines();
void UpdatePlayerStats();
};
} // namespace game

4
include/game/server/ServerWorld.h
View File

@@ -18,8 +18,8 @@ public:
ServerWorld(Server* server, ServerGame* game);
void spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count);
game::TowerPtr placeTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder);
void SpawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count);
game::TowerPtr PlaceTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder);
virtual void OnMobDie(game::Mob* mob);

4
include/misc/Compression.h
View File

@@ -6,8 +6,8 @@
namespace td {
namespace utils {
std::uint64_t inflate(const std::string& source, std::string& dest);
std::uint64_t deflate(const std::string& source, std::string& dest);
std::uint64_t Inflate(const std::string& source, std::string& dest);
std::uint64_t Deflate(const std::string& source, std::string& dest);
DataBuffer Compress(const DataBuffer& buffer);
DataBuffer Decompress(DataBuffer& buffer);

60
include/misc/Easing.h
View File

@@ -7,63 +7,63 @@ constexpr float PI = 3.14159274101257324219;
/* Sine functions */
float easeInSine(float x);
float easeOutSine(float x);
float easeInOutSine(float x);
float EaseInSine(float x);
float EaseOutSine(float x);
float EaseInOutSine(float x);
/* Cubic functions */
float easeInCubic(float x);
float easeOutCubic(float x);
float easeInOutCubic(float x);
float EaseInCubic(float x);
float EaseOutCubic(float x);
float EaseInOutCubic(float x);
/* Quint functions */
float easeInQuint(float x);
float easeOutQuint(float x);
float easeInOutQuint(float x);
float EaseInQuint(float x);
float EaseOutQuint(float x);
float EaseInOutQuint(float x);
/* Circ functions */
float easeInCirc(float x);
float easeOutCirc(float x);
float easeInOutCirc(float x);
float EaseInCirc(float x);
float EaseOutCirc(float x);
float EaseInOutCirc(float x);
/* Elastic functions */
float easeInElastic(float x);
float easeOutElastic(float x);
float easeInOutElastic(float x);
float EaseInElastic(float x);
float EaseOutElastic(float x);
float EaseInOutElastic(float x);
/* Quad functions */
float easeInQuad(float x);
float easeOutQuad(float x);
float easeInOutQuad(float x);
float EaseInQuad(float x);
float EaseOutQuad(float x);
float EaseInOutQuad(float x);
/* Quart functions */
float easeInQuart(float x);
float easeOutQuart(float x);
float easeInOutQuart(float x);
float EaseInQuart(float x);
float EaseOutQuart(float x);
float EaseInOutQuart(float x);
/* Expo functions */
float easeInExpo(float x);
float easeOutExpo(float x);
float easeInOutExpo(float x);
float EaseInExpo(float x);
float EaseOutExpo(float x);
float EaseInOutExpo(float x);
/* Back functions */
float easeInBack(float x);
float easeOutBack(float x);
float easeInOutBack(float x);
float EaseInBack(float x);
float EaseOutBack(float x);
float EaseInOutBack(float x);
/* Bounce functions */
float easeInBounce(float x);
float easeOutBounce(float x);
float easeInOutBounce(float x);
float EaseInBounce(float x);
float EaseOutBounce(float x);
float EaseInOutBounce(float x);
} // namespace utils
} // namespace td

8
include/misc/ObjectNotifier.h
View File

@@ -13,20 +13,20 @@ protected:
std::vector<Listener*> m_Listeners;
public:
void bindListener(Listener* listener) {
void BindListener(Listener* listener) {
m_Listeners.push_back(listener);
}
void unbindListener(Listener* listener) {
void UnbindListener(Listener* listener) {
auto iter = std::find(m_Listeners.begin(), m_Listeners.end(), listener);
if(iter == m_Listeners.end()) return;
if (iter == m_Listeners.end()) return;
m_Listeners.erase(iter);
}
template <typename Func, typename... Args>
void notifyListeners(Func function, Args... args) {
void NotifyListeners(Func function, Args... args) {
for (Listener* listener : m_Listeners)
std::bind(function, listener, args...)();
}

4
include/misc/Platform.h
View File

@@ -18,7 +18,7 @@ enum class Architecture {
Unknown,
};
inline Os getSystemOs() {
inline Os GetSystemOs() {
#if defined(_WIN32) || defined(_WIN64)
return Os::Windows;
#elif defined(__ANDROID__)
@@ -31,7 +31,7 @@ inline Os getSystemOs() {
#endif
}
inline Architecture getSystemArchitecture() {
inline Architecture GetSystemArchitecture() {
#if defined(_WIN64)
return Architecture::x86_64;
#elif defined(_WIN32)

4
include/misc/Random.h
View File

@@ -6,7 +6,7 @@ namespace td {
namespace utils {
template<typename NumberType>
NumberType getRandomInt(NumberType min, NumberType max) {
NumberType GetRandomInt(NumberType min, NumberType max) {
std::random_device randomDevice;
std::mt19937 generator(randomDevice());
std::uniform_int_distribution<NumberType> distrib(min, max);
@@ -14,7 +14,7 @@ NumberType getRandomInt(NumberType min, NumberType max) {
}
template<typename NumberType>
NumberType getRandomReal(NumberType min, NumberType max) {
NumberType GetRandomReal(NumberType min, NumberType max) {
std::random_device randomDevice;
std::mt19937 generator(randomDevice());
std::uniform_real_distribution<NumberType> distrib(min, max);

78
include/misc/Shapes.h
View File

@@ -13,14 +13,14 @@ public:
Point() : m_X(0), m_Y(0) {}
Point(float x, float y) : m_X(x), m_Y(y) {}
float getX() const { return m_X; }
float getY() const { return m_Y; }
float GetX() const { return m_X; }
float GetY() const { return m_Y; }
void setX(float x) { m_X = x; }
void setY(float y) { m_Y = y; }
void SetX(float x) { m_X = x; }
void SetY(float y) { m_Y = y; }
float distance(const Point& point) const;
float distanceSquared(const Point& point) const;
float Distance(const Point& point) const;
float DistanceSquared(const Point& point) const;
};
class Circle;
@@ -32,34 +32,34 @@ private:
public:
Rectangle() {}
const Point& getCenter() const { return m_Center; }
float getCenterX() const { return m_Center.getX(); }
float getCenterY() const { return m_Center.getY(); }
const Point& GetCenter() const { return m_Center; }
float GetCenterX() const { return m_Center.GetX(); }
float GetCenterY() const { return m_Center.GetY(); }
float getWidth() const { return m_Width; }
float getHeight() const { return m_Height; }
float GetWidth() const { return m_Width; }
float GetHeight() const { return m_Height; }
Point getTopLeft() const { return { m_Center.getX() - (m_Width / 2.0f), m_Center.getY() - (m_Height / 2.0f) }; }
Point getBottomRight() const { return { m_Center.getX() + (m_Width / 2.0f), m_Center.getY() + (m_Height / 2.0f) }; }
Point GetTopLeft() const { return { m_Center.GetX() - (m_Width / 2.0f), m_Center.GetY() - (m_Height / 2.0f) }; }
Point GetBottomRight() const { return { m_Center.GetX() + (m_Width / 2.0f), m_Center.GetY() + (m_Height / 2.0f) }; }
void setCenter(const Point& center) { m_Center = center; }
void setCenterX(float x) { m_Center.setX(x); }
void setCenterY(float y) { m_Center.setY(y); }
void SetCenter(const Point& center) { m_Center = center; }
void SetCenterX(float x) { m_Center.SetX(x); }
void SetCenterY(float y) { m_Center.SetY(y); }
void setSize(float width, float height) { setWidth(width); setHeight(height); }
void setSize(Point size) { setSize(size.getX(), size.getY()); }
Point getSize() { return { m_Width, m_Height }; }
void SetSize(float width, float height) { SetWidth(width); SetHeight(height); }
void SetSize(Point size) { SetSize(size.GetX(), size.GetY()); }
Point GetSize() { return { m_Width, m_Height }; }
void setWidth(float width) { m_Width = width; }
void setHeight(float height) { m_Height = height; }
void SetWidth(float width) { m_Width = width; }
void SetHeight(float height) { m_Height = height; }
bool collidesWith(const Point& point) const;
bool collidesWith(const Rectangle& rect) const;
bool collidesWith(const Circle& circle) const;
bool CollidesWith(const Point& point) const;
bool CollidesWith(const Rectangle& rect) const;
bool CollidesWith(const Circle& circle) const;
// distance from the closest side of the rectangle
float distance(const Circle& circle) const;
float distanceSquared(const Circle& circle) const;
float Distance(const Circle& circle) const;
float DistanceSquared(const Circle& circle) const;
};
class Circle {
@@ -70,25 +70,25 @@ public:
Circle(float x, float y, float radius) : m_Center(x, y), m_Radius(radius) {}
Circle() : m_Radius(0) {}
const Point& getCenter() const { return m_Center; }
float getCenterX() const { return m_Center.getX(); }
float getCenterY() const { return m_Center.getY(); }
const Point& GetCenter() const { return m_Center; }
float GetCenterX() const { return m_Center.GetX(); }
float GetCenterY() const { return m_Center.GetY(); }
float getRadius() const { return m_Radius; }
float GetRadius() const { return m_Radius; }
void setCenter(const Point& center) { m_Center = center; }
void setCenterX(float x) { m_Center.setX(x); }
void setCenterY(float y) { m_Center.setY(y); }
void SetCenter(const Point& center) { m_Center = center; }
void SetCenterX(float x) { m_Center.SetX(x); }
void SetCenterY(float y) { m_Center.SetY(y); }
void setRadius(float radius) { m_Radius = radius; }
void SetRadius(float radius) { m_Radius = radius; }
bool collidesWith(const Point& point) const;
bool collidesWith(const Rectangle& rect) const;
bool collidesWith(const Circle& circle) const;
bool CollidesWith(const Point& point) const;
bool CollidesWith(const Rectangle& rect) const;
bool CollidesWith(const Circle& circle) const;
// distance from the closest side of the rectangle
float distance(const Rectangle& rect) const;
float distanceSquared(const Rectangle& rect) const;
float Distance(const Rectangle& rect) const;
float DistanceSquared(const Rectangle& rect) const;
};
} // namespace shape

36
include/misc/Time.h
View File

@@ -6,7 +6,7 @@
namespace td {
namespace utils {
std::uint64_t getTime();
std::uint64_t GetTime();
typedef std::function<void()> TimerExecFunction;
@@ -17,23 +17,23 @@ private:
std::uint64_t m_Interval;
TimerExecFunction m_Function;
std::uint64_t m_LastTime = getTime();
std::uint64_t m_LastTime = GetTime();
std::uint64_t m_InternalTime = 0;
public:
AutoTimer() : m_Interval(0), m_Function(nullptr) {}
AutoTimer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr) {}
AutoTimer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback) {}
void update();
void update(std::uint64_t delta);
void Update();
void Update(std::uint64_t delta);
void reset();
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; }
};
// utililty class to call function at regular period of time
@@ -45,12 +45,12 @@ public:
Timer() : m_Interval(0) {}
Timer(std::uint64_t interval) : m_Interval(interval) {}
bool update(std::uint64_t delta);
bool Update(std::uint64_t delta);
void reset();
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; }
};
// utililty class to call function at regular period of time with a cooldown (used for towers and mobs )
@@ -62,14 +62,14 @@ public:
CooldownTimer() : m_Cooldown(0), m_CooldownTime(0) {}
CooldownTimer(std::uint64_t cooldown) : m_Cooldown(0), m_CooldownTime(cooldown) {}
bool update(std::uint64_t delta);
bool Update(std::uint64_t delta);
void applyCooldown();
void ApplyCooldown();
void reset();
void Reset();
void setCooldown(std::uint64_t newCooldown) { m_CooldownTime = newCooldown; }
std::uint64_t getCooldown() const { return m_CooldownTime; }
void SetCooldown(std::uint64_t newCooldown) { m_CooldownTime = newCooldown; }
std::uint64_t GetCooldown() const { return m_CooldownTime; }
};
} // namespace utils

15
include/network/TCPListener.h
View File

@@ -13,17 +13,18 @@ public:
TCPListener();
~TCPListener();
bool listen(std::uint16_t port, int maxConnections);
bool accept(TCPSocket& newSocket);
bool Listen(std::uint16_t port, int maxConnections);
bool Accept(TCPSocket& newSocket);
void destroy();
bool close();
bool setBlocking(bool blocking);
void Destroy();
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;
}

2
include/protocol/PacketFactory.h
View File

@@ -6,7 +6,7 @@ namespace td {
namespace protocol {
namespace PacketFactory {
PacketPtr createPacket(PacketType type, DataBuffer& buffer);
PacketPtr CreatePacket(PacketType type, DataBuffer& buffer);
}
} // namespace protocol

160
include/protocol/Protocol.h
View File

@@ -74,8 +74,8 @@ public:
void WritePacketID(DataBuffer& data, bool packetID) const;
virtual PacketType getType() const = 0;
std::uint8_t getID() const { return (std::uint8_t)getType(); }
virtual PacketType GetType() const = 0;
std::uint8_t GetID() const { return static_cast<std::uint8_t>(GetType()); }
};
typedef std::unique_ptr<Packet> PacketPtr;
@@ -92,9 +92,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
std::uint64_t getAliveID() const { return m_AliveID; }
std::uint64_t GetAliveID() const { return m_AliveID; }
virtual PacketType getType() const { return PacketType::KeepAlive; }
virtual PacketType GetType() const { return PacketType::KeepAlive; }
};
class PlayerLoginPacket : public Packet {
@@ -109,9 +109,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::PlayerLogin; }
virtual PacketType GetType() const { return PacketType::PlayerLogin; }
const std::string& getPlayerName() const { return m_PlayerName; }
const std::string& GetPlayerName() const { return m_PlayerName; }
};
class WorldBeginDataPacket : public Packet {
@@ -128,22 +128,22 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::WorldBeginData; }
virtual PacketType GetType() const { return PacketType::WorldBeginData; }
const game::TowerTileColorPalette& getTowerTilePalette() const { return m_Header.m_TowerPlacePalette; }
const game::Color& getWalkableTileColor() const { return m_Header.m_WalkablePalette; }
const std::vector<game::Color>& getDecorationPalette() const { return m_Header.m_DecorationPalette; }
const game::Color& getBackgroundColor() const { return m_Header.m_Background; }
const game::TowerTileColorPalette& GetTowerTilePalette() const { return m_Header.m_TowerPlacePalette; }
const game::Color& GetWalkableTileColor() const { return m_Header.m_WalkablePalette; }
const std::vector<game::Color>& GetDecorationPalette() const { return m_Header.m_DecorationPalette; }
const game::Color& GetBackgroundColor() const { return m_Header.m_Background; }
const game::Spawn& getRedSpawn() const { return m_Header.m_RedSpawn; }
const game::Spawn& getBlueSpawn() const { return m_Header.m_BlueSpawn; }
const game::Spawn& GetRedSpawn() const { return m_Header.m_RedSpawn; }
const game::Spawn& GetBlueSpawn() const { return m_Header.m_BlueSpawn; }
const game::SpawnColorPalette& getSpawnPalette() const { return m_Header.m_SpawnColorPalette; }
const game::SpawnColorPalette& GetSpawnPalette() const { return m_Header.m_SpawnColorPalette; }
const game::TeamCastle& getRedCastle() const { return m_Header.m_RedCastle; }
const game::TeamCastle& getBlueCastle() const { return m_Header.m_BlueCastle; }
const game::TeamCastle& GetRedCastle() const { return m_Header.m_RedCastle; }
const game::TeamCastle& GetBlueCastle() const { return m_Header.m_BlueCastle; }
const game::TilePalette getTilePalette() const { return m_Header.m_TilePalette; }
const game::TilePalette GetTilePalette() const { return m_Header.m_TilePalette; }
void setWorldHeader(const WorldHeader& header) { m_Header = header; }
};
@@ -162,12 +162,12 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::WorldData; }
virtual PacketType GetType() const { return PacketType::WorldData; }
const std::unordered_map<game::ChunkCoord, game::ChunkPtr>& getChunks() const { return m_WorldData.m_Chunks; }
const std::unordered_map<game::ChunkCoord, game::ChunkPtr>& GetChunks() const { return m_WorldData.m_Chunks; }
DataBuffer SerializeCustom() const; // allow serialisation with invalid World member
void setWorldData(const WorldData& worldData) { m_WorldData = worldData; }
void SetWorldData(const WorldData& worldData) { m_WorldData = worldData; }
};
class UpdateMoneyPacket : public Packet {
@@ -178,13 +178,13 @@ public:
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(bool packetID = true) const;
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::UpdateMoney; }
virtual PacketType GetType() const { return PacketType::UpdateMoney; }
};
class UpdateExpPacket : public Packet {
@@ -199,7 +199,7 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::UpdateEXP; }
virtual PacketType GetType() const { return PacketType::UpdateEXP; }
};
class UpdateLobbyTimePacket : public Packet {
@@ -214,9 +214,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -231,9 +231,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -253,9 +253,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
const std::map<std::uint8_t, PlayerInfo>& getPlayers() const { return m_Players; }
const std::map<std::uint8_t, PlayerInfo>& GetPlayers() const { return m_Players; }
virtual PacketType getType() const { return PacketType::PlayerList; }
virtual PacketType GetType() const { return PacketType::PlayerList; }
};
class PlayerJoinPacket : public Packet {
@@ -271,10 +271,10 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -289,9 +289,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -306,9 +306,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -323,9 +323,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -341,10 +341,10 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -359,9 +359,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -377,10 +377,10 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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; }
};
struct MobSend { // represents a mob send
@@ -401,9 +401,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
const std::vector<MobSend>& getMobSends() const { return m_MobSends; }
const std::vector<MobSend>& GetMobSends() const { return m_MobSends; }
virtual PacketType getType() const { return PacketType::SendMobs; }
virtual PacketType GetType() const { return PacketType::SendMobs; }
};
class SpawnMobPacket : public Packet {
@@ -425,15 +425,15 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
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 {
@@ -450,11 +450,11 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
std::int32_t getTowerX() const { return m_TowerX; }
std::int32_t getTowerY() const { return m_TowerY; }
game::TowerType getTowerType() const { return m_TowerType; }
std::int32_t GetTowerX() const { return m_TowerX; }
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 {
@@ -473,13 +473,13 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; }
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::TowerID GetTowerID() const { return m_TowerID; }
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; }
virtual PacketType getType() const { return PacketType::WorldAddTower; }
virtual PacketType GetType() const { return PacketType::WorldAddTower; }
};
class RemoveTowerPacket : public Packet {
@@ -494,9 +494,9 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; }
game::TowerID GetTowerID() const { return m_TowerID; }
virtual PacketType getType() const { return PacketType::RemoveTower; }
virtual PacketType GetType() const { return PacketType::RemoveTower; }
};
class UpgradeTowerPacket : public Packet {
@@ -512,10 +512,10 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; }
game::TowerLevel getTowerLevel() const { return m_TowerLevel; }
game::TowerID GetTowerID() const { return m_TowerID; }
game::TowerLevel GetTowerLevel() const { return m_TowerLevel; }
virtual PacketType getType() const { return PacketType::UpgradeTower; }
virtual PacketType GetType() const { return PacketType::UpgradeTower; }
};
class MobState {
@@ -530,10 +530,10 @@ public:
MobState(game::MobID id, const Point& position, float life, game::Direction direction) :
m_MobID(id), m_MobPosition(position), m_MobLife(life), m_MobDirection(direction) {}
game::MobID getMobId() const { return m_MobID; }
Point getMobPosition() const { return m_MobPosition; }
float getMobLife() const { return m_MobLife; }
game::Direction getMobDirection() const { return m_MobDirection; }
game::MobID GetMobId() const { return m_MobID; }
Point GetMobPosition() const { return m_MobPosition; }
float GetMobLife() const { return m_MobLife; }
game::Direction GetMobDirection() const { return m_MobDirection; }
};
class UpdateMobStatesPacket : public Packet {
@@ -549,9 +549,9 @@ public:
void addMobState(MobState mobState) { m_MobStates.push_back(mobState); }
const std::vector<MobState>& getMobStates() const { return m_MobStates; }
const std::vector<MobState>& GetMobStates() const { return m_MobStates; }
virtual PacketType getType() const { return PacketType::UpdateMobStates; }
virtual PacketType GetType() const { return PacketType::UpdateMobStates; }
};
class UpdateCastleLifePacket : public Packet {
@@ -567,10 +567,10 @@ public:
virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler) const;
std::uint16_t getCastleLife() const { return m_CastleLife; }
game::TeamColor getTeamColor() const { return m_Team; }
std::uint16_t GetCastleLife() const { return m_CastleLife; }
game::TeamColor GetTeamColor() const { return m_Team; }
virtual PacketType getType() const { return PacketType::UpdateCastleLife; }
virtual PacketType GetType() const { return PacketType::UpdateCastleLife; }
};
}

44
include/render/Renderer.h
View File

@@ -1,12 +1,4 @@
/*
* Renderer.h
*
* Created on: 4 nov. 2020
* Author: simon
*/
#ifndef RENDER_RENDERER_H_
#define RENDER_RENDERER_H_
#pragma once
#include <glm/glm.hpp>
#include <memory>
@@ -26,8 +18,8 @@ public:
glm::vec2 positon;
};
private:
std::unique_ptr<WorldShader> m_WorldShader;
std::unique_ptr<EntityShader> m_EntityShader;
std::unique_ptr<shader::WorldShader> m_WorldShader;
std::unique_ptr<shader::EntityShader> m_EntityShader;
glm::vec3 m_BackgroundColor;
@@ -38,29 +30,27 @@ public:
Renderer();
~Renderer();
bool init();
bool Init();
void prepare();
void resize(const int width, const int height);
void Prepare();
void Resize(const int width, const int height);
void renderVAO(const GL::VertexArray& vao);
void renderModel(const Model& model);
void RenderVAO(const GL::VertexArray& vao);
void RenderModel(const Model& model);
void setZoom(float zoom);
void setCamMovement(const glm::vec2& mov);
void setCamPos(const glm::vec2& newPos);
void setIsometricView(bool isometric); // false = 2D true = Isometric
void SetZoom(float zoom);
void SetCamMovement(const glm::vec2& mov);
void SetCamPos(const glm::vec2& newPos);
void SetIsometricView(bool isometric); // false = 2D true = Isometric
void setBackgroundColor(const glm::vec3& color) { m_BackgroundColor = color; }
void SetBackgroundColor(const glm::vec3& color) { m_BackgroundColor = color; }
glm::vec2 getCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight);
glm::vec2 GetCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight);
private:
void updateIsometricView();
void updateIsometricFade();
void initShader();
void UpdateIsometricView();
void UpdateIsometricFade();
void InitShaders();
};
} // namespace render
} // namespace td
#endif /* RENDER_RENDERER_H_ */

12
include/render/VertexCache.h
View File

@@ -25,13 +25,13 @@ private:
public:
VertexCache() : m_VertexCount(0) {}
void addData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors);
void removeData(std::uint64_t index);
void clear();
void updateVertexArray();
void AddData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors);
void RemoveData(std::uint64_t index);
void Clear();
void UpdateVertexArray();
const GL::VertexArray& getVertexArray() const { return *m_VertexArray; }
bool isEmpty() const { return m_VertexArray == nullptr; }
const GL::VertexArray& GetVertexArray() const { return *m_VertexArray; }
bool IsEmpty() const { return m_VertexArray == nullptr; }
};
} // namespace render

48
include/render/WorldRenderer.h
View File

@@ -46,41 +46,41 @@ public:
WorldRenderer(game::World* world, client::ClientGame* client);
~WorldRenderer();
void loadModels();
void LoadModels();
static ImVec4 getImGuiTeamColor(game::TeamColor color);
static ImVec4 GetImGuiTeamColor(game::TeamColor color);
void update();
void render();
void Update();
void Render();
void setCamPos(float camX, float camY);
void SetCamPos(float camX, float camY);
void moveCam(float relativeX, float relativeY, float aspectRatio);
void changeZoom(float zoom);
void MoveCam(float relativeX, float relativeY, float aspectRatio);
void ChangeZoom(float zoom);
// WorldListener
virtual void OnTowerAdd(game::TowerPtr tower);
virtual void OnTowerRemove(game::TowerPtr tower);
private:
void click();
void renderWorld() const;
void renderTowers() const;
void renderMobs() const;
void renderTileSelect() const;
void renderPopups();
void renderTowerUpgradePopup();
void renderMobTooltip() const;
void renderCastleTooltip() const;
void detectClick();
void detectMobHovering() const;
void detectCastleHovering() const;
void renderTooltips() const;
void removeTower();
glm::vec2 getCursorWorldPos() const;
glm::vec2 getClickWorldPos() const;
void Click();
void RenderWorld() const;
void RenderTowers() const;
void RenderMobs() const;
void RenderTileSelect() const;
void RenderPopups();
void RenderTowerUpgradePopup();
void RenderMobTooltip() const;
void RenderCastleTooltip() const;
void DetectClick();
void DetectMobHovering() const;
void DetectCastleHovering() const;
void RenderTooltips() const;
void RemoveTower();
glm::vec2 GetCursorWorldPos() const;
glm::vec2 GetClickWorldPos() const;
void updateCursorPos();
void UpdateCursorPos();
};
} // namespace render

6
include/render/gui/CastleTooltip.h
View File

@@ -18,10 +18,10 @@ private:
public:
CastleTooltip(client::Client* client);
virtual void render();
virtual void Render();
void setCastle(const game::TeamCastle* castle) { m_Castle = castle; }
bool isShown() { return m_Castle != nullptr; }
void SetCastle(const game::TeamCastle* castle) { m_Castle = castle; }
bool IsShown() { return m_Castle != nullptr; }
};
} // namespace gui

2
include/render/gui/FrameMenu.h
View File

@@ -13,7 +13,7 @@ private:
public:
FrameMenu(client::Client* client);
virtual void render();
virtual void Render();
};
} // namespace gui

12
include/render/gui/GameMenu.h
View File

@@ -11,13 +11,13 @@ private:
public:
GameMenu(client::Client* client);
virtual void render();
virtual void Render();
private:
void showTPS();
void showStats();
void showPlayers();
void showLobbyProgress();
void showTeamSelection();
void ShowTPS();
void ShowStats();
void ShowPlayers();
void ShowLobbyProgress();
void ShowTeamSelection();
};
} // namespace gui

8
include/render/gui/GuiManager.h
View File

@@ -12,15 +12,15 @@ class GuiManager {
private:
std::vector<std::unique_ptr<GuiWidget>> m_Widgets;
public:
GuiManager(){}
GuiManager() {}
void renderWidgets() {
void RenderWidgets() {
for (auto& widget : m_Widgets) {
widget->render();
widget->Render();
}
}
void addWidget(std::unique_ptr<GuiWidget>&& widget) {
void AddWidget(std::unique_ptr<GuiWidget>&& widget) {
m_Widgets.push_back(std::move(widget));
}
};

4
include/render/gui/GuiWidget.h
View File

@@ -14,9 +14,9 @@ protected:
public:
GuiWidget(client::Client* client) : m_Client(client) {}
client::Client* getClient() { return m_Client; }
client::Client* GetClient() { return m_Client; }
virtual void render() = 0;
virtual void Render() = 0;
};
} // namespace gui

6
include/render/gui/MainMenu.h
View File

@@ -26,11 +26,11 @@ public:
MainMenu(client::Client* client);
~MainMenu();
virtual void render();
virtual void Render();
const server::Server* getServer() const { return m_Server.get(); }
const server::Server* GetServer() const { return m_Server.get(); }
private:
bool startServer();
bool StartServer();
};
} // namespace gui

6
include/render/gui/MobTooltip.h
View File

@@ -18,10 +18,10 @@ private:
public:
MobTooltip(client::Client* client);
virtual void render();
virtual void Render();
void setMob(const game::Mob* mob) { m_Mob = mob; }
bool isShown() { return m_Mob != nullptr; }
void SetMob(const game::Mob* mob) { m_Mob = mob; }
bool IsShown() { return m_Mob != nullptr; }
};
} // namespace gui

4
include/render/gui/SummonMenu.h
View File

@@ -17,9 +17,9 @@ private:
public:
SummonMenu(client::Client* client);
virtual void render();
virtual void Render();
private:
void setSummonMax(int valueIndex);
void SetSummonMax(int valueIndex);
};
} // namespace gui

10
include/render/gui/TowerGui.h
View File

@@ -37,12 +37,12 @@ public:
TowerGui(SDL_Window* wndow, SDL_GLContext glContext, td::render::Renderer* renderer);
~TowerGui();
void render();
void Render();
private:
void initWidgets();
void tick();
void beginFrame();
void endFrame();
void InitWidgets();
void Tick();
void BeginFrame();
void EndFrame();
};
} // namespace render

4
include/render/gui/TowerPlacePopup.h
View File

@@ -13,9 +13,9 @@ private:
public:
TowerPlacePopup(client::Client* client);
virtual void render();
virtual void Render();
void setClickPos(const glm::vec2& worldPos);
void SetClickPos(const glm::vec2& worldPos);
private:
static constexpr float m_TowerPopupTileWidth = 200.0f;
static constexpr float m_TowerPopupTileHeight = 200.0f;

8
include/render/gui/UpdateMenu.h
View File

@@ -18,11 +18,11 @@ private:
public:
UpdateMenu(client::Client* client);
virtual void render();
virtual void Render();
private:
void checkUpdates();
bool isUpdateChecked();
void renderErrorPopup();
void CheckUpdates();
bool IsUpdateChecked();
void RenderErrorPopup();
};
} // namespace gui

22
include/render/loader/GLLoader.h
View File

@@ -28,6 +28,7 @@ private:
std::vector<VertexAttribPointer> m_VertexAttribs;
public:
REMOVE_COPY(VertexBuffer);
VertexBuffer(VertexBuffer&& other) {
m_VertexAttribs = std::move(other.m_VertexAttribs);
m_ID = other.m_ID;
@@ -35,12 +36,14 @@ public:
other.m_ID = 0;
other.m_DataStride = 0;
}
VertexBuffer(const std::vector<float>& 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;
void Bind() const;
void Unbind() const;
void AddVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset);
void BindVertexAttribs() const;
};
class VertexArray {
@@ -49,6 +52,7 @@ private:
std::vector<VertexBuffer> 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;
@@ -56,12 +60,14 @@ public:
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;
unsigned int GetVertexCount() const { return m_VertexCount; }
void BindVertexBuffer(VertexBuffer& vbo);
void Bind() const;
void Unbind() const;
};
}

2
include/render/loader/TextureLoader.h
View File

@@ -10,7 +10,7 @@
namespace TextureLoader {
unsigned int loadGLTexture(const char* fileName);
unsigned int LoadGLTexture(const char* fileName);
}

8
include/render/loader/WorldLoader.h
View File

@@ -13,10 +13,10 @@ struct RenderData {
std::vector<float> colors;
};
GL::VertexArray loadMobModel();
GL::VertexArray loadWorldModel(const td::game::World* world);
GL::VertexArray loadTileSelectModel();
RenderData loadTowerModel(game::TowerPtr tower);
GL::VertexArray LoadMobModel();
GL::VertexArray LoadWorldModel(const td::game::World* world);
GL::VertexArray LoadTileSelectModel();
RenderData LoadTowerModel(game::TowerPtr tower);
} // namespace WorldLoader

28
include/render/shaders/EntityShader.h
View File

@@ -2,17 +2,29 @@
#include "ShaderProgram.h"
namespace td {
namespace shader {
class EntityShader : public ShaderProgram {
private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_translation = 0, location_viewtype = 0;
unsigned int m_LocationCam = 0;
unsigned int m_LocationZoom = 0;
unsigned int m_LocationAspectRatio = 0;
unsigned int m_LocationTranslation = 0;
unsigned int m_LocationViewtype = 0;
protected:
void getAllUniformLocation();
virtual void GetAllUniformLocation();
public:
EntityShader();
void loadShader();
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 LoadShader();
void SetCamPos(const glm::vec2& camPos);
void SetZoom(float zoom);
void SetAspectRatio(float aspectRatio);
void SetModelPos(const glm::vec2& modelPos);
void SetIsometricView(float isometric);
};
} // namespace shader
} // namespace td

50
include/render/shaders/ShaderProgram.h
View File

@@ -1,46 +1,44 @@
/*
* ShaderProgram.h
*
* Created on: 31 janv. 2020
* Author: simon
*/
#ifndef RENDER_SHADERS_SHADERPROGRAM_H_
#define RENDER_SHADERS_SHADERPROGRAM_H_
#pragma once
#include <string>
#include <glm/glm.hpp>
#include "render/GL.h"
namespace td {
namespace shader {
class ShaderProgram {
public:
ShaderProgram();
virtual ~ShaderProgram();
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 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);
protected:
virtual void getAllUniformLocation() = 0;
int getUniformLocation(const std::string& uniformName) const;
virtual void GetAllUniformLocation() = 0;
int GetUniformLocation(const std::string& uniformName) const;
void loadFloat(unsigned int location, float value) const;
void loadInt(unsigned int location, int value) const;
void loadVector(unsigned int location, const glm::vec2& vector) const;
void loadVector(unsigned int location, const glm::vec3& vector) const;
void loadVector(unsigned int location, const glm::vec4& vector) const;
void loadBoolean(unsigned int location, bool value) const;
void loadMatrix(unsigned int location, const glm::mat4& matrix) const;
void cleanUp() const;
void LoadFloat(unsigned int location, float value) const;
void LoadInt(unsigned int location, int value) const;
void LoadVector(unsigned int location, const glm::vec2& vector) const;
void LoadVector(unsigned int location, const glm::vec3& vector) const;
void LoadVector(unsigned int location, const glm::vec4& vector) const;
void LoadBoolean(unsigned int location, bool value) const;
void LoadMatrix(unsigned int location, const glm::mat4& matrix) const;
void CleanUp() const;
private:
unsigned int m_ProgramID;
unsigned int m_VertexShaderID;
unsigned int m_FragmentShaderID;
unsigned int loadShaderFromFile(const std::string& file, GLenum type);
unsigned int loadShader(const std::string& source, GLenum type);
unsigned int LoadShaderFromFile(const std::string& file, GLenum type);
unsigned int LoadShader(const std::string& source, GLenum type);
};
#endif /* RENDER_SHADERS_SHADERPROGRAM_H_ */
} // namespace shader
} // namespace td

30
include/render/shaders/WorldShader.h
View File

@@ -1,27 +1,23 @@
/*
* GameShader.h
*
* Created on: 4 nov. 2020
* Author: simon
*/
#ifndef RENDER_SHADERS_GAMESHADER_H_
#define RENDER_SHADERS_GAMESHADER_H_
#pragma once
#include "ShaderProgram.h"
namespace td {
namespace shader {
class WorldShader : public ShaderProgram {
private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_viewtype = 0;
unsigned int m_LocationCam = 0, m_LocationZoom = 0, m_LocationAspectRatio = 0, m_LocationViewtype = 0;
protected:
void getAllUniformLocation();
void GetAllUniformLocation();
public:
WorldShader();
void loadShader();
void setCamPos(const glm::vec2& camPos);
void setZoom(float zoom);
void setAspectRatio(float aspectRatio);
void setIsometricView(float isometric);
void LoadShader();
void SetCamPos(const glm::vec2& camPos);
void SetZoom(float zoom);
void SetAspectRatio(float aspectRatio);
void SetIsometricView(float isometric);
};
#endif /* RENDER_SHADERS_GAMESHADER_H_ */
} // namespace shader
} // namespace td

28
include/updater/Updater.h
View File

@@ -18,26 +18,26 @@ private:
public:
Updater() : m_Progress(0), m_DownloadComplete(false), m_FileWrited(false), m_CancelDownload(false) {}
bool checkUpdate();
void downloadUpdate();
void cancelDownload() { m_CancelDownload = true; m_Progress = 0.0f; m_DownloadComplete = false; }
bool writeFile();
bool CheckUpdate();
void DownloadUpdate();
void CancelDownload() { m_CancelDownload = true; m_Progress = 0.0f; m_DownloadComplete = false; }
bool WriteFile();
void clearCache() { m_FileBuffer.Clear(); }
void ClearCache() { m_FileBuffer.Clear(); }
float getDownloadProgress() { return m_Progress; }
bool isDownloadComplete() { return m_DownloadComplete; }
bool isFileWrited() { return m_FileWrited; }
float GetDownloadProgress() { return m_Progress; }
bool IsDownloadComplete() { return m_DownloadComplete; }
bool IsFileWrited() { return m_FileWrited; }
static std::string getLocalFilePath();
static void removeOldFile();
static std::string GetLocalFilePath();
static void RemoveOldFile();
static std::string getCurrentVersion() { return TD_VERSION; }
std::string getLastVersion() { return m_LastVersion; }
static std::string GetCurrentVersion() { return TD_VERSION; }
std::string GetLastVersion() { return m_LastVersion; }
bool canUpdate();
bool CanUpdate();
private:
std::string getDownloadFileURL();
std::string GetDownloadFileURL();
};
} // namespace utils

20
include/window/Display.h
View File

@@ -11,19 +11,19 @@
namespace Display {
bool create();
void render();
void update();
void destroy();
void pollEvents();
bool Create();
void Render();
void Update();
void Destroy();
void PollEvents();
bool isCloseRequested();
bool IsCloseRequested();
bool isMouseDown(int button);
bool IsMouseDown(int button);
float getAspectRatio();
int getWindowWidth();
int getWindowHeight();
float GetAspectRatio();
int GetWindowWidth();
int GetWindowHeight();
}

18
src/TowerDefense.cpp
View File

@@ -20,20 +20,20 @@ extern "C"
#endif
int main(int argc, const char* args[]) {
#if !defined(NDEBUG)
#if !defined(NDEBUG)
// setup signal handling
backward::SignalHandling sh;
#endif
#endif
// remove the outdated binary
td::utils::Updater::removeOldFile();
td::utils::Updater::RemoveOldFile();
Display::create();
while (!Display::isCloseRequested()) {
Display::pollEvents();
Display::render();
Display::update();
Display::Create();
while (!Display::IsCloseRequested()) {
Display::PollEvents();
Display::Render();
Display::Update();
}
Display::destroy();
Display::Destroy();
return 0;
}

8
src/game/BaseGame.cpp
View File

@@ -11,13 +11,13 @@ Game::~Game() {
}
void Game::tick(std::uint64_t delta) {
void Game::Tick(std::uint64_t delta) {
if (m_GameState == GameState::Game) {
m_World->tick(delta);
m_World->Tick(delta);
}
}
Player* Game::getPlayerById(PlayerID id) {
Player* Game::GetPlayerById(PlayerID id) {
auto it = m_Players.find(id);
if (it == m_Players.end()) return nullptr;
@@ -25,7 +25,7 @@ Player* Game::getPlayerById(PlayerID id) {
return &it->second;
}
const Player* Game::getPlayerById(PlayerID id) const {
const Player* Game::GetPlayerById(PlayerID id) const {
auto it = m_Players.find(id);
if (it == m_Players.end()) return nullptr;

10
src/game/Connexion.cpp
View File

@@ -28,7 +28,7 @@ Connexion::Connexion(protocol::PacketDispatcher* dispatcher, network::TCPSocket&
}
bool Connexion::updateSocket() {
bool Connexion::UpdateSocket() {
if (m_Socket.GetStatus() != network::Socket::Connected)
return false;
@@ -47,13 +47,13 @@ bool Connexion::updateSocket() {
protocol::PacketType packetType;
decompressed >> packetType;
PacketPtr packet = protocol::PacketFactory::createPacket(packetType, decompressed);
PacketPtr packet = protocol::PacketFactory::CreatePacket(packetType, decompressed);
GetDispatcher()->Dispatch(packet);
}
return true;
}
bool Connexion::connect(const std::string& address, std::uint16_t port) {
bool Connexion::Connect(const std::string& address, std::uint16_t port) {
if (!m_Socket.Connect(address, port)) {
return false;
}
@@ -61,11 +61,11 @@ bool Connexion::connect(const std::string& address, std::uint16_t port) {
return true;
}
void Connexion::sendPacket(const protocol::Packet* packet) {
void Connexion::SendPacket(const protocol::Packet* packet) {
network::SendPacket(packet->Serialize(), m_Socket);
}
void Connexion::closeConnection() {
void Connexion::CloseConnection() {
m_Socket.Disconnect();
}

194
src/game/Mobs.cpp
View File

@@ -8,136 +8,136 @@
namespace td {
namespace game {
bool Mob::isImmuneTo(TowerType type) {
return std::find(getTowerImmunities().begin(), getTowerImmunities().end(), type) != getTowerImmunities().end();
bool Mob::IsImmuneTo(TowerType type) {
return std::find(GetTowerImmunities().begin(), GetTowerImmunities().end(), type) != GetTowerImmunities().end();
}
bool Mob::isImmuneTo(EffectType type) {
return std::find(getEffectImmunities().begin(), getEffectImmunities().end(), type) != getEffectImmunities().end();
bool Mob::IsImmuneTo(EffectType type) {
return std::find(GetEffectImmunities().begin(), GetEffectImmunities().end(), type) != GetEffectImmunities().end();
}
EffectDuration& Mob::getEffect(EffectType effectType) {
EffectDuration& Mob::GetEffect(EffectType effectType) {
return *std::find_if(m_Effects.begin(), m_Effects.end(), [&effectType](EffectDuration effect) { return effect.type == effectType;});
}
void Mob::addEffect(EffectType effectType, float durationSec, Tower* tower) {
if (isImmuneTo(effectType))
void Mob::AddEffect(EffectType effectType, float durationSec, Tower* tower) {
if (IsImmuneTo(effectType))
return;
if (hasEffect(effectType)) {
EffectDuration& effect = getEffect(effectType);
if (HasEffect(effectType)) {
EffectDuration& effect = GetEffect(effectType);
if (effect.duration < durationSec)
effect.duration = durationSec; // setting new duration if it's greater then the actual
effect.duration = durationSec; // Setting new duration if it's greater then the actual
} else {
m_Effects.push_back({ effectType, durationSec, tower });
}
}
void Mob::attackCastle(std::uint64_t delta, World* world) {
if(!hasReachedEnemyCastle()) return;
if (m_AttackTimer.update(delta)) {
world->getMobNotifier().notifyListeners(&MobListener::OnMobCastleDamage, this, m_CastleTarget, getStats()->getDamage());
m_AttackTimer.applyCooldown();
void Mob::AttackCastle(std::uint64_t delta, World* world) {
if (!HasReachedEnemyCastle()) return;
if (m_AttackTimer.Update(delta)) {
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobCastleDamage, this, m_CastleTarget, GetStats()->GetDamage());
m_AttackTimer.ApplyCooldown();
}
}
void Mob::walk(std::uint64_t delta, World* world) {
float mobWalkSpeed = getStats()->getMovementSpeed();
void Mob::Walk(std::uint64_t delta, World* world) {
float mobWalkSpeed = GetStats()->GetMovementSpeed();
float walkAmount = mobWalkSpeed * ((float)delta / 1000.0f);
if (hasEffect(EffectType::Slowness))
if (HasEffect(EffectType::Slowness))
walkAmount *= 0.70; // walk 30% slower
switch (getDirection()) {
switch (GetDirection()) {
case Direction::NegativeX: {
setCenterX(getCenterX() - walkAmount);
SetCenterX(GetCenterX() - walkAmount);
break;
}
case Direction::PositiveX: {
setCenterX(getCenterX() + walkAmount);
SetCenterX(GetCenterX() + walkAmount);
break;
}
case Direction::NegativeY: {
setCenterY(getCenterY() - walkAmount);
SetCenterY(GetCenterY() - walkAmount);
break;
}
case Direction::PositiveY: {
setCenterY(getCenterY() + walkAmount);
SetCenterY(GetCenterY() + walkAmount);
break;
}
}
}
void Mob::move(std::uint64_t delta, World* world) {
TilePtr tile = world->getTile(getCenter().getX(), getCenter().getY());
void Mob::Move(std::uint64_t delta, World* world) {
TilePtr tile = world->GetTile(GetCenter().GetX(), GetCenter().GetY());
if (tile != nullptr && tile->getType() == TileType::Walk) {
if (tile != nullptr && tile->GetType() == TileType::Walk) {
WalkableTilePtr walkTile = std::static_pointer_cast<WalkableTile>(tile);
changeDirection(*walkTile, world);
ChangeDirection(*walkTile, world);
}
if (hasReachedEnemyCastle()) return;
if (HasReachedEnemyCastle()) return;
walk(delta, world);
Walk(delta, world);
TeamColor mobTeam = world->getPlayerById(getSender())->getTeamColor();
TeamColor mobTeam = world->GetPlayerById(GetSender())->GetTeamColor();
TeamCastle* enemyCastle = nullptr;
if (mobTeam == TeamColor::Red) {
enemyCastle = &world->getBlueTeam().getCastle();
enemyCastle = &world->GetBlueTeam().GetCastle();
} else if (mobTeam == TeamColor::Blue) {
enemyCastle = &world->getRedTeam().getCastle();
enemyCastle = &world->GetRedTeam().GetCastle();
}
if (isTouchingCastle(*enemyCastle)) {
moveBack(*enemyCastle, world);
setMobReachedCastle(enemyCastle);
if (IsTouchingCastle(*enemyCastle)) {
MoveBack(*enemyCastle, world);
SetMobReachedCastle(enemyCastle);
world->getMobNotifier().notifyListeners(&MobListener::OnMobTouchCastle, this, enemyCastle);
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobTouchCastle, this, enemyCastle);
}
}
void Mob::moveBack(const TeamCastle& enemyCastle, World* world) {
switch (getDirection()) {
void Mob::MoveBack(const TeamCastle& enemyCastle, World* world) {
switch (GetDirection()) {
case Direction::NegativeX: {
setCenterX(enemyCastle.getBottomRight().getX() + getWidth() / 2.0f);
SetCenterX(enemyCastle.GetBottomRight().GetX() + GetWidth() / 2.0f);
break;
}
case Direction::PositiveX: {
setCenterX(enemyCastle.getTopLeft().getX() - getWidth() / 2.0f);
SetCenterX(enemyCastle.GetTopLeft().GetX() - GetWidth() / 2.0f);
break;
}
case Direction::NegativeY: {
setCenterY(enemyCastle.getBottomRight().getY() + getHeight() / 2.0f);
SetCenterY(enemyCastle.GetBottomRight().GetY() + GetHeight() / 2.0f);
break;
}
case Direction::PositiveY: {
setCenterY(enemyCastle.getTopLeft().getY() - getHeight() / 2.0f);
SetCenterY(enemyCastle.GetTopLeft().GetY() - GetHeight() / 2.0f);
break;
}
}
}
void Mob::changeDirection(const WalkableTile& tile, World* world) {
if (getDirection() == tile.direction) return;
void Mob::ChangeDirection(const WalkableTile& tile, World* world) {
if (GetDirection() == tile.direction) return;
float tileX = static_cast<float>(static_cast<std::int32_t>(getCenterX()));
float tileY = static_cast<float>(static_cast<std::int32_t>(getCenterY()));
float tileX = static_cast<float>(static_cast<std::int32_t>(GetCenterX()));
float tileY = static_cast<float>(static_cast<std::int32_t>(GetCenterY()));
switch (getDirection()) {
switch (GetDirection()) {
case Direction::PositiveY: {
if (tile.direction == Direction::NegativeX) {
if (getTileY() > getTileX()) {
setCenterY(tileY + getTileX());
setDirection(tile.direction);
if (GetTileY() > GetTileX()) {
SetCenterY(tileY + GetTileX());
SetDirection(tile.direction);
}
} else { // tile->direction = Direction::PositiveX
if (getTileY() > 1 - getTileX()) {
setCenterY(tileY + (1 - getTileX()));
setDirection(tile.direction);
if (GetTileY() > 1 - GetTileX()) {
SetCenterY(tileY + (1 - GetTileX()));
SetDirection(tile.direction);
}
}
return;
@@ -145,14 +145,14 @@ void Mob::changeDirection(const WalkableTile& tile, World* world) {
case Direction::NegativeY: {
if (tile.direction == Direction::PositiveX) {
if (getTileY() < getTileX()) {
setCenterY(tileY + getTileX());
setDirection(tile.direction);
if (GetTileY() < GetTileX()) {
SetCenterY(tileY + GetTileX());
SetDirection(tile.direction);
}
} else { // tile.direction = Direction::NegativeX
if (getTileY() < 1 - getTileX()) {
setCenterY(tileY + (1 - getTileX()));
setDirection(tile.direction);
if (GetTileY() < 1 - GetTileX()) {
SetCenterY(tileY + (1 - GetTileX()));
SetDirection(tile.direction);
}
}
return;
@@ -160,14 +160,14 @@ void Mob::changeDirection(const WalkableTile& tile, World* world) {
case Direction::PositiveX: {
if (tile.direction == Direction::NegativeY) {
if (getTileX() > getTileY()) {
setCenterX(tileX + getTileY());
setDirection(tile.direction);
if (GetTileX() > GetTileY()) {
SetCenterX(tileX + GetTileY());
SetDirection(tile.direction);
}
} else { // tile.direction = Direction::PositiveY
if (getTileX() > 1 - getTileY()) {
setCenterX(tileX + (1 - getTileY()));
setDirection(tile.direction);
if (GetTileX() > 1 - GetTileY()) {
SetCenterX(tileX + (1 - GetTileY()));
SetDirection(tile.direction);
}
}
return;
@@ -175,14 +175,14 @@ void Mob::changeDirection(const WalkableTile& tile, World* world) {
case Direction::NegativeX: {
if (tile.direction == Direction::PositiveY) {
if (getTileX() < getTileY()) {
setCenterX(tileX + getTileY());
setDirection(tile.direction);
if (GetTileX() < GetTileY()) {
SetCenterX(tileX + GetTileY());
SetDirection(tile.direction);
}
} else { // tile.direction = Direction::NegativeY
if (getTileX() < 1 - getTileY()) {
setCenterX(tileX + (1 - getTileY()));
setDirection(tile.direction);
if (GetTileX() < 1 - GetTileY()) {
SetCenterX(tileX + (1 - GetTileY()));
SetDirection(tile.direction);
}
}
return;
@@ -191,17 +191,17 @@ void Mob::changeDirection(const WalkableTile& tile, World* world) {
}
}
bool Mob::isTouchingCastle(const TeamCastle& enemyCastle) const {
return enemyCastle.collidesWith(*this);
bool Mob::IsTouchingCastle(const TeamCastle& enemyCastle) const {
return enemyCastle.CollidesWith(*this);
}
void Mob::tick(std::uint64_t delta, World* world) {
updateEffects(delta, world);
move(delta, world);
attackCastle(delta, world);
void Mob::Tick(std::uint64_t delta, World* world) {
UpdateEffects(delta, world);
Move(delta, world);
AttackCastle(delta, world);
}
void Mob::updateEffects(std::uint64_t delta, World* world) {
void Mob::UpdateEffects(std::uint64_t delta, World* world) {
float deltaSec = (float)delta / 1000.0f;
for (std::size_t i = 0; i < m_Effects.size(); i++) {
EffectDuration& effect = m_Effects[i];
@@ -210,17 +210,17 @@ void Mob::updateEffects(std::uint64_t delta, World* world) {
m_Effects.erase(m_Effects.begin() + i);
switch (effect.type) {
case EffectType::Fire: {
m_EffectFireTimer.reset();
m_EffectFireTimer.Reset();
break;
}
case EffectType::Poison: {
m_EffectPoisonTimer.reset();
m_EffectPoisonTimer.Reset();
break;
}
case EffectType::Heal: {
m_EffectHealTimer.reset();
m_EffectHealTimer.Reset();
}
default:
@@ -228,24 +228,24 @@ void Mob::updateEffects(std::uint64_t delta, World* world) {
}
}
}
if (hasEffect(EffectType::Fire)) {
if (m_EffectFireTimer.update(delta)) {
world->getMobNotifier().notifyListeners(&MobListener::OnMobDamage, this, 3.0f, getEffect(EffectType::Fire).tower);
if (HasEffect(EffectType::Fire)) {
if (m_EffectFireTimer.Update(delta)) {
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, this, 3.0f, GetEffect(EffectType::Fire).tower);
}
}
if (hasEffect(EffectType::Poison)) {
if (m_EffectPoisonTimer.update(delta)) {
world->getMobNotifier().notifyListeners(&MobListener::OnMobDamage, this, 1.0f, getEffect(EffectType::Poison).tower);
if (HasEffect(EffectType::Poison)) {
if (m_EffectPoisonTimer.Update(delta)) {
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, this, 1.0f, GetEffect(EffectType::Poison).tower);
}
}
if (hasEffect(EffectType::Heal)) {
if (m_EffectFireTimer.update(delta)) {
heal(10);
if (HasEffect(EffectType::Heal)) {
if (m_EffectFireTimer.Update(delta)) {
Heal(10);
}
}
}
bool Mob::hasEffect(EffectType type) {
bool Mob::HasEffect(EffectType type) {
return std::find_if(m_Effects.begin(), m_Effects.end(), [&type](EffectDuration effect) { return effect.type == type;}) != m_Effects.end();
}
@@ -317,7 +317,7 @@ const std::map<MobKey, MobStats> MobConstants = {
{{MobType::Giant, 5},{MobStats{50, 0.8, {1, 1}, 6407, 22000, 648, 31640}}},
};
const MobStats* getMobStats(MobType type, std::uint8_t level) {
const MobStats* GetMobStats(MobType type, std::uint8_t level) {
return &MobConstants.at(MobKey{ type, level });
}
@@ -383,7 +383,7 @@ const std::map<MobKey, TowerImmunities> MobsTowerImmunities = {
{{MobType::Giant, 5},{}},
};
const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level) {
const TowerImmunities& GetMobTowerImmunities(MobType type, std::uint8_t level) {
return MobsTowerImmunities.at({ type, level });
}
@@ -449,11 +449,11 @@ const std::map<MobKey, EffectImmunities> MobsEffectImmunities = {
{{MobType::Giant, 5},{EffectType::Stun}},
};
const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t 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<std::shared_ptr<Mob>(MobID, std::uint8_t, PlayerID)>;
static std::map<MobType, MobCreator> mobFactory = {
@@ -472,7 +472,7 @@ MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerI
return mobFactory[type](id, level, sender);
}
std::string MobFactory::getMobName(MobType type) {
std::string MobFactory::GetMobName(MobType type) {
switch (type) {
case MobType::Zombie:
return "Zombie";

8
src/game/Team.cpp
View File

@@ -7,19 +7,19 @@ namespace game {
Team::Team(TeamColor color) : m_Color(color), m_TeamCastle(this) {}
void Team::addPlayer(Player* newPlayer) {
void Team::AddPlayer(Player* newPlayer) {
m_Players.push_back(newPlayer);
}
void Team::removePlayer(const Player* 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 {
std::uint8_t Team::GetPlayerCount() const {
return m_Players.size();
}

90
src/game/Towers.cpp
View File

@@ -6,10 +6,10 @@
namespace td {
namespace game {
bool Tower::isMobInRange(MobPtr mob) {
if (mob->isDead())
bool Tower::IsMobInRange(MobPtr mob) {
if (mob->IsDead())
return false;
return mob->collidesWith(*this);
return mob->CollidesWith(*this);
}
const std::map<std::pair<TowerType, TowerLevel>, TowerStats> TowerConstants = {
@@ -115,7 +115,7 @@ const std::map<std::pair<TowerType, TowerLevel>, TowerStats> TowerConstants = {
{{TowerType::Necromancer, {3, TowerPath::Bottom}}, {0, 30, 0}},
};
const TowerStats* getTowerStats(TowerType type, TowerLevel level) {
const TowerStats* GetTowerStats(TowerType type, TowerLevel level) {
auto it = TowerConstants.find({ type, level });
if (it == TowerConstants.end()) return nullptr;
return &it->second;
@@ -139,7 +139,7 @@ static const std::map<TowerType, TowerInfo> TowerInfoConstants = {
{TowerType::Zeus, {"Zeus", "Strike lightning", false}},
};
const TowerInfo& getTowerInfo(TowerType type) {
const TowerInfo& GetTowerInfo(TowerType type) {
return TowerInfoConstants.at(type);
}
@@ -165,11 +165,11 @@ static const std::map<TowerType, TowerCreator> towerFactory = {
{TowerType::Turret, [](TowerID id, std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<TurretTower>(id, x, y , builder);} },
};
TowerPtr createTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder) {
TowerPtr CreateTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder) {
return towerFactory.at(type)(id, x, y, builder);
}
std::string getTowerName(TowerType type) {
std::string GetTowerName(TowerType type) {
switch (type) {
case TowerType::Archer:
@@ -206,15 +206,15 @@ std::string getTowerName(TowerType type) {
void ArcherTower::tick(std::uint64_t delta, World* world) {
if (m_Timer.update(delta)) {
void ArcherTower::Tick(std::uint64_t delta, World* world) {
if (m_Timer.Update(delta)) {
std::uint8_t arrowsShot = 0;
bool explosiveArrows = getLevel().getPath() == TowerPath::Bottom;
std::uint8_t arrows = explosiveArrows ? 2 : getLevel().getLevel();
for (MobPtr mob : world->getMobList()) {
if (isMobInRange(mob)) {
world->getWorldNotifier().notifyListeners(&WorldListener::OnArcherTowerShot, mob, this);
m_Timer.applyCooldown();
bool explosiveArrows = GetLevel().GetPath() == TowerPath::Bottom;
std::uint8_t arrows = explosiveArrows ? 2 : GetLevel().GetLevel();
for (MobPtr mob : world->GetMobList()) {
if (IsMobInRange(mob)) {
world->GetWorldNotifier().NotifyListeners(&WorldListener::OnArcherTowerShot, mob, this);
m_Timer.ApplyCooldown();
arrowsShot++;
if (arrowsShot >= arrows)
break;
@@ -223,40 +223,40 @@ void ArcherTower::tick(std::uint64_t delta, World* world) {
}
}
void IceTower::tick(std::uint64_t delta, World* world) {
if (m_Timer.update(delta)) {
float damage = getStats()->getDamage();
for (MobPtr mob : world->getMobList()) {
if (isMobInRange(mob)) {
mob->addEffect(EffectType::Slowness, 1, this); // slowness for 1s every second
void IceTower::Tick(std::uint64_t delta, World* world) {
if (m_Timer.Update(delta)) {
float damage = GetStats()->GetDamage();
for (MobPtr mob : world->GetMobList()) {
if (IsMobInRange(mob)) {
mob->AddEffect(EffectType::Slowness, 1, this); // slowness for 1s every second
if (damage > 0)
world->getMobNotifier().notifyListeners(&MobListener::OnMobDamage, mob.get(), damage, this);
m_Timer.applyCooldown();
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, mob.get(), damage, this);
m_Timer.ApplyCooldown();
}
}
}
}
void MageTower::tick(std::uint64_t delta, World* world) {
if (m_Timer.update(delta)) {
for (MobPtr mob : world->getMobList()) {
if (isMobInRange(mob)) {
mob->addEffect(EffectType::Fire, getLevel().getLevel() * 3, this);
m_Timer.applyCooldown();
void MageTower::Tick(std::uint64_t delta, World* world) {
if (m_Timer.Update(delta)) {
for (MobPtr mob : world->GetMobList()) {
if (IsMobInRange(mob)) {
mob->AddEffect(EffectType::Fire, GetLevel().GetLevel() * 3, this);
m_Timer.ApplyCooldown();
}
}
}
}
void PoisonTower::tick(std::uint64_t delta, World* world) {
if (m_Timer.update(delta)) {
for (MobPtr mob : world->getMobList()) {
if (isMobInRange(mob)) {
if (getLevel().getPath() == TowerPath::Bottom) {
world->getMobNotifier().notifyListeners(&MobListener::OnMobDamage, mob.get(), getStats()->getDamage(), this);
void PoisonTower::Tick(std::uint64_t delta, World* world) {
if (m_Timer.Update(delta)) {
for (MobPtr mob : world->GetMobList()) {
if (IsMobInRange(mob)) {
if (GetLevel().GetPath() == TowerPath::Bottom) {
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, mob.get(), GetStats()->GetDamage(), this);
} else {
float durationSec;
switch (getLevel().getLevel()) {
switch (GetLevel().GetLevel()) {
case 1:
durationSec = 5;
break;
@@ -277,41 +277,41 @@ void PoisonTower::tick(std::uint64_t delta, World* world) {
durationSec = 0; // how did we get there ?
break;
}
mob->addEffect(EffectType::Poison, durationSec, this);
mob->AddEffect(EffectType::Poison, durationSec, this);
}
m_Timer.applyCooldown();
m_Timer.ApplyCooldown();
}
}
}
}
void QuakeTower::tick(std::uint64_t delta, World* world) {
void QuakeTower::Tick(std::uint64_t delta, World* world) {
}
void ZeusTower::tick(std::uint64_t delta, World* world) {
void ZeusTower::Tick(std::uint64_t delta, World* world) {
}
void ArtilleryTower::tick(std::uint64_t delta, World* world) {
void ArtilleryTower::Tick(std::uint64_t delta, World* world) {
}
void SorcererTower::tick(std::uint64_t delta, World* world) {
void SorcererTower::Tick(std::uint64_t delta, World* world) {
}
void LeachTower::tick(std::uint64_t delta, World* world) {
void LeachTower::Tick(std::uint64_t delta, World* world) {
}
void TurretTower::tick(std::uint64_t delta, World* world) {
void TurretTower::Tick(std::uint64_t delta, World* world) {
}
void NecromancerTower::tick(std::uint64_t delta, World* world) {
void NecromancerTower::Tick(std::uint64_t delta, World* world) {
}

194
src/game/World.cpp
View File

@@ -13,11 +13,11 @@ namespace td {
namespace game {
World::World(Game* game) : m_Game(game) {
getWorldNotifier().bindListener(this);
getMobNotifier().bindListener(this);
GetWorldNotifier().BindListener(this);
GetMobNotifier().BindListener(this);
}
TilePtr World::getTile(std::int32_t x, std::int32_t y) const {
TilePtr World::GetTile(std::int32_t x, std::int32_t y) const {
std::int16_t chunkX = x / Chunk::ChunkWidth;
std::int16_t chunkY = y / Chunk::ChunkHeight;
@@ -30,37 +30,37 @@ TilePtr World::getTile(std::int32_t x, std::int32_t y) const {
ChunkPtr chunk = chunkIt->second;
return getTilePtr(chunk->getTileIndex(subChunkY * Chunk::ChunkWidth + subChunkX));
return GetTilePtr(chunk->GetTileIndex(subChunkY * Chunk::ChunkWidth + subChunkX));
}
bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader) {
m_TowerPlacePalette = worldHeader->getTowerTilePalette();
m_WalkablePalette = worldHeader->getWalkableTileColor();
m_DecorationPalette = worldHeader->getDecorationPalette();
m_Background = worldHeader->getBackgroundColor();
bool World::LoadMap(const protocol::WorldBeginDataPacket* worldHeader) {
m_TowerPlacePalette = worldHeader->GetTowerTilePalette();
m_WalkablePalette = worldHeader->GetWalkableTileColor();
m_DecorationPalette = worldHeader->GetDecorationPalette();
m_Background = worldHeader->GetBackgroundColor();
getRedTeam().getSpawn() = worldHeader->getRedSpawn();
getBlueTeam().getSpawn() = worldHeader->getBlueSpawn();
GetRedTeam().GetSpawn() = worldHeader->GetRedSpawn();
GetBlueTeam().GetSpawn() = worldHeader->GetBlueSpawn();
m_SpawnColorPalette = worldHeader->getSpawnPalette();
m_SpawnColorPalette = worldHeader->GetSpawnPalette();
getRedTeam().getCastle() = worldHeader->getRedCastle();
getRedTeam().getCastle().setTeam(&getRedTeam());
GetRedTeam().GetCastle() = worldHeader->GetRedCastle();
GetRedTeam().GetCastle().SetTeam(&GetRedTeam());
getBlueTeam().getCastle() = worldHeader->getBlueCastle();
getBlueTeam().getCastle().setTeam(&getBlueTeam());
GetBlueTeam().GetCastle() = worldHeader->GetBlueCastle();
GetBlueTeam().GetCastle().SetTeam(&GetBlueTeam());
m_TilePalette = worldHeader->getTilePalette();
m_TilePalette = worldHeader->GetTilePalette();
return true;
}
bool World::loadMap(const protocol::WorldDataPacket* worldData) {
m_Chunks = worldData->getChunks();
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) {
DataBuffer buffer;
if (!buffer.ReadFile(fileName)) {
std::cerr << "Failed to load map from file " << fileName << " !\n";
@@ -78,13 +78,13 @@ bool World::loadMapFromFile(const std::string& fileName) {
protocol::WorldDataPacket dataPacket;
dataPacket.Deserialize(mapDataPacketBuffer);
loadMap(&headerPacket);
loadMap(&dataPacket);
LoadMap(&headerPacket);
LoadMap(&dataPacket);
return true;
}
bool World::saveMap(const std::string& fileName) const {
bool World::SaveMap(const std::string& fileName) const {
protocol::WorldBeginDataPacket headerPacket(this);
protocol::WorldDataPacket dataPacket(this);
@@ -99,32 +99,32 @@ bool World::saveMap(const std::string& fileName) const {
return buffer.WriteFile(fileName);
}
void World::tick(std::uint64_t delta) {
if (m_Game->getGameState() != GameState::Game) return;
void World::Tick(std::uint64_t delta) {
if (m_Game->GetGameState() != GameState::Game) return;
tickMobs(delta);
TickMobs(delta);
for (TowerPtr tower : m_Towers) {
tower->tick(delta, this);
tower->Tick(delta, this);
}
cleanDeadMobs();
CleanDeadMobs();
}
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->setCenter({ x, y });
mob->setDirection(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->SetCenter({ x, y });
mob->SetDirection(dir);
m_Mobs.push_back(mob);
getMobNotifier().notifyListeners(&MobListener::OnMobSpawn, mob.get());
GetMobNotifier().NotifyListeners(&MobListener::OnMobSpawn, mob.get());
}
TowerPtr World::placeTowerAt(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) {
TowerPtr tower = TowerFactory::createTower(type, id, x, y, builder);
TowerPtr World::PlaceTowerAt(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) {
TowerPtr tower = TowerFactory::CreateTower(type, id, x, y, builder);
m_Towers.push_back(tower);
return tower;
}
TowerPtr World::removeTower(TowerID towerId) {
auto it = std::find_if(m_Towers.begin(), m_Towers.end(), [towerId](TowerPtr tower) { return tower->getID() == towerId;});
TowerPtr World::RemoveTower(TowerID towerId) {
auto it = std::find_if(m_Towers.begin(), m_Towers.end(), [towerId](TowerPtr tower) { return tower->GetID() == towerId;});
if (it == m_Towers.end()) return nullptr;
TowerPtr tower = *it;
@@ -134,14 +134,14 @@ TowerPtr World::removeTower(TowerID towerId) {
return tower;
}
void World::tickMobs(std::uint64_t delta) {
void World::TickMobs(std::uint64_t delta) {
for (MobPtr mob : m_Mobs) {
mob->tick(delta, this);
mob->Tick(delta, this);
}
}
const Color* World::getTileColor(TilePtr tile) const {
switch (tile->getType()) {
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];
@@ -162,21 +162,21 @@ const Color* World::getTileColor(TilePtr tile) const {
}
bool World::CanPlaceLittleTower(const glm::vec2& worldPos, PlayerID playerID) const {
TilePtr tile = getTile(worldPos.x, worldPos.y);
const Player& player = m_Game->getPlayers()[playerID];
TilePtr tile = GetTile(worldPos.x, worldPos.y);
const Player& player = m_Game->GetPlayers()[playerID];
if (tile == nullptr) {
return false;
}
if (tile->getType() == game::TileType::Tower) {
if (tile->GetType() == game::TileType::Tower) {
const TowerTile* towerTile = (const TowerTile*)tile.get();
if (towerTile->team_owner != player.getTeamColor())
if (towerTile->team_owner != player.GetTeamColor())
return false;
for (int x = -1; x < 2; x++) {
for (int y = -1; y < 2; y++) {
game::TilePtr adjacentTile = getTile(worldPos.x + x, worldPos.y + y);
if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower || getTower({ worldPos.x + x, worldPos.y + y }) != nullptr) {
game::TilePtr adjacentTile = GetTile(worldPos.x + x, worldPos.y + y);
if (adjacentTile == nullptr || adjacentTile->GetType() != game::TileType::Tower || GetTower({ worldPos.x + x, worldPos.y + y }) != nullptr) {
return false;
}
}
@@ -190,21 +190,21 @@ bool World::CanPlaceLittleTower(const glm::vec2& worldPos, PlayerID playerID) co
bool World::CanPlaceBigTower(const glm::vec2& worldPos, PlayerID playerID) const {
if (!CanPlaceLittleTower(worldPos, playerID)) return false;
TilePtr tile = getTile(worldPos.x, worldPos.y);
const Player& player = m_Game->getPlayers()[playerID];
TilePtr tile = GetTile(worldPos.x, worldPos.y);
const Player& player = m_Game->GetPlayers()[playerID];
if (tile == nullptr) {
return false;
}
if (tile->getType() == game::TileType::Tower) {
if (tile->GetType() == game::TileType::Tower) {
const TowerTile* towerTile = (const TowerTile*)tile.get();
if (towerTile->team_owner != player.getTeamColor())
if (towerTile->team_owner != player.GetTeamColor())
return false;
for (int x = -2; x < 3; x++) {
for (int y = -2; y < 3; y++) {
game::TilePtr adjacentTile = getTile(worldPos.x + x, worldPos.y + y);
if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower || getTower({ worldPos.x + x, worldPos.y + y }) != nullptr) {
game::TilePtr adjacentTile = GetTile(worldPos.x + x, worldPos.y + y);
if (adjacentTile == nullptr || adjacentTile->GetType() != game::TileType::Tower || GetTower({ worldPos.x + x, worldPos.y + y }) != nullptr) {
return false;
}
}
@@ -215,26 +215,26 @@ bool World::CanPlaceBigTower(const glm::vec2& worldPos, PlayerID playerID) const
return false;
}
void World::cleanDeadMobs() {
void World::CleanDeadMobs() {
// safely remove mobs when unused
for (std::size_t i = 0; i < m_Mobs.size(); i++) {
MobPtr mob = m_Mobs[i];
if (mob->isDead()) {
if (mob->IsDead()) {
m_Mobs.erase(m_Mobs.begin() + i);
}
}
}
TowerPtr World::getTower(const glm::vec2& position) const {
TowerPtr World::GetTower(const glm::vec2& position) const {
for (TowerPtr tower : m_Towers) {
if (tower->getSize() == TowerSize::Big) {
if (tower->getCenterX() - 2.5f < position.x && tower->getCenterX() + 2.5f > position.x &&
tower->getCenterY() - 2.5f < position.y && tower->getCenterY() + 2.5f > position.y) {
if (tower->GetSize() == TowerSize::Big) {
if (tower->GetCenterX() - 2.5f < position.x && tower->GetCenterX() + 2.5f > position.x &&
tower->GetCenterY() - 2.5f < position.y && tower->GetCenterY() + 2.5f > position.y) {
return tower;
}
} else { // little tower
if (tower->getCenterX() - 1.5f < position.x && tower->getCenterX() + 1.5f > position.x &&
tower->getCenterY() - 1.5f < position.y && tower->getCenterY() + 1.5f > position.y) {
if (tower->GetCenterX() - 1.5f < position.x && tower->GetCenterX() + 1.5f > position.x &&
tower->GetCenterY() - 1.5f < position.y && tower->GetCenterY() + 1.5f > position.y) {
return tower;
}
}
@@ -242,83 +242,83 @@ TowerPtr World::getTower(const glm::vec2& position) const {
return nullptr;
}
TowerPtr World::getTowerById(TowerID towerID) {
auto it = std::find_if(m_Towers.begin(), m_Towers.end(), [towerID](TowerPtr tower) { return tower->getID() == towerID;});
TowerPtr World::GetTowerById(TowerID towerID) {
auto it = std::find_if(m_Towers.begin(), m_Towers.end(), [towerID](TowerPtr tower) { return tower->GetID() == towerID;});
if (it == m_Towers.end()) return nullptr;
return *it;
}
void World::OnArcherTowerShot(MobPtr target, ArcherTower* shooter) {
bool fireArrows = shooter->getLevel().getPath() == TowerPath::Bottom;
bool explosiveArrows = shooter->getLevel().getLevel() == 4 && fireArrows;
void World::OnArcherTowerShot(MobPtr tarGet, ArcherTower* shooter) {
bool fireArrows = shooter->GetLevel().GetPath() == TowerPath::Bottom;
bool explosiveArrows = shooter->GetLevel().GetLevel() == 4 && fireArrows;
getWorldNotifier().notifyListeners(&WorldListener::OnArrowShot, target, fireArrows, shooter);
GetWorldNotifier().NotifyListeners(&WorldListener::OnArrowShot, tarGet, fireArrows, shooter);
if (explosiveArrows) {
getWorldNotifier().notifyListeners(&WorldListener::OnExplosion, utils::shape::Circle{ target->getCenterX(), target->getCenterY(), ArcherTower::ExplosionRadius }, shooter->getStats()->getDamage(), shooter);
GetWorldNotifier().NotifyListeners(&WorldListener::OnExplosion, utils::shape::Circle{ tarGet->GetCenterX(), tarGet->GetCenterY(), ArcherTower::ExplosionRadius }, shooter->GetStats()->GetDamage(), shooter);
}
}
void World::OnArrowShot(MobPtr target, bool fireArrow, Tower* shooter) {
getMobNotifier().notifyListeners(&MobListener::OnMobDamage, target.get(), shooter->getStats()->getDamage(), shooter);
void World::OnArrowShot(MobPtr tarGet, bool fireArrow, Tower* shooter) {
GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, tarGet.get(), shooter->GetStats()->GetDamage(), shooter);
if (fireArrow) {
target->addEffect(EffectType::Fire, ArcherTower::FireDurationSec, shooter);
tarGet->AddEffect(EffectType::Fire, ArcherTower::FireDurationSec, shooter);
}
}
void World::OnExplosion(utils::shape::Circle explosion, float centerDamage, Tower* shooter) {
for (MobPtr mob : m_Mobs) {
if (mob->isAlive() && mob->collidesWith(explosion)) {
if (mob->IsAlive() && mob->CollidesWith(explosion)) {
// linear distance damage reduction
float explosionDamage = mob->distance(explosion) / explosion.getRadius() * centerDamage;
getMobNotifier().notifyListeners(&MobListener::OnMobDamage, mob.get(), explosionDamage, shooter);
float explosionDamage = mob->Distance(explosion) / explosion.GetRadius() * centerDamage;
GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, mob.get(), explosionDamage, shooter);
}
}
}
void World::OnMobCastleDamage(Mob* damager, TeamCastle* enemyCastle, float damage) {
enemyCastle->damage(damage);
if (enemyCastle->getLife() <= 0) {
m_Game->notifyListeners(&GameListener::OnGameEnd);
enemyCastle->Damage(damage);
if (enemyCastle->GetLife() <= 0) {
m_Game->NotifyListeners(&GameListener::OnGameEnd);
}
}
void World::OnMobDamage(Mob* target, float damage, Tower* source) {
target->damage(damage, source);
if (target->isDead()) {
getMobNotifier().notifyListeners(&MobListener::OnMobDie, target);
void World::OnMobDamage(Mob* tarGet, float damage, Tower* source) {
tarGet->Damage(damage, source);
if (tarGet->IsDead()) {
GetMobNotifier().NotifyListeners(&MobListener::OnMobDie, tarGet);
}
}
Team& World::getRedTeam() {
return m_Game->getRedTeam();
Team& World::GetRedTeam() {
return m_Game->GetRedTeam();
}
const Team& World::getRedTeam() const {
return m_Game->getRedTeam();
const Team& World::GetRedTeam() const {
return m_Game->GetRedTeam();
}
Team& World::getBlueTeam() {
return m_Game->getBlueTeam();
Team& World::GetBlueTeam() {
return m_Game->GetBlueTeam();
}
const Team& World::getBlueTeam() const {
return m_Game->getBlueTeam();
const Team& World::GetBlueTeam() const {
return m_Game->GetBlueTeam();
}
Team& World::getTeam(TeamColor team) {
return m_Game->getTeam(team);
Team& World::GetTeam(TeamColor team) {
return m_Game->GetTeam(team);
}
const Team& World::getTeam(TeamColor team) const {
return m_Game->getTeam(team);
const Team& World::GetTeam(TeamColor team) const {
return m_Game->GetTeam(team);
}
const Player* World::getPlayerById(PlayerID id) const {
return m_Game->getPlayerById(id);
const Player* World::GetPlayerById(PlayerID id) const {
return m_Game->GetPlayerById(id);
}
const TeamList& World::getTeams() const {
return m_Game->getTeams();
const TeamList& World::GetTeams() const {
return m_Game->GetTeams();
}
} // namespace game

44
src/game/client/Client.cpp
View File

@@ -5,9 +5,9 @@
namespace td {
namespace client {
bool Client::connect(const network::IPAddresses& addresses, std::uint16_t port) {
bool Client::Connect(const network::IPAddresses& addresses, std::uint16_t port) {
for (const network::IPAddress& address : addresses) {
if (address.IsValid() && m_Connexion.connect(address.ToString(), port)) {
if (address.IsValid() && m_Connexion.Connect(address.ToString(), port)) {
m_Connected = true;
return true;
}
@@ -16,63 +16,63 @@ bool Client::connect(const network::IPAddresses& addresses, std::uint16_t port)
return false;
}
void Client::selectTeam(game::TeamColor team) {
void Client::SelectTeam(game::TeamColor team) {
if (!m_Connected)
return;
protocol::SelectTeamPacket packet(team);
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
void Client::closeConnection() {
void Client::CloseConnection() {
if (!m_Connected)
return;
m_Connected = false;
protocol::DisconnectPacket packet;
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
void Client::tick(std::uint64_t delta) {
void Client::Tick(std::uint64_t delta) {
if (!m_Connected)
return;
m_Connected = m_Connexion.updateSocket();
m_Connected = m_Connexion.UpdateSocket();
if (!m_Connected) {
std::cout << "Disconnected ! (Reason : " << m_Connexion.getDisconnectReason() << ")\n";
reset();
std::cout << "Disconnected ! (Reason : " << m_Connexion.GetDisconnectReason() << ")\n";
Reset();
} else {
m_Game->tick(delta);
m_Game->Tick(delta);
}
}
void Client::render() {
m_Game->renderWorld();
void Client::Render() {
m_Game->RenderWorld();
}
void Client::reset() {
void Client::Reset() {
m_Game.reset(0);
m_Game = std::make_unique<ClientGame>(this);
}
void Client::sendMobs(const std::vector<protocol::MobSend>& mobSends) {
void Client::SendMobs(const std::vector<protocol::MobSend>& mobSends) {
protocol::SendMobsPacket packet(mobSends);
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
void Client::placeTower(game::TowerType type, const glm::vec2& position) {
void Client::PlaceTower(game::TowerType type, const glm::vec2& position) {
protocol::PlaceTowerPacket packet(position.x, position.y, type);
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
void Client::upgradeTower(game::TowerID tower, game::TowerLevel level) {
void Client::UpgradeTower(game::TowerID tower, game::TowerLevel level) {
protocol::UpgradeTowerPacket packet(tower, level);
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
void Client::removeTower(game::TowerID tower) {
void Client::RemoveTower(game::TowerID tower) {
protocol::RemoveTowerPacket packet(tower);
m_Connexion.sendPacket(&packet);
m_Connexion.SendPacket(&packet);
}
} // namespace client

28
src/game/client/ClientConnexion.cpp
View File

@@ -5,10 +5,10 @@ namespace td {
namespace client {
ClientConnexion::ClientConnexion() : Connexion(&m_Dispatcher), m_ServerTPS(0) {
registerHandlers();
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);
@@ -16,32 +16,32 @@ void ClientConnexion::registerHandlers() {
}
void ClientConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID());
sendPacket(&keepAlivePacket);
protocol::KeepAlivePacket keepAlivePacket(packet->GetAliveID());
SendPacket(&keepAlivePacket);
}
void ClientConnexion::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
m_ConnectionID = packet->getConnectionID();
login();
m_ConnectionID = packet->GetConnectionID();
Login();
}
void ClientConnexion::HandlePacket(const protocol::ServerTpsPacket* packet) {
m_ServerTPS = packet->getTPS();
m_Ping = utils::getTime() - packet->getPacketSendTime();
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);
SendPacket(&loginPacket);
}
bool ClientConnexion::updateSocket() {
return Connexion::updateSocket();
bool ClientConnexion::UpdateSocket() {
return Connexion::UpdateSocket();
}
void ClientConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
m_DisconnectReason = packet->getReason();
closeConnection();
m_DisconnectReason = packet->GetReason();
CloseConnection();
}
} // namespace client

70
src/game/client/ClientGame.cpp
View File

@@ -5,8 +5,8 @@
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),
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);
@@ -24,88 +24,88 @@ ClientGame::~ClientGame() {
GetDispatcher()->UnregisterHandler(this);
}
void ClientGame::tick(std::uint64_t delta) {
game::Game::tick(delta);
m_WorldRenderer.update();
void ClientGame::Tick(std::uint64_t delta) {
game::Game::Tick(delta);
m_WorldRenderer.Update();
if (m_GameState == game::GameState::Lobby && m_LobbyTime > 0) {
m_LobbyTime -= delta;
}
}
void ClientGame::HandlePacket(const protocol::PlayerJoinPacket* packet) {
game::Player player(packet->getPlayerID());
player.setName(packet->getPlayerName());
game::Player player(packet->GetPlayerID());
player.SetName(packet->GetPlayerName());
m_Players.insert({ player.getID(), player });
m_Players.insert({ player.GetID(), player });
}
void ClientGame::HandlePacket(const protocol::PlayerLeavePacket* packet) {
game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player);
game::Player* player = &m_Players[packet->GetPlayerID()];
if (player->GetTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player->GetTeamColor()].RemovePlayer(player);
}
m_Players.erase(player->getID());
m_Players.erase(player->GetID());
}
void ClientGame::HandlePacket(const protocol::PlayerListPacket* packet) {
for (auto pair : packet->getPlayers()) {
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);
player.SetName(playerInfo.name);
player.SetTeamColor(playerInfo.team);
m_Players.insert({ playerID, player });
if (player.getTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player.getTeamColor()].addPlayer(&m_Players[playerID]);
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(const protocol::UpdatePlayerTeamPacket* packet) {
game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() == game::TeamColor::None) { //join a team
getTeam(packet->getSelectedTeam()).addPlayer(player);
} else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team
getTeam(player->getTeamColor()).removePlayer(player);
game::Player* player = &m_Players[packet->GetPlayerID()];
if (player->GetTeamColor() == game::TeamColor::None) { //join a team
GetTeam(packet->GetSelectedTeam()).AddPlayer(player);
} else if (packet->GetSelectedTeam() == game::TeamColor::None) { // leave a team
GetTeam(player->GetTeamColor()).RemovePlayer(player);
} else { // change team
getTeam(player->getTeamColor()).removePlayer(player);
getTeam(packet->getSelectedTeam()).addPlayer(player);
GetTeam(player->GetTeamColor()).RemovePlayer(player);
GetTeam(packet->GetSelectedTeam()).AddPlayer(player);
}
player->setTeamColor(packet->getSelectedTeam());
player->SetTeamColor(packet->GetSelectedTeam());
}
void ClientGame::HandlePacket(const protocol::UpdateGameStatePacket* packet) {
setGameState(packet->getGameState());
SetGameState(packet->GetGameState());
}
void ClientGame::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
m_ConnexionID = packet->getConnectionID();
m_ConnexionID = packet->GetConnectionID();
}
void ClientGame::HandlePacket(const protocol::UpdateLobbyTimePacket* packet) {
m_LobbyTime = packet->getRemainingTime();
m_LobbyTime = packet->GetRemainingTime();
}
void ClientGame::HandlePacket(const protocol::UpdateMoneyPacket* packet) {
m_Player->setGold(packet->getGold());
m_Player->SetGold(packet->GetGold());
}
void ClientGame::HandlePacket(const protocol::DisconnectPacket* packet) {
m_GameState = game::GameState::Disconnected;
m_Renderer->setBackgroundColor({ 0, 0, 0 });
m_Renderer->SetBackgroundColor({ 0, 0, 0 });
}
void ClientGame::HandlePacket(const protocol::WorldDataPacket* packet) {
m_WorldRenderer.loadModels();
m_WorldRenderer.LoadModels();
// set cam pos to player spawn
const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn();
m_WorldRenderer.setCamPos(spawn.getCenterX(), spawn.getCenterY());
const game::Spawn& spawn = m_World->GetTeam(m_Player->GetTeamColor()).GetSpawn();
m_WorldRenderer.SetCamPos(spawn.GetCenterX(), spawn.GetCenterY());
}
void ClientGame::renderWorld() {
void ClientGame::RenderWorld() {
if (m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame) {
m_WorldRenderer.render();
m_WorldRenderer.Render();
}
}

42
src/game/client/WorldClient.cpp
View File

@@ -18,58 +18,58 @@ WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::Packet
}
void WorldClient::HandlePacket(const protocol::WorldBeginDataPacket* packet) {
loadMap(packet);
if (m_Game->getGameState() == game::GameState::Game) {
const game::Color& backgroundColor = getBackgroundColor();
m_Game->getRenderer()->setBackgroundColor({ static_cast<float>(backgroundColor.r / 255.0f), static_cast<float>(backgroundColor.g / 255.0f),
LoadMap(packet);
if (m_Game->GetGameState() == game::GameState::Game) {
const game::Color& backgroundColor = GetBackgroundColor();
m_Game->GetRenderer()->SetBackgroundColor({ static_cast<float>(backgroundColor.r / 255.0f), static_cast<float>(backgroundColor.g / 255.0f),
static_cast<float>(backgroundColor.b / 255.0f) });
}
}
void WorldClient::HandlePacket(const protocol::WorldDataPacket* packet) {
loadMap(packet);
LoadMap(packet);
}
void WorldClient::HandlePacket(const protocol::SpawnMobPacket* packet) {
spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
packet->getMobX(), packet->getMobY(), packet->getMobDirection());
SpawnMobAt(packet->GetMobID(), packet->GetMobType(), packet->GetMobLevel(), packet->GetSender(),
packet->GetMobX(), packet->GetMobY(), packet->GetMobDirection());
}
void WorldClient::HandlePacket(const protocol::UpgradeTowerPacket* packet) {
game::TowerPtr tower = getTowerById(packet->getTowerID());
game::TowerPtr tower = GetTowerById(packet->GetTowerID());
if (tower == nullptr) return; // this should not happen but who knows ?
tower->upgrade(packet->getTowerLevel().getLevel(), packet->getTowerLevel().getPath());
tower->Upgrade(packet->GetTowerLevel().GetLevel(), packet->GetTowerLevel().GetPath());
}
void WorldClient::HandlePacket(const protocol::WorldAddTowerPacket* packet) {
game::TowerPtr newTower = placeTowerAt(packet->getTowerID(), packet->getTowerType(), packet->getTowerX(), packet->getTowerY(), packet->getBuilder());
game::TowerPtr newTower = PlaceTowerAt(packet->GetTowerID(), packet->GetTowerType(), packet->GetTowerX(), packet->GetTowerY(), packet->GetBuilder());
getWorldNotifier().notifyListeners(&WorldListener::OnTowerAdd, newTower);
GetWorldNotifier().NotifyListeners(&WorldListener::OnTowerAdd, newTower);
}
void WorldClient::HandlePacket(const protocol::RemoveTowerPacket* packet) {
game::TowerPtr tower = removeTower(packet->getTowerID());
game::TowerPtr tower = RemoveTower(packet->GetTowerID());
if (tower != nullptr) {
getWorldNotifier().notifyListeners(&WorldListener::OnTowerRemove, tower);
GetWorldNotifier().NotifyListeners(&WorldListener::OnTowerRemove, tower);
}
}
void WorldClient::HandlePacket(const protocol::UpdateMobStatesPacket* packet) {
for (auto mobState : packet->getMobStates()) {
game::MobID mobId = mobState.getMobId();
auto it = std::find_if(getMobList().begin(), getMobList().end(), [mobId](game::MobPtr mob) { return mob->getMobID() == mobId; });
if (it != getMobList().end()) {
for (auto mobState : packet->GetMobStates()) {
game::MobID mobId = mobState.GetMobId();
auto it = std::find_if(GetMobList().begin(), GetMobList().end(), [mobId](game::MobPtr mob) { return mob->GetMobID() == mobId; });
if (it != GetMobList().end()) {
game::MobPtr& mob = *it;
mob->setCenter(mobState.getMobPosition());
mob->setDirection(mobState.getMobDirection());
mob->setHealth(mobState.getMobLife());
mob->SetCenter(mobState.GetMobPosition());
mob->SetDirection(mobState.GetMobDirection());
mob->SetHealth(mobState.GetMobLife());
}
}
}
void WorldClient::HandlePacket(const protocol::UpdateCastleLifePacket* packet) {
getTeam(packet->getTeamColor()).getCastle().setLife(packet->getCastleLife());
GetTeam(packet->GetTeamColor()).GetCastle().SetLife(packet->GetCastleLife());
}
} // namespace client

26
src/game/server/Lobby.cpp
View File

@@ -28,26 +28,26 @@ 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 >= LobbyWaitingTime) {
m_Server->getGame().notifyListeners(&game::GameListener::OnGameBegin);
if (utils::GetTime() - m_StartTimerTime >= LobbyWaitingTime) {
m_Server->GetGame().NotifyListeners(&game::GameListener::OnGameBegin);
m_GameStarted = true;
return;
}
m_Timer.update();
m_Timer.Update();
}
void Lobby::sendTimeRemaining() {
protocol::UpdateLobbyTimePacket packet(LobbyWaitingTime - (utils::getTime() - m_StartTimerTime)); // converting second to millis
m_Server->broadcastPacket(&packet);
void Lobby::SendTimeRemaining() {
protocol::UpdateLobbyTimePacket packet(LobbyWaitingTime - (utils::GetTime() - m_StartTimerTime)); // converting second to millis
m_Server->BroadcastPacket(&packet);
}
void Lobby::OnPlayerJoin(std::uint8_t playerID) {
@@ -56,9 +56,9 @@ void Lobby::OnPlayerJoin(std::uint8_t playerID) {
std::cout << "(Server) Player Joined Lobby !\n";
m_Players.push_back(playerID);
if (m_Players.size() == MIN_PLAYER_WAITING) { // start timer if a second player join the match
m_StartTimerTime = utils::getTime();
m_Timer.reset();
sendTimeRemaining();
m_StartTimerTime = utils::GetTime();
m_Timer.Reset();
SendTimeRemaining();
}
}
@@ -66,13 +66,15 @@ 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) {
protocol::UpdateLobbyTimePacket packet(0);
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
m_StartTimerTime = 0; // reset timer if there is only one player left
}
}

86
src/game/server/Server.cpp
View File

@@ -6,7 +6,7 @@ namespace td {
namespace server {
Server::Server(const std::string& worldFilePath) : m_ServerRunning(false) {
m_Game.getWorld()->loadMapFromFile(worldFilePath);
m_Game.GetWorld()->LoadMapFromFile(worldFilePath);
}
Server::~Server() {
@@ -14,117 +14,117 @@ Server::~Server() {
m_Thread.join();
}
void Server::startThread() {
void Server::StartThread() {
m_Thread = std::thread([this]() {
std::uint64_t lastTime = td::utils::getTime();
std::uint64_t lastTime = td::utils::GetTime();
while (m_ServerRunning) {
std::uint64_t time = td::utils::getTime();
std::uint64_t time = td::utils::GetTime();
std::uint64_t delta = time - lastTime;
if (delta >= SERVER_TICK) {
tick(delta);
lastTime = td::utils::getTime();
Tick(delta);
lastTime = td::utils::GetTime();
std::uint64_t sleepTime = SERVER_TICK - (delta - SERVER_TICK);
std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
}
}
clean();
Clean();
});
}
void Server::close() {
stopThread();
void Server::Close() {
StopThread();
}
void Server::stopThread() {
void Server::StopThread() {
m_ServerRunning = false;
}
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;
}
std::cout << "Server started at port " << port << " !\n";
m_TickCounter.reset();
m_TickCounter.Reset();
m_ServerRunning = true;
startThread();
StartThread();
return true;
}
void Server::clean() {
m_Listener.close();
m_Listener.destroy();
void Server::Clean() {
m_Listener.Close();
m_Listener.Destroy();
m_Connections.clear();
getPlayers().clear();
GetPlayers().clear();
std::cout << "Server successfully stopped !\n";
}
void Server::stop() {
void Server::Stop() {
if (!m_ServerRunning)
return;
protocol::DisconnectPacket packet("Server closed");
broadcastPacket(&packet);
BroadcastPacket(&packet);
stopThread();
StopThread();
}
void Server::tick(std::uint64_t delta) {
accept();
updateSockets();
m_Lobby.tick();
m_Game.tick(delta);
if (m_TickCounter.update()) {
protocol::ServerTpsPacket packet(m_TickCounter.getTPS(), utils::getTime());
broadcastPacket(&packet);
void Server::Tick(std::uint64_t delta) {
Accept();
UpdateSockets();
m_Lobby.Tick();
m_Game.Tick(delta);
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) }));
OnPlayerJoin(newPlayerID);
m_Connections[newPlayerID].setServer(this);
m_Connections[newPlayerID].SetServer(this);
newPlayerID++;
}
}
void Server::updateSockets() {
void Server::UpdateSockets() {
std::int16_t closedConnexionID = -1;
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 {
con.updateSocket();
con.UpdateSocket();
}
}
if (closedConnexionID != -1) {
removeConnexion(closedConnexionID);
RemoveConnexion(closedConnexionID);
}
}
void Server::broadcastPacket(const protocol::Packet* packet) {
void Server::BroadcastPacket(const protocol::Packet* packet) {
for (auto& connection : m_Connections) {
ServerConnexion& con = connection.second;
con.sendPacket(packet);
con.SendPacket(packet);
}
}
void Server::removeConnexion(std::uint8_t connexionID) {
getPlayers().erase(getPlayers().find(connexionID));
void Server::RemoveConnexion(std::uint8_t connexionID) {
GetPlayers().erase(GetPlayers().find(connexionID));
m_Connections.erase(connexionID);
m_Lobby.OnPlayerLeave(connexionID);
OnPlayerLeave(connexionID);
@@ -133,12 +133,12 @@ void Server::removeConnexion(std::uint8_t connexionID) {
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) {
protocol::PlayerLeavePacket packet(id);
broadcastPacket(&packet);
BroadcastPacket(&packet);
}
} // namespace server

132
src/game/server/ServerConnexion.cpp
View File

@@ -23,17 +23,17 @@ 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) {
Connexion::updateSocket();
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) {
move.m_Server = nullptr;
registerHandlers();
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);
@@ -44,148 +44,148 @@ void ServerConnexion::registerHandlers() {
GetDispatcher()->RegisterHandler(protocol::PacketType::RemoveTower, this);
}
bool ServerConnexion::updateSocket() {
checkKeepAlive();
return Connexion::updateSocket();
bool ServerConnexion::UpdateSocket() {
CheckKeepAlive();
return Connexion::UpdateSocket();
}
void ServerConnexion::checkKeepAlive() {
std::uint64_t time = utils::getTime();
void ServerConnexion::CheckKeepAlive() {
std::uint64_t time = utils::GetTime();
if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT) {
if (m_KeepAlive.recievedResponse) {
sendKeepAlive();
SendKeepAlive();
} else {
protocol::DisconnectPacket packet("Time out");
sendPacket(&packet);
closeConnection();
SendPacket(&packet);
CloseConnection();
}
}
}
void ServerConnexion::sendKeepAlive() {
m_KeepAlive.keepAliveID = utils::getRandomInt<std::uint64_t>(0, RAND_MAX);
void ServerConnexion::SendKeepAlive() {
m_KeepAlive.keepAliveID = utils::GetRandomInt<std::uint64_t>(0, RAND_MAX);
m_KeepAlive.recievedResponse = false;
protocol::KeepAlivePacket keepAlivePacket(m_KeepAlive.keepAliveID);
sendPacket(&keepAlivePacket);
SendPacket(&keepAlivePacket);
std::uint64_t time = utils::getTime();
std::uint64_t time = utils::GetTime();
m_KeepAlive.sendTime = time;
}
void ServerConnexion::HandlePacket(const protocol::PlayerLoginPacket* packet) {
if (m_Player->getName().empty() && !packet->getPlayerName().empty()) {
m_Player->setName(packet->getPlayerName());
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);
protocol::PlayerJoinPacket joinPacket(m_ID, m_Player->GetName());
m_Server->BroadcastPacket(&joinPacket);
std::map<std::uint8_t, protocol::PlayerInfo> 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 });
playerInfo.name = player.GetName();
playerInfo.team = player.GetTeamColor();
playerNames.insert({ player.GetID(), playerInfo });
}
}
protocol::PlayerListPacket listPacket(playerNames);
sendPacket(&listPacket);
SendPacket(&listPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::SelectTeamPacket* packet) {
if (m_Server->getGame().getGameState() != game::GameState::Lobby)
if (m_Server->GetGame().GetGameState() != game::GameState::Lobby)
return;
if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) {
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
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Player->setTeamColor(game::TeamColor::None);
if ((std::int8_t)packet->GetSelectedTeam() >= -1 || (std::int8_t)packet->GetSelectedTeam() <= 1) {
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
m_Server->GetGame().GetTeam(m_Player->GetTeamColor()).RemovePlayer(m_Player);
m_Player->SetTeamColor(game::TeamColor::None);
} else { // change team
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player);
m_Server->GetGame().GetTeam(m_Player->GetTeamColor()).RemovePlayer(m_Player);
m_Server->GetGame().GetTeam(packet->GetSelectedTeam()).AddPlayer(m_Player);
}
m_Player->setTeamColor(packet->getSelectedTeam());
protocol::UpdatePlayerTeamPacket updateTeamPacket(m_ID, packet->getSelectedTeam());
m_Server->broadcastPacket(&updateTeamPacket);
m_Player->SetTeamColor(packet->GetSelectedTeam());
protocol::UpdatePlayerTeamPacket updateTeamPacket(m_ID, packet->GetSelectedTeam());
m_Server->BroadcastPacket(&updateTeamPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
if (packet->getAliveID() == m_KeepAlive.keepAliveID)
if (packet->GetAliveID() == m_KeepAlive.keepAliveID)
m_KeepAlive.recievedResponse = true;
}
void ServerConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
closeConnection();
CloseConnection();
}
void ServerConnexion::setServer(Server* server) {
void ServerConnexion::SetServer(Server* server) {
m_Server = server;
m_Player = &m_Server->getPlayers().at(m_ID);
initConnection();
sendKeepAlive();
m_Player = &m_Server->GetPlayers().at(m_ID);
InitConnection();
SendKeepAlive();
}
void ServerConnexion::initConnection() {
protocol::UpdateGameStatePacket statePacket(m_Server->getGame().getGameState());
sendPacket(&statePacket);
void ServerConnexion::InitConnection() {
protocol::UpdateGameStatePacket statePacket(m_Server->GetGame().GetGameState());
SendPacket(&statePacket);
protocol::ConnexionInfoPacket conPacket(m_ID);
sendPacket(&conPacket);
SendPacket(&conPacket);
if (m_Server->getGame().getGameState() == game::GameState::Game) {
protocol::WorldBeginDataPacket headerDataPacket(m_Server->getGame().getWorld());
protocol::WorldBeginDataPacket dataPacket(m_Server->getGame().getWorld());
sendPacket(&headerDataPacket);
sendPacket(&dataPacket);
if (m_Server->GetGame().GetGameState() == game::GameState::Game) {
protocol::WorldBeginDataPacket headerDataPacket(m_Server->GetGame().GetWorld());
protocol::WorldBeginDataPacket dataPacket(m_Server->GetGame().GetWorld());
SendPacket(&headerDataPacket);
SendPacket(&dataPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::PlaceTowerPacket* packet) {
game::TowerType towerType = packet->getTowerType();
const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
server::ServerWorld* world = m_Server->getGame().getServerWorld();
game::TowerType towerType = packet->GetTowerType();
const game::TowerInfo& towerInfo = game::GetTowerInfo(towerType);
server::ServerWorld* world = m_Server->GetGame().GetServerWorld();
if (!world->CanPlaceLittleTower({ packet->getTowerX(), packet->getTowerY() }, m_ID))
if (!world->CanPlaceLittleTower({ packet->GetTowerX(), packet->GetTowerY() }, m_ID))
return;
if (towerInfo.isBigTower())
if (!world->CanPlaceBigTower({ packet->getTowerX(), packet->getTowerY() }, m_ID))
if (towerInfo.IsBigTower())
if (!world->CanPlaceBigTower({ packet->GetTowerX(), packet->GetTowerY() }, m_ID))
return;
game::TowerPtr tower = world->placeTowerAt(towerType, packet->getTowerX(), packet->getTowerY(), m_ID);
game::TowerPtr tower = world->PlaceTowerAt(towerType, packet->GetTowerX(), packet->GetTowerY(), m_ID);
world->getWorldNotifier().notifyListeners(&game::WorldListener::OnTowerAdd, tower);
world->GetWorldNotifier().NotifyListeners(&game::WorldListener::OnTowerAdd, tower);
protocol::WorldAddTowerPacket addTowerPacket(tower->getID(), packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID);
m_Server->broadcastPacket(&addTowerPacket);
protocol::WorldAddTowerPacket addTowerPacket(tower->GetID(), packet->GetTowerX(), packet->GetTowerY(), packet->GetTowerType(), m_ID);
m_Server->BroadcastPacket(&addTowerPacket);
}
void ServerConnexion::HandlePacket(const protocol::SendMobsPacket* packet) {
const std::vector<protocol::MobSend>& mobSent = packet->getMobSends();
const std::vector<protocol::MobSend>& mobSent = packet->GetMobSends();
//TODO: verify the packet
for (protocol::MobSend mobSend : mobSent) {
m_Server->getGame().getServerWorld()->spawnMobs(mobSend.mobType, mobSend.mobLevel, m_ID, mobSend.mobCount);
m_Server->GetGame().GetServerWorld()->SpawnMobs(mobSend.mobType, mobSend.mobLevel, m_ID, mobSend.mobCount);
}
}
void ServerConnexion::HandlePacket(const protocol::UpgradeTowerPacket* packet) {
//TODO: verify the packet
m_Server->broadcastPacket(packet);
m_Server->BroadcastPacket(packet);
}
void ServerConnexion::HandlePacket(const protocol::RemoveTowerPacket* packet) {
//TODO: verify the packet
m_Server->broadcastPacket(packet);
m_Server->BroadcastPacket(packet);
}
ServerConnexion::~ServerConnexion() {

94
src/game/server/ServerGame.cpp
View File

@@ -5,105 +5,105 @@ namespace td {
namespace server {
ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this),
m_GoldMineTimer{ 1000, std::bind(&ServerGame::updateGoldMines, this) },
m_MobStatesTimer{ 5000, std::bind(&ServerGame::updateMobStates, this) },
m_EndGameCooldown{ 1000 * 10 } {
bindListener(this);
m_GoldMineTimer{ 1000, std::bind(&ServerGame::UpdateGoldMines, this) },
m_MobStatesTimer{ 5000, std::bind(&ServerGame::UpdateMobStates, this) },
m_EndGameCooldown{ 1000 * 10 } {
BindListener(this);
}
void ServerGame::tick(std::uint64_t delta) {
void ServerGame::Tick(std::uint64_t delta) {
if (m_GameState == game::GameState::Game) {
Game::tick(delta);
m_MobStatesTimer.update(delta);
updatePlayerStats();
Game::Tick(delta);
m_MobStatesTimer.Update(delta);
UpdatePlayerStats();
} else if (m_GameState == game::GameState::EndGame) {
if (m_EndGameCooldown.update(delta)) {
notifyListeners(&game::GameListener::OnGameClose);
if (m_EndGameCooldown.Update(delta)) {
NotifyListeners(&game::GameListener::OnGameClose);
}
}
}
void ServerGame::startGame() {
balanceTeams();
void ServerGame::StartGame() {
BalanceTeams();
protocol::WorldBeginDataPacket headerMapData(m_World);
m_Server->broadcastPacket(&headerMapData);
m_Server->BroadcastPacket(&headerMapData);
protocol::WorldDataPacket mapData(m_World);
m_Server->broadcastPacket(&mapData);
m_Server->BroadcastPacket(&mapData);
m_GameState = game::GameState::Game;
}
void ServerGame::updatePlayerStats() {
m_GoldMineTimer.update();
void ServerGame::UpdatePlayerStats() {
m_GoldMineTimer.Update();
}
void ServerGame::updateGoldMines() {
for (auto& pair : m_Server->getPlayers()) {
void ServerGame::UpdateGoldMines() {
for (auto& pair : m_Server->GetPlayers()) {
game::Player* player = &pair.second;
player->addGold(player->getGoldPerSecond());
player->AddGold(player->GetGoldPerSecond());
// Update player money and exp every second
protocol::UpdateMoneyPacket moneyPacket(player->getGold());
m_Server->getConnexions()[player->getID()].sendPacket(&moneyPacket);
protocol::UpdateMoneyPacket moneyPacket(player->GetGold());
m_Server->GetConnexions()[player->GetID()].SendPacket(&moneyPacket);
protocol::UpdateExpPacket expPacket(player->getExp());
m_Server->getConnexions()[player->getID()].sendPacket(&expPacket);
protocol::UpdateExpPacket expPacket(player->GetExp());
m_Server->GetConnexions()[player->GetID()].SendPacket(&expPacket);
}
}
void ServerGame::updateMobStates() {
void ServerGame::UpdateMobStates() {
protocol::UpdateMobStatesPacket packet;
for (auto mob : m_World->getMobList()) {
packet.addMobState({ mob->getMobID(), mob->getCenter(), mob->getHealth(), mob->getDirection() });
for (auto mob : m_World->GetMobList()) {
packet.addMobState({ mob->GetMobID(), mob->GetCenter(), mob->GetHealth(), mob->GetDirection() });
}
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
}
void ServerGame::balanceTeams() {
void ServerGame::BalanceTeams() {
for (auto& playerInfo : Game::m_Players) {
game::Player& player = playerInfo.second;
if (player.getTeamColor() == game::TeamColor::None) {
game::Team& redTeam = getRedTeam();
game::Team& blueTeam = getBlueTeam();
if (blueTeam.getPlayerCount() > redTeam.getPlayerCount()) {
player.setTeamColor(game::TeamColor::Red);
redTeam.addPlayer(&player);
if (player.GetTeamColor() == game::TeamColor::None) {
game::Team& redTeam = GetRedTeam();
game::Team& blueTeam = GetBlueTeam();
if (blueTeam.GetPlayerCount() > redTeam.GetPlayerCount()) {
player.SetTeamColor(game::TeamColor::Red);
redTeam.AddPlayer(&player);
} else {
player.setTeamColor(game::TeamColor::Blue);
blueTeam.addPlayer(&player);
player.SetTeamColor(game::TeamColor::Blue);
blueTeam.AddPlayer(&player);
}
protocol::UpdatePlayerTeamPacket packet(player.getID(), player.getTeamColor());
m_Server->broadcastPacket(&packet);
protocol::UpdatePlayerTeamPacket packet(player.GetID(), player.GetTeamColor());
m_Server->BroadcastPacket(&packet);
}
}
}
void ServerGame::OnGameStateUpdate(game::GameState newState) {
setGameState(newState);
SetGameState(newState);
protocol::UpdateGameStatePacket packet(newState);
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
}
void ServerGame::OnGameBegin() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Game);
startGame();
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Game);
StartGame();
}
void ServerGame::OnGameEnd() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::EndGame);
m_EndGameCooldown.applyCooldown();
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::EndGame);
m_EndGameCooldown.ApplyCooldown();
}
void ServerGame::OnGameClose() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Closed);
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Closed);
// Disconnect clients
protocol::DisconnectPacket packet("Game finished");
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
// Closing server
m_Server->close();
m_Server->Close();
}
} // namespace game

46
src/game/server/ServerWorld.cpp
View File

@@ -11,25 +11,25 @@ ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game),
}
void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count) {
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::TeamColor senderTeam = m_Game->GetPlayers().at(sender).GetTeamColor();
game::Spawn* enemyMobSpawn;
if (senderTeam == game::TeamColor::Red) {
enemyMobSpawn = &getTeam(game::TeamColor::Blue).getSpawn();
enemyMobSpawn = &GetTeam(game::TeamColor::Blue).GetSpawn();
} else {
enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn();
enemyMobSpawn = &GetTeam(game::TeamColor::Red).GetSpawn();
}
float spawnWidth = enemyMobSpawn->getWidth();
float spawnHeight = enemyMobSpawn->getHeight();
float spawnWidth = enemyMobSpawn->GetWidth();
float spawnHeight = enemyMobSpawn->GetHeight();
float spawnCenterX = enemyMobSpawn->getCenterX();
float spawnCenterY = enemyMobSpawn->getCenterY();
float spawnCenterX = enemyMobSpawn->GetCenterX();
float spawnCenterY = enemyMobSpawn->GetCenterY();
auto mobStats = getMobStats(type, level);
auto mobSize = mobStats->getSize();
auto mobStats = GetMobStats(type, level);
auto mobSize = mobStats->GetSize();
float minSpawnX = spawnCenterX - spawnWidth / 2.0f + mobSize.x / 2.0f;
float maxSpawnX = spawnCenterX + spawnWidth / 2.0f - mobSize.x / 2.0f;
@@ -37,20 +37,20 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
float minSpawnY = spawnCenterY - spawnHeight / 2.0f + mobSize.y / 2.0f;
float maxSpawnY = spawnCenterY + spawnHeight / 2.0f - mobSize.y / 2.0f;
float mobX = utils::getRandomReal<float>(minSpawnX + MobSpawnBorder, maxSpawnX - MobSpawnBorder);
float mobY = utils::getRandomReal<float>(minSpawnY + MobSpawnBorder, maxSpawnY - MobSpawnBorder);
float mobX = utils::GetRandomReal<float>(minSpawnX + MobSpawnBorder, maxSpawnX - MobSpawnBorder);
float mobY = utils::GetRandomReal<float>(minSpawnY + MobSpawnBorder, maxSpawnY - MobSpawnBorder);
spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
SpawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->GetDirection());
protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
m_Server->broadcastPacket(&packet);
protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->GetDirection());
m_Server->BroadcastPacket(&packet);
m_CurrentMobID++;
}
}
game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder) {
game::TowerPtr tower = World::placeTowerAt(m_CurrentTowerID, type, x, y, builder);
game::TowerPtr ServerWorld::PlaceTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder) {
game::TowerPtr tower = World::PlaceTowerAt(m_CurrentTowerID, type, x, y, builder);
m_CurrentTowerID++;
return tower;
}
@@ -58,11 +58,11 @@ game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, s
void ServerWorld::OnMobDie(game::Mob* mob) {
if (mob->OnDeath(this)) { // check if the mob is actually dead (slimes ...)
//reward players
game::Player* sender = m_Game->getPlayerById(mob->getSender());
sender->addExp(mob->getStats()->getExpReward());
game::Player* sender = m_Game->GetPlayerById(mob->GetSender());
sender->AddExp(mob->GetStats()->GetExpReward());
game::Player* killer = m_Game->getPlayerById(mob->getLastDamageTower()->getBuilder());
killer->addGold(mob->getStats()->getMoneyCost());
game::Player* killer = m_Game->GetPlayerById(mob->GetLastDamageTower()->GetBuilder());
killer->AddGold(mob->GetStats()->GetMoneyCost());
}
}
@@ -70,8 +70,8 @@ void ServerWorld::OnMobCastleDamage(game::Mob* damager, game::TeamCastle* enemyC
// calling base class event
World::OnMobCastleDamage(damager, enemyCastle, damage);
protocol::UpdateCastleLifePacket packet(enemyCastle->getLife(), enemyCastle->getTeam()->getColor());
m_Server->broadcastPacket(&packet);
protocol::UpdateCastleLifePacket packet(enemyCastle->GetLife(), enemyCastle->GetTeam()->GetColor());
m_Server->BroadcastPacket(&packet);
}
} // namespace server

8
src/misc/Compression.cpp
View File

@@ -8,13 +8,13 @@
namespace td {
namespace utils {
std::uint64_t inflate(const std::string& source, std::string& dest) {
std::uint64_t Inflate(const std::string& source, std::string& dest) {
std::size_t size;
uncompress(reinterpret_cast<Bytef*>(dest.data()), &size, reinterpret_cast<const Bytef*>(source.c_str()), source.length());
return size;
}
std::uint64_t deflate(const std::string& source, std::string& dest) {
std::uint64_t Deflate(const std::string& source, std::string& dest) {
std::size_t size;
dest.resize(source.size()); // Resize for the compressed data to fit into
compress(reinterpret_cast<Bytef*>(dest.data()), &size, reinterpret_cast<const Bytef*>(source.c_str()), source.length());
@@ -37,7 +37,7 @@ DataBuffer Compress(const DataBuffer& buffer) {
return packet;
}
deflate(buffer.ToString(), compressedData);
Deflate(buffer.ToString(), compressedData);
std::uint64_t dataLength = buffer.GetSize();
std::uint64_t packetLength = compressedData.length() + sizeof(dataLength);
@@ -70,7 +70,7 @@ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
std::string inflated;
inflated.resize(uncompressedLength);
inflate(deflatedData, inflated);
Inflate(deflatedData, inflated);
assert(inflated.length() == uncompressedLength);
return DataBuffer(inflated);

84
src/misc/Easing.cpp
View File

@@ -5,59 +5,61 @@
namespace td {
namespace utils {
// Found at https://easings.net/
/* 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) {
return x * easeInQuad(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) {
return x < 0.5 ? 4 * easeInCubic(x) : 1 - std::pow(-2 * x + 2, 3) / 2.0f;
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) {
return x * easeInQuart(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) {
return x < 0.5 ? 16 * easeInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0f;
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;
@@ -65,7 +67,7 @@ float easeInOutCirc(float x) {
/* Elastic functions */
float easeInElastic(float x) {
float EaseInElastic(float x) {
const float c4 = (2 * PI) / 3.0f;
return x == 0
@@ -75,7 +77,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 +87,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 +101,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) {
return x * easeInCubic(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) {
return x < 0.5 ? 8 * easeInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0f;
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 +148,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);
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,16 +173,16 @@ float easeInOutBack(float x) {
/* Bounce functions */
float easeInBounce(float x) {
return 1 - easeOutBounce(1 - 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);
return n1 * EaseInQuad(x);
} else if (x < 2 / d1) {
x -= 1.5;
return n1 * (x / d1) * x + 0.75;
@@ -193,10 +195,10 @@ 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;
? (1 - EaseOutBounce(1 - 2 * x)) / 2.0f
: (1 + EaseOutBounce(2 * x - 1)) / 2.0f;
}
} // namespace utils

75
src/misc/Shapes.cpp
View File

@@ -7,76 +7,77 @@ namespace td {
namespace utils {
namespace shape {
float Point::distance(const Point& point) const {
return std::sqrt(distanceSquared(point));
float Point::Distance(const Point& point) const {
return std::sqrt(DistanceSquared(point));
}
float Point::distanceSquared(const Point& point) const {
return (m_X - point.getX()) * (m_X - point.getX()) + (m_Y - point.getY()) * (m_Y - point.getY());
float Point::DistanceSquared(const Point& point) const {
return (m_X - point.GetX()) * (m_X - point.GetX()) + (m_Y - point.GetY()) * (m_Y - point.GetY());
}
bool Rectangle::collidesWith(const Point& point) const {
return point.getX() > getTopLeft().getX() && point.getX() < getBottomRight().getX() &&
point.getY() > getTopLeft().getY() && point.getY() < getBottomRight().getY();
bool Rectangle::CollidesWith(const Point& point) const {
return point.GetX() > GetTopLeft().GetX() && point.GetX() < GetBottomRight().GetX() &&
point.GetY() > GetTopLeft().GetY() && point.GetY() < GetBottomRight().GetY();
}
bool Rectangle::collidesWith(const Rectangle& rect) const {
Point point1{ rect.getTopLeft().getX(), rect.getTopLeft().getY() };
Point point2{ rect.getTopLeft().getX(), rect.getBottomRight().getY() };
Point point3{ rect.getBottomRight().getX(), rect.getTopLeft().getY() };
Point point4{ rect.getBottomRight().getX(), rect.getBottomRight().getY() };
bool Rectangle::CollidesWith(const Rectangle& rect) const {
if (collidesWith(point1)) return true;
if (collidesWith(point2)) return true;
if (collidesWith(point3)) return true;
if (collidesWith(point4)) return true;
Point point1{ rect.GetTopLeft().GetX(), rect.GetTopLeft().GetY() };
Point point2{ rect.GetTopLeft().GetX(), rect.GetBottomRight().GetY() };
Point point3{ rect.GetBottomRight().GetX(), rect.GetTopLeft().GetY() };
Point point4{ rect.GetBottomRight().GetX(), rect.GetBottomRight().GetY() };
if (CollidesWith(point1)) return true;
if (CollidesWith(point2)) return true;
if (CollidesWith(point3)) return true;
if (CollidesWith(point4)) return true;
return false;
}
bool Rectangle::collidesWith(const Circle& circle) const {
return circle.collidesWith(*this);
bool Rectangle::CollidesWith(const Circle& circle) const {
return circle.CollidesWith(*this);
}
float Rectangle::distance(const Circle& circle) const {
return circle.distance(*this);
float Rectangle::Distance(const Circle& circle) const {
return circle.Distance(*this);
}
float Rectangle::distanceSquared(const Circle& circle) const {
return circle.distanceSquared(*this);
float Rectangle::DistanceSquared(const Circle& circle) const {
return circle.DistanceSquared(*this);
}
bool Circle::collidesWith(const Point& point) const {
return m_Radius * m_Radius > m_Center.distanceSquared(point);
bool Circle::CollidesWith(const Point& point) const {
return m_Radius * m_Radius > m_Center.DistanceSquared(point);
}
bool Circle::collidesWith(const Rectangle& rect) const {
float distanceSquared_ = distanceSquared(rect);
bool Circle::CollidesWith(const Rectangle& rect) const {
float DistanceSquared_ = DistanceSquared(rect);
return distanceSquared_ < m_Radius* m_Radius;
return DistanceSquared_ < m_Radius* m_Radius;
}
bool Circle::collidesWith(const Circle& circle) const {
return m_Radius + circle.getRadius() > m_Center.distanceSquared(circle.getCenter());
bool Circle::CollidesWith(const Circle& circle) const {
return m_Radius + circle.GetRadius() > m_Center.DistanceSquared(circle.GetCenter());
}
float Circle::distance(const Rectangle& rect) const {
return std::sqrt(distanceSquared(rect));
float Circle::Distance(const Rectangle& rect) const {
return std::sqrt(DistanceSquared(rect));
}
float Circle::distanceSquared(const Rectangle& rect) const {
float closestX = std::clamp(m_Center.getX(), rect.getTopLeft().getX(), rect.getBottomRight().getX());
float closestY = std::clamp(m_Center.getY(), rect.getTopLeft().getY(), rect.getBottomRight().getY());
float Circle::DistanceSquared(const Rectangle& rect) const {
float closestX = std::clamp(m_Center.GetX(), rect.GetTopLeft().GetX(), rect.GetBottomRight().GetX());
float closestY = std::clamp(m_Center.GetY(), rect.GetTopLeft().GetY(), rect.GetBottomRight().GetY());
float distanceX = m_Center.getX() - closestX;
float distanceY = m_Center.getY() - closestY;
float DistanceX = m_Center.GetX() - closestX;
float DistanceY = m_Center.GetY() - closestY;
return (distanceX * distanceX) + (distanceY * distanceY);
return (DistanceX * DistanceX) + (DistanceY * DistanceY);
}
} // namespace shape

26
src/misc/Time.cpp
View File

@@ -6,32 +6,32 @@
namespace td {
namespace utils {
void AutoTimer::update() {
m_InternalTime += getTime() - m_LastTime;
void AutoTimer::Update() {
m_InternalTime += GetTime() - m_LastTime;
if (m_InternalTime >= m_Interval) {
if (m_Function != nullptr)
m_Function();
m_InternalTime %= m_Interval;
}
m_LastTime = getTime();
m_LastTime = GetTime();
}
void AutoTimer::update(std::uint64_t delta) {
void AutoTimer::Update(std::uint64_t delta) {
m_InternalTime += delta;
if (m_InternalTime >= m_Interval) {
if (m_Function != nullptr)
m_Function();
m_InternalTime %= m_Interval;
}
m_LastTime = getTime();
m_LastTime = GetTime();
}
void AutoTimer::reset() {
void AutoTimer::Reset() {
m_InternalTime = 0;
m_LastTime = getTime();
m_LastTime = GetTime();
}
bool Timer::update(std::uint64_t delta) {
bool Timer::Update(std::uint64_t delta) {
m_InternalTime += delta;
if (m_InternalTime >= m_Interval) {
m_InternalTime %= m_Interval;
@@ -40,26 +40,26 @@ bool Timer::update(std::uint64_t delta) {
return false;
}
void Timer::reset() {
void Timer::Reset() {
m_InternalTime = 0; // let the timer active once at the beginning
}
bool CooldownTimer::update(std::uint64_t delta) {
bool CooldownTimer::Update(std::uint64_t delta) {
if (m_Cooldown > 0) {
m_Cooldown = static_cast<std::uint64_t>(std::max(static_cast<std::int64_t>(0), static_cast<std::int64_t>(m_Cooldown - delta)));
}
return m_Cooldown == 0;
}
void CooldownTimer::reset() {
void CooldownTimer::Reset() {
m_Cooldown = 0; // let the timer active once at the beginning
}
void CooldownTimer::applyCooldown() {
void CooldownTimer::ApplyCooldown() {
m_Cooldown = m_CooldownTime;
}
std::uint64_t getTime() {
std::uint64_t GetTime() {
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock().now().time_since_epoch()).count());
}

14
src/network/TCPListener.cpp
View File

@@ -14,10 +14,10 @@ namespace network {
TCPListener::TCPListener() {}
TCPListener::~TCPListener() {
destroy();
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<sockaddr*>(&newSocket.m_RemoteAddr),
reinterpret_cast<socklen_t*>(&addrlen))) < 0)
@@ -48,21 +48,21 @@ bool TCPListener::accept(TCPSocket& newSocket) {
return true;
}
void TCPListener::destroy() {
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;

2
src/protocol/PacketDispatcher.cpp
View File

@@ -28,7 +28,7 @@ void PacketDispatcher::UnregisterHandler(PacketHandler* handler) {
void PacketDispatcher::Dispatch(const PacketPtr& packet) {
if (!packet) return;
PacketType type = packet->getType();
PacketType type = packet->GetType();
for (PacketHandler* handler : m_Handlers[type])
packet->Dispatch(handler);
}

2
src/protocol/PacketFactory.cpp
View File

@@ -35,7 +35,7 @@ static std::map<PacketType, PacketCreator> packets = {
{PacketType::UpdateMobStates, []() -> PacketPtr {return std::make_unique<UpdateMobStatesPacket>(); } },
};
PacketPtr createPacket(PacketType type, DataBuffer& buffer) {
PacketPtr CreatePacket(PacketType type, DataBuffer& buffer) {
PacketPtr packet = packets[type]();
packet->Deserialize(buffer);
return packet;

32
src/protocol/Protocol.cpp
View File

@@ -20,14 +20,14 @@ unsigned int countBits(unsigned int number) {
void Packet::WritePacketID(DataBuffer& data, bool packetID) const {
if (packetID) {
data << getID();
data << GetID();
}
}
DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile) {
buffer << tile->getType();
buffer << tile->GetType();
switch (tile->getType()) {
switch (tile->GetType()) {
case game::TileType::Tower: {
const game::TowerTile* towerTile = dynamic_cast<const game::TowerTile*>(tile.get());
@@ -96,12 +96,12 @@ void PlayerLoginPacket::Deserialize(DataBuffer& data) {
DataBuffer WorldBeginDataPacket::Serialize(bool packetID) const {
DataBuffer data;
const game::TowerTileColorPalette& towerTilePalette = m_Header.m_World->getTowerTileColorPalette();
const std::vector<game::Color>& decoTilePalette = m_Header.m_World->getDecorationPalette();
const game::TowerTileColorPalette& towerTilePalette = m_Header.m_World->GetTowerTileColorPalette();
const std::vector<game::Color>& decoTilePalette = m_Header.m_World->GetDecorationPalette();
WritePacketID(data, packetID);
data << towerTilePalette << m_Header.m_World->getWalkableTileColor()
data << towerTilePalette << m_Header.m_World->GetWalkableTileColor()
<< (std::uint16_t)decoTilePalette.size();
// deco color palette
@@ -110,22 +110,22 @@ DataBuffer WorldBeginDataPacket::Serialize(bool packetID) const {
memcpy(reinterpret_cast<std::uint8_t*>(data.data()) + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
data << m_Header.m_World->getBackgroundColor();
data << m_Header.m_World->GetBackgroundColor();
const game::Spawn& redSpawn = m_Header.m_World->getRedTeam().getSpawn(), blueSpawn = m_Header.m_World->getBlueTeam().getSpawn();
const game::TeamCastle& redCastle = m_Header.m_World->getRedTeam().getCastle(), blueCastle = m_Header.m_World->getBlueTeam().getCastle();
const game::Spawn& redSpawn = m_Header.m_World->GetRedTeam().GetSpawn(), blueSpawn = m_Header.m_World->GetBlueTeam().GetSpawn();
const game::TeamCastle& redCastle = m_Header.m_World->GetRedTeam().GetCastle(), blueCastle = m_Header.m_World->GetBlueTeam().GetCastle();
data << redSpawn << static_cast<utils::shape::Rectangle>(redCastle);
data << blueSpawn << static_cast<utils::shape::Rectangle>(blueCastle);
// tile palette
data << static_cast<std::uint64_t>(m_Header.m_World->getTilePalette().size());
data << static_cast<std::uint64_t>(m_Header.m_World->GetTilePalette().size());
for (game::TilePtr tile : m_Header.m_World->getTilePalette()) {
for (game::TilePtr tile : m_Header.m_World->GetTilePalette()) {
data << tile;
}
data << m_Header.m_World->getSpawnColors();
data << m_Header.m_World->GetSpawnColors();
return data;
}
@@ -151,8 +151,8 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
data >> m_Header.m_RedSpawn >> redCastle;
data >> m_Header.m_BlueSpawn >> blueCastle;
m_Header.m_RedCastle.setShape(redCastle);
m_Header.m_BlueCastle.setShape(blueCastle);
m_Header.m_RedCastle.SetShape(redCastle);
m_Header.m_BlueCastle.SetShape(blueCastle);
std::uint64_t tilePaletteSize;
data >> tilePaletteSize;
@@ -175,8 +175,8 @@ DataBuffer WorldDataPacket::Serialize(bool packetID) const {
WritePacketID(data, packetID);
data << m_World->getChunks().size();
for (const auto& pair : m_World->getChunks()) {
data << m_World->GetChunks().size();
for (const auto& pair : m_World->GetChunks()) {
game::ChunkCoord coords = pair.first;
game::ChunkPtr chunk = pair.second;

106
src/render/Renderer.cpp
View File

@@ -25,53 +25,53 @@ Renderer::~Renderer() {
}
void Renderer::updateIsometricView() {
float isometricEased = utils::easeInOutExpo(m_IsometricShade);
m_WorldShader->start();
m_WorldShader->setIsometricView(isometricEased);
m_EntityShader->start();
m_EntityShader->setIsometricView(isometricEased);
void Renderer::UpdateIsometricView() {
float isometricEased = utils::EaseInOutExpo(m_IsometricShade);
m_WorldShader->Start();
m_WorldShader->SetIsometricView(isometricEased);
m_EntityShader->Start();
m_EntityShader->SetIsometricView(isometricEased);
}
void Renderer::initShader() {
m_WorldShader = std::make_unique<WorldShader>();
m_WorldShader->loadShader();
m_EntityShader = std::make_unique<EntityShader>();
m_EntityShader->loadShader();
setIsometricView(true);
updateIsometricView();
void Renderer::InitShaders() {
m_WorldShader = std::make_unique<shader::WorldShader>();
m_WorldShader->LoadShader();
m_EntityShader = std::make_unique<shader::EntityShader>();
m_EntityShader->LoadShader();
SetIsometricView(true);
UpdateIsometricView();
}
bool Renderer::init() {
bool Renderer::Init() {
#ifndef ANDROID
glbinding::Binding::initialize();
#endif
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
initShader();
InitShaders();
return true;
}
void Renderer::renderVAO(const GL::VertexArray& vao) {
m_WorldShader->start();
vao.bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vao.getVertexCount()));
vao.unbind();
void Renderer::RenderVAO(const GL::VertexArray& vao) {
m_WorldShader->Start();
vao.Bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vao.GetVertexCount()));
vao.Unbind();
}
void Renderer::renderModel(const Model& model) {
m_EntityShader->start();
m_EntityShader->setModelPos(model.positon);
model.vao->bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(model.vao->getVertexCount()));
model.vao->unbind();
void Renderer::RenderModel(const Model& model) {
m_EntityShader->Start();
m_EntityShader->SetModelPos(model.positon);
model.vao->Bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(model.vao->GetVertexCount()));
model.vao->Unbind();
}
void Renderer::updateIsometricFade() {
static std::uint64_t lastTime = utils::getTime();
void Renderer::UpdateIsometricFade() {
static std::uint64_t lastTime = utils::GetTime();
if (m_IsometricShade != static_cast<float>(m_IsometricView)) {
float step = static_cast<float>(utils::getTime() - lastTime) / 1000.0f * m_AnimationSpeed;
float step = static_cast<float>(utils::GetTime() - lastTime) / 1000.0f * m_AnimationSpeed;
if (m_IsometricShade < m_IsometricView) {
m_IsometricShade += step;
} else {
@@ -79,52 +79,52 @@ void Renderer::updateIsometricFade() {
}
m_IsometricShade = std::min(m_IsometricShade, 1.0f);
m_IsometricShade = std::max(m_IsometricShade, 0.0f);
updateIsometricView();
UpdateIsometricView();
}
lastTime = utils::getTime();
lastTime = utils::GetTime();
}
void Renderer::prepare() {
void Renderer::Prepare() {
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(m_BackgroundColor.r, m_BackgroundColor.g, m_BackgroundColor.b, 0);
updateIsometricFade();
UpdateIsometricFade();
}
void Renderer::resize(int width, int height) {
m_WorldShader->start();
m_WorldShader->setAspectRatio(static_cast<float>(width) / height);
m_EntityShader->start();
m_EntityShader->setAspectRatio(static_cast<float>(width) / height);
void Renderer::Resize(int width, int height) {
m_WorldShader->Start();
m_WorldShader->SetAspectRatio(static_cast<float>(width) / height);
m_EntityShader->Start();
m_EntityShader->SetAspectRatio(static_cast<float>(width) / height);
glViewport(0, 0, width, height);
}
void Renderer::setZoom(float zoom) {
m_WorldShader->start();
m_WorldShader->setZoom(zoom);
m_EntityShader->start();
m_EntityShader->setZoom(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);
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);
m_EntityShader->start();
m_EntityShader->setCamPos(newPos);
m_WorldShader->Start();
m_WorldShader->SetCamPos(newPos);
m_EntityShader->Start();
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) {
float isometricEased = utils::easeInOutExpo(m_IsometricShade);
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;
float relativeY = (cursorPos.y / windowHeight * 2) - 1;

20
src/render/VertexCache.cpp
View File

@@ -4,12 +4,12 @@
namespace td {
namespace render {
void VertexCache::addData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors) {
void VertexCache::AddData(std::uint64_t index, std::vector<float> positions, std::vector<float> colors) {
m_Indexes.insert({ index, {positions, colors} });
m_VertexCount += colors.size(); // one color per vertex
}
void VertexCache::removeData(std::uint64_t index) {
void VertexCache::RemoveData(std::uint64_t index) {
auto it = m_Indexes.find(index);
if (it != m_Indexes.end()) {
m_Indexes.erase(it);
@@ -17,12 +17,12 @@ void VertexCache::removeData(std::uint64_t index) {
}
}
void VertexCache::clear() {
void VertexCache::Clear() {
m_Indexes.clear();
m_VertexCount = 0;
}
void VertexCache::updateVertexArray() {
void VertexCache::UpdateVertexArray() {
m_VertexArray = std::make_unique<GL::VertexArray>(m_VertexCount); // one color per vertex
Vector positions;
@@ -39,15 +39,15 @@ void VertexCache::updateVertexArray() {
}
GL::VertexBuffer positionsBuffer(positions, 2);
positionsBuffer.addVertexAttribPointer(0, 2, 0);
positionsBuffer.AddVertexAttribPointer(0, 2, 0);
GL::VertexBuffer colorsBuffer(colors, 1);
colorsBuffer.addVertexAttribPointer(1, 1, 0);
colorsBuffer.AddVertexAttribPointer(1, 1, 0);
m_VertexArray->bind();
m_VertexArray->bindVertexBuffer(positionsBuffer);
m_VertexArray->bindVertexBuffer(colorsBuffer);
m_VertexArray->unbind();
m_VertexArray->Bind();
m_VertexArray->BindVertexBuffer(positionsBuffer);
m_VertexArray->BindVertexBuffer(colorsBuffer);
m_VertexArray->Unbind();
}
} // namespace render

198
src/render/WorldRenderer.cpp
View File

@@ -12,7 +12,7 @@
namespace td {
namespace render {
ImVec4 WorldRenderer::getImGuiTeamColor(game::TeamColor color) {
ImVec4 WorldRenderer::GetImGuiTeamColor(game::TeamColor color) {
switch (color) {
case td::game::TeamColor::None:
break;
@@ -24,41 +24,41 @@ ImVec4 WorldRenderer::getImGuiTeamColor(game::TeamColor color) {
return ImVec4(1, 1, 1, 1);
}
void WorldRenderer::loadModels() {
void WorldRenderer::LoadModels() {
std::cout << "World Created !\n";
m_WorldVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::loadWorldModel(m_World)));
m_MobVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::loadMobModel()));
m_SelectTileVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::loadTileSelectModel()));
std::cout << "Vertex Count : " << m_WorldVao->getVertexCount() << std::endl;
m_WorldVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadWorldModel(m_World)));
m_MobVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadMobModel()));
m_SelectTileVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadTileSelectModel()));
std::cout << "Vertex Count : " << m_WorldVao->GetVertexCount() << std::endl;
}
WorldRenderer::WorldRenderer(game::World* world, client::ClientGame* client) : m_Client(client), m_Renderer(m_Client->getRenderer()), m_World(world), m_Zoom(0.1) {
m_Renderer->setZoom(m_Zoom);
m_Renderer->setCamMovement({});
m_TowerPlacePopup = std::make_unique<gui::TowerPlacePopup>(m_Client->getClient());
m_MobTooltip = std::make_unique<gui::MobTooltip>(m_Client->getClient());
m_CastleTooltip = std::make_unique<gui::CastleTooltip>(m_Client->getClient());
m_Client->getWorldClient().getWorldNotifier().bindListener(this);
WorldRenderer::WorldRenderer(game::World* world, client::ClientGame* client) : m_Client(client), m_Renderer(m_Client->GetRenderer()), m_World(world), m_Zoom(0.1) {
m_Renderer->SetZoom(m_Zoom);
m_Renderer->SetCamMovement({});
m_TowerPlacePopup = std::make_unique<gui::TowerPlacePopup>(m_Client->GetClient());
m_MobTooltip = std::make_unique<gui::MobTooltip>(m_Client->GetClient());
m_CastleTooltip = std::make_unique<gui::CastleTooltip>(m_Client->GetClient());
m_Client->GetWorldClient().GetWorldNotifier().BindListener(this);
}
void WorldRenderer::updateCursorPos() {
m_CursorPos = getCursorWorldPos();
void WorldRenderer::UpdateCursorPos() {
m_CursorPos = GetCursorWorldPos();
}
void WorldRenderer::update() {
void WorldRenderer::Update() {
if (m_WorldVao == nullptr)
return;
ImGuiIO& io = ImGui::GetIO();
if (io.MouseDown[0] && !ImGui::IsAnyItemActive()) {
ImVec2 mouseDelta = ImGui::GetIO().MouseDelta;
const float relativeX = mouseDelta.x / (float)Display::getWindowWidth() * 2;
const float relativeY = mouseDelta.y / (float)Display::getWindowHeight() * 2;
moveCam(relativeX, relativeY, Display::getAspectRatio());
const float relativeX = mouseDelta.x / (float)Display::GetWindowWidth() * 2;
const float relativeY = mouseDelta.y / (float)Display::GetWindowHeight() * 2;
MoveCam(relativeX, relativeY, Display::GetAspectRatio());
}
if (io.MouseWheel != 0) {
changeZoom(io.MouseWheel);
ChangeZoom(io.MouseWheel);
}
updateCursorPos();
UpdateCursorPos();
if (ImGui::IsMouseClicked(0)) {
if (!m_PopupOpened) {
m_HoldCursorPos = { io.MousePos.x, io.MousePos.y };
@@ -67,84 +67,84 @@ void WorldRenderer::update() {
}
}
if (ImGui::IsMouseDoubleClicked(1)) removeTower();
if (ImGui::IsMouseDoubleClicked(1)) RemoveTower();
}
void WorldRenderer::removeTower() {
glm::vec2 cursorPos = getCursorWorldPos();
void WorldRenderer::RemoveTower() {
glm::vec2 cursorPos = GetCursorWorldPos();
game::TowerPtr clickedTower = m_World->getTower(cursorPos);
game::TowerPtr clickedTower = m_World->GetTower(cursorPos);
if (clickedTower != nullptr) {
m_Client->getClient()->removeTower(clickedTower->getID());
m_Client->GetClient()->RemoveTower(clickedTower->GetID());
}
}
void WorldRenderer::renderWorld() const {
m_Renderer->renderVAO(*m_WorldVao);
void WorldRenderer::RenderWorld() const {
m_Renderer->RenderVAO(*m_WorldVao);
}
void WorldRenderer::renderMobs() const {
for (game::MobPtr mob : m_World->getMobList()) {
void WorldRenderer::RenderMobs() const {
for (game::MobPtr mob : m_World->GetMobList()) {
Renderer::Model model;
model.vao = m_MobVao.get();
model.positon = { mob->getCenterX(), mob->getCenterY() };
m_Renderer->renderModel(model);
model.positon = { mob->GetCenterX(), mob->GetCenterY() };
m_Renderer->RenderModel(model);
}
}
void WorldRenderer::renderTowers() const {
if (!m_TowersCache.isEmpty())
m_Renderer->renderVAO(m_TowersCache.getVertexArray());
void WorldRenderer::RenderTowers() const {
if (!m_TowersCache.IsEmpty())
m_Renderer->RenderVAO(m_TowersCache.GetVertexArray());
}
void WorldRenderer::renderTileSelect() const {
void WorldRenderer::RenderTileSelect() const {
if (ImGui::IsAnyItemHovered()) return;
if(m_MobTooltip->isShown() || m_CastleTooltip->isShown()) return;
if (m_MobTooltip->IsShown() || m_CastleTooltip->IsShown()) return;
Renderer::Model tileSelectModel;
tileSelectModel.vao = m_SelectTileVao.get();
tileSelectModel.positon = { (int)m_CursorPos.x, (int)m_CursorPos.y };
m_Renderer->renderModel(tileSelectModel);
m_Renderer->RenderModel(tileSelectModel);
}
void WorldRenderer::renderPopups() {
m_TowerPlacePopup->render();
renderTowerUpgradePopup();
void WorldRenderer::RenderPopups() {
m_TowerPlacePopup->Render();
RenderTowerUpgradePopup();
}
void WorldRenderer::render() {
void WorldRenderer::Render() {
if (m_WorldVao == nullptr)
return;
renderWorld();
renderMobs();
renderTowers();
renderTileSelect();
renderTooltips();
renderPopups();
detectClick();
RenderWorld();
RenderMobs();
RenderTowers();
RenderTileSelect();
RenderTooltips();
RenderPopups();
DetectClick();
}
WorldRenderer::~WorldRenderer() {
}
void WorldRenderer::renderTooltips() const {
renderMobTooltip();
renderCastleTooltip();
void WorldRenderer::RenderTooltips() const {
RenderMobTooltip();
RenderCastleTooltip();
}
void WorldRenderer::moveCam(float relativeX, float relativeY, float aspectRatio) {
void WorldRenderer::MoveCam(float relativeX, float relativeY, float aspectRatio) {
if (m_WorldVao == nullptr)
return;
float movementX = -relativeX / m_Zoom * aspectRatio;
float movementY = relativeY / m_Zoom;
m_Renderer->setCamMovement({ movementX, movementY });
m_Renderer->SetCamMovement({ movementX, movementY });
}
void WorldRenderer::changeZoom(float zoomStep) {
void WorldRenderer::ChangeZoom(float zoomStep) {
if (m_WorldVao == nullptr)
return;
static float sensibility = 1.5f;
@@ -153,34 +153,34 @@ void WorldRenderer::changeZoom(float zoomStep) {
} else {
m_Zoom *= zoomStep * sensibility;
}
m_Renderer->setZoom(m_Zoom);
m_Renderer->setCamMovement({});
m_Renderer->SetZoom(m_Zoom);
m_Renderer->SetCamMovement({});
}
void WorldRenderer::click() {
const game::TowerPtr tower = m_Client->getWorld().getTower(getClickWorldPos());
m_TowerPlacePopup->setClickPos(getClickWorldPos());
void WorldRenderer::Click() {
const game::TowerPtr tower = m_Client->GetWorld().GetTower(GetClickWorldPos());
m_TowerPlacePopup->SetClickPos(GetClickWorldPos());
if (tower != nullptr) { // there is a tower here
ImGui::OpenPopup("TowerUpgrade");
} else if (m_Client->getWorld().CanPlaceLittleTower(getClickWorldPos(), m_Client->getPlayer()->getID())) {
} else if (m_Client->GetWorld().CanPlaceLittleTower(GetClickWorldPos(), m_Client->GetPlayer()->GetID())) {
ImGui::OpenPopup("TowerPlace");
}
}
void WorldRenderer::setCamPos(float camX, float camY) {
void WorldRenderer::SetCamPos(float camX, float camY) {
m_CamPos = { camX, camY };
m_Renderer->setCamPos(m_CamPos);
m_Renderer->SetCamPos(m_CamPos);
}
void WorldRenderer::renderTowerUpgradePopup() {
void WorldRenderer::RenderTowerUpgradePopup() {
if (ImGui::BeginPopup("TowerUpgrade")) {
m_PopupOpened = true;
game::TowerPtr tower = m_Client->getWorld().getTower(getClickWorldPos());
game::TowerPtr tower = m_Client->GetWorld().GetTower(GetClickWorldPos());
if (tower == nullptr) {
ImGui::EndPopup();
return;
}
ImGui::Text("Tower : %s", game::TowerFactory::getTowerName(tower->getType()).c_str());
ImGui::Text("Tower : %s", game::TowerFactory::GetTowerName(tower->GetType()).c_str());
for (int y = 0; y < 3; y++) { // path: 0 -> top 1 -> middle 2 -> bottom
for (int x = 0; x < 4; x++) { // level: 1, 2, 3, 4
@@ -191,12 +191,12 @@ void WorldRenderer::renderTowerUpgradePopup() {
std::uint8_t currentLevel = x + 1;
game::TowerPath currentPath = game::TowerPath(y);
const game::TowerStats* towerStats = game::getTowerStats(tower->getType(), { currentLevel, currentPath });
game::TowerPath towerPath = tower->getLevel().getPath();
const game::TowerStats* towerStats = game::GetTowerStats(tower->GetType(), { currentLevel, currentPath });
game::TowerPath towerPath = tower->GetLevel().GetPath();
bool disabled = towerStats == nullptr;
int towerLevel = tower->getLevel().getLevel();
int towerLevel = tower->GetLevel().GetLevel();
bool alreadyUpgraded = currentLevel <= towerLevel;
bool canUpgrade = (towerLevel + 1) == currentLevel;
@@ -220,7 +220,7 @@ void WorldRenderer::renderTowerUpgradePopup() {
ImGui::EndDisabled();
} else if (canUpgrade) {
if (ImGui::Button("Upgrade", ImVec2(100, 100))) {
m_Client->getClient()->upgradeTower(tower->getID(), { currentLevel, currentPath });
m_Client->GetClient()->UpgradeTower(tower->GetID(), { currentLevel, currentPath });
}
} else {
ImGui::BeginDisabled();
@@ -235,71 +235,71 @@ void WorldRenderer::renderTowerUpgradePopup() {
}
}
void WorldRenderer::detectClick() {
void WorldRenderer::DetectClick() {
ImGuiIO& io = ImGui::GetIO();
if (ImGui::IsMouseReleased(0) && !ImGui::IsAnyItemHovered() && !ImGui::IsAnyItemFocused()) {
glm::vec2 cursorPos = { io.MousePos.x, io.MousePos.y };
if (cursorPos == m_HoldCursorPos) {
m_LastClicked = m_HoldCursorPos;
click();
Click();
}
}
}
void WorldRenderer::renderMobTooltip() const {
void WorldRenderer::RenderMobTooltip() const {
if (ImGui::IsAnyItemHovered()) return;
detectMobHovering();
m_MobTooltip->render();
DetectMobHovering();
m_MobTooltip->Render();
}
void WorldRenderer::renderCastleTooltip() const {
void WorldRenderer::RenderCastleTooltip() const {
if (ImGui::IsAnyItemHovered()) return;
detectCastleHovering();
m_CastleTooltip->render();
DetectCastleHovering();
m_CastleTooltip->Render();
}
void WorldRenderer::detectMobHovering() const {
glm::vec2 cursorWorldPos = getCursorWorldPos();
for (game::MobPtr mob : m_World->getMobList()) {
if (mob->collidesWith({ cursorWorldPos.x, cursorWorldPos.y })) {
m_MobTooltip->setMob(mob.get());
void WorldRenderer::DetectMobHovering() const {
glm::vec2 cursorWorldPos = GetCursorWorldPos();
for (game::MobPtr mob : m_World->GetMobList()) {
if (mob->CollidesWith({ cursorWorldPos.x, cursorWorldPos.y })) {
m_MobTooltip->SetMob(mob.get());
return;
}
}
m_MobTooltip->setMob(nullptr);
m_MobTooltip->SetMob(nullptr);
}
void WorldRenderer::detectCastleHovering() const {
glm::vec2 cursorWorldPos = getCursorWorldPos();
for (const game::Team& team : m_World->getTeams()) {
if (team.getCastle().collidesWith({ cursorWorldPos.x, cursorWorldPos.y })) {
m_CastleTooltip->setCastle(&team.getCastle());
void WorldRenderer::DetectCastleHovering() const {
glm::vec2 cursorWorldPos = GetCursorWorldPos();
for (const game::Team& team : m_World->GetTeams()) {
if (team.GetCastle().CollidesWith({ cursorWorldPos.x, cursorWorldPos.y })) {
m_CastleTooltip->SetCastle(&team.GetCastle());
return;
}
}
m_CastleTooltip->setCastle(nullptr);
m_CastleTooltip->SetCastle(nullptr);
}
void WorldRenderer::OnTowerAdd(game::TowerPtr tower) {
WorldLoader::RenderData renderData = WorldLoader::loadTowerModel(tower);
m_TowersCache.addData(tower->getID(), renderData.positions, renderData.colors);
m_TowersCache.updateVertexArray();
WorldLoader::RenderData RenderData = WorldLoader::LoadTowerModel(tower);
m_TowersCache.AddData(tower->GetID(), RenderData.positions, RenderData.colors);
m_TowersCache.UpdateVertexArray();
}
void WorldRenderer::OnTowerRemove(game::TowerPtr tower) {
m_TowersCache.removeData(tower->getID());
m_TowersCache.updateVertexArray();
m_TowersCache.RemoveData(tower->GetID());
m_TowersCache.UpdateVertexArray();
}
glm::vec2 WorldRenderer::getCursorWorldPos() const {
glm::vec2 WorldRenderer::GetCursorWorldPos() const {
ImGuiIO& io = ImGui::GetIO();
return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
return m_Renderer->GetCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::GetAspectRatio(), m_Zoom, Display::GetWindowWidth(), Display::GetWindowHeight());
}
glm::vec2 WorldRenderer::getClickWorldPos() const {
return m_Renderer->getCursorWorldPos(m_LastClicked, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
glm::vec2 WorldRenderer::GetClickWorldPos() const {
return m_Renderer->GetCursorWorldPos(m_LastClicked, Display::GetAspectRatio(), m_Zoom, Display::GetWindowWidth(), Display::GetWindowHeight());
}
} // namespace render

6
src/render/gui/CastleTooltip.cpp
View File

@@ -12,14 +12,14 @@ CastleTooltip::CastleTooltip(client::Client* client) : GuiWidget(client) {
}
void CastleTooltip::render() {
void CastleTooltip::Render() {
if (m_Castle == nullptr) return;
ImGui::BeginTooltip();
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::getImGuiTeamColor(m_Castle->getTeam()->getColor()));
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::GetImGuiTeamColor(m_Castle->GetTeam()->GetColor()));
ImGui::Text("Castle : ");
ImGui::PopStyleColor();
ImGui::Text("\tCastle HP : %i/%i", static_cast<int>(m_Castle->getLife()), game::TeamCastle::CastleMaxLife);
ImGui::Text("\tCastle HP : %i/%i", static_cast<int>(m_Castle->GetLife()), game::TeamCastle::CastleMaxLife);
ImGui::EndTooltip();
}

4
src/render/gui/FrameMenu.cpp
View File

@@ -12,14 +12,14 @@ FrameMenu::FrameMenu(client::Client* client) : GuiWidget(client), m_VSync(true),
}
void FrameMenu::render() {
void FrameMenu::Render() {
ImGui::Begin("FPS Counter");
ImGui::Text("FPS : %i", (int)ImGui::GetIO().Framerate);
if (ImGui::Checkbox("V-Sync", &m_VSync)) {
SDL_GL_SetSwapInterval(m_VSync);
}
if (ImGui::Checkbox("Vue Isometrique ?", &m_IsometricView)) {
getClient()->getRenderer()->setIsometricView(m_IsometricView);
GetClient()->GetRenderer()->SetIsometricView(m_IsometricView);
}
#if !defined(NDEBUG)

66
src/render/gui/GameMenu.cpp
View File

@@ -13,69 +13,69 @@ GameMenu::GameMenu(client::Client* client) : GuiWidget(client), m_SummonMenu(std
}
void GameMenu::render() {
if(!m_Client->isConnected()) return;
void GameMenu::Render() {
if (!m_Client->IsConnected()) return;
if (getClient()->getGame().getGameState() == td::game::GameState::Lobby) {
if (GetClient()->GetGame().GetGameState() == td::game::GameState::Lobby) {
ImGui::Begin("Lobby");
showTPS();
showPlayers();
showLobbyProgress();
showTeamSelection();
ShowTPS();
ShowPlayers();
ShowLobbyProgress();
ShowTeamSelection();
ImGui::End();
}
if (getClient()->getGame().getGameState() == td::game::GameState::Game) {
if (GetClient()->GetGame().GetGameState() == td::game::GameState::Game) {
ImGui::Begin("Game");
showTPS();
showStats();
showPlayers();
ShowTPS();
ShowStats();
ShowPlayers();
ImGui::End();
m_SummonMenu->render();
m_SummonMenu->Render();
}
}
void GameMenu::showPlayers() {
if (ImGui::TreeNode(std::string("Players (" + std::to_string(getClient()->getGame().getPlayers().size()) + ")##player_list").c_str())) {
for (auto pair : getClient()->getGame().getPlayers()) {
void GameMenu::ShowPlayers() {
if (ImGui::TreeNode(std::string("Players (" + std::to_string(GetClient()->GetGame().GetPlayers().size()) + ")##player_list").c_str())) {
for (auto pair : GetClient()->GetGame().GetPlayers()) {
const td::game::Player& player = pair.second;
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::getImGuiTeamColor(player.getTeamColor()));
ImGui::Text("%s", player.getName().c_str());
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::GetImGuiTeamColor(player.GetTeamColor()));
ImGui::Text("%s", player.GetName().c_str());
ImGui::PopStyleColor();
}
ImGui::TreePop();
}
}
void GameMenu::showTeamSelection() {
if (getClient()->getGame().getPlayer() == nullptr)
void GameMenu::ShowTeamSelection() {
if (GetClient()->GetGame().GetPlayer() == nullptr)
return;
td::game::TeamColor playerTeam = getClient()->getGame().getPlayer()->getTeamColor();
td::game::TeamColor playerTeam = GetClient()->GetGame().GetPlayer()->GetTeamColor();
if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Red ? "Leave" : "Join") + std::string(" Red Team")).c_str())) {
if (playerTeam == td::game::TeamColor::Red)
getClient()->selectTeam(td::game::TeamColor::None);
GetClient()->SelectTeam(td::game::TeamColor::None);
else
getClient()->selectTeam(td::game::TeamColor::Red);
GetClient()->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 (playerTeam == td::game::TeamColor::Blue)
getClient()->selectTeam(td::game::TeamColor::None);
GetClient()->SelectTeam(td::game::TeamColor::None);
else
getClient()->selectTeam(td::game::TeamColor::Blue);
GetClient()->SelectTeam(td::game::TeamColor::Blue);
}
}
void GameMenu::showLobbyProgress() {
const int timePassed = server::Lobby::LobbyWaitingTime - getClient()->getGame().getLobbyTime();
void GameMenu::ShowLobbyProgress() {
const int timePassed = server::Lobby::LobbyWaitingTime - GetClient()->GetGame().GetLobbyTime();
const float progress = (float)timePassed / (float)(server::Lobby::LobbyWaitingTime);
if (progress > 0 && progress < 1) {
ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f), std::string(std::to_string(getClient()->getGame().getLobbyTime() / 1000) + "s").c_str());
ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f), std::string(std::to_string(GetClient()->GetGame().GetLobbyTime() / 1000) + "s").c_str());
ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
ImGui::Text("Time Remaining");
} else {
@@ -83,14 +83,14 @@ void GameMenu::showLobbyProgress() {
}
}
void GameMenu::showTPS() {
ImGui::Text("Server TPS : %.1f", getClient()->getConnexion().getServerTPS());
ImGui::Text("Server Ping : %i", getClient()->getConnexion().getServerPing());
void GameMenu::ShowTPS() {
ImGui::Text("Server TPS : %.1f", GetClient()->GetConnexion().GetServerTPS());
ImGui::Text("Server Ping : %i", GetClient()->GetConnexion().GetServerPing());
}
void GameMenu::showStats() {
ImGui::Text("Gold : %i", getClient()->getGame().getPlayer()->getGold());
ImGui::Text("EXP: %i", getClient()->getGame().getPlayer()->getExp());
void GameMenu::ShowStats() {
ImGui::Text("Gold : %i", GetClient()->GetGame().GetPlayer()->GetGold());
ImGui::Text("EXP: %i", GetClient()->GetGame().GetPlayer()->GetExp());
}
} // namespace gui

18
src/render/gui/MainMenu.cpp
View File

@@ -14,15 +14,15 @@ MainMenu::MainMenu(client::Client* client) : GuiWidget(client), m_ConnectPort(25
MainMenu::~MainMenu() {
if (m_Server != nullptr)
m_Server->stop();
m_Server->Stop();
}
void MainMenu::render() {
if (m_Server != nullptr && !m_Server->isRunning()) {
void MainMenu::Render() {
if (m_Server != nullptr && !m_Server->IsRunning()) {
m_Server.reset(0); // destroying server if it stoped
}
if(m_Client->isConnected()) return;
if (m_Client->IsConnected()) return;
ImGui::Begin("Main Menu");
if (ImGui::Button("Rejoindre une partie##join")) {
@@ -39,7 +39,7 @@ void MainMenu::render() {
ImGui::InputText("Server Adress", &m_ConnectAddress.front(), m_ConnectAddress.capacity());
ImGui::InputInt("Port", &m_ConnectPort, -1);
if (ImGui::Button("Rejoindre")) {
getClient()->connect(td::network::Dns::Resolve(m_ConnectAddress), m_ConnectPort);
GetClient()->Connect(td::network::Dns::Resolve(m_ConnectAddress), m_ConnectPort);
m_TriedToConnect = true;
}
if (m_TriedToConnect) {
@@ -61,10 +61,10 @@ void MainMenu::render() {
m_WorldFilePath = m_FileDialog.selected_path;
}
if (ImGui::Button("Créer")) {
if (!startServer()) {
if (!StartServer()) {
m_TriedToCreate = true;
} else {
getClient()->connect(td::network::Dns::Resolve("localhost"), m_ServerPort);
GetClient()->Connect(td::network::Dns::Resolve("localhost"), m_ServerPort);
}
}
if (m_TriedToCreate)
@@ -77,11 +77,11 @@ void MainMenu::render() {
ImGui::End();
}
bool MainMenu::startServer() {
bool MainMenu::StartServer() {
if (m_WorldFilePath.empty())
return false;
m_Server = std::make_unique<td::server::Server>(m_WorldFilePath);
if (!m_Server->start(m_ServerPort)) {
if (!m_Server->Start(m_ServerPort)) {
return false;
}
return true;

26
src/render/gui/MobTooltip.cpp
View File

@@ -14,29 +14,29 @@ MobTooltip::MobTooltip(client::Client* client) : GuiWidget(client) {
}
void MobTooltip::render() {
void MobTooltip::Render() {
if (m_Mob == nullptr) return;
// TODO: add sender null check
const game::Player* sender = getClient()->getGame().getPlayerById(m_Mob->getSender());
const game::Player* sender = GetClient()->GetGame().GetPlayerById(m_Mob->GetSender());
ImGui::BeginTooltip();
ImGui::Text("Sender :");
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::getImGuiTeamColor(sender->getTeamColor()));
ImGui::Text("%s", sender->getName().c_str());
ImGui::PushStyleColor(ImGuiCol_Text, render::WorldRenderer::GetImGuiTeamColor(sender->GetTeamColor()));
ImGui::Text("%s", sender->GetName().c_str());
ImGui::PopStyleColor();
ImGui::Text("Mob HP : %.1f/%i", m_Mob->getHealth(), m_Mob->getStats()->getMaxLife());
ImGui::Text("Mob Type : %s", game::MobFactory::getMobName(m_Mob->getType()).c_str());
ImGui::Text("Mob Level : %i", m_Mob->getLevel());
ImGui::Text("Mob HP : %.1f/%i", m_Mob->GetHealth(), m_Mob->GetStats()->GetMaxLife());
ImGui::Text("Mob Type : %s", game::MobFactory::GetMobName(m_Mob->GetType()).c_str());
ImGui::Text("Mob Level : %i", m_Mob->GetLevel());
ImGui::NewLine();
ImGui::Text("Mob Stats :");
ImGui::Text("\tMax health : %i", m_Mob->getStats()->getMaxLife());
ImGui::Text("\tSpeed : %.1f", m_Mob->getStats()->getMovementSpeed());
ImGui::Text("\tDamage : %.1f", m_Mob->getStats()->getDamage());
ImGui::Text("\tMoney cost : %i", m_Mob->getStats()->getMoneyCost());
ImGui::Text("\tEXP cost : %i", m_Mob->getStats()->getExpCost());
ImGui::Text("\tEXP reward : %i", m_Mob->getStats()->getExpReward());
ImGui::Text("\tMax health : %i", m_Mob->GetStats()->GetMaxLife());
ImGui::Text("\tSpeed : %.1f", m_Mob->GetStats()->GetMovementSpeed());
ImGui::Text("\tDamage : %.1f", m_Mob->GetStats()->GetDamage());
ImGui::Text("\tMoney cost : %i", m_Mob->GetStats()->GetMoneyCost());
ImGui::Text("\tEXP cost : %i", m_Mob->GetStats()->GetExpCost());
ImGui::Text("\tEXP reward : %i", m_Mob->GetStats()->GetExpReward());
ImGui::EndTooltip();
}

10
src/render/gui/SummonMenu.cpp
View File

@@ -9,7 +9,7 @@ SummonMenu::SummonMenu(client::Client* client) : GuiWidget(client), m_MenuOpened
m_Values.fill(0);
}
void SummonMenu::render() {
void SummonMenu::Render() {
if (m_MenuOpened) {
ImGui::Begin("Summon", &m_MenuOpened);
ImTextureID my_tex_id = ImGui::GetIO().Fonts->TexID;
@@ -25,7 +25,7 @@ void SummonMenu::render() {
ImGui::SameLine();
ImGui::PushID(i);
if (ImGui::InputInt("", m_Values.data() + i, 1, 10)) {
setSummonMax(i);
SetSummonMax(i);
}
ImGui::PopID();
}
@@ -43,7 +43,7 @@ void SummonMenu::render() {
ImGui::SameLine();
ImGui::PushID(i);
if (ImGui::InputInt("", m_Values.data() + i, 1, m_MobTypeCount)) {
setSummonMax(i);
SetSummonMax(i);
}
ImGui::PopID();
}
@@ -59,14 +59,14 @@ void SummonMenu::render() {
mobSent.push_back(mobSend);
}
}
m_Client->sendMobs(mobSent);
m_Client->SendMobs(mobSent);
m_Values.fill(0);
}
ImGui::End();
}
}
void SummonMenu::setSummonMax(int valueIndex) {
void SummonMenu::SetSummonMax(int valueIndex) {
int& value = m_Values[valueIndex];
value = std::max(0, value);
value = std::min(12, value);

40
src/render/gui/TowerGui.cpp
View File

@@ -21,11 +21,11 @@
namespace td {
namespace render {
void TowerGui::initWidgets() {
m_GuiManager.addWidget(std::make_unique<td::gui::MainMenu>(m_Client.get()));
m_GuiManager.addWidget(std::make_unique<td::gui::GameMenu>(m_Client.get()));
m_GuiManager.addWidget(std::make_unique<td::gui::FrameMenu>(m_Client.get()));
m_GuiManager.addWidget(std::make_unique<td::gui::UpdateMenu>(m_Client.get()));
void TowerGui::InitWidgets() {
m_GuiManager.AddWidget(std::make_unique<td::gui::MainMenu>(m_Client.get()));
m_GuiManager.AddWidget(std::make_unique<td::gui::GameMenu>(m_Client.get()));
m_GuiManager.AddWidget(std::make_unique<td::gui::FrameMenu>(m_Client.get()));
m_GuiManager.AddWidget(std::make_unique<td::gui::UpdateMenu>(m_Client.get()));
}
TowerGui::TowerGui(SDL_Window* sdl_window, SDL_GLContext glContext, td::render::Renderer* renderer) : m_Window(sdl_window),
@@ -38,45 +38,45 @@ m_GlContext(glContext), m_Renderer(renderer), m_Client(std::make_unique<client::
ImFontConfig c;
c.SizePixels = 25;
ImGui::GetIO().Fonts->AddFontDefault(&c);
initWidgets();
InitWidgets();
}
void TowerGui::beginFrame() {
void TowerGui::BeginFrame() {
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplSDL2_NewFrame();
ImGui::NewFrame();
}
void TowerGui::endFrame() {
void TowerGui::EndFrame() {
ImGui::EndFrame();
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
}
void TowerGui::tick() {
static std::uint64_t lastTime = td::utils::getTime();
std::uint64_t time = td::utils::getTime();
void TowerGui::Tick() {
static std::uint64_t lastTime = td::utils::GetTime();
std::uint64_t time = td::utils::GetTime();
std::uint64_t delta = time - lastTime;
m_Client->tick(delta);
m_Client->Tick(delta);
lastTime = td::utils::getTime();
lastTime = td::utils::GetTime();
}
void TowerGui::render() {
tick();
beginFrame();
void TowerGui::Render() {
Tick();
BeginFrame();
m_Client->render();
m_Client->Render();
m_GuiManager.renderWidgets();
m_GuiManager.RenderWidgets();
endFrame();
EndFrame();
}
TowerGui::~TowerGui() {
m_Client->closeConnection();
m_Client->CloseConnection();
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();

16
src/render/gui/TowerPlacePopup.cpp
View File

@@ -13,21 +13,21 @@ TowerPlacePopup::TowerPlacePopup(client::Client* client) : GuiWidget(client) {
}
void TowerPlacePopup::render() {
void TowerPlacePopup::Render() {
if (ImGui::BeginPopup("TowerPlace")) {
ImGui::BeginChild("TowerPlacePopupChild", ImVec2(800, m_TowerPopupTileHeight + 20), false, ImGuiWindowFlags_HorizontalScrollbar);
for (int i = 0; i < (int)game::TowerType::TowerCount; i++) {
if (i > 0) ImGui::SameLine();
game::TowerType towerType = game::TowerType(i);
const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
const game::TowerInfo& towerInfo = game::GetTowerInfo(towerType);
if (!towerInfo.isBigTower() || (towerInfo.isBigTower() &&
getClient()->getGame().getWorld().CanPlaceBigTower(m_ClickWorldPos, getClient()->getGame().getPlayer()->getID()))) {
if (!towerInfo.IsBigTower() || (towerInfo.IsBigTower() &&
GetClient()->GetGame().GetWorld().CanPlaceBigTower(m_ClickWorldPos, GetClient()->GetGame().GetPlayer()->GetID()))) {
ImGui::BeginChild(std::to_string(i).c_str(), ImVec2(m_TowerPopupTileWidth, m_TowerPopupTileHeight), true);
ImGui::Text(towerInfo.getName().c_str());
ImGui::Text(towerInfo.GetName().c_str());
ImGui::SameLine();
ImGui::SetCursorPosX(m_TowerPopupTileWidth - 10 - ImGui::CalcTextSize("(?)").x);
@@ -35,7 +35,7 @@ void TowerPlacePopup::render() {
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::Text(towerInfo.getDescription().c_str());
ImGui::Text(towerInfo.GetDescription().c_str());
ImGui::EndTooltip();
}
@@ -45,7 +45,7 @@ void TowerPlacePopup::render() {
ImGui::SetCursorPosX(m_TowerPopupTileWidth / 2.0f - m_PlaceTowerButtonWidth / 2.0f);
if (ImGui::Button(buyText.c_str(), ImVec2(m_PlaceTowerButtonWidth, m_PlaceTowerButtonHeight))) {
getClient()->placeTower(towerType, m_ClickWorldPos);
GetClient()->PlaceTower(towerType, m_ClickWorldPos);
ImGui::CloseCurrentPopup();
}
@@ -57,7 +57,7 @@ void TowerPlacePopup::render() {
}
}
void TowerPlacePopup::setClickPos(const glm::vec2& worldPos) {
void TowerPlacePopup::SetClickPos(const glm::vec2& worldPos) {
m_ClickWorldPos = worldPos;
}

44
src/render/gui/UpdateMenu.cpp
View File

@@ -8,52 +8,52 @@ namespace td {
namespace gui {
UpdateMenu::UpdateMenu(client::Client* client) : GuiWidget(client), m_Opened(true) {
checkUpdates();
CheckUpdates();
}
void UpdateMenu::render() {
renderErrorPopup();
void UpdateMenu::Render() {
RenderErrorPopup();
if (m_Opened) {
ImGui::Begin("Updater", &m_Opened);
if (isUpdateChecked()) {
if (IsUpdateChecked()) {
bool updateAvailable = m_UpdateAvailable.get();
if (updateAvailable) {
if (m_Updater.isFileWrited()) {
if (m_Updater.IsFileWrited()) {
ImGui::Text("The update is now installed");
ImGui::Text("The game needs to be restarted");
} else if (m_Updater.isDownloadComplete()) {
} else if (m_Updater.IsDownloadComplete()) {
ImGui::Text("Download done!");
if (ImGui::Button("Install")) {
if (!m_Updater.writeFile()) {
if (!m_Updater.WriteFile()) {
m_Error = "Failed to write file !\n";
ImGui::OpenPopup("UpdateError");
}
}
if (ImGui::Button("Cancel")) {
m_Updater.cancelDownload();
m_Updater.clearCache();
m_Updater.CancelDownload();
m_Updater.ClearCache();
}
} else {
if (m_Updater.getDownloadProgress() > 0) {
if (m_Updater.GetDownloadProgress() > 0) {
ImGui::Text("Downloading ...");
ImGui::ProgressBar(m_Updater.getDownloadProgress());
ImGui::ProgressBar(m_Updater.GetDownloadProgress());
if (ImGui::Button("Cancel")) {
m_Updater.cancelDownload();
m_Updater.CancelDownload();
}
} else {
ImGui::Text("An update is available!");
ImGui::Separator();
ImGui::Text("Current version : %s", m_Updater.getCurrentVersion().c_str());
ImGui::Text("Last version : %s", m_Updater.getLastVersion().c_str());
ImGui::Text("Current version : %s", m_Updater.GetCurrentVersion().c_str());
ImGui::Text("Last version : %s", m_Updater.GetLastVersion().c_str());
bool canDownloadFile = m_Updater.canUpdate();
bool canDownloadFile = m_Updater.CanUpdate();
if (!canDownloadFile) ImGui::BeginDisabled();
if (ImGui::Button("Download")) {
m_Updater.downloadUpdate();
m_Updater.DownloadUpdate();
}
if (!canDownloadFile) ImGui::EndDisabled();
@@ -67,8 +67,8 @@ void UpdateMenu::render() {
} else {
ImGui::Text("No update available!");
ImGui::Separator();
ImGui::Text("Current version : %s", m_Updater.getCurrentVersion().c_str());
ImGui::Text("Last version : %s", m_Updater.getLastVersion().c_str());
ImGui::Text("Current version : %s", m_Updater.GetCurrentVersion().c_str());
ImGui::Text("Last version : %s", m_Updater.GetLastVersion().c_str());
}
} else {
ImGui::Text("Checking updates ...");
@@ -77,19 +77,19 @@ void UpdateMenu::render() {
}
}
void UpdateMenu::renderErrorPopup() {
void UpdateMenu::RenderErrorPopup() {
if (ImGui::BeginPopup("UpdateError")) {
ImGui::Text("Error : %s", m_Error.c_str());
ImGui::EndPopup();
}
}
bool UpdateMenu::isUpdateChecked() {
bool UpdateMenu::IsUpdateChecked() {
return m_UpdateAvailable.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
}
void UpdateMenu::checkUpdates() {
m_UpdateAvailable = std::async(std::launch::async, [&]() { return m_Updater.checkUpdate();});
void UpdateMenu::CheckUpdates() {
m_UpdateAvailable = std::async(std::launch::async, [&]() { return m_Updater.CheckUpdate();});
}
} // namespace gui

22
src/render/loader/GLLoader.cpp
View File

@@ -20,17 +20,17 @@ VertexArray::VertexArray(unsigned int vertexCount) : m_VertexCount(vertexCount)
glGenVertexArrays(1, &m_ID);
}
void VertexArray::bind() const {
void VertexArray::Bind() const {
glBindVertexArray(m_ID);
}
void VertexArray::unbind() const {
void VertexArray::Unbind() const {
glBindVertexArray(0);
}
void VertexArray::bindVertexBuffer(VertexBuffer& VertexBuffer) {
VertexBuffer.bind();
VertexBuffer.bindVertexAttribs();
void VertexArray::BindVertexBuffer(VertexBuffer& VertexBuffer) {
VertexBuffer.Bind();
VertexBuffer.BindVertexAttribs();
m_VertexBuffers.push_back(std::move(VertexBuffer));
}
@@ -41,21 +41,21 @@ VertexBuffer::~VertexBuffer() {
VertexBuffer::VertexBuffer(const std::vector<float>& data, unsigned int stride) : m_DataStride(stride) {
glGenBuffers(1, &m_ID);
bind();
Bind();
glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(data.size() * sizeof(float)), nullptr, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(data.size() * sizeof(float)), data.data());
unbind();
Unbind();
}
void VertexBuffer::bind() const {
void VertexBuffer::Bind() const {
glBindBuffer(GL_ARRAY_BUFFER, m_ID);
}
void VertexBuffer::unbind() const {
void VertexBuffer::Unbind() const {
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void VertexBuffer::addVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset) {
void VertexBuffer::AddVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset) {
VertexAttribPointer pointer;
pointer.m_Index = index;
pointer.m_Size = coordinateSize;
@@ -63,7 +63,7 @@ void VertexBuffer::addVertexAttribPointer(unsigned int index, unsigned int coord
m_VertexAttribs.push_back(pointer);
}
void VertexBuffer::bindVertexAttribs() const {
void VertexBuffer::BindVertexAttribs() const {
for (const VertexAttribPointer& pointer : m_VertexAttribs) {
glEnableVertexAttribArray(pointer.m_Index);
glVertexAttribPointer(pointer.m_Index, static_cast<GLint>(pointer.m_Size), GL_FLOAT, false, m_DataStride * sizeof(float), reinterpret_cast<void*>(pointer.m_Offset));

2
src/render/loader/TextureLoader.cpp
View File

@@ -13,7 +13,7 @@
namespace TextureLoader {
unsigned int loadGLTexture(const char* fileName) {
unsigned int LoadGLTexture(const char* fileName) {
int width, height, comp;

96
src/render/loader/WorldLoader.cpp
View File

@@ -10,7 +10,7 @@ namespace render {
namespace WorldLoader {
GL::VertexArray loadMobModel() {
GL::VertexArray LoadMobModel() {
std::vector<float> positions = {
-0.5, -0.5,
0.5, -0.5,
@@ -36,23 +36,23 @@ GL::VertexArray loadMobModel() {
};
GL::VertexBuffer positionVBO(positions, 2);
positionVBO.addVertexAttribPointer(0, 2, 0);
positionVBO.AddVertexAttribPointer(0, 2, 0);
GL::VertexBuffer colorVBO(colors, 1);
colorVBO.addVertexAttribPointer(1, 1, 0);
colorVBO.AddVertexAttribPointer(1, 1, 0);
GL::VertexArray mobVao(colors.size()); // each pos = 1 color
mobVao.bind();
mobVao.bindVertexBuffer(positionVBO);
mobVao.bindVertexBuffer(colorVBO);
mobVao.unbind();
mobVao.Bind();
mobVao.BindVertexBuffer(positionVBO);
mobVao.BindVertexBuffer(colorVBO);
mobVao.Unbind();
return mobVao;
}
GL::VertexArray loadWorldModel(const td::game::World* world) {
GL::VertexArray LoadWorldModel(const td::game::World* world) {
std::vector<float> positions;
std::vector<float> 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;
@@ -62,8 +62,8 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
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);
td::game::TileIndex tileIndex = chunk->GetTileIndex(tileNumber);
td::game::TilePtr tile = world->GetTilePtr(tileIndex);
if (tile == nullptr)
continue;
@@ -78,7 +78,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
(float)chunkX + tileX + 1, (float)chunkY + tileY + 1,
});
const td::game::Color* tileColor = world->getTileColor(tile);
const td::game::Color* tileColor = world->GetTileColor(tile);
for (int i = 0; i < 6; i++) {
int color = 255;
@@ -96,9 +96,9 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
}
for (int spawnColor = 0; spawnColor < 2; spawnColor++) {
const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn();
float fromX = spawn.getTopLeft().getX(), toX = spawn.getBottomRight().getX();
float fromY = spawn.getTopLeft().getY(), toY = spawn.getBottomRight().getY();
const game::Spawn& spawn = world->GetTeam(game::TeamColor(spawnColor)).GetSpawn();
float fromX = spawn.GetTopLeft().GetX(), toX = spawn.GetBottomRight().GetX();
float fromY = spawn.GetTopLeft().GetY(), toY = spawn.GetBottomRight().GetY();
positions.insert(positions.end(), {
fromX, fromY,
@@ -112,9 +112,9 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
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;
color |= world->getSpawnColor(game::TeamColor(spawnColor)).b << 8;
color |= world->GetSpawnColor(game::TeamColor(spawnColor)).r << 24;
color |= world->GetSpawnColor(game::TeamColor(spawnColor)).g << 16;
color |= world->GetSpawnColor(game::TeamColor(spawnColor)).b << 8;
int newColorIndex = colors.size();
colors.push_back(0);
@@ -124,9 +124,9 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
}
for (int castleColor = 0; castleColor < 2; castleColor++) {
const game::TeamCastle& castle = world->getTeam(game::TeamColor(castleColor)).getCastle();
float fromX = castle.getTopLeft().getX(), toX = castle.getBottomRight().getX();
float fromY = castle.getTopLeft().getY(), toY = castle.getBottomRight().getY();
const game::TeamCastle& castle = world->GetTeam(game::TeamColor(castleColor)).GetCastle();
float fromX = castle.GetTopLeft().GetX(), toX = castle.GetBottomRight().GetX();
float fromY = castle.GetTopLeft().GetY(), toY = castle.GetBottomRight().GetY();
positions.insert(positions.end(), {
fromX, fromY,
@@ -140,9 +140,9 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
for (int i = 0; i < 6; i++) {
int color = 255;
color |= world->getSpawnColor(game::TeamColor(castleColor)).r << 24;
color |= world->getSpawnColor(game::TeamColor(castleColor)).g << 16;
color |= world->getSpawnColor(game::TeamColor(castleColor)).b << 8;
color |= world->GetSpawnColor(game::TeamColor(castleColor)).r << 24;
color |= world->GetSpawnColor(game::TeamColor(castleColor)).g << 16;
color |= world->GetSpawnColor(game::TeamColor(castleColor)).b << 8;
int newColorIndex = colors.size();
colors.push_back(0);
@@ -152,19 +152,19 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
}
GL::VertexBuffer positionVBO(positions, 2);
positionVBO.addVertexAttribPointer(0, 2, 0);
positionVBO.AddVertexAttribPointer(0, 2, 0);
GL::VertexBuffer colorVBO(colors, 1);
colorVBO.addVertexAttribPointer(1, 1, 0);
colorVBO.AddVertexAttribPointer(1, 1, 0);
GL::VertexArray worldVao(positions.size() / 2); // each pos = 2 vertecies
worldVao.bind();
worldVao.bindVertexBuffer(positionVBO);
worldVao.bindVertexBuffer(colorVBO);
worldVao.unbind();
worldVao.Bind();
worldVao.BindVertexBuffer(positionVBO);
worldVao.BindVertexBuffer(colorVBO);
worldVao.Unbind();
return worldVao;
}
GL::VertexArray loadTileSelectModel() {
GL::VertexArray LoadTileSelectModel() {
std::vector<float> positions = {
0, 0,
1, 0,
@@ -183,37 +183,37 @@ GL::VertexArray loadTileSelectModel() {
std::vector<float> colors(6, colorFloat);
GL::VertexBuffer positionVBO(positions, 2);
positionVBO.addVertexAttribPointer(0, 2, 0);
positionVBO.AddVertexAttribPointer(0, 2, 0);
GL::VertexBuffer colorVBO(colors, 1);
colorVBO.addVertexAttribPointer(1, 1, 0);
colorVBO.AddVertexAttribPointer(1, 1, 0);
GL::VertexArray tileSelectVao(positions.size() / 2); // each pos = 2 vertecies
tileSelectVao.bind();
tileSelectVao.bindVertexBuffer(positionVBO);
tileSelectVao.bindVertexBuffer(colorVBO);
tileSelectVao.unbind();
tileSelectVao.Bind();
tileSelectVao.BindVertexBuffer(positionVBO);
tileSelectVao.BindVertexBuffer(colorVBO);
tileSelectVao.Unbind();
return tileSelectVao;
}
RenderData loadTowerModel(game::TowerPtr tower) {
RenderData LoadTowerModel(game::TowerPtr tower) {
RenderData renderData;
float towerX, towerDX;
float towerY, towerDY;
if (tower->getSize() == game::TowerSize::Little) {
towerX = tower->getCenterX() - 1.5f;
towerDX = tower->getCenterX() + 1.5f;
if (tower->GetSize() == game::TowerSize::Little) {
towerX = tower->GetCenterX() - 1.5f;
towerDX = tower->GetCenterX() + 1.5f;
towerY = tower->getCenterY() - 1.5f;
towerDY = tower->getCenterY() + 1.5f;
towerY = tower->GetCenterY() - 1.5f;
towerDY = tower->GetCenterY() + 1.5f;
} else {
towerX = tower->getCenterX() - 2.5f;
towerDX = tower->getCenterX() + 2.5f;
towerX = tower->GetCenterX() - 2.5f;
towerDX = tower->GetCenterX() + 2.5f;
towerY = tower->getCenterY() - 2.5f;
towerDY = tower->getCenterY() + 2.5f;
towerY = tower->GetCenterY() - 2.5f;
towerDY = tower->GetCenterY() + 2.5f;
}
std::vector<float> positions = {
towerX, towerY,
@@ -227,7 +227,7 @@ RenderData loadTowerModel(game::TowerPtr tower) {
renderData.positions = positions;
std::uint8_t towerType = static_cast<std::uint8_t>(tower->getType());
std::uint8_t towerType = static_cast<std::uint8_t>(tower->GetType());
std::uint8_t r = 10 * towerType + 40, g = 5 * towerType + 30, b = 10 * towerType + 20;
float colorFloat;

43
src/render/shaders/EntityShader.cpp
View File

@@ -1,5 +1,8 @@
#include "render/shaders/EntityShader.h"
namespace td {
namespace shader {
#ifdef __ANDROID__
static const char vertexSource[] =
R"(#version 300 es
@@ -92,30 +95,34 @@ void main(void){
EntityShader::EntityShader() : ShaderProgram() {}
void EntityShader::loadShader() {
ShaderProgram::loadProgram(vertexSource, fragmentSource);
void EntityShader::LoadShader() {
ShaderProgram::LoadProgram(vertexSource, fragmentSource);
}
void EntityShader::getAllUniformLocation() {
location_aspect_ratio = static_cast<unsigned int>(getUniformLocation("aspectRatio"));
location_zoom = static_cast<unsigned int>(getUniformLocation("zoom"));
location_cam = static_cast<unsigned int>(getUniformLocation("camPos"));
location_translation = static_cast<unsigned int>(getUniformLocation("translation"));
location_viewtype = static_cast<unsigned int>(getUniformLocation("isometricView"));
void EntityShader::GetAllUniformLocation() {
m_LocationAspectRatio = static_cast<unsigned int>(GetUniformLocation("aspectRatio"));
m_LocationZoom = static_cast<unsigned int>(GetUniformLocation("zoom"));
m_LocationCam = static_cast<unsigned int>(GetUniformLocation("camPos"));
m_LocationTranslation = static_cast<unsigned int>(GetUniformLocation("translation"));
m_LocationViewtype = static_cast<unsigned int>(GetUniformLocation("isometricView"));
}
void EntityShader::setCamPos(const glm::vec2& camPos) {
loadVector(location_cam, camPos);
void EntityShader::SetCamPos(const glm::vec2& camPos) {
LoadVector(m_LocationCam, camPos);
}
void EntityShader::setZoom(float zoom) {
loadFloat(location_zoom, zoom);
void EntityShader::SetZoom(float zoom) {
LoadFloat(m_LocationZoom, zoom);
}
void EntityShader::setAspectRatio(float aspectRatio) {
loadFloat(location_aspect_ratio, aspectRatio);
void EntityShader::SetAspectRatio(float aspectRatio) {
LoadFloat(m_LocationAspectRatio, aspectRatio);
}
void EntityShader::setModelPos(const glm::vec2& modelPos) {
loadVector(location_translation, modelPos);
void EntityShader::SetModelPos(const glm::vec2& modelPos) {
LoadVector(m_LocationTranslation, modelPos);
}
void EntityShader::setIsometricView(float isometric) {
loadFloat(location_viewtype, isometric);
void EntityShader::SetIsometricView(float isometric) {
LoadFloat(m_LocationViewtype, isometric);
}
} // namespace shader
} // namespace td

56
src/render/shaders/ShaderProgram.cpp
View File

@@ -17,23 +17,26 @@
#include <android/log.h>
#endif
namespace td {
namespace shader {
ShaderProgram::ShaderProgram() :
m_ProgramID(0), m_VertexShaderID(0), m_FragmentShaderID(0) {
}
ShaderProgram::~ShaderProgram() {
cleanUp();
CleanUp();
}
void ShaderProgram::start() const {
void ShaderProgram::Start() const {
glUseProgram(m_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(m_ProgramID, uniformName.c_str());
if (location == -1) {
std::cout << "Warning ! Uniform variable " << uniformName << " not found !\n";
@@ -41,39 +44,39 @@ int ShaderProgram::getUniformLocation(const std::string& uniformName) const {
return location;
}
void ShaderProgram::loadFloat(unsigned int location, float value) const {
void ShaderProgram::LoadFloat(unsigned int location, float value) const {
glUniform1f(static_cast<GLint>(location), value);
}
void ShaderProgram::loadInt(unsigned int location, int value) const {
void ShaderProgram::LoadInt(unsigned int location, int value) const {
glUniform1i(static_cast<GLint>(location), value);
}
void ShaderProgram::loadVector(unsigned int location,
void ShaderProgram::LoadVector(unsigned int location,
const glm::vec2& vector) const {
glUniform2f(static_cast<GLint>(location), vector.x, vector.y);
}
void ShaderProgram::loadVector(unsigned int location,
void ShaderProgram::LoadVector(unsigned int location,
const glm::vec3& vector) const {
glUniform3f(static_cast<GLint>(location), vector.x, vector.y, vector.z);
}
void ShaderProgram::loadVector(unsigned int location,
void ShaderProgram::LoadVector(unsigned int location,
const glm::vec4& vector) const {
glUniform4f(static_cast<GLint>(location), vector.x, vector.y, vector.z, vector.w);
}
void ShaderProgram::loadBoolean(unsigned int location, bool value) const {
void ShaderProgram::LoadBoolean(unsigned int location, bool value) const {
glUniform1i(static_cast<GLint>(location), value);
}
void ShaderProgram::loadMatrix(unsigned int location, const glm::mat4& matrix) const {
void ShaderProgram::LoadMatrix(unsigned int location, const glm::mat4& matrix) const {
glUniformMatrix4fv(static_cast<GLint>(location), 1, false, glm::value_ptr(matrix));
}
void ShaderProgram::cleanUp() const {
stop();
void ShaderProgram::CleanUp() const {
Stop();
glDetachShader(m_ProgramID, m_VertexShaderID);
glDetachShader(m_ProgramID, m_FragmentShaderID);
glDeleteShader(m_VertexShaderID);
@@ -81,31 +84,31 @@ void ShaderProgram::cleanUp() const {
glDeleteProgram(m_ProgramID);
}
void ShaderProgram::loadProgramFile(const std::string& vertexFile,
void ShaderProgram::LoadProgramFile(const std::string& vertexFile,
const std::string& fragmentFile) {
m_VertexShaderID = static_cast<unsigned int>(loadShaderFromFile(vertexFile, GL_VERTEX_SHADER));
m_FragmentShaderID = static_cast<unsigned int>(loadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER));
m_VertexShaderID = static_cast<unsigned int>(LoadShaderFromFile(vertexFile, GL_VERTEX_SHADER));
m_FragmentShaderID = static_cast<unsigned int>(LoadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER));
m_ProgramID = glCreateProgram();
glAttachShader(m_ProgramID, m_VertexShaderID);
glAttachShader(m_ProgramID, m_FragmentShaderID);
glLinkProgram(m_ProgramID);
glValidateProgram(m_ProgramID);
getAllUniformLocation();
GetAllUniformLocation();
}
void ShaderProgram::loadProgram(const std::string& vertexSource,
void ShaderProgram::LoadProgram(const std::string& vertexSource,
const std::string& fragmentSource) {
m_VertexShaderID = static_cast<unsigned int>(loadShader(vertexSource, GL_VERTEX_SHADER));
m_FragmentShaderID = static_cast<unsigned int>(loadShader(fragmentSource, GL_FRAGMENT_SHADER));
m_VertexShaderID = static_cast<unsigned int>(LoadShader(vertexSource, GL_VERTEX_SHADER));
m_FragmentShaderID = static_cast<unsigned int>(LoadShader(fragmentSource, GL_FRAGMENT_SHADER));
m_ProgramID = glCreateProgram();
glAttachShader(m_ProgramID, m_VertexShaderID);
glAttachShader(m_ProgramID, m_FragmentShaderID);
glLinkProgram(m_ProgramID);
glValidateProgram(m_ProgramID);
getAllUniformLocation();
GetAllUniformLocation();
}
unsigned int ShaderProgram::loadShader(const std::string& source, GLenum type) {
unsigned int ShaderProgram::LoadShader(const std::string& source, GLenum type) {
unsigned int shaderID = glCreateShader(type);
const char* c_str = source.c_str();
@@ -128,15 +131,18 @@ unsigned int ShaderProgram::loadShader(const std::string& source, GLenum type) {
return shaderID;
}
unsigned int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type) {
unsigned int ShaderProgram::LoadShaderFromFile(const std::string& file, GLenum type) {
std::stringstream stream;
std::ifstream fileStream(file);
if(fileStream) {
if (fileStream) {
stream << fileStream.rdbuf();
} else {
return 0;
}
return loadShader(stream.str(), type);
return LoadShader(stream.str(), type);
}
} // namespace shader
} // namespace td

43
src/render/shaders/WorldShader.cpp
View File

@@ -1,12 +1,8 @@
/*
* WorldShader.cpp
*
* Created on: 4 nov. 2020
* Author: simon
*/
#include "render/shaders/WorldShader.h"
namespace td {
namespace shader {
#ifdef __ANDROID__
static const char vertexSource[] =
R"(#version 300 es
@@ -93,26 +89,29 @@ void main(void){
WorldShader::WorldShader() : ShaderProgram() {}
void WorldShader::loadShader() {
ShaderProgram::loadProgram(vertexSource, fragmentSource);
void WorldShader::LoadShader() {
ShaderProgram::LoadProgram(vertexSource, fragmentSource);
}
void WorldShader::getAllUniformLocation() {
location_aspect_ratio = static_cast<unsigned int>(getUniformLocation("aspectRatio"));
location_zoom = static_cast<unsigned int>(getUniformLocation("zoom"));
location_cam = static_cast<unsigned int>(getUniformLocation("camPos"));
location_viewtype = static_cast<unsigned int>(getUniformLocation("isometricView"));
void WorldShader::GetAllUniformLocation() {
m_LocationAspectRatio = static_cast<unsigned int>(GetUniformLocation("aspectRatio"));
m_LocationZoom = static_cast<unsigned int>(GetUniformLocation("zoom"));
m_LocationCam = static_cast<unsigned int>(GetUniformLocation("camPos"));
m_LocationViewtype = static_cast<unsigned int>(GetUniformLocation("isometricView"));
}
void WorldShader::setCamPos(const glm::vec2& camPos) {
loadVector(location_cam, camPos);
void WorldShader::SetCamPos(const glm::vec2& camPos) {
LoadVector(m_LocationCam, camPos);
}
void WorldShader::setZoom(float zoom) {
loadFloat(location_zoom, zoom);
void WorldShader::SetZoom(float zoom) {
LoadFloat(m_LocationZoom, zoom);
}
void WorldShader::setAspectRatio(float aspectRatio) {
loadFloat(location_aspect_ratio, aspectRatio);
void WorldShader::SetAspectRatio(float aspectRatio) {
LoadFloat(m_LocationAspectRatio, aspectRatio);
}
void WorldShader::setIsometricView(float isometric) {
loadFloat(location_viewtype, isometric);
void WorldShader::SetIsometricView(float isometric) {
LoadFloat(m_LocationViewtype, isometric);
}
} // namespace shader
} // namespace td

36
src/updater/Updater.cpp
View File

@@ -13,18 +13,18 @@
namespace td {
namespace utils {
bool Updater::checkUpdate() {
bool Updater::CheckUpdate() {
httplib::Client client("thesims.freeboxos.fr", 30000);
if (auto res = client.Get("/Tower%20Defense/version")) {
std::string currentVersion = getCurrentVersion();
std::string currentVersion = GetCurrentVersion();
m_LastVersion = res.value().body;
// we only look at the first line
m_LastVersion = m_LastVersion.substr(0, m_LastVersion.find('\n'));
std::cout << "Current version : [" << getCurrentVersion() << "]\n";
std::cout << "Current version : [" << GetCurrentVersion() << "]\n";
std::cout << "Last version : [" << m_LastVersion << "]\n";
if (currentVersion != m_LastVersion) {
@@ -39,13 +39,13 @@ bool Updater::checkUpdate() {
return false;
}
bool Updater::canUpdate() {
return !getDownloadFileURL().empty();
bool Updater::CanUpdate() {
return !GetDownloadFileURL().empty();
}
std::string Updater::getDownloadFileURL() {
Os systemOs = getSystemOs();
Architecture systemArch = getSystemArchitecture();
std::string Updater::GetDownloadFileURL() {
Os systemOs = GetSystemOs();
Architecture systemArch = GetSystemArchitecture();
switch (systemOs) {
@@ -67,7 +67,7 @@ std::string Updater::getDownloadFileURL() {
}
}
std::string Updater::getLocalFilePath() {
std::string Updater::GetLocalFilePath() {
#ifdef _WIN32
char filePathBuffer[1024];
GetModuleFileName(nullptr, filePathBuffer, sizeof(filePathBuffer));
@@ -78,12 +78,12 @@ std::string Updater::getLocalFilePath() {
return "";
}
void Updater::downloadUpdate() {
void Updater::DownloadUpdate() {
if (m_DownloadComplete) return;
m_CancelDownload = false;
std::string newFileUrl = getDownloadFileURL();
std::string newFileUrl = GetDownloadFileURL();
httplib::Client client("thesims.freeboxos.fr", 30000);
@@ -105,25 +105,25 @@ void Updater::downloadUpdate() {
}
}
void Updater::removeOldFile() {
std::remove(std::string(getLocalFilePath() + "_old").c_str());
void Updater::RemoveOldFile() {
std::remove(std::string(GetLocalFilePath() + "_old").c_str());
}
bool Updater::writeFile() {
bool Updater::WriteFile() {
if (m_FileWrited || !m_DownloadComplete) return false;
if (!m_FileBuffer.WriteFile(getLocalFilePath() + "_recent"))
if (!m_FileBuffer.WriteFile(GetLocalFilePath() + "_recent"))
return false;
#ifdef _WIN32
std::rename(getLocalFilePath().c_str(), std::string(getLocalFilePath() + "_old").c_str());
std::rename(std::string(getLocalFilePath() + "_recent").c_str(), getLocalFilePath().c_str());
std::rename(GetLocalFilePath().c_str(), std::string(GetLocalFilePath() + "_old").c_str());
std::rename(std::string(GetLocalFilePath() + "_recent").c_str(), GetLocalFilePath().c_str());
#endif
m_FileWrited = true;
m_DownloadComplete = false;
clearCache();
ClearCache();
return true;
}

34
src/window/Display.cpp
View File

@@ -35,14 +35,14 @@ static float aspectRatio;
static bool shouldClose = false;
void windowResizeEvent(int width, int height) {
void WindowResizeEvent(int width, int height) {
aspectRatio = (float)width / height;
renderer->resize(width, height);
renderer->Resize(width, height);
lastWidth = width;
lastHeight = height;
}
bool create() {
bool Create() {
window = SDL_CreateWindow(WindowName, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WindowWidth, WindowHeight, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
// Prepare and create context
#ifdef __ANDROID__
@@ -99,24 +99,24 @@ bool create() {
SDL_GL_MakeCurrent(window, glContext);
if (!renderer->init()) {
if (!renderer->Init()) {
exit(1);
}
towerGui = std::make_unique<td::render::TowerGui>(window, glContext, renderer.get());
windowResizeEvent(WindowWidth, WindowHeight);
WindowResizeEvent(WindowWidth, WindowHeight);
return true;
}
void render() {
renderer->prepare();
towerGui->render();
void Render() {
renderer->Prepare();
towerGui->Render();
}
void update() {
void Update() {
SDL_GL_SwapWindow(window);
}
void destroy() {
void Destroy() {
renderer.reset(0);
towerGui.reset(0);
SDL_GL_DeleteContext(glContext);
@@ -125,7 +125,7 @@ void destroy() {
window = NULL;
}
void pollEvents() {
void PollEvents() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_WINDOWEVENT) {
@@ -137,7 +137,7 @@ void pollEvents() {
case SDL_WINDOWEVENT_RESIZED: {
int windowWidth, windowHeight;
SDL_GetWindowSize(window, &windowWidth, &windowHeight);
windowResizeEvent(windowWidth, windowHeight);
WindowResizeEvent(windowWidth, windowHeight);
}
default:
@@ -148,22 +148,22 @@ void pollEvents() {
}
}
bool isCloseRequested() {
bool IsCloseRequested() {
return shouldClose;
}
bool isMouseDown(int button) {
bool IsMouseDown(int button) {
return ImGui::GetIO().MouseDown[button];
}
float getAspectRatio() {
float GetAspectRatio() {
return aspectRatio;
}
int getWindowWidth() {
int GetWindowWidth() {
return lastWidth;
}
int getWindowHeight() {
int GetWindowHeight() {
return lastHeight;
}