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);