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

refactor: format code

Browse Source
This commit is contained in:
Simon Pribylski
2021-09-19 17:33:16 +02:00
parent 52a143769e
commit 0856ca47ca
71 changed files with 1102 additions and 1110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
include/game/BaseGame.h
View File

@@ -7,7 +7,7 @@
namespace td { namespace td {
namespace game { namespace game {
enum class GameState : std::uint8_t{ enum class GameState : std::uint8_t {
Lobby, Lobby,
Game, Game,
EndGame, EndGame,
@@ -16,10 +16,10 @@ enum class GameState : std::uint8_t{
typedef std::map<std::uint8_t, Player> PlayerList; typedef std::map<std::uint8_t, Player> PlayerList;
class Game{ class Game {
protected: protected:
World* m_World; World* m_World;
std::array<Team, 2> m_Teams = {Team{TeamColor::Red}, Team{TeamColor::Blue}}; std::array<Team, 2> m_Teams = { Team{TeamColor::Red}, Team{TeamColor::Blue} };
GameState m_GameState = GameState::Lobby; GameState m_GameState = GameState::Lobby;
PlayerList m_Players; PlayerList m_Players;
public: public:
@@ -28,23 +28,23 @@ public:
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
Team& getRedTeam(){ 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]; } const Team& getRedTeam() const { return m_Teams[(std::uint8_t)TeamColor::Red]; }
Team& getBlueTeam(){ 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]; } const Team& getBlueTeam() const { return m_Teams[(std::uint8_t)TeamColor::Blue]; }
Team& getTeam(TeamColor team){ 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]; } const Team& getTeam(TeamColor team) const { return m_Teams[(std::uint8_t)team]; }
GameState getGameState() const{ return m_GameState; } GameState getGameState() const { return m_GameState; }
void setGameState(GameState gameState){ m_GameState = gameState; }; void setGameState(GameState gameState) { m_GameState = gameState; };
const World* getWorld() const{ return m_World; } const World* getWorld() const { return m_World; }
World* getWorld(){ return m_World; } World* getWorld() { return m_World; }
const PlayerList& getPlayers() const{ return m_Players; } const PlayerList& getPlayers() const { return m_Players; }
PlayerList& getPlayers(){ return m_Players; } PlayerList& getPlayers() { return m_Players; }
}; };

4
include/game/Connexion.h
View File

@@ -8,7 +8,7 @@
namespace td { namespace td {
namespace protocol { namespace protocol {
class Connexion : public protocol::PacketHandler{ class Connexion : public protocol::PacketHandler {
protected: protected:
protocol::PacketDispatcher m_Dispatcher; protocol::PacketDispatcher m_Dispatcher;
private: private:
@@ -25,7 +25,7 @@ public:
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(protocol::Packet* packet); void sendPacket(protocol::Packet* packet);

2
include/game/GameManager.h
View File

@@ -8,7 +8,7 @@
#ifndef GAME_GAMEMANAGER_H_ #ifndef GAME_GAMEMANAGER_H_
#define GAME_GAMEMANAGER_H_ #define GAME_GAMEMANAGER_H_
namespace GameManager{ namespace GameManager {
void render(); void render();
void init(); void init();

74
include/game/Mobs.h
View File

@@ -9,7 +9,7 @@
namespace td { namespace td {
namespace game { namespace game {
enum class EffectType : std::uint8_t{ enum class EffectType : std::uint8_t {
Slowness = 0, Slowness = 0,
Stun, Stun,
Fire, Fire,
@@ -17,7 +17,7 @@ enum class EffectType : std::uint8_t{
Heal, Heal,
}; };
enum class MobType : std::uint8_t{ enum class MobType : std::uint8_t {
Zombie = 0, Zombie = 0,
Spider, Spider,
Skeleton, Skeleton,
@@ -36,7 +36,7 @@ typedef std::uint8_t MobLevel;
typedef std::vector<TowerType> TowerImmunities; typedef std::vector<TowerType> TowerImmunities;
typedef std::vector<EffectType> EffectImmunities; typedef std::vector<EffectType> EffectImmunities;
class MobStats{ class MobStats {
private: private:
float m_Damage; float m_Damage;
float m_Speed; float m_Speed;
@@ -47,24 +47,24 @@ private:
public: public:
MobStats(float damage, float speed, std::uint16_t moneyCost, MobStats(float damage, float speed, std::uint16_t moneyCost,
std::uint16_t expCost, std::uint16_t maxLife, std::uint16_t expCost, std::uint16_t maxLife,
std::uint16_t expReward): m_Damage(damage), m_Speed(speed), std::uint16_t expReward) : m_Damage(damage), m_Speed(speed),
m_MoneyCost(moneyCost), m_ExpCost(expCost), m_MaxLife(maxLife), m_MoneyCost(moneyCost), m_ExpCost(expCost), m_MaxLife(maxLife),
m_ExpReward(expReward){ m_ExpReward(expReward) {
} }
float getDamage() const{ return m_Damage; } float getDamage() const { return m_Damage; }
float getMovementSpeed() const{ return m_Speed; } float getMovementSpeed() const { return m_Speed; }
std::uint16_t getMoneyCost() const{ return m_MoneyCost; } std::uint16_t getMoneyCost() const { return m_MoneyCost; }
std::uint16_t getExpCost() const{ return m_ExpCost; } std::uint16_t getExpCost() const { return m_ExpCost; }
std::uint16_t getExpReward() const{ return m_ExpReward; } std::uint16_t getExpReward() const { return m_ExpReward; }
std::uint16_t getMaxLife() const{ return m_MaxLife; } std::uint16_t getMaxLife() const { return m_MaxLife; }
}; };
const MobStats* getMobStats(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 TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level);
const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level); const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level);
class Mob{ class Mob {
protected: protected:
float m_Health; float m_Health;
private: private:
@@ -75,54 +75,54 @@ private:
float m_X = 0, m_Y = 0; float m_X = 0, m_Y = 0;
public: public:
Mob(MobID id, MobLevel level, PlayerID sender): m_Sender(sender), m_Level(level){ Mob(MobID id, MobLevel level, PlayerID sender) : m_Sender(sender), m_Level(level) {
} }
virtual MobType getType() const = 0; virtual MobType getType() const = 0;
virtual void tick(std::uint64_t delta){} virtual void tick(std::uint64_t delta) {}
const TowerImmunities& getTowerImmunities() const{ return getMobTowerImmunities(getType(), m_Level); } const TowerImmunities& getTowerImmunities() const { return getMobTowerImmunities(getType(), m_Level); }
const EffectImmunities& getEffectImmunities() const{ return getMobEffectImmunities(getType(), m_Level); } const EffectImmunities& getEffectImmunities() const { return getMobEffectImmunities(getType(), m_Level); }
PlayerID getSender() const{ return m_Sender; } PlayerID getSender() const { return m_Sender; }
MobLevel getLevel() const{ return m_Level; } MobLevel getLevel() const { return m_Level; }
const MobStats* getStats() const{ return getMobStats(getType(), m_Level); } const MobStats* getStats() const { return getMobStats(getType(), m_Level); }
float getHealth() const{ return m_Health; } float getHealth() const { return m_Health; }
bool isAlive() const{ return m_Health > 0; } bool isAlive() const { return m_Health > 0; }
void damage(float dmg){ m_Health -= dmg; } void damage(float dmg) { m_Health -= dmg; }
void heal(float heal){ m_Health = std::min((float)getStats()->getMaxLife(), m_Health + heal); } void heal(float heal) { m_Health = std::min((float)getStats()->getMaxLife(), m_Health + heal); }
float getX() const{ return m_X; } float getX() const { return m_X; }
void setX(float x){ m_X = x; } void setX(float x) { m_X = x; }
float getY() const{ return m_Y; } float getY() const { return m_Y; }
void setY(float y){ m_Y = y; } void setY(float y) { m_Y = y; }
Direction getDirection() const{ return m_Direction; } Direction getDirection() const { return m_Direction; }
void setDirection(Direction dir){ m_Direction = dir; } void setDirection(Direction dir) { m_Direction = dir; }
protected: protected:
void initHealth(){m_Health = (float)getStats()->getMaxLife();} void initHealth() { m_Health = (float)getStats()->getMaxLife(); }
}; };
typedef std::shared_ptr<Mob> MobPtr; typedef std::shared_ptr<Mob> MobPtr;
class Zombie : public Mob{ class Zombie : public Mob {
public: public:
Zombie(MobID id, std::uint8_t level, PlayerID sender): Mob(id, level, sender){initHealth();} Zombie(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
virtual MobType getType() const{ return MobType::Zombie; } virtual MobType getType() const { return MobType::Zombie; }
}; };
class Spider : public Mob{ class Spider : public Mob {
public: public:
Spider(MobID id, std::uint8_t level, PlayerID sender): Mob(id, level, sender){initHealth();} Spider(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
virtual MobType getType() const{ return MobType::Spider; } virtual MobType getType() const { return MobType::Spider; }
}; };
namespace MobFactory{ namespace MobFactory {
MobPtr createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender); MobPtr createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender);
} }

26
include/game/Player.h
View File

@@ -5,10 +5,10 @@
#include "game/Team.h" #include "game/Team.h"
namespace td{ namespace td {
namespace game{ namespace game {
class Player{ class Player {
private: private:
game::TeamColor m_TeamColor = game::TeamColor::None; game::TeamColor m_TeamColor = game::TeamColor::None;
@@ -19,21 +19,21 @@ private:
std::uint8_t m_GoldPerSecond = 5; std::uint8_t m_GoldPerSecond = 5;
public: public:
Player(std::uint8_t id = 0) : m_ID(id){} Player(std::uint8_t id = 0) : m_ID(id) {}
const std::string& getName() const{return m_Name;} const std::string& getName() const { return m_Name; }
void setName(const std::string& name){m_Name = name;} void setName(const std::string& name) { m_Name = name; }
game::TeamColor getTeamColor() const{return m_TeamColor;} game::TeamColor getTeamColor() const { return m_TeamColor; }
void setTeamColor(game::TeamColor teamColor){m_TeamColor = teamColor;} void setTeamColor(game::TeamColor teamColor) { m_TeamColor = teamColor; }
std::uint8_t getGoldPerSecond() const{ return m_GoldPerSecond;} std::uint8_t getGoldPerSecond() const { return m_GoldPerSecond; }
void setGoldPerSecond(std::uint8_t goldPerSecond){m_GoldPerSecond = goldPerSecond;} void setGoldPerSecond(std::uint8_t goldPerSecond) { m_GoldPerSecond = goldPerSecond; }
std::uint32_t getGold() const{ return m_Gold;} std::uint32_t getGold() const { return m_Gold; }
void setGold(std::uint32_t gold){m_Gold = gold;} void setGold(std::uint32_t gold) { m_Gold = gold; }
std::uint8_t getID() const{return m_ID;} std::uint8_t getID() const { return m_ID; }
}; };
} // namespace game } // namespace game

16
include/game/Team.h
View File

@@ -11,23 +11,23 @@ namespace game {
class Player; class Player;
enum class TeamColor : std::int8_t{ enum class TeamColor : std::int8_t {
None = -1, None = -1,
Red, Red,
Blue Blue
}; };
struct Spawn{ struct Spawn {
Direction direction; Direction direction;
std::int32_t x, y; std::int32_t x, y;
}; };
struct TeamCastle{ struct TeamCastle {
std::int32_t x, y; std::int32_t x, y;
std::uint16_t life = 1000; std::uint16_t life = 1000;
}; };
class Team{ class Team {
private: private:
std::vector<Player*> m_Players; std::vector<Player*> m_Players;
TeamColor m_Color; TeamColor m_Color;
@@ -41,11 +41,11 @@ public:
TeamColor getColor() const; TeamColor getColor() const;
const Spawn& getSpawn() const {return m_Spawn;} const Spawn& getSpawn() const { return m_Spawn; }
Spawn& getSpawn() {return m_Spawn;} Spawn& getSpawn() { return m_Spawn; }
const TeamCastle& getCastle() const {return m_TeamCastle;} const TeamCastle& getCastle() const { return m_TeamCastle; }
TeamCastle& getCastle() {return m_TeamCastle;} TeamCastle& getCastle() { return m_TeamCastle; }
std::uint8_t getPlayerCount() const; std::uint8_t getPlayerCount() const;
}; };

126
include/game/Towers.h
View File

@@ -6,7 +6,7 @@
namespace td { namespace td {
namespace game { namespace game {
enum class TowerType : std::uint8_t{ enum class TowerType : std::uint8_t {
Archer = 0, Archer = 0,
Ice, Ice,
Sorcerer, Sorcerer,
@@ -23,49 +23,49 @@ enum class TowerType : std::uint8_t{
TowerCount TowerCount
}; };
enum class TowerSize : bool{ enum class TowerSize : bool {
Little = 0, // 3x3 Little = 0, // 3x3
Big, // 5x5 Big, // 5x5
}; };
enum class TowerPath : std::uint8_t{ enum class TowerPath : std::uint8_t {
Top = 0, // Base path Top = 0, // Base path
Bottom Bottom
}; };
class TowerStats{ class TowerStats {
private: private:
float m_Rate; float m_Rate;
float m_Damage; float m_Damage;
std::uint8_t m_Range; std::uint8_t m_Range;
public: public:
TowerStats(float rate, float damage, std::uint8_t range): m_Rate(rate), m_Damage(damage), TowerStats(float rate, float damage, std::uint8_t range) : m_Rate(rate), m_Damage(damage),
m_Range(range){ m_Range(range) {
} }
float getDamageRate() const{ return m_Rate; } float getDamageRate() const { return m_Rate; }
float getDamage() const{ return m_Damage; } float getDamage() const { return m_Damage; }
std::uint8_t getRange() const{ return m_Range; } std::uint8_t getRange() const { return m_Range; }
}; };
class TowerLevel{ class TowerLevel {
private: private:
// 1, 2, 3, 4 // 1, 2, 3, 4
std::uint8_t m_Level : 3; std::uint8_t m_Level : 3;
// 0 : base path 1 : top path (if there is bottom path) 2 : bottom path (if there is top path) // 0 : base path 1 : top path (if there is bottom path) 2 : bottom path (if there is top path)
TowerPath m_Path : 1; TowerPath m_Path : 1;
public: public:
TowerLevel(): m_Level(1), m_Path(TowerPath::Top){} TowerLevel() : m_Level(1), m_Path(TowerPath::Top) {}
TowerLevel(std::uint8_t level, TowerPath path): m_Level(level), m_Path(path){} TowerLevel(std::uint8_t level, TowerPath path) : m_Level(level), m_Path(path) {}
std::uint8_t getLevel() const{ return m_Level; } std::uint8_t getLevel() const { return m_Level; }
TowerPath getPath() const{ return m_Path; } TowerPath getPath() const { return m_Path; }
void setLevel(std::uint8_t level){ m_Level = level; } void setLevel(std::uint8_t level) { m_Level = level; }
void setPath(TowerPath path){ m_Path = path; } void setPath(TowerPath path) { m_Path = path; }
// operator to sort maps // operator to sort maps
friend bool operator<(const TowerLevel& level, const TowerLevel& other){ friend bool operator<(const TowerLevel& level, const TowerLevel& other) {
return level.getLevel() * static_cast<std::uint8_t>(level.getPath()) < return level.getLevel() * static_cast<std::uint8_t>(level.getPath()) <
other.getLevel() * static_cast<std::uint8_t>(other.getPath()); other.getLevel() * static_cast<std::uint8_t>(other.getPath());
} }
@@ -73,140 +73,140 @@ public:
const TowerStats* getTowerStats(TowerType type, TowerLevel level); const TowerStats* getTowerStats(TowerType type, TowerLevel level);
class Tower{ class Tower {
private: private:
std::uint16_t m_X, m_Y; std::uint16_t m_X, m_Y;
TowerLevel m_Level{}; TowerLevel m_Level{};
protected: protected:
utils::Timer m_Timer; utils::Timer m_Timer;
public: // converting seconds to millis public: // converting seconds to millis
Tower(std::uint16_t x, std::uint16_t y): m_X(x), m_Y(y), m_Timer(getStats()->getDamageRate() * 1000){} Tower(std::uint16_t x, std::uint16_t y) : m_X(x), m_Y(y), m_Timer(getStats()->getDamageRate() * 1000) {}
virtual TowerType getType() const = 0; virtual TowerType getType() const = 0;
virtual TowerSize getSize() const = 0; virtual TowerSize getSize() const = 0;
virtual void tick(std::uint64_t delta) = 0; virtual void tick(std::uint64_t delta) = 0;
void upgrade(std::uint8_t level, TowerPath path){ void upgrade(std::uint8_t level, TowerPath path) {
m_Level.setLevel(level); m_Level.setLevel(level);
m_Level.setPath(path); m_Level.setPath(path);
} }
std::uint16_t getX() const{ return m_X; } std::uint16_t getX() const { return m_X; }
std::uint16_t getY() const{ return m_Y; } std::uint16_t getY() const { return m_Y; }
const TowerLevel& getLevel() const{ return m_Level; } const TowerLevel& getLevel() const { return m_Level; }
const TowerStats* getStats() const{ return getTowerStats(getType(), m_Level); } const TowerStats* getStats() const { return getTowerStats(getType(), m_Level); }
}; };
// ---------- Little Towers ---------- // ---------- Little Towers ----------
class LittleTower : public Tower{ class LittleTower : public Tower {
public: public:
LittleTower(std::uint16_t x, std::uint16_t y): Tower(x, y){} LittleTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {}
virtual TowerSize getSize() const{ return TowerSize::Little; } virtual TowerSize getSize() const { return TowerSize::Little; }
virtual TowerType getType() const = 0; virtual TowerType getType() const = 0;
virtual void tick(std::uint64_t delta) = 0; virtual void tick(std::uint64_t delta) = 0;
}; };
class ArcherTower : public LittleTower{ class ArcherTower : public LittleTower {
public: public:
ArcherTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} ArcherTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Archer; } virtual TowerType getType() const { return TowerType::Archer; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class IceTower : public LittleTower{ class IceTower : public LittleTower {
public: public:
IceTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} IceTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Ice; } virtual TowerType getType() const { return TowerType::Ice; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class MageTower : public LittleTower{ class MageTower : public LittleTower {
public: public:
MageTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} MageTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Mage; } virtual TowerType getType() const { return TowerType::Mage; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class PoisonTower : public LittleTower{ class PoisonTower : public LittleTower {
public: public:
PoisonTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} PoisonTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Poison; } virtual TowerType getType() const { return TowerType::Poison; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class QuakeTower : public LittleTower{ class QuakeTower : public LittleTower {
public: public:
QuakeTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} QuakeTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Quake; } virtual TowerType getType() const { return TowerType::Quake; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class ArtilleryTower : public LittleTower{ class ArtilleryTower : public LittleTower {
public: public:
ArtilleryTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} ArtilleryTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Artillery; } virtual TowerType getType() const { return TowerType::Artillery; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class SorcererTower : public LittleTower{ class SorcererTower : public LittleTower {
public: public:
SorcererTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} SorcererTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Sorcerer; } virtual TowerType getType() const { return TowerType::Sorcerer; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class ZeusTower : public LittleTower{ class ZeusTower : public LittleTower {
public: public:
ZeusTower(std::uint16_t x, std::uint16_t y): LittleTower(x, y){} ZeusTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Zeus; } virtual TowerType getType() const { return TowerType::Zeus; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
// ---------- Big Towers ---------- // ---------- Big Towers ----------
class BigTower : public Tower{ class BigTower : public Tower {
public: public:
BigTower(std::uint16_t x, std::uint16_t y): Tower(x, y){} BigTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {}
virtual TowerSize getSize() const{ return TowerSize::Big; } virtual TowerSize getSize() const { return TowerSize::Big; }
virtual TowerType getType() const = 0; virtual TowerType getType() const = 0;
virtual void tick(std::uint64_t delta) = 0; virtual void tick(std::uint64_t delta) = 0;
}; };
class TurretTower : public BigTower{ class TurretTower : public BigTower {
public: public:
TurretTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} TurretTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Turret; } virtual TowerType getType() const { return TowerType::Turret; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class NecromancerTower : public BigTower{ class NecromancerTower : public BigTower {
public: public:
NecromancerTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} NecromancerTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Necromancer; } virtual TowerType getType() const { return TowerType::Necromancer; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };
class LeachTower : public BigTower{ class LeachTower : public BigTower {
public: public:
LeachTower(std::uint16_t x, std::uint16_t y): BigTower(x, y){} LeachTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
virtual TowerType getType() const{ return TowerType::Leach; } virtual TowerType getType() const { return TowerType::Leach; }
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
}; };

2
include/game/Types.h
View File

@@ -5,7 +5,7 @@
namespace td { namespace td {
namespace game { namespace game {
enum class Direction : std::uint8_t{ enum class Direction : std::uint8_t {
PositiveX = 1 << 0, PositiveX = 1 << 0,
NegativeX = 1 << 1, NegativeX = 1 << 1,
PositiveY = 1 << 2, PositiveY = 1 << 2,

64
include/game/World.h
View File

@@ -7,15 +7,15 @@
#include "Mobs.h" #include "Mobs.h"
#include "Team.h" #include "Team.h"
namespace td{ namespace td {
namespace game{ namespace game {
typedef std::pair<std::int16_t, std::int16_t> ChunkCoord; typedef std::pair<std::int16_t, std::int16_t> ChunkCoord;
} }
} }
namespace std{ namespace std {
template <> template <>
struct hash<td::game::ChunkCoord>{ struct hash<td::game::ChunkCoord> {
std::size_t operator()(const td::game::ChunkCoord& key) const{ std::size_t operator()(const td::game::ChunkCoord& key) const {
// Compute individual hash values for first, // Compute individual hash values for first,
// second and third and combine them using XOR // second and third and combine them using XOR
// and bit shifting: // and bit shifting:
@@ -37,7 +37,7 @@ namespace game {
class Game; class Game;
enum class TileType : std::uint8_t{ enum class TileType : std::uint8_t {
None = 0, None = 0,
Tower, Tower,
Walk, Walk,
@@ -49,31 +49,31 @@ enum class TileType : std::uint8_t{
Ice,*/ Ice,*/
}; };
struct Color{ struct Color {
std::uint8_t r, g, b; std::uint8_t r, g, b;
}; };
struct Tile{ struct Tile {
virtual TileType getType() const = 0; virtual TileType getType() const = 0;
}; };
struct TowerTile : Tile{ struct TowerTile : Tile {
std::uint8_t color_palette_ref; std::uint8_t color_palette_ref;
TeamColor team_owner; TeamColor team_owner;
virtual TileType getType() const{ return TileType::Tower; } virtual TileType getType() const { return TileType::Tower; }
}; };
struct WalkableTile : Tile{ struct WalkableTile : Tile {
Direction direction; Direction direction;
virtual TileType getType() const{ return TileType::Walk; } virtual TileType getType() const { return TileType::Walk; }
}; };
struct DecorationTile : Tile{ struct DecorationTile : Tile {
std::uint16_t color_palette_ref; 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; typedef std::shared_ptr<Tile> TilePtr;
@@ -85,15 +85,15 @@ typedef std::array<std::uint16_t, 32 * 32> ChunkData;
typedef std::uint32_t TileIndex; typedef std::uint32_t TileIndex;
//32 x 32 area //32 x 32 area
struct Chunk{ struct Chunk {
enum{ ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight }; enum { ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight };
// stores index of tile palette // stores index of tile palette
ChunkData tiles{0}; ChunkData tiles{ 0 };
ChunkPalette palette; ChunkPalette palette;
TileIndex getTileIndex(std::uint16_t tileNumber) const{ TileIndex getTileIndex(std::uint16_t tileNumber) const {
TileIndex chunkPaletteIndex = tiles.at(tileNumber); TileIndex chunkPaletteIndex = tiles.at(tileNumber);
if(chunkPaletteIndex == 0) // index 0 means empty tile index 1 = first tile if (chunkPaletteIndex == 0) // index 0 means empty tile index 1 = first tile
return 0; return 0;
return palette.at(chunkPaletteIndex); return palette.at(chunkPaletteIndex);
} }
@@ -110,7 +110,7 @@ typedef std::vector<MobPtr> MobList;
typedef std::array<Color, 2> SpawnColorPalette; typedef std::array<Color, 2> SpawnColorPalette;
class World{ class World {
protected: protected:
TowerTileColorPalette m_TowerPlacePalette; TowerTileColorPalette m_TowerPlacePalette;
Color m_WalkablePalette; Color m_WalkablePalette;
@@ -140,25 +140,25 @@ public:
TilePtr getTile(std::int32_t x, std::int32_t y); TilePtr getTile(std::int32_t x, std::int32_t y);
const TowerTileColorPalette& getTowerTileColorPalette() const{ return m_TowerPlacePalette; } const TowerTileColorPalette& getTowerTileColorPalette() const { return m_TowerPlacePalette; }
const Color& getWalkableTileColor() const{ return m_WalkablePalette; } const Color& getWalkableTileColor() const { return m_WalkablePalette; }
const std::vector<Color>& getDecorationPalette() const{ return m_DecorationPalette; } const std::vector<Color>& getDecorationPalette() const { return m_DecorationPalette; }
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) if (index == 0)
return nullptr; return nullptr;
return m_TilePalette.at(index - 1); return m_TilePalette.at(index - 1);
} }
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 Color& getSpawnColor(TeamColor color) const { return m_SpawnColorPalette[(std::size_t)color]; }
const SpawnColorPalette& getSpawnColors() const{ return m_SpawnColorPalette; } const SpawnColorPalette& getSpawnColors() const { return m_SpawnColorPalette; }
const MobList& getMobList() const{ return m_Mobs; } const MobList& getMobList() const { return m_Mobs; }
MobList& getMobList(){ return m_Mobs; } MobList& getMobList() { return m_Mobs; }
const Color* getTileColor(TilePtr tile) const; const Color* getTileColor(TilePtr tile) const;

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

@@ -11,21 +11,21 @@
namespace td { namespace td {
namespace client { namespace client {
class Client{ class Client {
private: private:
render::Renderer* m_Renderer; render::Renderer* m_Renderer;
ClientConnexion m_Connexion; ClientConnexion m_Connexion;
ClientGame m_Game; ClientGame m_Game;
bool m_Connected; bool m_Connected;
public: public:
Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(this), m_Connected(false){} Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(this), m_Connected(false) {}
const ClientGame& getGame() const{ return m_Game; } const ClientGame& getGame() const { return m_Game; }
const ClientConnexion& getConnexion() const{ return m_Connexion; } const ClientConnexion& getConnexion() const { return m_Connexion; }
render::Renderer* getRenderer() const {return m_Renderer;} render::Renderer* getRenderer() const { return m_Renderer; }
ClientGame& getGame(){ return m_Game; } ClientGame& getGame() { return m_Game; }
ClientConnexion& getConnexion(){ return m_Connexion; } ClientConnexion& getConnexion() { return m_Connexion; }
void tick(std::uint64_t delta); void tick(std::uint64_t delta);
@@ -34,7 +34,7 @@ public:
void connect(const std::string& address, std::uint16_t port); void connect(const std::string& address, std::uint16_t port);
void closeConnection(); 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 selectTeam(game::TeamColor team);
}; };

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

@@ -7,7 +7,7 @@
namespace td { namespace td {
namespace client { namespace client {
class ClientConnexion : public protocol::Connexion{ class ClientConnexion : public protocol::Connexion {
private: private:
std::uint8_t m_ConnectionID; std::uint8_t m_ConnectionID;
std::string m_DisconnectReason; std::string m_DisconnectReason;
@@ -23,9 +23,9 @@ public:
virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(protocol::DisconnectPacket* packet);
virtual void HandlePacket(protocol::ServerTpsPacket* packet); virtual void HandlePacket(protocol::ServerTpsPacket* packet);
const std::string& getDisconnectReason() const{ return m_DisconnectReason; } const std::string& getDisconnectReason() const { return m_DisconnectReason; }
float getServerTPS() const{ return m_ServerTPS; } float getServerTPS() const { return m_ServerTPS; }
int getServerPing() const {return m_Ping;} int getServerPing() const { return m_Ping; }
REMOVE_COPY(ClientConnexion); REMOVE_COPY(ClientConnexion);
private: private:

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

@@ -14,7 +14,7 @@ namespace client {
class Client; class Client;
class ClientGame : public protocol::PacketHandler, public game::Game{ class ClientGame : public protocol::PacketHandler, public game::Game {
private: private:
Client* m_Client; Client* m_Client;
std::uint8_t m_ConnexionID; std::uint8_t m_ConnexionID;
@@ -31,10 +31,10 @@ public:
void renderWorld(); void renderWorld();
std::uint32_t getLobbyTime() const{return m_LobbyTime;} std::uint32_t getLobbyTime() const { return m_LobbyTime; }
const game::Player* getPlayer() const{return m_Player;} const game::Player* getPlayer() const { return m_Player; }
render::Renderer* getRenderer() const {return m_Renderer;} render::Renderer* getRenderer() const { return m_Renderer; }
void PlaceTower(game::TowerType type, const glm::vec2& position); void PlaceTower(game::TowerType type, const glm::vec2& position);

2
include/game/client/WorldClient.h
View File

@@ -8,7 +8,7 @@ namespace client {
class ClientGame; class ClientGame;
class WorldClient : public game::World, public protocol::PacketHandler{ class WorldClient : public game::World, public protocol::PacketHandler {
private: private:
ClientGame* m_Game; ClientGame* m_Game;
public: public:

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

@@ -9,7 +9,7 @@ namespace server {
class Server; class Server;
class Lobby{ class Lobby {
private: private:
Server* m_Server; Server* m_Server;
bool m_GameStarted = false; bool m_GameStarted = false;

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

@@ -22,23 +22,23 @@ namespace server {
typedef std::map<std::uint8_t, ServerConnexion> ConnexionMap; typedef std::map<std::uint8_t, ServerConnexion> ConnexionMap;
class TickCounter{ class TickCounter {
private: private:
float m_TPS; float m_TPS;
std::uint64_t m_LastTPSTime; std::uint64_t m_LastTPSTime;
std::uint8_t m_TickCount; std::uint8_t m_TickCount;
public: public:
TickCounter(){} TickCounter() {}
void reset(){ void reset() {
m_TPS = SERVER_TPS; m_TPS = SERVER_TPS;
m_LastTPSTime = utils::getTime(); m_LastTPSTime = utils::getTime();
m_TickCount = 0; m_TickCount = 0;
} }
bool update(){ // return true when tps is updated bool update() { // return true when tps is updated
m_TickCount++; m_TickCount++;
if (m_TickCount >= SERVER_TPS){ 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_TPS = (float)SERVER_TPS / (float)(timeElapsedSinceLast20Ticks / 1000.0f);
m_TickCount = 0; m_TickCount = 0;
@@ -48,19 +48,19 @@ public:
return false; return false;
} }
float getTPS() const{ return m_TPS; } float getTPS() const { return m_TPS; }
}; };
class Server{ class Server {
private: private:
network::TCPListener m_Listener; network::TCPListener m_Listener;
ConnexionMap m_Connections; ConnexionMap m_Connections;
ServerGame m_Game{this}; ServerGame m_Game{ this };
Lobby m_Lobby{this}; Lobby m_Lobby{ this };
TickCounter m_TickCounter; TickCounter m_TickCounter;
public: public:
Server(const std::string& worldFilePath); Server(const std::string& worldFilePath);
virtual ~Server(){} virtual ~Server() {}
bool start(std::uint16_t port); bool start(std::uint16_t port);
void tick(std::uint64_t delta); void tick(std::uint64_t delta);
@@ -72,17 +72,17 @@ public:
void broadcastPacket(protocol::Packet* packet); void broadcastPacket(protocol::Packet* packet);
float getTPS() const{ return m_TickCounter.getTPS(); } float getTPS() const { return m_TickCounter.getTPS(); }
const ServerGame& getGame() const{ return m_Game; } const ServerGame& getGame() const { return m_Game; }
ServerGame& getGame() { return m_Game; } ServerGame& getGame() { return m_Game; }
const Lobby& getLobby() const{ return m_Lobby; } const Lobby& getLobby() const { return m_Lobby; }
const ConnexionMap& getConnexions() const{ return m_Connections; } const ConnexionMap& getConnexions() const { return m_Connections; }
ConnexionMap& getConnexions(){ return m_Connections; } ConnexionMap& getConnexions() { return m_Connections; }
const game::PlayerList& getPlayers() const{ return m_Game.getPlayers(); } const game::PlayerList& getPlayers() const { return m_Game.getPlayers(); }
game::PlayerList& getPlayers(){ return m_Game.getPlayers(); } game::PlayerList& getPlayers() { return m_Game.getPlayers(); }
private: private:
void accept(); void accept();

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

@@ -6,8 +6,8 @@
#include "game/Player.h" #include "game/Player.h"
#include "game/Connexion.h" #include "game/Connexion.h"
namespace td{ namespace td {
namespace server{ namespace server {
class Server; class Server;
@@ -19,7 +19,7 @@ struct KeepAlive
}; };
class ServerConnexion : public protocol::Connexion{ class ServerConnexion : public protocol::Connexion {
private: private:
Server* m_Server = nullptr; Server* m_Server = nullptr;
std::uint8_t m_ID; std::uint8_t m_ID;
@@ -39,9 +39,9 @@ public:
virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(protocol::DisconnectPacket* packet);
virtual void HandlePacket(protocol::PlaceTowerPacket* packet); virtual void HandlePacket(protocol::PlaceTowerPacket* packet);
std::uint8_t getID() const{return m_ID;} std::uint8_t getID() const { return m_ID; }
const game::Player* getPlayer() const{return m_Player;} const game::Player* getPlayer() const { return m_Player; }
game::Player* getPlayer() {return m_Player;} game::Player* getPlayer() { return m_Player; }
virtual bool updateSocket(); virtual bool updateSocket();

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

@@ -9,14 +9,14 @@ namespace server {
class Server; class Server;
class ServerGame : public game::Game{ class ServerGame : public game::Game {
private: private:
Server* m_Server; Server* m_Server;
ServerWorld m_ServerWorld; ServerWorld m_ServerWorld;
utils::Timer m_GoldMineTimer{1000, std::bind(&ServerGame::updateGoldMines, this)}; utils::Timer m_GoldMineTimer{ 1000, std::bind(&ServerGame::updateGoldMines, this) };
public: public:
ServerGame(Server* server); ServerGame(Server* server);
~ServerGame(){} ~ServerGame() {}
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
void startGame(); void startGame();

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

@@ -8,7 +8,7 @@ namespace server {
class Server; class Server;
class ServerGame; class ServerGame;
class ServerWorld : public game::World{ class ServerWorld : public game::World {
private: private:
game::MobID m_CurrentMobID; game::MobID m_CurrentMobID;
Server* m_Server; Server* m_Server;

2
include/misc/Easing.h
View File

@@ -1,7 +1,7 @@
#pragma once #pragma once
namespace td { namespace td {
namespace utils{ namespace utils {
constexpr float PI = 3.14159274101257324219; constexpr float PI = 3.14159274101257324219;

16
include/misc/Time.h
View File

@@ -12,7 +12,7 @@ std::uint64_t getTime();
typedef std::function<void()> TimerExecFunction; typedef std::function<void()> TimerExecFunction;
// utililty class to call function at regular period of time // utililty class to call function at regular period of time
class Timer{ class Timer {
private: private:
std::uint64_t m_Interval; std::uint64_t m_Interval;
TimerExecFunction m_Function; TimerExecFunction m_Function;
@@ -20,20 +20,20 @@ private:
std::uint64_t m_LastTime = getTime(); std::uint64_t m_LastTime = getTime();
std::uint64_t m_InternalTime = 0; std::uint64_t m_InternalTime = 0;
public: public:
Timer() : m_Interval(0), m_Function(nullptr){} Timer() : m_Interval(0), m_Function(nullptr) {}
Timer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr){} Timer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr) {}
Timer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback){} Timer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback) {}
void update(); void update();
void update(std::uint64_t delta); void update(std::uint64_t delta);
void reset(); void reset();
void setInterval(std::uint64_t newInterval){m_Interval = newInterval;} void setInterval(std::uint64_t newInterval) { m_Interval = newInterval; }
std::uint64_t getInterval() const{return m_Interval;} std::uint64_t getInterval() const { return m_Interval; }
void setCallbackFunction(TimerExecFunction newCallback){m_Function = newCallback;} void setCallbackFunction(TimerExecFunction newCallback) { m_Function = newCallback; }
TimerExecFunction getCallbackFunction() const{return m_Function;} TimerExecFunction getCallbackFunction() const { return m_Function; }
}; };

50
include/network/DataBuffer.h
View File

@@ -7,9 +7,9 @@
#include <cassert> #include <cassert>
#include <string> #include <string>
namespace td{ namespace td {
class DataBuffer{ class DataBuffer {
private: private:
typedef std::vector<std::uint8_t> Data; typedef std::vector<std::uint8_t> Data;
Data m_Buffer; Data m_Buffer;
@@ -31,7 +31,7 @@ public:
DataBuffer& operator=(DataBuffer&& other); DataBuffer& operator=(DataBuffer&& other);
template <typename T> template <typename T>
void Append(T data){ void Append(T data) {
std::size_t size = sizeof(data); std::size_t size = sizeof(data);
std::size_t end_pos = m_Buffer.size(); std::size_t end_pos = m_Buffer.size();
m_Buffer.resize(m_Buffer.size() + size); m_Buffer.resize(m_Buffer.size() + size);
@@ -39,30 +39,30 @@ public:
} }
template <typename T> template <typename T>
DataBuffer& operator<<(T data){ DataBuffer& operator<<(T data) {
// Switch to big endian // Switch to big endian
//std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T)); //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T));
Append(data); Append(data);
return *this; return *this;
} }
DataBuffer& operator<<(std::string str){ DataBuffer& operator<<(std::string str) {
m_Buffer.insert(m_Buffer.end(), str.begin(), str.end()); m_Buffer.insert(m_Buffer.end(), str.begin(), str.end());
return *this; return *this;
} }
DataBuffer& operator<<(DataBuffer& data){ DataBuffer& operator<<(DataBuffer& data) {
m_Buffer.insert(m_Buffer.end(), data.begin(), data.end()); m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
return *this; return *this;
} }
DataBuffer& operator<<(const DataBuffer& data){ DataBuffer& operator<<(const DataBuffer& data) {
m_Buffer.insert(m_Buffer.end(), data.begin(), data.end()); m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
return *this; return *this;
} }
template <typename T> template <typename T>
DataBuffer& operator>>(T& data){ DataBuffer& operator>>(T& data) {
assert(m_ReadOffset + sizeof(T) <= GetSize()); assert(m_ReadOffset + sizeof(T) <= GetSize());
data = *(T*)&m_Buffer[m_ReadOffset]; data = *(T*)&m_Buffer[m_ReadOffset];
//std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T)); //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T));
@@ -70,77 +70,77 @@ public:
return *this; return *this;
} }
DataBuffer& operator>>(DataBuffer& data){ DataBuffer& operator>>(DataBuffer& data) {
data.Resize(GetSize() - m_ReadOffset); data.Resize(GetSize() - m_ReadOffset);
std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.end(), data.begin()); std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.end(), data.begin());
m_ReadOffset = m_Buffer.size(); m_ReadOffset = m_Buffer.size();
return *this; return *this;
} }
DataBuffer& operator>>(std::string& str){ DataBuffer& operator>>(std::string& str) {
std::size_t stringSize = strlen((const char*) m_Buffer.data() + m_ReadOffset) + 1; // including null character std::size_t stringSize = strlen((const char*)m_Buffer.data() + m_ReadOffset) + 1; // including null character
str.resize(stringSize); str.resize(stringSize);
std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.begin() + m_ReadOffset + stringSize, str.begin()); std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.begin() + m_ReadOffset + stringSize, str.begin());
m_ReadOffset += stringSize; m_ReadOffset += stringSize;
return *this; return *this;
} }
void ReadSome(char* buffer, std::size_t amount){ void ReadSome(char* buffer, std::size_t amount) {
assert(m_ReadOffset + amount <= GetSize()); assert(m_ReadOffset + amount <= GetSize());
std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
m_ReadOffset += amount; m_ReadOffset += amount;
} }
void ReadSome(std::uint8_t* buffer, std::size_t amount){ void ReadSome(std::uint8_t* buffer, std::size_t amount) {
assert(m_ReadOffset + amount <= GetSize()); assert(m_ReadOffset + amount <= GetSize());
std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
m_ReadOffset += amount; m_ReadOffset += amount;
} }
void ReadSome(DataBuffer& buffer, std::size_t amount){ void ReadSome(DataBuffer& buffer, std::size_t amount) {
assert(m_ReadOffset + amount <= GetSize()); assert(m_ReadOffset + amount <= GetSize());
buffer.Resize(amount); buffer.Resize(amount);
std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin()); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
m_ReadOffset += amount; m_ReadOffset += amount;
} }
void ReadSome(std::string& buffer, std::size_t amount){ void ReadSome(std::string& buffer, std::size_t amount) {
assert(m_ReadOffset + amount <= GetSize()); assert(m_ReadOffset + amount <= GetSize());
buffer.resize(amount); buffer.resize(amount);
std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin()); std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
m_ReadOffset += amount; m_ReadOffset += amount;
} }
void Resize(std::size_t size){ void Resize(std::size_t size) {
m_Buffer.resize(size); m_Buffer.resize(size);
} }
void Reserve(std::size_t amount){ void Reserve(std::size_t amount) {
m_Buffer.reserve(amount); m_Buffer.reserve(amount);
} }
void erase(iterator it){ void erase(iterator it) {
m_Buffer.erase(it); m_Buffer.erase(it);
} }
void Clear(){ void Clear() {
m_Buffer.clear(); m_Buffer.clear();
m_ReadOffset = 0; m_ReadOffset = 0;
} }
bool IsFinished() const{ bool IsFinished() const {
return m_ReadOffset >= m_Buffer.size(); return m_ReadOffset >= m_Buffer.size();
} }
std::uint8_t* data(){ std::uint8_t* data() {
return m_Buffer.data(); return m_Buffer.data();
} }
const std::uint8_t* data() const{ const std::uint8_t* data() const {
return m_Buffer.data(); return m_Buffer.data();
} }
std::size_t GetReadOffset() const{ return m_ReadOffset; } std::size_t GetReadOffset() const { return m_ReadOffset; }
void SetReadOffset(std::size_t pos); void SetReadOffset(std::size_t pos);
std::string ToString() const; std::string ToString() const;
@@ -153,8 +153,8 @@ public:
const_iterator begin() const; const_iterator begin() const;
const_iterator end() const; const_iterator end() const;
reference operator[](Data::size_type i){ return m_Buffer[i]; } reference operator[](Data::size_type i) { return m_Buffer[i]; }
const_reference operator[](Data::size_type i) const{ return m_Buffer[i]; } const_reference operator[](Data::size_type i) const { return m_Buffer[i]; }
bool ReadFile(const std::string& fileName); bool ReadFile(const std::string& fileName);
bool WriteFile(const std::string& fileName); bool WriteFile(const std::string& fileName);

10
include/network/TCPListener.h
View File

@@ -1,10 +1,10 @@
#pragma once #pragma once
#include "TCPSocket.h" #include "TCPSocket.h"
namespace td{ namespace td {
namespace network{ namespace network {
class TCPListener{ class TCPListener {
int m_Handle; int m_Handle;
std::uint16_t m_Port; std::uint16_t m_Port;
int m_MaxConnections; int m_MaxConnections;
@@ -20,10 +20,10 @@ public:
bool close(); bool close();
bool setBlocking(bool blocking); bool setBlocking(bool blocking);
std::uint16_t getListeningPort() const{ std::uint16_t getListeningPort() const {
return m_Port; return m_Port;
} }
int getMaximumConnections() const{ int getMaximumConnections() const {
return m_MaxConnections; return m_MaxConnections;
} }

46
include/protocol/PacketHandler.h
View File

@@ -7,34 +7,34 @@ namespace protocol {
class PacketDispatcher; class PacketDispatcher;
class PacketHandler{ class PacketHandler {
private: private:
PacketDispatcher* m_Dispatcher; PacketDispatcher* m_Dispatcher;
public: public:
PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher){} PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher) {}
virtual ~PacketHandler(){} virtual ~PacketHandler() {}
PacketDispatcher* GetDispatcher(){return m_Dispatcher;} PacketDispatcher* GetDispatcher() { return m_Dispatcher; }
virtual void HandlePacket(PlayerLoginPacket* packet){} virtual void HandlePacket(PlayerLoginPacket* packet) {}
virtual void HandlePacket(WorldBeginDataPacket* packet){} virtual void HandlePacket(WorldBeginDataPacket* packet) {}
virtual void HandlePacket(WorldDataPacket* packet){} virtual void HandlePacket(WorldDataPacket* packet) {}
virtual void HandlePacket(KeepAlivePacket* packet){} virtual void HandlePacket(KeepAlivePacket* packet) {}
virtual void HandlePacket(UpdateMoneyPacket* packet){} virtual void HandlePacket(UpdateMoneyPacket* packet) {}
virtual void HandlePacket(UpdateExpPacket* packet){} virtual void HandlePacket(UpdateExpPacket* packet) {}
virtual void HandlePacket(UpdateLobbyTimePacket* packet){} virtual void HandlePacket(UpdateLobbyTimePacket* packet) {}
virtual void HandlePacket(UpdateGameStatePacket* packet){} virtual void HandlePacket(UpdateGameStatePacket* packet) {}
virtual void HandlePacket(PlayerListPacket* packet){} virtual void HandlePacket(PlayerListPacket* packet) {}
virtual void HandlePacket(PlayerJoinPacket* packet){} virtual void HandlePacket(PlayerJoinPacket* packet) {}
virtual void HandlePacket(PlayerLeavePacket* packet){} virtual void HandlePacket(PlayerLeavePacket* packet) {}
virtual void HandlePacket(ConnexionInfoPacket* packet){} virtual void HandlePacket(ConnexionInfoPacket* packet) {}
virtual void HandlePacket(SelectTeamPacket* packet){} virtual void HandlePacket(SelectTeamPacket* packet) {}
virtual void HandlePacket(UpdatePlayerTeamPacket* packet){} virtual void HandlePacket(UpdatePlayerTeamPacket* packet) {}
virtual void HandlePacket(DisconnectPacket* packet){} virtual void HandlePacket(DisconnectPacket* packet) {}
virtual void HandlePacket(ServerTpsPacket* packet){} virtual void HandlePacket(ServerTpsPacket* packet) {}
virtual void HandlePacket(SpawnMobPacket* packet){} virtual void HandlePacket(SpawnMobPacket* packet) {}
virtual void HandlePacket(PlaceTowerPacket* packet){} virtual void HandlePacket(PlaceTowerPacket* packet) {}
virtual void HandlePacket(WorldAddTowerPacket* packet){} virtual void HandlePacket(WorldAddTowerPacket* packet) {}
}; };
} // namespace protocol } // namespace protocol

270
include/protocol/Protocol.h
View File

@@ -9,7 +9,7 @@ namespace protocol {
class PacketHandler; class PacketHandler;
enum class PacketType : std::uint8_t{ enum class PacketType : std::uint8_t {
PlayerLogin = 0, PlayerLogin = 0,
PlayerJoin, PlayerJoin,
PlayerLeave, PlayerLeave,
@@ -32,55 +32,55 @@ enum class PacketType : std::uint8_t{
WorldAddTower WorldAddTower
}; };
class Packet{ class Packet {
public: public:
Packet(){} Packet() {}
virtual ~Packet(){} virtual ~Packet() {}
virtual DataBuffer Serialize() const = 0; virtual DataBuffer Serialize() const = 0;
virtual void Deserialize(DataBuffer& data) = 0; virtual void Deserialize(DataBuffer& data) = 0;
virtual void Dispatch(PacketHandler* handler) = 0; virtual void Dispatch(PacketHandler* handler) = 0;
virtual PacketType getType() const = 0; virtual PacketType getType() const = 0;
std::uint8_t getID() const{ return (std::uint8_t)getType(); } std::uint8_t getID() const { return (std::uint8_t)getType(); }
}; };
class KeepAlivePacket : public Packet{ class KeepAlivePacket : public Packet {
private: private:
std::uint64_t m_AliveID; std::uint64_t m_AliveID;
public: public:
KeepAlivePacket(){} KeepAlivePacket() {}
KeepAlivePacket(std::uint64_t aliveID): m_AliveID(aliveID){} KeepAlivePacket(std::uint64_t aliveID) : m_AliveID(aliveID) {}
virtual ~KeepAlivePacket(){} virtual ~KeepAlivePacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
std::uint64_t getAliveID(){ return m_AliveID; } std::uint64_t getAliveID() { return m_AliveID; }
virtual PacketType getType() const{ return PacketType::KeepAlive; } virtual PacketType getType() const { return PacketType::KeepAlive; }
}; };
class PlayerLoginPacket : public Packet{ class PlayerLoginPacket : public Packet {
private: private:
std::string m_PlayerName; std::string m_PlayerName;
public: public:
PlayerLoginPacket(){} PlayerLoginPacket() {}
PlayerLoginPacket(std::string playerName): m_PlayerName(playerName){} PlayerLoginPacket(std::string playerName) : m_PlayerName(playerName) {}
virtual ~PlayerLoginPacket(){} virtual ~PlayerLoginPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
virtual PacketType getType() const{ return PacketType::PlayerLogin; } virtual PacketType getType() const { return PacketType::PlayerLogin; }
const std::string& getPlayerName(){ return m_PlayerName; } const std::string& getPlayerName() { return m_PlayerName; }
}; };
class WorldBeginDataPacket : public Packet{ class WorldBeginDataPacket : public Packet {
private: private:
game::TowerTileColorPalette m_TowerPlacePalette; game::TowerTileColorPalette m_TowerPlacePalette;
game::Color m_WalkablePalette; game::Color m_WalkablePalette;
@@ -95,264 +95,264 @@ private:
const game::World* m_World; const game::World* m_World;
public: public:
WorldBeginDataPacket(){} WorldBeginDataPacket() {}
WorldBeginDataPacket(const game::World* world): m_World(world){} WorldBeginDataPacket(const game::World* world) : m_World(world) {}
virtual ~WorldBeginDataPacket(){} virtual ~WorldBeginDataPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
virtual PacketType getType() const{ return PacketType::WorldBeginData; } virtual PacketType getType() const { return PacketType::WorldBeginData; }
const game::TowerTileColorPalette& getTowerTilePalette() const{ return m_TowerPlacePalette; } const game::TowerTileColorPalette& getTowerTilePalette() const { return m_TowerPlacePalette; }
const game::Color& getWalkableTileColor() const{ return m_WalkablePalette; } const game::Color& getWalkableTileColor() const { return m_WalkablePalette; }
const std::vector<game::Color>& getDecorationPalette() const{ return m_DecorationPalette; } const std::vector<game::Color>& getDecorationPalette() const { return m_DecorationPalette; }
const game::Spawn& getRedSpawn() const{ return m_RedSpawn; } const game::Spawn& getRedSpawn() const { return m_RedSpawn; }
const game::Spawn& getBlueSpawn() const{ return m_BlueSpawn; } const game::Spawn& getBlueSpawn() const { return m_BlueSpawn; }
const game::SpawnColorPalette& getSpawnPalette() const{ return m_SpawnColorPalette; } const game::SpawnColorPalette& getSpawnPalette() const { return m_SpawnColorPalette; }
const game::TeamCastle& getRedCastle() const{ return m_RedTower; } const game::TeamCastle& getRedCastle() const { return m_RedTower; }
const game::TeamCastle& getBlueCastle() const{ return m_BlueTower; } const game::TeamCastle& getBlueCastle() const { return m_BlueTower; }
const game::TilePalette getTilePalette() const{ return m_TilePalette; } const game::TilePalette getTilePalette() const { return m_TilePalette; }
}; };
class WorldDataPacket : public Packet{ class WorldDataPacket : public Packet {
private: private:
std::unordered_map<game::ChunkCoord, game::ChunkPtr> m_Chunks; std::unordered_map<game::ChunkCoord, game::ChunkPtr> m_Chunks;
const game::World* m_World; const game::World* m_World;
public: public:
WorldDataPacket(){} WorldDataPacket() {}
WorldDataPacket(const game::World* world): m_World(world){} WorldDataPacket(const game::World* world) : m_World(world) {}
virtual ~WorldDataPacket(){} virtual ~WorldDataPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
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_Chunks; } const std::unordered_map<game::ChunkCoord, game::ChunkPtr>& getChunks() const { return m_Chunks; }
}; };
class UpdateMoneyPacket : public Packet{ class UpdateMoneyPacket : public Packet {
private: private:
std::uint32_t m_NewAmount; std::uint32_t m_NewAmount;
public: public:
UpdateMoneyPacket(){} UpdateMoneyPacket() {}
UpdateMoneyPacket(std::uint32_t newAmount): m_NewAmount(newAmount){} UpdateMoneyPacket(std::uint32_t newAmount) : m_NewAmount(newAmount) {}
virtual ~UpdateMoneyPacket(){} virtual ~UpdateMoneyPacket() {}
std::uint32_t getGold() const{ return m_NewAmount; } std::uint32_t getGold() const { return m_NewAmount; }
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
virtual PacketType getType() const{ return PacketType::UpdateMoney; } virtual PacketType getType() const { return PacketType::UpdateMoney; }
}; };
class UpdateExpPacket : public Packet{ class UpdateExpPacket : public Packet {
private: private:
std::uint32_t m_NewAmount; std::uint32_t m_NewAmount;
public: public:
UpdateExpPacket(){} UpdateExpPacket() {}
UpdateExpPacket(std::uint32_t newAmount): m_NewAmount(newAmount){} UpdateExpPacket(std::uint32_t newAmount) : m_NewAmount(newAmount) {}
virtual ~UpdateExpPacket(){} virtual ~UpdateExpPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
virtual PacketType getType() const{ return PacketType::UpdateEXP; } virtual PacketType getType() const { return PacketType::UpdateEXP; }
}; };
class UpdateLobbyTimePacket : public Packet{ class UpdateLobbyTimePacket : public Packet {
private: private:
std::uint32_t m_RemainingTime; std::uint32_t m_RemainingTime;
public: public:
UpdateLobbyTimePacket(){} UpdateLobbyTimePacket() {}
UpdateLobbyTimePacket(std::uint32_t remainingTime): m_RemainingTime(remainingTime){} UpdateLobbyTimePacket(std::uint32_t remainingTime) : m_RemainingTime(remainingTime) {}
virtual ~UpdateLobbyTimePacket(){} virtual ~UpdateLobbyTimePacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
std::uint32_t getRemainingTime() const{ return m_RemainingTime; } std::uint32_t getRemainingTime() const { return m_RemainingTime; }
virtual PacketType getType() const{ return PacketType::UpdateLobbyTime; } virtual PacketType getType() const { return PacketType::UpdateLobbyTime; }
}; };
class UpdateGameStatePacket : public Packet{ class UpdateGameStatePacket : public Packet {
private: private:
game::GameState m_GameState; game::GameState m_GameState;
public: public:
UpdateGameStatePacket(){} UpdateGameStatePacket() {}
UpdateGameStatePacket(game::GameState gameState): m_GameState(gameState){} UpdateGameStatePacket(game::GameState gameState) : m_GameState(gameState) {}
virtual ~UpdateGameStatePacket(){} virtual ~UpdateGameStatePacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
game::GameState getGameState() const{ return m_GameState; } game::GameState getGameState() const { return m_GameState; }
virtual PacketType getType() const{ return PacketType::UpdateGameState; } virtual PacketType getType() const { return PacketType::UpdateGameState; }
}; };
struct PlayerInfo{ struct PlayerInfo {
std::string name; std::string name;
game::TeamColor team; game::TeamColor team;
}; };
class PlayerListPacket : public Packet{ class PlayerListPacket : public Packet {
private: private:
std::map<std::uint8_t, PlayerInfo> m_Players; std::map<std::uint8_t, PlayerInfo> m_Players;
public: public:
PlayerListPacket(){} PlayerListPacket() {}
PlayerListPacket(std::map<std::uint8_t, PlayerInfo> players): m_Players(players){} PlayerListPacket(std::map<std::uint8_t, PlayerInfo> players) : m_Players(players) {}
virtual ~PlayerListPacket(){} virtual ~PlayerListPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
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{ class PlayerJoinPacket : public Packet {
private: private:
std::uint8_t m_PlayerID; std::uint8_t m_PlayerID;
std::string m_PlayerName; std::string m_PlayerName;
public: public:
PlayerJoinPacket(){} PlayerJoinPacket() {}
PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName): m_PlayerID(playerID), m_PlayerName(playerName){} PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName) : m_PlayerID(playerID), m_PlayerName(playerName) {}
virtual ~PlayerJoinPacket(){} virtual ~PlayerJoinPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
std::uint8_t getPlayerID() const{ return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
const std::string& getPlayerName() const{ return m_PlayerName; } const std::string& getPlayerName() const { return m_PlayerName; }
virtual PacketType getType() const{ return PacketType::PlayerJoin; } virtual PacketType getType() const { return PacketType::PlayerJoin; }
}; };
class PlayerLeavePacket : public Packet{ class PlayerLeavePacket : public Packet {
private: private:
std::uint8_t m_PlayerID; std::uint8_t m_PlayerID;
public: public:
PlayerLeavePacket(){} PlayerLeavePacket() {}
PlayerLeavePacket(std::uint8_t playerID): m_PlayerID(playerID){} PlayerLeavePacket(std::uint8_t playerID) : m_PlayerID(playerID) {}
virtual ~PlayerLeavePacket(){} virtual ~PlayerLeavePacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
std::uint8_t getPlayerID() const{ return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
virtual PacketType getType() const{ return PacketType::PlayerLeave; } virtual PacketType getType() const { return PacketType::PlayerLeave; }
}; };
class ConnexionInfoPacket : public Packet{ class ConnexionInfoPacket : public Packet {
private: private:
std::uint8_t m_ConnectionID; std::uint8_t m_ConnectionID;
public: public:
ConnexionInfoPacket(){} ConnexionInfoPacket() {}
ConnexionInfoPacket(std::uint8_t connectionID): m_ConnectionID(connectionID){} ConnexionInfoPacket(std::uint8_t connectionID) : m_ConnectionID(connectionID) {}
virtual ~ConnexionInfoPacket(){} virtual ~ConnexionInfoPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
std::uint8_t getConnectionID() const{ return m_ConnectionID; } std::uint8_t getConnectionID() const { return m_ConnectionID; }
virtual PacketType getType() const{ return PacketType::ConnectionInfo; } virtual PacketType getType() const { return PacketType::ConnectionInfo; }
}; };
class SelectTeamPacket : public Packet{ class SelectTeamPacket : public Packet {
private: private:
game::TeamColor m_SelectedTeam; game::TeamColor m_SelectedTeam;
public: public:
SelectTeamPacket(){} SelectTeamPacket() {}
SelectTeamPacket(game::TeamColor selectedTeam): m_SelectedTeam(selectedTeam){} SelectTeamPacket(game::TeamColor selectedTeam) : m_SelectedTeam(selectedTeam) {}
virtual ~SelectTeamPacket(){} virtual ~SelectTeamPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; } game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
virtual PacketType getType() const{ return PacketType::SelectTeam; } virtual PacketType getType() const { return PacketType::SelectTeam; }
}; };
class UpdatePlayerTeamPacket : public Packet{ class UpdatePlayerTeamPacket : public Packet {
private: private:
std::uint8_t m_PlayerID; std::uint8_t m_PlayerID;
game::TeamColor m_SelectedTeam; game::TeamColor m_SelectedTeam;
public: public:
UpdatePlayerTeamPacket(){} UpdatePlayerTeamPacket() {}
UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam): m_PlayerID(playerID), m_SelectedTeam(selectedTeam){} UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam) : m_PlayerID(playerID), m_SelectedTeam(selectedTeam) {}
virtual ~UpdatePlayerTeamPacket(){} virtual ~UpdatePlayerTeamPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; } game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
std::uint8_t getPlayerID() const{ return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
virtual PacketType getType() const{ return PacketType::UpdatePlayerTeam; } virtual PacketType getType() const { return PacketType::UpdatePlayerTeam; }
}; };
class DisconnectPacket : public Packet{ class DisconnectPacket : public Packet {
private: private:
std::string m_Reason; // only when sent from server std::string m_Reason; // only when sent from server
public: public:
DisconnectPacket(){} DisconnectPacket() {}
DisconnectPacket(std::string reason): m_Reason(reason){} DisconnectPacket(std::string reason) : m_Reason(reason) {}
virtual ~DisconnectPacket(){} virtual ~DisconnectPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
const std::string& getReason() const{ return m_Reason; } const std::string& getReason() const { return m_Reason; }
virtual PacketType getType() const{ return PacketType::Disconnect; } virtual PacketType getType() const { return PacketType::Disconnect; }
}; };
class ServerTpsPacket : public Packet{ class ServerTpsPacket : public Packet {
private: private:
float m_TPS; float m_TPS;
std::uint64_t m_PacketSendTime; // used to calculate ping std::uint64_t m_PacketSendTime; // used to calculate ping
public: public:
ServerTpsPacket(){} ServerTpsPacket() {}
ServerTpsPacket(float tps, std::uint64_t sendTime): m_TPS(tps), m_PacketSendTime(sendTime){} ServerTpsPacket(float tps, std::uint64_t sendTime) : m_TPS(tps), m_PacketSendTime(sendTime) {}
virtual ~ServerTpsPacket(){} virtual ~ServerTpsPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
float getTPS() const{ return m_TPS; } float getTPS() const { return m_TPS; }
std::uint64_t getPacketSendTime() const {return m_PacketSendTime;} std::uint64_t getPacketSendTime() const { return m_PacketSendTime; }
virtual PacketType getType() const{ return PacketType::ServerTps; } virtual PacketType getType() const { return PacketType::ServerTps; }
}; };
class SpawnMobPacket : public Packet{ class SpawnMobPacket : public Packet {
private: private:
game::MobID m_MobID; game::MobID m_MobID;
game::MobType m_MobType; game::MobType m_MobType;
@@ -361,36 +361,36 @@ private:
game::PlayerID m_Sender; game::PlayerID m_Sender;
float m_MobX, m_MobY; float m_MobX, m_MobY;
public: public:
SpawnMobPacket(){} SpawnMobPacket() {}
SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender, SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender,
float x, float y, game::Direction dir) : m_MobID(id), m_MobType(type), m_MobLevel(level), float x, float y, game::Direction dir) : m_MobID(id), m_MobType(type), m_MobLevel(level),
m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y){} m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y) {}
virtual ~SpawnMobPacket(){} virtual ~SpawnMobPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler);
game::MobID getMobID() const{ return m_MobID; } game::MobID getMobID() const { return m_MobID; }
game::MobType getMobType() const{ return m_MobType; } game::MobType getMobType() const { return m_MobType; }
game::MobLevel getMobLevel() const{ return m_MobLevel; } game::MobLevel getMobLevel() const { return m_MobLevel; }
game::Direction getMobDirection() const{ return m_MobDirection; } game::Direction getMobDirection() const { return m_MobDirection; }
game::PlayerID getSender() const{ return m_Sender; } game::PlayerID getSender() const { return m_Sender; }
float getMobX() const{ return m_MobX; } float getMobX() const { return m_MobX; }
float getMobY() const{ return m_MobY; } float getMobY() const { return m_MobY; }
virtual PacketType getType() const{ return PacketType::SpawnMob; } virtual PacketType getType() const { return PacketType::SpawnMob; }
}; };
class PlaceTowerPacket : public Packet{ class PlaceTowerPacket : public Packet {
private: private:
std::int32_t m_TowerX, m_TowerY; std::int32_t m_TowerX, m_TowerY;
game::TowerType m_TowerType; game::TowerType m_TowerType;
public: public:
PlaceTowerPacket(){} PlaceTowerPacket() {}
PlaceTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type) : PlaceTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type) :
m_TowerX(x), m_TowerY(y), m_TowerType(type){} m_TowerX(x), m_TowerY(y), m_TowerType(type) {}
virtual ~PlaceTowerPacket(){} virtual ~PlaceTowerPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
@@ -400,19 +400,19 @@ public:
std::int32_t getTowerY() const { return m_TowerY; } std::int32_t getTowerY() const { return m_TowerY; }
game::TowerType getTowerType() const { return m_TowerType; } game::TowerType getTowerType() const { return m_TowerType; }
virtual PacketType getType() const{ return PacketType::PlaceTower; } virtual PacketType getType() const { return PacketType::PlaceTower; }
}; };
class WorldAddTowerPacket : public Packet{ class WorldAddTowerPacket : public Packet {
private: private:
std::int32_t m_TowerX, m_TowerY; std::int32_t m_TowerX, m_TowerY;
game::TowerType m_TowerType; game::TowerType m_TowerType;
game::PlayerID m_Builder; game::PlayerID m_Builder;
public: public:
WorldAddTowerPacket(){} WorldAddTowerPacket() {}
WorldAddTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type, game::PlayerID player) : WorldAddTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type, game::PlayerID player) :
m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player){} m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player) {}
virtual ~WorldAddTowerPacket(){} virtual ~WorldAddTowerPacket() {}
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
@@ -421,9 +421,9 @@ public:
std::int32_t getTowerX() const { return m_TowerX; } std::int32_t getTowerX() const { return m_TowerX; }
std::int32_t getTowerY() const { return m_TowerY; } std::int32_t getTowerY() const { return m_TowerY; }
game::TowerType getTowerType() const { return m_TowerType; } game::TowerType getTowerType() const { return m_TowerType; }
game::PlayerID getBuilder() const {return m_Builder;} game::PlayerID getBuilder() const { return m_Builder; }
virtual PacketType getType() const{ return PacketType::WorldAddTower; } virtual PacketType getType() const { return PacketType::WorldAddTower; }
}; };
} }

4
include/render/WorldRenderer.h
View File

@@ -8,7 +8,7 @@
namespace td { namespace td {
namespace client{ namespace client {
class ClientGame; class ClientGame;
@@ -17,7 +17,7 @@ class ClientGame;
namespace render { namespace render {
class WorldRenderer{ class WorldRenderer {
private: private:
client::ClientGame* m_Client; client::ClientGame* m_Client;
Renderer* m_Renderer; Renderer* m_Renderer;

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

@@ -14,20 +14,20 @@
className& operator=(const className &) = delete className& operator=(const className &) = delete
namespace GL{ namespace GL {
struct VertexAttribPointer{ struct VertexAttribPointer {
unsigned int m_Index, m_Size; unsigned int m_Index, m_Size;
int m_Offset; int m_Offset;
}; };
class VertexBuffer{ class VertexBuffer {
private: private:
unsigned int m_ID, m_DataStride; unsigned int m_ID, m_DataStride;
std::vector<VertexAttribPointer> m_VertexAttribs; std::vector<VertexAttribPointer> m_VertexAttribs;
public: public:
REMOVE_COPY(VertexBuffer); REMOVE_COPY(VertexBuffer);
VertexBuffer(VertexBuffer&& other){ VertexBuffer(VertexBuffer&& other) {
m_VertexAttribs = std::move(other.m_VertexAttribs); m_VertexAttribs = std::move(other.m_VertexAttribs);
m_ID = other.m_ID; m_ID = other.m_ID;
m_DataStride = other.m_DataStride; m_DataStride = other.m_DataStride;
@@ -42,13 +42,13 @@ class VertexBuffer{
void bindVertexAttribs() const; void bindVertexAttribs() const;
}; };
class VertexArray{ class VertexArray {
private: private:
unsigned int m_ID, m_VertexCount; unsigned int m_ID, m_VertexCount;
std::vector<VertexBuffer> m_VertexBuffers; //use to destroy vbos when become unused std::vector<VertexBuffer> m_VertexBuffers; //use to destroy vbos when become unused
public: public:
REMOVE_COPY(VertexArray); REMOVE_COPY(VertexArray);
VertexArray(VertexArray&& other){ VertexArray(VertexArray&& other) {
m_ID = other.m_ID; m_ID = other.m_ID;
m_VertexCount = other.m_VertexCount; m_VertexCount = other.m_VertexCount;
m_VertexBuffers = std::move(other.m_VertexBuffers); m_VertexBuffers = std::move(other.m_VertexBuffers);
@@ -57,7 +57,7 @@ class VertexArray{
} }
VertexArray(unsigned int vertexCount); VertexArray(unsigned int vertexCount);
~VertexArray(); ~VertexArray();
unsigned int getVertexCount() const {return m_VertexCount;} unsigned int getVertexCount() const { return m_VertexCount; }
void bindVertexBuffer(VertexBuffer& vbo); void bindVertexBuffer(VertexBuffer& vbo);
void bind() const; void bind() const;
void unbind() const; void unbind() const;

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

@@ -8,7 +8,7 @@
#ifndef RENDER_LOADER_TEXTURELOADER_H_ #ifndef RENDER_LOADER_TEXTURELOADER_H_
#define RENDER_LOADER_TEXTURELOADER_H_ #define RENDER_LOADER_TEXTURELOADER_H_
namespace TextureLoader{ namespace TextureLoader {
const unsigned int loadGLTexture(const char* fileName); const unsigned int loadGLTexture(const char* fileName);
} }

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

@@ -2,7 +2,7 @@
#include "ShaderProgram.h" #include "ShaderProgram.h"
class EntityShader : public ShaderProgram{ class EntityShader : public ShaderProgram {
private: private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_translation = 0, location_viewtype = 0; unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_translation = 0, location_viewtype = 0;
protected: protected:

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

@@ -11,8 +11,8 @@
#include <string> #include <string>
#include <glm/glm.hpp> #include <glm/glm.hpp>
namespace gl{ namespace gl {
enum class GLenum : unsigned int; enum class GLenum : unsigned int;
} }
class ShaderProgram { class ShaderProgram {

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

@@ -10,7 +10,7 @@
#include "ShaderProgram.h" #include "ShaderProgram.h"
class WorldShader : public ShaderProgram{ class WorldShader : public ShaderProgram {
private: private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_viewtype = 0; unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_viewtype = 0;
protected: protected:

2
include/window/Display.h
View File

@@ -9,7 +9,7 @@
#define WINDOW_DISPLAY_H_ #define WINDOW_DISPLAY_H_
namespace Display{ namespace Display {
void create(); void create();
void render(); void render();

4
src/Tower Defense.cpp
View File

@@ -9,10 +9,10 @@
#include "window/Display.h" #include "window/Display.h"
#include "misc/Random.h" #include "misc/Random.h"
int main(int argc, const char* args[]){ int main(int argc, const char* args[]) {
td::utils::initRandomizer(); td::utils::initRandomizer();
Display::create(); Display::create();
while (!Display::isCloseRequested()){ while (!Display::isCloseRequested()) {
Display::pollEvents(); Display::pollEvents();
Display::render(); Display::render();
Display::update(); Display::update();

8
src/game/BaseGame.cpp
View File

@@ -3,16 +3,16 @@
namespace td { namespace td {
namespace game { namespace game {
Game::Game(World* world) : m_World(world){ Game::Game(World* world) : m_World(world) {
} }
Game::~Game(){ Game::~Game() {
} }
void Game::tick(std::uint64_t delta){ void Game::tick(std::uint64_t delta) {
if(m_GameState == GameState::Game){ if (m_GameState == GameState::Game) {
m_World->tick(delta); m_World->tick(delta);
} }
} }

22
src/game/Connexion.cpp
View File

@@ -12,15 +12,15 @@
namespace td { namespace td {
namespace protocol { namespace protocol {
Connexion::Connexion() : protocol::PacketHandler(nullptr){ Connexion::Connexion() : protocol::PacketHandler(nullptr) {
} }
Connexion::Connexion(Connexion&& move) : protocol::PacketHandler(&m_Dispatcher), m_Socket(std::move(move.m_Socket)){ Connexion::Connexion(Connexion&& move) : protocol::PacketHandler(&m_Dispatcher), m_Socket(std::move(move.m_Socket)) {
} }
Connexion::Connexion(protocol::PacketDispatcher* dispatcher) : protocol::PacketHandler(dispatcher){ Connexion::Connexion(protocol::PacketDispatcher* dispatcher) : protocol::PacketHandler(dispatcher) {
} }
@@ -28,13 +28,13 @@ Connexion::Connexion(protocol::PacketDispatcher* dispatcher, network::TCPSocket&
} }
bool Connexion::updateSocket(){ bool Connexion::updateSocket() {
if(m_Socket.GetStatus() != network::Socket::Connected) if (m_Socket.GetStatus() != network::Socket::Connected)
return false; return false;
DataBuffer buffer; DataBuffer buffer;
m_Socket.Receive(buffer, sizeof(std::uint64_t)); m_Socket.Receive(buffer, sizeof(std::uint64_t));
if (buffer.GetSize() > 0){ if (buffer.GetSize() > 0) {
std::uint64_t packetLenght; std::uint64_t packetLenght;
buffer >> packetLenght; buffer >> packetLenght;
@@ -52,23 +52,23 @@ bool Connexion::updateSocket(){
return true; 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)){ if (!m_Socket.Connect(address, port)) {
return false; return false;
} }
m_Socket.SetBlocking(false); m_Socket.SetBlocking(false);
return true; return true;
} }
void Connexion::sendPacket(protocol::Packet* packet){ void Connexion::sendPacket(protocol::Packet* packet) {
network::SendPacket(packet->Serialize(), m_Socket); network::SendPacket(packet->Serialize(), m_Socket);
} }
void Connexion::closeConnection(){ void Connexion::closeConnection() {
m_Socket.Disconnect(); m_Socket.Disconnect();
} }
Connexion::~Connexion(){ Connexion::~Connexion() {
} }

14
src/game/Mobs.cpp
View File

@@ -69,8 +69,8 @@ const std::map<MobKey, MobStats> MobConstants = {
{{MobType::Giant, 5},{MobStats{0, 0, 0, 0, 0, 0}}}, {{MobType::Giant, 5},{MobStats{0, 0, 0, 0, 0, 0}}},
}; };
const MobStats* getMobStats(MobType type, std::uint8_t level){ const MobStats* getMobStats(MobType type, std::uint8_t level) {
return &MobConstants.at(MobKey{type, level}); return &MobConstants.at(MobKey{ type, level });
} }
const std::map<MobKey, TowerImmunities> MobsTowerImmunities = { const std::map<MobKey, TowerImmunities> MobsTowerImmunities = {
@@ -135,8 +135,8 @@ const std::map<MobKey, TowerImmunities> MobsTowerImmunities = {
{{MobType::Giant, 5},{}}, {{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}); return MobsTowerImmunities.at({ type, level });
} }
const std::map<MobKey, EffectImmunities> MobsEffectImmunities = { const std::map<MobKey, EffectImmunities> MobsEffectImmunities = {
@@ -201,11 +201,11 @@ const std::map<MobKey, EffectImmunities> MobsEffectImmunities = {
{{MobType::Giant, 5},{EffectType::Stun}}, {{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}); 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)>; using MobCreator = std::function<std::shared_ptr<Mob>(MobID, std::uint8_t, PlayerID)>;
static std::map<MobType, MobCreator> mobFactory = { static std::map<MobType, MobCreator> mobFactory = {

10
src/game/Team.cpp
View File

@@ -3,22 +3,22 @@
namespace td { namespace td {
namespace game { namespace game {
Team::Team(TeamColor color): m_Color(color){} Team::Team(TeamColor color) : m_Color(color) {}
void Team::addPlayer(Player* newPlayer){ void Team::addPlayer(Player* newPlayer) {
m_Players.push_back(newPlayer); m_Players.push_back(newPlayer);
newPlayer->setTeamColor(m_Color); newPlayer->setTeamColor(m_Color);
} }
void Team::removePlayer(const Player* player){ void Team::removePlayer(const Player* player) {
m_Players.erase(std::find(m_Players.begin(), m_Players.end(), player)); m_Players.erase(std::find(m_Players.begin(), m_Players.end(), player));
} }
TeamColor Team::getColor() const{ TeamColor Team::getColor() const {
return m_Color; return m_Color;
} }
std::uint8_t Team::getPlayerCount() const{ std::uint8_t Team::getPlayerCount() const {
return m_Players.size(); return m_Players.size();
} }

26
src/game/Towers.cpp
View File

@@ -103,57 +103,57 @@ const std::map<std::pair<TowerType, TowerLevel>, TowerStats> TowerConstants = {
{{TowerType::Necromancer, {4, TowerPath::Bottom}}, {0, 0, 0}}, {{TowerType::Necromancer, {4, TowerPath::Bottom}}, {0, 0, 0}},
}; };
const TowerStats* getTowerStats(TowerType type, TowerLevel level){ const TowerStats* getTowerStats(TowerType type, TowerLevel level) {
return &TowerConstants.at({type, level}); return &TowerConstants.at({ type, level });
} }
void ArcherTower::tick(std::uint64_t delta){ void ArcherTower::tick(std::uint64_t delta) {
} }
void IceTower::tick(std::uint64_t delta){ void IceTower::tick(std::uint64_t delta) {
} }
void MageTower::tick(std::uint64_t delta){ void MageTower::tick(std::uint64_t delta) {
} }
void PoisonTower::tick(std::uint64_t delta){ void PoisonTower::tick(std::uint64_t delta) {
} }
void QuakeTower::tick(std::uint64_t delta){ void QuakeTower::tick(std::uint64_t delta) {
} }
void ZeusTower::tick(std::uint64_t delta){ void ZeusTower::tick(std::uint64_t delta) {
} }
void ArtilleryTower::tick(std::uint64_t delta){ void ArtilleryTower::tick(std::uint64_t delta) {
} }
void SorcererTower::tick(std::uint64_t delta){ void SorcererTower::tick(std::uint64_t delta) {
} }
void LeachTower::tick(std::uint64_t delta){ void LeachTower::tick(std::uint64_t delta) {
} }
void TurretTower::tick(std::uint64_t delta){ void TurretTower::tick(std::uint64_t delta) {
} }
void NecromancerTower::tick(std::uint64_t delta){ void NecromancerTower::tick(std::uint64_t delta) {
} }

106
src/game/World.cpp
View File

@@ -14,21 +14,21 @@
namespace td { namespace td {
namespace game { namespace game {
World::World(Game* game) : m_Game(game){ World::World(Game* game) : m_Game(game) {
#if WRITE_MAP #if WRITE_MAP
loadMapFromFile(""); loadMapFromFile("");
#endif #endif
} }
TilePtr World::getTile(std::int32_t x, std::int32_t y){ TilePtr World::getTile(std::int32_t x, std::int32_t y) {
std::int16_t chunkX = x / Chunk::ChunkWidth; std::int16_t chunkX = x / Chunk::ChunkWidth;
std::int16_t chunkY = y / Chunk::ChunkHeight; std::int16_t chunkY = y / Chunk::ChunkHeight;
std::uint16_t subChunkX = x % Chunk::ChunkWidth; std::uint16_t subChunkX = x % Chunk::ChunkWidth;
std::uint16_t subChunkY = y % Chunk::ChunkHeight; std::uint16_t subChunkY = y % Chunk::ChunkHeight;
auto chunkIt = m_Chunks.find({chunkX, chunkY}); auto chunkIt = m_Chunks.find({ chunkX, chunkY });
if(chunkIt == m_Chunks.end()) if (chunkIt == m_Chunks.end())
return nullptr; return nullptr;
ChunkPtr chunk = chunkIt->second; ChunkPtr chunk = chunkIt->second;
@@ -36,7 +36,7 @@ TilePtr World::getTile(std::int32_t x, std::int32_t y){
return getTilePtr(chunk->getTileIndex(subChunkY * Chunk::ChunkWidth + subChunkX)); return getTilePtr(chunk->getTileIndex(subChunkY * Chunk::ChunkWidth + subChunkX));
} }
bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader){ bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader) {
m_TowerPlacePalette = worldHeader->getTowerTilePalette(); m_TowerPlacePalette = worldHeader->getTowerTilePalette();
m_WalkablePalette = worldHeader->getWalkableTileColor(); m_WalkablePalette = worldHeader->getWalkableTileColor();
m_DecorationPalette = worldHeader->getDecorationPalette(); m_DecorationPalette = worldHeader->getDecorationPalette();
@@ -54,15 +54,15 @@ bool World::loadMap(const protocol::WorldBeginDataPacket* worldHeader){
return true; return true;
} }
bool World::loadMap(const protocol::WorldDataPacket* worldData){ bool World::loadMap(const protocol::WorldDataPacket* worldData) {
m_Chunks = worldData->getChunks(); m_Chunks = worldData->getChunks();
return true; return true;
} }
bool World::loadMapFromFile(const std::string& fileName){ bool World::loadMapFromFile(const std::string& fileName) {
#if !WRITE_MAP #if !WRITE_MAP
DataBuffer buffer; DataBuffer buffer;
if(!buffer.ReadFile(fileName)){ if (!buffer.ReadFile(fileName)) {
std::cerr << "Failed to load map from file " << fileName << " !\n"; std::cerr << "Failed to load map from file " << fileName << " !\n";
} }
@@ -89,10 +89,10 @@ bool World::loadMapFromFile(const std::string& fileName){
return true; return true;
#else #else
m_WalkablePalette = {102, 102, 153}; m_WalkablePalette = { 102, 102, 153 };
m_TowerPlacePalette[0] = {204, 51, 0}; m_TowerPlacePalette[0] = { 204, 51, 0 };
m_TowerPlacePalette[1] = {255, 153, 0}; m_TowerPlacePalette[1] = { 255, 153, 0 };
WalkableTile walkableTileDown; // 1 WalkableTile walkableTileDown; // 1
walkableTileDown.direction = Direction::PositiveY; walkableTileDown.direction = Direction::PositiveY;
@@ -137,12 +137,12 @@ bool World::loadMapFromFile(const std::string& fileName){
getRedTeam().getSpawn().y = 13; getRedTeam().getSpawn().y = 13;
getRedTeam().getSpawn().direction = Direction::PositiveY; getRedTeam().getSpawn().direction = Direction::PositiveY;
m_SpawnColorPalette[(uint) TeamColor::Red] = {255, 0, 0}; m_SpawnColorPalette[(uint)TeamColor::Red] = { 255, 0, 0 };
//Chunks //Chunks
Chunk chunk0; Chunk chunk0;
for (int i = 0; i <= 6; i++){ for (int i = 0; i <= 6; i++) {
chunk0.palette.push_back(i); chunk0.palette.push_back(i);
} }
chunk0.tiles = { chunk0.tiles = {
@@ -182,7 +182,7 @@ bool World::loadMapFromFile(const std::string& fileName){
Chunk chunk1; Chunk chunk1;
for (int i = 0; i <= 6; i++){ for (int i = 0; i <= 6; i++) {
chunk1.palette.push_back(i); chunk1.palette.push_back(i);
} }
@@ -223,7 +223,7 @@ bool World::loadMapFromFile(const std::string& fileName){
Chunk chunk2; Chunk chunk2;
for (int i = 0; i <= 6; i++){ for (int i = 0; i <= 6; i++) {
chunk2.palette.push_back(i); chunk2.palette.push_back(i);
} }
@@ -262,9 +262,9 @@ bool World::loadMapFromFile(const std::string& fileName){
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
}; };
m_Chunks.insert({{0, 0}, std::make_shared<Chunk>(chunk0)}); m_Chunks.insert({ {0, 0}, std::make_shared<Chunk>(chunk0) });
m_Chunks.insert({{1, 0}, std::make_shared<Chunk>(chunk1)}); m_Chunks.insert({ {1, 0}, std::make_shared<Chunk>(chunk1) });
m_Chunks.insert({{1, 1}, std::make_shared<Chunk>(chunk2)}); m_Chunks.insert({ {1, 1}, std::make_shared<Chunk>(chunk2) });
// blue map = same but with offset of 64 (in x coordinate) // blue map = same but with offset of 64 (in x coordinate)
@@ -276,35 +276,35 @@ bool World::loadMapFromFile(const std::string& fileName){
getBlueTeam().getSpawn().y = 13; getBlueTeam().getSpawn().y = 13;
getBlueTeam().getSpawn().direction = Direction::PositiveY; getBlueTeam().getSpawn().direction = Direction::PositiveY;
m_SpawnColorPalette[(uint) TeamColor::Blue] = {0, 0, 255}; m_SpawnColorPalette[(uint)TeamColor::Blue] = { 0, 0, 255 };
Chunk chunk01; Chunk chunk01;
chunk01.palette = {0, 1, 2, 3, 4, 7, 8}; chunk01.palette = { 0, 1, 2, 3, 4, 7, 8 };
chunk01.tiles = chunk0.tiles; // the tiles indicies are the same, only the palette has changed chunk01.tiles = chunk0.tiles; // the tiles indicies are the same, only the palette has changed
Chunk chunk11; Chunk chunk11;
chunk11.palette = {0, 1, 2, 3, 4, 7, 8}; chunk11.palette = { 0, 1, 2, 3, 4, 7, 8 };
chunk11.tiles = chunk1.tiles; // the tiles indicies are the same, only the palette has changed chunk11.tiles = chunk1.tiles; // the tiles indicies are the same, only the palette has changed
Chunk chunk21; Chunk chunk21;
chunk21.palette = {0, 1, 2, 3, 4, 7, 8}; chunk21.palette = { 0, 1, 2, 3, 4, 7, 8 };
chunk21.tiles = chunk2.tiles; // the tiles indicies are the same, only the palette has changed chunk21.tiles = chunk2.tiles; // the tiles indicies are the same, only the palette has changed
m_Chunks.insert({{2, 0}, std::make_shared<Chunk>(chunk01)}); m_Chunks.insert({ {2, 0}, std::make_shared<Chunk>(chunk01) });
m_Chunks.insert({{3, 0}, std::make_shared<Chunk>(chunk11)}); m_Chunks.insert({ {3, 0}, std::make_shared<Chunk>(chunk11) });
m_Chunks.insert({{3, 1}, std::make_shared<Chunk>(chunk21)}); m_Chunks.insert({ {3, 1}, std::make_shared<Chunk>(chunk21) });
saveMap("tdmap.tdmap"); saveMap("tdmap.tdmap");
#endif #endif
} }
bool World::saveMap(const std::string& fileName) const{ bool World::saveMap(const std::string& fileName) const {
protocol::WorldBeginDataPacket headerPacket(this); protocol::WorldBeginDataPacket headerPacket(this);
protocol::WorldDataPacket dataPacket(this); protocol::WorldDataPacket dataPacket(this);
@@ -319,11 +319,11 @@ bool World::saveMap(const std::string& fileName) const{
return buffer.WriteFile(fileName); return buffer.WriteFile(fileName);
} }
void World::tick(std::uint64_t delta){ void World::tick(std::uint64_t delta) {
moveMobs(delta); moveMobs(delta);
} }
void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir){ void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir) {
MobPtr mob = MobFactory::createMob(id, type, level, sender); MobPtr mob = MobFactory::createMob(id, type, level, sender);
mob->setX(x); mob->setX(x);
mob->setY(y); mob->setY(y);
@@ -331,33 +331,33 @@ void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID send
m_Mobs.push_back(mob); m_Mobs.push_back(mob);
} }
void World::moveMobs(std::uint64_t delta){ void World::moveMobs(std::uint64_t delta) {
for(MobPtr mob : m_Mobs){ for (MobPtr mob : m_Mobs) {
TilePtr tile = getTile(mob->getX(), mob->getY()); TilePtr tile = getTile(mob->getX(), mob->getY());
if(tile != nullptr && tile->getType() == TileType::Walk){ if (tile != nullptr && tile->getType() == TileType::Walk) {
WalkableTile* walkTile = dynamic_cast<WalkableTile*>(tile.get()); WalkableTile* walkTile = dynamic_cast<WalkableTile*>(tile.get());
mob->setDirection(walkTile->direction); mob->setDirection(walkTile->direction);
} }
float mobWalkSpeed = mob->getStats()->getMovementSpeed(); float mobWalkSpeed = mob->getStats()->getMovementSpeed();
float walkAmount = mobWalkSpeed * ((float) delta / 1000.0f); float walkAmount = mobWalkSpeed * ((float)delta / 1000.0f);
switch(mob->getDirection()){ switch (mob->getDirection()) {
case Direction::NegativeX:{ case Direction::NegativeX: {
mob->setX(mob->getX() - walkAmount); mob->setX(mob->getX() - walkAmount);
break; break;
} }
case Direction::PositiveX:{ case Direction::PositiveX: {
mob->setX(mob->getX() + walkAmount); mob->setX(mob->getX() + walkAmount);
break; break;
} }
case Direction::NegativeY:{ case Direction::NegativeY: {
mob->setY(mob->getY() - walkAmount); mob->setY(mob->getY() - walkAmount);
break; break;
} }
case Direction::PositiveY:{ case Direction::PositiveY: {
mob->setY(mob->getY() + walkAmount); mob->setY(mob->getY() + walkAmount);
break; break;
} }
@@ -365,48 +365,48 @@ void World::moveMobs(std::uint64_t delta){
} }
} }
const Color* World::getTileColor(TilePtr tile) const{ const Color* World::getTileColor(TilePtr tile) const {
switch(tile->getType()){ switch (tile->getType()) {
case TileType::Tower:{ case TileType::Tower: {
TowerTile* towerTile = (TowerTile*) tile.get(); TowerTile* towerTile = (TowerTile*)tile.get();
return &m_TowerPlacePalette[towerTile->color_palette_ref]; return &m_TowerPlacePalette[towerTile->color_palette_ref];
} }
case TileType::Walk:{ case TileType::Walk: {
return &m_WalkablePalette; return &m_WalkablePalette;
} }
case TileType::Decoration:{ case TileType::Decoration: {
DecorationTile* towerTile = (DecorationTile*) tile.get(); DecorationTile* towerTile = (DecorationTile*)tile.get();
return &m_DecorationPalette[towerTile->color_palette_ref]; return &m_DecorationPalette[towerTile->color_palette_ref];
break; break;
} }
case TileType::None:{ case TileType::None: {
return nullptr; return nullptr;
} }
} }
return nullptr; return nullptr;
} }
Team& World::getRedTeam(){ Team& World::getRedTeam() {
return m_Game->getRedTeam(); return m_Game->getRedTeam();
} }
const Team& World::getRedTeam() const{ const Team& World::getRedTeam() const {
return m_Game->getRedTeam(); return m_Game->getRedTeam();
} }
Team& World::getBlueTeam(){ Team& World::getBlueTeam() {
return m_Game->getBlueTeam(); return m_Game->getBlueTeam();
} }
const Team& World::getBlueTeam() const{ const Team& World::getBlueTeam() const {
return m_Game->getBlueTeam(); return m_Game->getBlueTeam();
} }
Team& World::getTeam(TeamColor team){ Team& World::getTeam(TeamColor team) {
return m_Game->getTeam(team); return m_Game->getTeam(team);
} }
const Team& World::getTeam(TeamColor team) const{ const Team& World::getTeam(TeamColor team) const {
return m_Game->getTeam(team); return m_Game->getTeam(team);
} }

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

@@ -5,24 +5,24 @@
namespace td { namespace td {
namespace client { namespace client {
void Client::connect(const std::string& address, std::uint16_t port){ void Client::connect(const std::string& address, std::uint16_t port) {
if(!m_Connexion.connect(address, port)){ if (!m_Connexion.connect(address, port)) {
std::cout << "Failed to connect !\n"; std::cout << "Failed to connect !\n";
return; return;
} }
m_Connected = true; m_Connected = true;
} }
void Client::selectTeam(game::TeamColor team){ void Client::selectTeam(game::TeamColor team) {
if(!m_Connected) if (!m_Connected)
return; return;
protocol::SelectTeamPacket packet(team); protocol::SelectTeamPacket packet(team);
m_Connexion.sendPacket(&packet); m_Connexion.sendPacket(&packet);
} }
void Client::closeConnection(){ void Client::closeConnection() {
if(!m_Connected) if (!m_Connected)
return; return;
m_Connected = false; m_Connected = false;
@@ -31,18 +31,18 @@ void Client::closeConnection(){
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) if (!m_Connected)
return; return;
m_Connected = m_Connexion.updateSocket(); m_Connected = m_Connexion.updateSocket();
if(!m_Connected){ if (!m_Connected) {
std::cout << "Disconnected ! (Reason : " << m_Connexion.getDisconnectReason() << ")\n"; std::cout << "Disconnected ! (Reason : " << m_Connexion.getDisconnectReason() << ")\n";
}else{ } else {
m_Game.tick(delta); m_Game.tick(delta);
} }
} }
void Client::render(){ void Client::render() {
m_Game.renderWorld(); m_Game.renderWorld();
} }

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

@@ -4,42 +4,42 @@
namespace td { namespace td {
namespace client { namespace client {
ClientConnexion::ClientConnexion(): Connexion(&m_Dispatcher){ ClientConnexion::ClientConnexion() : Connexion(&m_Dispatcher) {
registerHandlers(); registerHandlers();
} }
void ClientConnexion::registerHandlers(){ void ClientConnexion::registerHandlers() {
GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this); GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::Disconnect, this); GetDispatcher()->RegisterHandler(protocol::PacketType::Disconnect, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this);
} }
void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet){ void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet) {
protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID()); protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID());
sendPacket(&keepAlivePacket); sendPacket(&keepAlivePacket);
} }
void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet){ void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet) {
m_ConnectionID = packet->getConnectionID(); m_ConnectionID = packet->getConnectionID();
login(); login();
} }
void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet){ void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet) {
m_ServerTPS = packet->getTPS(); m_ServerTPS = packet->getTPS();
m_Ping = utils::getTime() - packet->getPacketSendTime(); m_Ping = utils::getTime() - packet->getPacketSendTime();
} }
void ClientConnexion::login(){ void ClientConnexion::login() {
td::protocol::PlayerLoginPacket loginPacket("Persson" + std::to_string(m_ConnectionID)); td::protocol::PlayerLoginPacket loginPacket("Persson" + std::to_string(m_ConnectionID));
sendPacket(&loginPacket); sendPacket(&loginPacket);
} }
bool ClientConnexion::updateSocket(){ bool ClientConnexion::updateSocket() {
return Connexion::updateSocket(); return Connexion::updateSocket();
} }
void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet){ void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet) {
m_DisconnectReason = packet->getReason(); m_DisconnectReason = packet->getReason();
closeConnection(); closeConnection();
} }

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

@@ -8,9 +8,9 @@
namespace td { namespace td {
namespace client { namespace client {
ClientGame::ClientGame(Client* client): protocol::PacketHandler(client->getConnexion().GetDispatcher()), ClientGame::ClientGame(Client* client) : protocol::PacketHandler(client->getConnexion().GetDispatcher()),
game::Game(&m_WorldClient), m_Client(client), m_Renderer(client->getRenderer()), m_WorldClient(this), game::Game(&m_WorldClient), m_Client(client), m_Renderer(client->getRenderer()), m_WorldClient(this),
m_WorldRenderer(&m_WorldClient, this){ m_WorldRenderer(&m_WorldClient, this) {
GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ConnectionInfo, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerJoin, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerJoin, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerList, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerList, this);
@@ -23,113 +23,111 @@ ClientGame::ClientGame(Client* client): protocol::PacketHandler(client->getConne
GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this);
} }
ClientGame::~ClientGame(){ ClientGame::~ClientGame() {
GetDispatcher()->UnregisterHandler(this); GetDispatcher()->UnregisterHandler(this);
} }
void ClientGame::tick(std::uint64_t delta){ void ClientGame::tick(std::uint64_t delta) {
game::Game::tick(delta); game::Game::tick(delta);
m_WorldRenderer.update(); m_WorldRenderer.update();
if (m_GameState == game::GameState::Lobby && m_LobbyTime > 0){ if (m_GameState == game::GameState::Lobby && m_LobbyTime > 0) {
m_LobbyTime -= delta; m_LobbyTime -= delta;
} }
} }
void ClientGame::HandlePacket(protocol::PlayerJoinPacket* packet){ void ClientGame::HandlePacket(protocol::PlayerJoinPacket* packet) {
game::Player player(packet->getPlayerID()); game::Player player(packet->getPlayerID());
player.setName(packet->getPlayerName()); player.setName(packet->getPlayerName());
m_Players.insert({player.getID(), player}); m_Players.insert({ player.getID(), player });
} }
void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet){ void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet) {
game::Player* player = &m_Players[packet->getPlayerID()]; game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() != game::TeamColor::None){ if (player->getTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player); m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player);
} }
m_Players.erase(player->getID()); m_Players.erase(player->getID());
} }
void ClientGame::HandlePacket(protocol::PlayerListPacket* packet){ void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) {
for (auto pair : packet->getPlayers()){ for (auto pair : packet->getPlayers()) {
std::uint8_t playerID = pair.first; std::uint8_t playerID = pair.first;
protocol::PlayerInfo playerInfo = pair.second; protocol::PlayerInfo playerInfo = pair.second;
game::Player player(playerID); game::Player player(playerID);
player.setName(playerInfo.name); player.setName(playerInfo.name);
player.setTeamColor(playerInfo.team); player.setTeamColor(playerInfo.team);
m_Players.insert({playerID, player}); m_Players.insert({ playerID, player });
if (player.getTeamColor() != game::TeamColor::None){ if (player.getTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player.getTeamColor()].addPlayer(&m_Players[playerID]); m_Teams[(std::size_t)player.getTeamColor()].addPlayer(&m_Players[playerID]);
} }
} }
m_Player = &m_Players[m_ConnexionID]; m_Player = &m_Players[m_ConnexionID];
} }
void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet){ void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) {
game::Player* player = &m_Players[packet->getPlayerID()]; game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() == game::TeamColor::None){ //join a team if (player->getTeamColor() == game::TeamColor::None) { //join a team
getTeam(packet->getSelectedTeam()).addPlayer(player); getTeam(packet->getSelectedTeam()).addPlayer(player);
} } else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team
else if (packet->getSelectedTeam() == game::TeamColor::None){ // leave a team
getTeam(player->getTeamColor()).removePlayer(player); getTeam(player->getTeamColor()).removePlayer(player);
player->setTeamColor(game::TeamColor::None); player->setTeamColor(game::TeamColor::None);
} } else { // change team
else{ // change team
getTeam(player->getTeamColor()).removePlayer(player); getTeam(player->getTeamColor()).removePlayer(player);
getTeam(packet->getSelectedTeam()).addPlayer(player); getTeam(packet->getSelectedTeam()).addPlayer(player);
} }
} }
void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet){ void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet) {
setGameState(packet->getGameState()); setGameState(packet->getGameState());
} }
void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet){ void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet) {
m_ConnexionID = packet->getConnectionID(); m_ConnexionID = packet->getConnectionID();
} }
void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet){ void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet) {
m_LobbyTime = packet->getRemainingTime(); m_LobbyTime = packet->getRemainingTime();
} }
void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet){ void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet) {
m_Player->setGold(packet->getGold()); m_Player->setGold(packet->getGold());
} }
void ClientGame::HandlePacket(protocol::DisconnectPacket* packet){ void ClientGame::HandlePacket(protocol::DisconnectPacket* packet) {
m_GameState = game::GameState::Disconnected; m_GameState = game::GameState::Disconnected;
} }
void ClientGame::HandlePacket(protocol::WorldDataPacket* packet){ void ClientGame::HandlePacket(protocol::WorldDataPacket* packet) {
m_WorldRenderer.loadModels(); m_WorldRenderer.loadModels();
// set cam pos to player spawn // set cam pos to player spawn
const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn(); const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn();
m_WorldRenderer.setCamPos(spawn.x + 0.5, spawn.y + 0.5); m_WorldRenderer.setCamPos(spawn.x + 0.5, spawn.y + 0.5);
} }
void ClientGame::renderWorld(){ void ClientGame::renderWorld() {
if(m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame){ if (m_GameState == game::GameState::Game || m_GameState == game::GameState::EndGame) {
m_WorldRenderer.render(); m_WorldRenderer.render();
} }
} }
void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position){ void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position) {
protocol::PlaceTowerPacket packet(position.x, position.y, type); protocol::PlaceTowerPacket packet(position.x, position.y, type);
m_Client->getConnexion().sendPacket(&packet); m_Client->getConnexion().sendPacket(&packet);
} }
bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos){ bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos) {
game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y); game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y);
if(tile == nullptr){ if (tile == nullptr) {
return false; return false;
} }
if(tile->getType() == game::TileType::Tower){ if (tile->getType() == game::TileType::Tower) {
for(int x = -1; x < 2; x++){ for (int x = -1; x < 2; x++) {
for(int y = -1; y < 2; y++){ for (int y = -1; y < 2; y++) {
game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y); game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y);
if(adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower){ if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower) {
return false; return false;
} }
} }
@@ -140,18 +138,18 @@ bool ClientGame::CanPlaceLittleTower(const glm::vec2& worldPos){
return false; return false;
} }
bool ClientGame::CanPlaceBigTower(const glm::vec2& worldPos){ bool ClientGame::CanPlaceBigTower(const glm::vec2& worldPos) {
game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y); game::TilePtr tile = m_WorldClient.getTile(worldPos.x, worldPos.y);
if(tile == nullptr){ if (tile == nullptr) {
return false; return false;
} }
if(tile->getType() == game::TileType::Tower){ if (tile->getType() == game::TileType::Tower) {
for(int x = -2; x < 3; x++){ for (int x = -2; x < 3; x++) {
for(int y = -2; y < 3; y++){ for (int y = -2; y < 3; y++) {
game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y); game::TilePtr adjacentTile = m_WorldClient.getTile(worldPos.x + x, worldPos.y + y);
if(adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower){ if (adjacentTile == nullptr || adjacentTile->getType() != game::TileType::Tower) {
return false; return false;
} }
} }

2
src/game/client/TowersInfo.cpp
View File

@@ -19,7 +19,7 @@ static const std::map<TowerType, TowerInfo> TowerInfoConstants = {
{TowerType::Zeus, {"Zeus", "Strike lightning", false}}, {TowerType::Zeus, {"Zeus", "Strike lightning", false}},
}; };
const TowerInfo& getTowerInfo(TowerType type){ const TowerInfo& getTowerInfo(TowerType type) {
return TowerInfoConstants.at(type); return TowerInfoConstants.at(type);
} }

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

@@ -3,29 +3,29 @@
#include "game/client/ClientGame.h" #include "game/client/ClientGame.h"
#include "render/WorldRenderer.h" #include "render/WorldRenderer.h"
namespace td{ namespace td {
namespace client{ namespace client {
WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::PacketHandler(game->GetDispatcher()), m_Game(game){ WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::PacketHandler(game->GetDispatcher()), m_Game(game) {
GetDispatcher()->RegisterHandler(protocol::PacketType::WorldBeginData, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldBeginData, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldData, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::WorldAddTower, this); GetDispatcher()->RegisterHandler(protocol::PacketType::WorldAddTower, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this); GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this);
} }
void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet){ void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet) {
loadMap(packet); loadMap(packet);
} }
void WorldClient::HandlePacket(protocol::WorldDataPacket* packet){ void WorldClient::HandlePacket(protocol::WorldDataPacket* packet) {
loadMap(packet); loadMap(packet);
} }
void WorldClient::HandlePacket(protocol::WorldAddTowerPacket* packet){ void WorldClient::HandlePacket(protocol::WorldAddTowerPacket* packet) {
} }
void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet){ void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) {
spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(), spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
packet->getMobX(), packet->getMobY(), packet->getMobDirection()); packet->getMobX(), packet->getMobY(), packet->getMobDirection());
} }

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

@@ -22,15 +22,15 @@ namespace server {
1, // 1 s 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) if (m_GameStarted || m_StartTimerTime == 0)
return; return;
if(utils::getTime() - m_StartTimerTime >= LOBBY_WAITING_TIME){ if (utils::getTime() - m_StartTimerTime >= LOBBY_WAITING_TIME) {
protocol::UpdateGameStatePacket packet(game::GameState::Game); protocol::UpdateGameStatePacket packet(game::GameState::Game);
m_Server->broadcastPacket(&packet); m_Server->broadcastPacket(&packet);
m_GameStarted = true; m_GameStarted = true;
@@ -41,32 +41,32 @@ void Lobby::tick(){
m_Timer.update(); m_Timer.update();
} }
void Lobby::sendTimeRemaining(){ void Lobby::sendTimeRemaining() {
protocol::UpdateLobbyTimePacket packet(LOBBY_WAITING_TIME - (utils::getTime() - m_StartTimerTime)); // converting second to millis protocol::UpdateLobbyTimePacket packet(LOBBY_WAITING_TIME - (utils::getTime() - m_StartTimerTime)); // converting second to millis
m_Server->broadcastPacket(&packet); m_Server->broadcastPacket(&packet);
} }
void Lobby::OnPlayerJoin(std::uint8_t playerID){ void Lobby::OnPlayerJoin(std::uint8_t playerID) {
if(m_GameStarted) if (m_GameStarted)
return; return;
std::cout << "(Server) Player Joined Lobby !\n"; std::cout << "(Server) Player Joined Lobby !\n";
m_Players.push_back(playerID); m_Players.push_back(playerID);
if (m_Players.size() == 2){ // start timer if a second player join the match if (m_Players.size() == 2) { // start timer if a second player join the match
m_StartTimerTime = utils::getTime(); m_StartTimerTime = utils::getTime();
m_Timer.reset(); m_Timer.reset();
sendTimeRemaining(); sendTimeRemaining();
} }
} }
void Lobby::OnPlayerLeave(std::uint8_t playerID){ void Lobby::OnPlayerLeave(std::uint8_t playerID) {
if(m_GameStarted) if (m_GameStarted)
return; return;
std::cout << "(Server) Player Leaved Lobby !\n"; std::cout << "(Server) Player Leaved Lobby !\n";
auto it = std::find(m_Players.begin(), m_Players.end(), playerID); auto it = std::find(m_Players.begin(), m_Players.end(), playerID);
if (it == m_Players.end()) if (it == m_Players.end())
return; return;
m_Players.erase(it); m_Players.erase(it);
if (m_Players.size() == 1){ if (m_Players.size() == 1) {
protocol::UpdateLobbyTimePacket packet(0); protocol::UpdateLobbyTimePacket packet(0);
m_Server->broadcastPacket(&packet); m_Server->broadcastPacket(&packet);
m_StartTimerTime = 0; // reset timer if there is only one player left m_StartTimerTime = 0; // reset timer if there is only one player left

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

@@ -5,20 +5,20 @@
namespace td { namespace td {
namespace server { namespace server {
Server::Server(const std::string& worldFilePath){ Server::Server(const std::string& worldFilePath) {
m_Game.getWorld()->loadMapFromFile(worldFilePath); m_Game.getWorld()->loadMapFromFile(worldFilePath);
} }
void Server::lauchGame(){ void Server::lauchGame() {
m_Game.startGame(); m_Game.startGame();
} }
bool Server::start(std::uint16_t port){ bool Server::start(std::uint16_t port) {
if(!m_Listener.listen(port, 10)){ if (!m_Listener.listen(port, 10)) {
std::cout << "Failed to bind port " << port << " !\n"; std::cout << "Failed to bind port " << port << " !\n";
return false; return false;
} }
if(!m_Listener.setBlocking(false)){ if (!m_Listener.setBlocking(false)) {
std::cout << "Failed to block server socket !\n"; std::cout << "Failed to block server socket !\n";
return false; return false;
} }
@@ -27,7 +27,7 @@ bool Server::start(std::uint16_t port){
return true; return true;
} }
void Server::stop(){ void Server::stop() {
protocol::DisconnectPacket packet("Server closed"); protocol::DisconnectPacket packet("Server closed");
broadcastPacket(&packet); broadcastPacket(&packet);
@@ -38,65 +38,65 @@ void Server::stop(){
getPlayers().clear(); getPlayers().clear();
} }
void Server::tick(std::uint64_t delta){ void Server::tick(std::uint64_t delta) {
accept(); accept();
updateSockets(); updateSockets();
m_Lobby.tick(); m_Lobby.tick();
m_Game.tick(delta); m_Game.tick(delta);
if(m_TickCounter.update()){ if (m_TickCounter.update()) {
protocol::ServerTpsPacket packet(m_TickCounter.getTPS(), utils::getTime()); protocol::ServerTpsPacket packet(m_TickCounter.getTPS(), utils::getTime());
broadcastPacket(&packet); broadcastPacket(&packet);
} }
} }
void Server::accept(){ void Server::accept() {
static std::uint8_t newPlayerID = 0; static std::uint8_t newPlayerID = 0;
network::TCPSocket newSocket; network::TCPSocket newSocket;
if (m_Listener.accept(newSocket)){ if (m_Listener.accept(newSocket)) {
ServerConnexion con(newSocket, newPlayerID); ServerConnexion con(newSocket, newPlayerID);
m_Connections.insert(std::move(ConnexionMap::value_type{newPlayerID, std::move(con)})); m_Connections.insert(std::move(ConnexionMap::value_type{ newPlayerID, std::move(con) }));
OnPlayerJoin(newPlayerID); OnPlayerJoin(newPlayerID);
m_Connections[newPlayerID].setServer(this); m_Connections[newPlayerID].setServer(this);
newPlayerID++; newPlayerID++;
} }
} }
void Server::updateSockets(){ void Server::updateSockets() {
std::int16_t closedConnexionID = -1; std::int16_t closedConnexionID = -1;
for (auto& connection : m_Connections){ for (auto& connection : m_Connections) {
ServerConnexion& con = connection.second; ServerConnexion& con = connection.second;
if(con.getSocketStatus() != network::Socket::Status::Connected){ if (con.getSocketStatus() != network::Socket::Status::Connected) {
closedConnexionID = connection.first; closedConnexionID = connection.first;
}else{ } else {
con.updateSocket(); con.updateSocket();
} }
} }
if(closedConnexionID != -1){ if (closedConnexionID != -1) {
removeConnexion(closedConnexionID); removeConnexion(closedConnexionID);
} }
} }
void Server::broadcastPacket(protocol::Packet* packet){ void Server::broadcastPacket(protocol::Packet* packet) {
for (auto& connection : m_Connections){ for (auto& connection : m_Connections) {
ServerConnexion& con = connection.second; ServerConnexion& con = connection.second;
con.sendPacket(packet); con.sendPacket(packet);
} }
} }
void Server::removeConnexion(std::uint8_t connexionID){ void Server::removeConnexion(std::uint8_t connexionID) {
getPlayers().erase(getPlayers().find(connexionID)); getPlayers().erase(getPlayers().find(connexionID));
m_Connections.erase(connexionID); m_Connections.erase(connexionID);
m_Lobby.OnPlayerLeave(connexionID); m_Lobby.OnPlayerLeave(connexionID);
OnPlayerLeave(connexionID); OnPlayerLeave(connexionID);
} }
void Server::OnPlayerJoin(std::uint8_t id){ void Server::OnPlayerJoin(std::uint8_t id) {
m_Lobby.OnPlayerJoin(id); m_Lobby.OnPlayerJoin(id);
getPlayers().insert({id, game::Player{id}}); getPlayers().insert({ id, game::Player{id} });
} }
void Server::OnPlayerLeave(std::uint8_t id){ void Server::OnPlayerLeave(std::uint8_t id) {
protocol::PlayerLeavePacket packet(id); protocol::PlayerLeavePacket packet(id);
broadcastPacket(&packet); broadcastPacket(&packet);
} }

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

@@ -10,30 +10,30 @@
#define KEEP_ALIVE_TIMEOUT 10 * 1000 // 10s #define KEEP_ALIVE_TIMEOUT 10 * 1000 // 10s
namespace td{ namespace td {
namespace server{ namespace server {
/* /*
NEVER TRUST USER INPUT NEVER TRUST USER INPUT
*/ */
ServerConnexion::ServerConnexion(): m_Player(0){ ServerConnexion::ServerConnexion() : m_Player(0) {
} }
ServerConnexion::ServerConnexion(network::TCPSocket& socket, std::uint8_t id) : Connexion::Connexion(&m_Dispatcher, socket), m_ID(id), m_Player(0){ ServerConnexion::ServerConnexion(network::TCPSocket& socket, std::uint8_t id) : Connexion::Connexion(&m_Dispatcher, socket), m_ID(id), m_Player(0) {
Connexion::updateSocket(); Connexion::updateSocket();
} }
ServerConnexion::ServerConnexion(ServerConnexion&& move) : Connexion::Connexion(std::move(move)), m_Server(move.m_Server), ServerConnexion::ServerConnexion(ServerConnexion&& move) : Connexion::Connexion(std::move(move)), m_Server(move.m_Server),
m_ID(move.m_ID), m_KeepAlive(move.m_KeepAlive), m_Player(move.m_Player){ m_ID(move.m_ID), m_KeepAlive(move.m_KeepAlive), m_Player(move.m_Player) {
move.m_Server = nullptr; move.m_Server = nullptr;
registerHandlers(); registerHandlers();
} }
void ServerConnexion::registerHandlers(){ void ServerConnexion::registerHandlers() {
GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerLogin, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlayerLogin, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this); GetDispatcher()->RegisterHandler(protocol::PacketType::KeepAlive, this);
GetDispatcher()->RegisterHandler(protocol::PacketType::SelectTeam, this); GetDispatcher()->RegisterHandler(protocol::PacketType::SelectTeam, this);
@@ -41,18 +41,17 @@ void ServerConnexion::registerHandlers(){
GetDispatcher()->RegisterHandler(protocol::PacketType::PlaceTower, this); GetDispatcher()->RegisterHandler(protocol::PacketType::PlaceTower, this);
} }
bool ServerConnexion::updateSocket(){ bool ServerConnexion::updateSocket() {
checkKeepAlive(); checkKeepAlive();
return Connexion::updateSocket(); return Connexion::updateSocket();
} }
void ServerConnexion::checkKeepAlive(){ void ServerConnexion::checkKeepAlive() {
std::uint64_t time = utils::getTime(); std::uint64_t time = utils::getTime();
if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT){ if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT) {
if (m_KeepAlive.recievedResponse){ if (m_KeepAlive.recievedResponse) {
sendKeepAlive(); sendKeepAlive();
} } else {
else{
protocol::DisconnectPacket packet("Time out"); protocol::DisconnectPacket packet("Time out");
sendPacket(&packet); sendPacket(&packet);
closeConnection(); closeConnection();
@@ -60,7 +59,7 @@ void ServerConnexion::checkKeepAlive(){
} }
} }
void ServerConnexion::sendKeepAlive(){ void ServerConnexion::sendKeepAlive() {
m_KeepAlive.keepAliveID = utils::getRandomNumber(RAND_MAX); m_KeepAlive.keepAliveID = utils::getRandomNumber(RAND_MAX);
m_KeepAlive.recievedResponse = false; m_KeepAlive.recievedResponse = false;
@@ -71,21 +70,21 @@ void ServerConnexion::sendKeepAlive(){
m_KeepAlive.sendTime = time; m_KeepAlive.sendTime = time;
} }
void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet){ void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet) {
if (m_Player->getName().empty() && !packet->getPlayerName().empty()){ if (m_Player->getName().empty() && !packet->getPlayerName().empty()) {
m_Player->setName(packet->getPlayerName()); m_Player->setName(packet->getPlayerName());
protocol::PlayerJoinPacket joinPacket(m_ID, m_Player->getName()); protocol::PlayerJoinPacket joinPacket(m_ID, m_Player->getName());
m_Server->broadcastPacket(&joinPacket); m_Server->broadcastPacket(&joinPacket);
std::map<std::uint8_t, protocol::PlayerInfo> playerNames; 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; const game::Player& player = pair.second;
if (!player.getName().empty()){ if (!player.getName().empty()) {
protocol::PlayerInfo playerInfo; protocol::PlayerInfo playerInfo;
playerInfo.name = player.getName(); playerInfo.name = player.getName();
playerInfo.team = player.getTeamColor(); playerInfo.team = player.getTeamColor();
playerNames.insert({player.getID(), playerInfo}); playerNames.insert({ player.getID(), playerInfo });
} }
} }
@@ -94,17 +93,17 @@ void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet){
} }
} }
void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet){ void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet) {
if(m_Server->getGame().getGameState() != game::GameState::Lobby) if (m_Server->getGame().getGameState() != game::GameState::Lobby)
return; return;
if((std::int8_t) packet->getSelectedTeam() >= -1 || (std::int8_t) packet->getSelectedTeam() <= 1){ if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) {
//m_Player->setTeamColor(packet->getSelectedTeam()); //m_Player->setTeamColor(packet->getSelectedTeam());
if(m_Player->getTeamColor() == game::TeamColor::None){ //join a team if (m_Player->getTeamColor() == game::TeamColor::None) { //join a team
m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player); m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player);
}else if(packet->getSelectedTeam() == game::TeamColor::None){ // leave a team } else if (packet->getSelectedTeam() == game::TeamColor::None) { // leave a team
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player); m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Player->setTeamColor(game::TeamColor::None); m_Player->setTeamColor(game::TeamColor::None);
}else{ // change team } else { // change team
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player); m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player); m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player);
} }
@@ -113,30 +112,30 @@ void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet){
} }
} }
void ServerConnexion::HandlePacket(protocol::KeepAlivePacket* packet){ void ServerConnexion::HandlePacket(protocol::KeepAlivePacket* packet) {
if(packet->getAliveID() == m_KeepAlive.keepAliveID) if (packet->getAliveID() == m_KeepAlive.keepAliveID)
m_KeepAlive.recievedResponse = true; m_KeepAlive.recievedResponse = true;
} }
void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet){ void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet) {
closeConnection(); closeConnection();
} }
void ServerConnexion::setServer(Server* server){ void ServerConnexion::setServer(Server* server) {
m_Server = server; m_Server = server;
m_Player = &m_Server->getPlayers().at(m_ID); m_Player = &m_Server->getPlayers().at(m_ID);
initConnection(); initConnection();
sendKeepAlive(); sendKeepAlive();
} }
void ServerConnexion::initConnection(){ void ServerConnexion::initConnection() {
protocol::UpdateGameStatePacket statePacket(m_Server->getGame().getGameState()); protocol::UpdateGameStatePacket statePacket(m_Server->getGame().getGameState());
sendPacket(&statePacket); sendPacket(&statePacket);
protocol::ConnexionInfoPacket conPacket(m_ID); protocol::ConnexionInfoPacket conPacket(m_ID);
sendPacket(&conPacket); sendPacket(&conPacket);
if (m_Server->getGame().getGameState() == game::GameState::Game){ if (m_Server->getGame().getGameState() == game::GameState::Game) {
protocol::WorldBeginDataPacket headerDataPacket(m_Server->getGame().getWorld()); protocol::WorldBeginDataPacket headerDataPacket(m_Server->getGame().getWorld());
protocol::WorldBeginDataPacket dataPacket(m_Server->getGame().getWorld()); protocol::WorldBeginDataPacket dataPacket(m_Server->getGame().getWorld());
sendPacket(&headerDataPacket); sendPacket(&headerDataPacket);
@@ -144,13 +143,13 @@ void ServerConnexion::initConnection(){
} }
} }
void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet){ void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
// process packet // process packet
protocol::WorldAddTowerPacket addTowerPacket(packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID); protocol::WorldAddTowerPacket addTowerPacket(packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID);
m_Server->broadcastPacket(&addTowerPacket); m_Server->broadcastPacket(&addTowerPacket);
} }
ServerConnexion::~ServerConnexion(){ ServerConnexion::~ServerConnexion() {
if (GetDispatcher() != nullptr) if (GetDispatcher() != nullptr)
GetDispatcher()->UnregisterHandler(this); GetDispatcher()->UnregisterHandler(this);
} }

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

@@ -4,16 +4,16 @@
namespace td { namespace td {
namespace server { namespace server {
ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this){ ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this) {
} }
void ServerGame::tick(std::uint64_t delta){ void ServerGame::tick(std::uint64_t delta) {
Game::tick(delta); Game::tick(delta);
m_GoldMineTimer.update(); m_GoldMineTimer.update();
} }
void ServerGame::startGame(){ void ServerGame::startGame() {
balanceTeams(); balanceTeams();
protocol::WorldBeginDataPacket headerMapData(m_World); protocol::WorldBeginDataPacket headerMapData(m_World);
@@ -27,8 +27,8 @@ void ServerGame::startGame(){
m_ServerWorld.spawnMobs(game::MobType::Zombie, 1, 0, 12); m_ServerWorld.spawnMobs(game::MobType::Zombie, 1, 0, 12);
} }
void ServerGame::updateGoldMines(){ void ServerGame::updateGoldMines() {
for(auto& pair : m_Server->getPlayers()){ for (auto& pair : m_Server->getPlayers()) {
game::Player* player = &pair.second; game::Player* player = &pair.second;
player->setGold(player->getGold() + player->getGoldPerSecond()); player->setGold(player->getGold() + player->getGoldPerSecond());
protocol::UpdateMoneyPacket packet(player->getGold()); protocol::UpdateMoneyPacket packet(player->getGold());
@@ -36,15 +36,15 @@ void ServerGame::updateGoldMines(){
} }
} }
void ServerGame::balanceTeams(){ void ServerGame::balanceTeams() {
for(auto playerInfo : m_Players){ for (auto playerInfo : m_Players) {
game::Player& player = playerInfo.second; game::Player& player = playerInfo.second;
if(player.getTeamColor() == game::TeamColor::None){ if (player.getTeamColor() == game::TeamColor::None) {
game::Team& redTeam = getRedTeam(); game::Team& redTeam = getRedTeam();
game::Team& blueTeam = getBlueTeam(); game::Team& blueTeam = getBlueTeam();
if(blueTeam.getPlayerCount() > redTeam.getPlayerCount()){ if (blueTeam.getPlayerCount() > redTeam.getPlayerCount()) {
redTeam.addPlayer(&player); redTeam.addPlayer(&player);
}else{ } else {
blueTeam.addPlayer(&player); blueTeam.addPlayer(&player);
} }
protocol::UpdatePlayerTeamPacket packet(player.getID(), player.getTeamColor()); protocol::UpdatePlayerTeamPacket packet(player.getID(), player.getTeamColor());

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

@@ -7,18 +7,18 @@
namespace td { namespace td {
namespace server { namespace server {
ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game), m_CurrentMobID(0), m_Server(server){ ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game), m_CurrentMobID(0), m_Server(server) {
} }
void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count){ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count) {
for (int i = 0; i < count; i++){ 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; game::Spawn* enemyMobSpawn;
if(senderTeam == game::TeamColor::Red){ if (senderTeam == game::TeamColor::Red) {
enemyMobSpawn = &getTeam(game::TeamColor::Blue).getSpawn(); enemyMobSpawn = &getTeam(game::TeamColor::Blue).getSpawn();
}else{ } else {
enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn(); enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn();
} }
@@ -32,10 +32,10 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
std::int32_t maxSpawnX = spawnCenterX + 2; std::int32_t maxSpawnX = spawnCenterX + 2;
std::uint64_t randomX = utils::getRandomNumber(std::abs(minSpawnX - maxSpawnX) * MOB_SPAWN_PRECISION); std::uint64_t randomX = utils::getRandomNumber(std::abs(minSpawnX - maxSpawnX) * MOB_SPAWN_PRECISION);
float mobX = (float) randomX / MOB_SPAWN_PRECISION + (float) minSpawnX; float mobX = (float)randomX / MOB_SPAWN_PRECISION + (float)minSpawnX;
std::uint64_t randomY = utils::getRandomNumber(std::abs(minSpawnY - maxSpawnY) * MOB_SPAWN_PRECISION); std::uint64_t randomY = utils::getRandomNumber(std::abs(minSpawnY - maxSpawnY) * MOB_SPAWN_PRECISION);
float mobY = (float) randomY / MOB_SPAWN_PRECISION + (float) minSpawnY; float mobY = (float)randomY / MOB_SPAWN_PRECISION + (float)minSpawnY;
spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->direction); spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->direction);

2
src/misc/Compression.cpp
View File

@@ -49,7 +49,7 @@ DataBuffer Compress(const DataBuffer& buffer) {
return packet; return packet;
} }
DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength){ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
std::uint64_t uncompressedLength; std::uint64_t uncompressedLength;
buffer >> uncompressedLength; buffer >> uncompressedLength;

66
src/misc/Easing.cpp
View File

@@ -2,62 +2,62 @@
#include <cmath> #include <cmath>
namespace td{ namespace td {
namespace utils{ namespace utils {
/* Sine functions */ /* Sine functions */
float easeInSine(float x){ float easeInSine(float x) {
return 1.0f - std::cos((x * PI) / 2.0f); return 1.0f - std::cos((x * PI) / 2.0f);
} }
float easeOutSine(float x){ float easeOutSine(float x) {
return std::sin((x * PI) / 2.0f); return std::sin((x * PI) / 2.0f);
} }
float easeInOutSine(float x){ float easeInOutSine(float x) {
return -(std::cos(PI * x) - 1.0f) / 2.0f; return -(std::cos(PI * x) - 1.0f) / 2.0f;
} }
/* Cubic functions */ /* Cubic functions */
float easeInCubic(float x){ float easeInCubic(float x) {
return x * easeInQuad(x); return x * easeInQuad(x);
} }
float easeOutCubic(float x){ float easeOutCubic(float x) {
return 1 - std::pow(1 - x, 3); return 1 - std::pow(1 - x, 3);
} }
float easeInOutCubic(float x){ float easeInOutCubic(float x) {
return x < 0.5 ? 4 * easeInCubic(x) : 1 - std::pow(-2 * x + 2, 3) / 2.0f; return x < 0.5 ? 4 * easeInCubic(x) : 1 - std::pow(-2 * x + 2, 3) / 2.0f;
} }
/* Quint functions */ /* Quint functions */
float easeInQuint(float x){ float easeInQuint(float x) {
return x * easeInQuart(x); return x * easeInQuart(x);
} }
float easeOutQuint(float x){ float easeOutQuint(float x) {
return 1 - std::pow(1 - x, 5); return 1 - std::pow(1 - x, 5);
} }
float easeInOutQuint(float x){ float easeInOutQuint(float x) {
return x < 0.5 ? 16 * easeInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0f; return x < 0.5 ? 16 * easeInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0f;
} }
/* Circ functions */ /* Circ functions */
float easeInCirc(float x){ float easeInCirc(float x) {
return 1 - std::sqrt(1 - std::pow(x, 2)); 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)); return std::sqrt(1 - std::pow(x - 1, 2));
} }
float easeInOutCirc(float x){ float easeInOutCirc(float x) {
return x < 0.5 return x < 0.5
? (1 - std::sqrt(1 - std::pow(2 * x, 2))) / 2.0f ? (1 - std::sqrt(1 - std::pow(2 * x, 2))) / 2.0f
: (std::sqrt(1 - std::pow(-2 * x + 2, 2)) + 1) / 2.0f; : (std::sqrt(1 - std::pow(-2 * x + 2, 2)) + 1) / 2.0f;
@@ -65,7 +65,7 @@ float easeInOutCirc(float x){
/* Elastic functions */ /* Elastic functions */
float easeInElastic(float x){ float easeInElastic(float x) {
const float c4 = (2 * PI) / 3.0f; const float c4 = (2 * PI) / 3.0f;
return x == 0 return x == 0
@@ -75,7 +75,7 @@ float easeInElastic(float x){
: -std::pow(2, 10 * x - 10) * std::sin((x * 10 - 10.75) * c4); : -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; const float c4 = (2 * PI) / 3.0f;
return x == 0 return x == 0
@@ -85,7 +85,7 @@ float easeOutElastic(float x){
: std::pow(2, -10 * x) * std::sin((x * 10 - 0.75) * c4) + 1; : 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; const float c5 = (2 * PI) / 4.5;
return x == 0 return x == 0
@@ -99,43 +99,43 @@ float easeInOutElastic(float x){
/* Quad functions */ /* Quad functions */
float easeInQuad(float x){ float easeInQuad(float x) {
return x * x; return x * x;
} }
float easeOutQuad(float x){ float easeOutQuad(float x) {
return 1 - (1 - x) * (1 - 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; return x < 0.5 ? 2 * x * x : 1 - std::pow(-2 * x + 2, 2) / 2.0f;
} }
/* Quart functions */ /* Quart functions */
float easeInQuart(float x){ float easeInQuart(float x) {
return x * easeInCubic(x); return x * easeInCubic(x);
} }
float easeOutQuart(float x){ float easeOutQuart(float x) {
return 1 - std::pow(1 - x, 4); return 1 - std::pow(1 - x, 4);
} }
float easeInOutQuart(float x){ float easeInOutQuart(float x) {
return x < 0.5 ? 8 * easeInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0f; return x < 0.5 ? 8 * easeInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0f;
} }
/* Expo functions */ /* Expo functions */
float easeInExpo(float x){ float easeInExpo(float x) {
return x == 0 ? 0 : std::pow(2, 10 * x - 10); 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); return x == 1 ? 1 : 1 - std::pow(2, -10 * x);
} }
float easeInOutExpo(float x){ float easeInOutExpo(float x) {
return x == 0 return x == 0
? 0 ? 0
: x == 1 : x == 1
@@ -146,21 +146,21 @@ float easeInOutExpo(float x){
/* Back functions */ /* Back functions */
float easeInBack(float x){ float easeInBack(float x) {
const float c1 = 1.70158; const float c1 = 1.70158;
const float c3 = c1 + 1; 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 c1 = 1.70158;
const float c3 = c1 + 1; const float c3 = c1 + 1;
return 1 + c3 * std::pow(x - 1, 3) + c1 * std::pow(x - 1, 2); 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 c1 = 1.70158;
const float c2 = c1 * 1.525; const float c2 = c1 * 1.525;
@@ -171,18 +171,18 @@ float easeInOutBack(float x){
/* Bounce functions */ /* Bounce functions */
float easeInBounce(float x){ float easeInBounce(float x) {
return 1 - easeOutBounce(1 - x); return 1 - easeOutBounce(1 - x);
} }
float easeOutBounce(float x){ float easeOutBounce(float x) {
const float n1 = 7.5625; const float n1 = 7.5625;
const float d1 = 2.75; const float d1 = 2.75;
if (x < 1 / d1) { if (x < 1 / d1) {
return n1 * easeInQuad(x); return n1 * easeInQuad(x);
} else if (x < 2 / d1) { } else if (x < 2 / d1) {
x-= 1.5; x -= 1.5;
return n1 * (x / d1) * x + 0.75; return n1 * (x / d1) * x + 0.75;
} else if (x < 2.5 / d1) { } else if (x < 2.5 / d1) {
x -= 2.25; x -= 2.25;
@@ -193,7 +193,7 @@ float easeOutBounce(float x){
} }
} }
float easeInOutBounce(float x){ float easeInOutBounce(float x) {
return x < 0.5 return x < 0.5
? (1 - easeOutBounce(1 - 2 * x)) / 2.0f ? (1 - easeOutBounce(1 - 2 * x)) / 2.0f
: (1 + easeOutBounce(2 * x - 1)) / 2.0f; : (1 + easeOutBounce(2 * x - 1)) / 2.0f;

4
src/misc/Random.cpp
View File

@@ -5,11 +5,11 @@
namespace td { namespace td {
namespace utils { namespace utils {
void initRandomizer(){ void initRandomizer() {
srand(time(0)); srand(time(0));
} }
std::uint64_t getRandomNumber(std::uint64_t max){ std::uint64_t getRandomNumber(std::uint64_t max) {
return rand() % max; return rand() % max;
} }

16
src/misc/Time.cpp
View File

@@ -4,32 +4,32 @@
namespace td { namespace td {
namespace utils { namespace utils {
void Timer::update(){ void Timer::update() {
m_InternalTime += getTime() - m_LastTime; m_InternalTime += getTime() - m_LastTime;
if(m_InternalTime >= m_Interval){ if (m_InternalTime >= m_Interval) {
if(m_Function != nullptr) if (m_Function != nullptr)
m_Function(); m_Function();
m_InternalTime %= m_Interval; m_InternalTime %= m_Interval;
} }
m_LastTime = getTime(); m_LastTime = getTime();
} }
void Timer::update(std::uint64_t delta){ void Timer::update(std::uint64_t delta) {
m_InternalTime += delta; m_InternalTime += delta;
if(m_InternalTime >= m_Interval){ if (m_InternalTime >= m_Interval) {
if(m_Function != nullptr) if (m_Function != nullptr)
m_Function(); m_Function();
m_InternalTime %= m_Interval; m_InternalTime %= m_Interval;
} }
m_LastTime = getTime(); m_LastTime = getTime();
} }
void Timer::reset(){ void Timer::reset() {
m_InternalTime = 0; m_InternalTime = 0;
m_LastTime = getTime(); m_LastTime = getTime();
} }
std::uint64_t getTime(){ std::uint64_t getTime() {
return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock().now().time_since_epoch()).count(); return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock().now().time_since_epoch()).count();
} }

14
src/network/DataBuffer.cpp
View File

@@ -62,27 +62,27 @@ std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer) {
return os; return os;
} }
bool DataBuffer::ReadFile(const std::string& fileName){ bool DataBuffer::ReadFile(const std::string& fileName) {
try{ try {
std::ifstream file(fileName); std::ifstream file(fileName);
std::ostringstream ss; std::ostringstream ss;
ss << file.rdbuf(); ss << file.rdbuf();
const std::string& s = ss.str(); const std::string& s = ss.str();
m_Buffer = DataBuffer::Data(s.begin(), s.end()); m_Buffer = DataBuffer::Data(s.begin(), s.end());
m_ReadOffset = 0; m_ReadOffset = 0;
}catch(std::exception& e){ } catch (std::exception& e) {
std::cerr << "Failed to read file \"" << fileName << "\" reason : " << e.what() << std::endl; std::cerr << "Failed to read file \"" << fileName << "\" reason : " << e.what() << std::endl;
return false; return false;
} }
return m_Buffer.size() > 0; return m_Buffer.size() > 0;
} }
bool DataBuffer::WriteFile(const std::string& fileName){ bool DataBuffer::WriteFile(const std::string& fileName) {
try{ try {
std::ofstream file(fileName); std::ofstream file(fileName);
file.write((const char*) m_Buffer.data(), m_Buffer.size()); file.write((const char*)m_Buffer.data(), m_Buffer.size());
file.flush(); file.flush();
}catch(std::exception& e){ } catch (std::exception& e) {
std::cerr << "Failed to write file \"" << fileName << "\" reason : " << e.what() << std::endl; std::cerr << "Failed to write file \"" << fileName << "\" reason : " << e.what() << std::endl;
return false; return false;
} }

10
src/network/IPAddress.cpp
View File

@@ -16,13 +16,13 @@ namespace network {
/* Create an invalid address */ /* Create an invalid address */
IPAddress::IPAddress() noexcept IPAddress::IPAddress() noexcept
: m_Address(0), m_Valid(false){ : m_Address(0), m_Valid(false) {
} }
/* Initialize by string IP */ /* Initialize by string IP */
IPAddress::IPAddress(const std::string& ip) IPAddress::IPAddress(const std::string& ip)
: m_Address(0), m_Valid(false){ : m_Address(0), m_Valid(false) {
std::sregex_iterator begin(ip.begin(), ip.end(), IPRegex); std::sregex_iterator begin(ip.begin(), ip.end(), IPRegex);
std::sregex_iterator end; std::sregex_iterator end;
@@ -41,7 +41,7 @@ IPAddress::IPAddress(const std::string& ip)
} }
IPAddress::IPAddress(const std::wstring& ip) IPAddress::IPAddress(const std::wstring& ip)
: m_Address(0), m_Valid(false){ : m_Address(0), m_Valid(false) {
std::wsregex_iterator begin(ip.begin(), ip.end(), IPRegexW); std::wsregex_iterator begin(ip.begin(), ip.end(), IPRegexW);
std::wsregex_iterator end; std::wsregex_iterator end;
@@ -61,7 +61,7 @@ IPAddress::IPAddress(const std::wstring& ip)
/* Initialize by octets */ /* Initialize by octets */
IPAddress::IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) noexcept IPAddress::IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) noexcept
: m_Valid(true){ : m_Valid(true) {
m_Address = (octet1 << 24) | (octet2 << 16) | (octet3 << 8) | octet4; m_Address = (octet1 << 24) | (octet2 << 16) | (octet3 << 8) | octet4;
} }

4
src/network/Network.cpp
View File

@@ -33,7 +33,7 @@ NetworkInitializer initializer;
IPAddresses Dns::Resolve(const std::string& host) { IPAddresses Dns::Resolve(const std::string& host) {
IPAddresses list; IPAddresses list;
addrinfo hints = { 0 }, *addresses; addrinfo hints = { 0 }, * addresses;
//hints.ai_family = AF_UNSPEC; //hints.ai_family = AF_UNSPEC;
hints.ai_family = AF_INET; hints.ai_family = AF_INET;
@@ -42,7 +42,7 @@ IPAddresses Dns::Resolve(const std::string& host) {
getaddrinfo(host.c_str(), NULL, &hints, &addresses); getaddrinfo(host.c_str(), NULL, &hints, &addresses);
for (addrinfo *p = addresses; p != NULL; p = p->ai_next) { for (addrinfo* p = addresses; p != NULL; p = p->ai_next) {
#ifdef _WIN32 #ifdef _WIN32
//wchar_t straddr[35]; //wchar_t straddr[35];
//char straddr[512]; //char straddr[512];

4
src/network/Socket.cpp
View File

@@ -16,7 +16,7 @@ Socket::Socket(Type type)
: m_Blocking(false), : m_Blocking(false),
m_Type(type), m_Type(type),
m_Status(Disconnected), m_Status(Disconnected),
m_Handle((SocketHandle) INVALID_SOCKET) m_Handle((SocketHandle)INVALID_SOCKET)
{ {
} }
@@ -28,7 +28,7 @@ Socket::~Socket() {
bool Socket::SetBlocking(bool block) { bool Socket::SetBlocking(bool block) {
unsigned long mode = block ? 0 : 1; unsigned long mode = block ? 0 : 1;
if(ioctl(m_Handle, FIONBIO, &mode) < 0){ if (ioctl(m_Handle, FIONBIO, &mode) < 0) {
return false; return false;
} }

22
src/network/TCPListener.cpp
View File

@@ -8,16 +8,16 @@
#define ioctlsocket ioctl #define ioctlsocket ioctl
#endif #endif
namespace td{ namespace td {
namespace network{ namespace network {
TCPListener::TCPListener(){} TCPListener::TCPListener() {}
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) if ((m_Handle = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
return false; return false;
@@ -38,7 +38,7 @@ bool TCPListener::listen(uint16_t port, int maxConnections){
return true; return true;
} }
bool TCPListener::accept(TCPSocket& newSocket){ bool TCPListener::accept(TCPSocket& newSocket) {
int addrlen = sizeof(newSocket.m_RemoteAddr); int addrlen = sizeof(newSocket.m_RemoteAddr);
if ((newSocket.m_Handle = ::accept(m_Handle, reinterpret_cast<sockaddr*>(&newSocket.m_RemoteAddr), if ((newSocket.m_Handle = ::accept(m_Handle, reinterpret_cast<sockaddr*>(&newSocket.m_RemoteAddr),
reinterpret_cast<socklen_t*>(&addrlen))) < 0) reinterpret_cast<socklen_t*>(&addrlen))) < 0)
@@ -48,21 +48,21 @@ bool TCPListener::accept(TCPSocket& newSocket){
return true; return true;
} }
void TCPListener::destroy(){ void TCPListener::destroy() {
if(m_Handle < 0) if (m_Handle < 0)
::closesocket(m_Handle); ::closesocket(m_Handle);
} }
bool TCPListener::close(){ bool TCPListener::close() {
if (::shutdown(m_Handle, SD_BOTH) == 0) if (::shutdown(m_Handle, SD_BOTH) == 0)
return true; return true;
return false; return false;
} }
bool TCPListener::setBlocking(bool blocking){ bool TCPListener::setBlocking(bool blocking) {
unsigned long mode = blocking ? 0 : 1; unsigned long mode = blocking ? 0 : 1;
if(ioctlsocket(m_Handle, FIONBIO, &mode) < 0){ if (ioctlsocket(m_Handle, FIONBIO, &mode) < 0) {
return false; return false;
} }
return true; return true;

14
src/network/TCPSocket.cpp
View File

@@ -16,14 +16,14 @@ namespace network {
TCPSocket::TCPSocket() TCPSocket::TCPSocket()
: Socket(Socket::TCP), m_Port(0) : Socket(Socket::TCP), m_Port(0)
{ {
m_Handle = (SocketHandle) INVALID_SOCKET; m_Handle = (SocketHandle)INVALID_SOCKET;
} }
bool TCPSocket::Connect(const IPAddress& address, unsigned short port) { bool TCPSocket::Connect(const IPAddress& address, unsigned short port) {
if (this->GetStatus() == Connected) if (this->GetStatus() == Connected)
return true; return true;
struct addrinfo hints = { 0 }, *result = nullptr; struct addrinfo hints = { 0 }, * result = nullptr;
if ((m_Handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) if ((m_Handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
return false; return false;
@@ -55,7 +55,7 @@ bool TCPSocket::Connect(const IPAddress& address, unsigned short port) {
return true; return true;
} }
size_t TCPSocket::Send(const unsigned char* data, size_t size){ size_t TCPSocket::Send(const unsigned char* data, size_t size) {
if (this->GetStatus() != Connected) if (this->GetStatus() != Connected)
return 0; return 0;
@@ -118,19 +118,19 @@ DataBuffer TCPSocket::Receive(std::size_t amount) {
return DataBuffer(std::string(buf.get(), received)); return DataBuffer(std::string(buf.get(), received));
} }
TCPSocket::TCPSocket(TCPSocket&& other) : Socket(TCP){ TCPSocket::TCPSocket(TCPSocket&& other) : Socket(TCP) {
m_Handle = other.m_Handle; m_Handle = other.m_Handle;
m_Port = other.m_Port; m_Port = other.m_Port;
m_RemoteAddr = other.m_RemoteAddr; m_RemoteAddr = other.m_RemoteAddr;
m_RemoteIP = other.m_RemoteIP; m_RemoteIP = other.m_RemoteIP;
SetStatus(other.GetStatus()); SetStatus(other.GetStatus());
SetBlocking(other.IsBlocking()); SetBlocking(other.IsBlocking());
other.m_Handle = (SocketHandle) INVALID_SOCKET; other.m_Handle = (SocketHandle)INVALID_SOCKET;
} }
void SendPacket(const DataBuffer& data, network::TCPSocket& socket){ void SendPacket(const DataBuffer& data, network::TCPSocket& socket) {
DataBuffer compressed = utils::Compress(data); DataBuffer compressed = utils::Compress(data);
socket.Send((const std::uint8_t*) compressed.ToString().data(), compressed.GetSize()); socket.Send((const std::uint8_t*)compressed.ToString().data(), compressed.GetSize());
} }

10
src/protocol/PacketDispatcher.cpp
View File

@@ -3,20 +3,20 @@
namespace td { namespace td {
namespace protocol { namespace protocol {
void PacketDispatcher::RegisterHandler(PacketType type, PacketHandler* handler){ void PacketDispatcher::RegisterHandler(PacketType type, PacketHandler* handler) {
auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler); auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler);
if (found == m_Handlers[type].end()) if (found == m_Handlers[type].end())
m_Handlers[type].push_back(handler); m_Handlers[type].push_back(handler);
} }
void PacketDispatcher::UnregisterHandler(PacketType type, PacketHandler* handler){ void PacketDispatcher::UnregisterHandler(PacketType type, PacketHandler* handler) {
auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler); auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), handler);
if (found != m_Handlers[type].end()) if (found != m_Handlers[type].end())
m_Handlers[type].erase(found); m_Handlers[type].erase(found);
} }
void PacketDispatcher::UnregisterHandler(PacketHandler* handler){ void PacketDispatcher::UnregisterHandler(PacketHandler* handler) {
for (auto& pair : m_Handlers){ for (auto& pair : m_Handlers) {
if (pair.second.empty()) continue; if (pair.second.empty()) continue;
PacketType type = pair.first; PacketType type = pair.first;
@@ -25,7 +25,7 @@ void PacketDispatcher::UnregisterHandler(PacketHandler* handler){
} }
} }
void PacketDispatcher::Dispatch(Packet* packet){ void PacketDispatcher::Dispatch(Packet* packet) {
if (!packet) return; if (!packet) return;
PacketType type = packet->getType(); PacketType type = packet->getType();

6
src/protocol/PacketFactory.cpp
View File

@@ -4,9 +4,9 @@
namespace td { namespace td {
namespace protocol { namespace protocol {
namespace PacketFactory{ namespace PacketFactory {
using PacketCreator = std::function<Packet*()>; using PacketCreator = std::function<Packet* ()>;
static std::map<PacketType, PacketCreator> packets = { static std::map<PacketType, PacketCreator> packets = {
{PacketType::PlayerLogin, []() -> Packet* {return new PlayerLoginPacket();} }, {PacketType::PlayerLogin, []() -> Packet* {return new PlayerLoginPacket();} },
@@ -30,7 +30,7 @@ static std::map<PacketType, PacketCreator> packets = {
{PacketType::WorldAddTower, []() -> Packet* {return new WorldAddTowerPacket(); } }, {PacketType::WorldAddTower, []() -> Packet* {return new WorldAddTowerPacket(); } },
}; };
Packet* createPacket(PacketType type, DataBuffer& buffer){ Packet* createPacket(PacketType type, DataBuffer& buffer) {
Packet* packet = packets[type](); Packet* packet = packets[type]();
packet->Deserialize(buffer); packet->Deserialize(buffer);
return packet; return packet;

133
src/protocol/Protocol.cpp
View File

@@ -9,27 +9,27 @@ namespace protocol {
const int BITS_IN_BYTE = 8; const int BITS_IN_BYTE = 8;
const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t); const int BITS_IN_LONG = BITS_IN_BYTE * sizeof(std::uint64_t);
unsigned int countBits(unsigned int number){ unsigned int countBits(unsigned int number) {
// log function in base 2 // log function in base 2
// take only integer part // take only integer part
return (int)std::log2(number) + 1; return (int)std::log2(number) + 1;
} }
DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile){ DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile) {
buffer << tile->getType(); buffer << tile->getType();
switch (tile->getType()){ switch (tile->getType()) {
case game::TileType::Tower:{ case game::TileType::Tower: {
const game::TowerTile* towerTile = (const game::TowerTile*) tile.get(); const game::TowerTile* towerTile = (const game::TowerTile*)tile.get();
buffer << towerTile->color_palette_ref << towerTile->team_owner; buffer << towerTile->color_palette_ref << towerTile->team_owner;
break; break;
} }
case game::TileType::Walk:{ case game::TileType::Walk: {
const game::WalkableTile* walkTile = (const game::WalkableTile*) tile.get(); const game::WalkableTile* walkTile = (const game::WalkableTile*)tile.get();
buffer << walkTile->direction; buffer << walkTile->direction;
break; break;
} }
case game::TileType::Decoration:{ case game::TileType::Decoration: {
const game::DecorationTile* decoTile = (const game::DecorationTile*) tile.get(); const game::DecorationTile* decoTile = (const game::DecorationTile*)tile.get();
buffer << decoTile->color_palette_ref; buffer << decoTile->color_palette_ref;
break; break;
} }
@@ -39,23 +39,23 @@ DataBuffer& operator<<(DataBuffer& buffer, game::TilePtr tile){
return buffer; return buffer;
} }
DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile){ DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile) {
game::TileType tileType; game::TileType tileType;
buffer >> tileType; buffer >> tileType;
switch (tileType){ switch (tileType) {
case game::TileType::Tower:{ case game::TileType::Tower: {
std::shared_ptr<game::TowerTile> tilePtr = std::make_shared<game::TowerTile>(); std::shared_ptr<game::TowerTile> tilePtr = std::make_shared<game::TowerTile>();
buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner; buffer >> tilePtr->color_palette_ref >> tilePtr->team_owner;
tile = tilePtr; tile = tilePtr;
break; break;
} }
case game::TileType::Walk:{ case game::TileType::Walk: {
std::shared_ptr<game::WalkableTile> tilePtr = std::make_shared<game::WalkableTile>(); std::shared_ptr<game::WalkableTile> tilePtr = std::make_shared<game::WalkableTile>();
buffer >> tilePtr->direction; buffer >> tilePtr->direction;
tile = tilePtr; tile = tilePtr;
break; break;
} }
case game::TileType::Decoration:{ case game::TileType::Decoration: {
std::shared_ptr<game::DecorationTile> tilePtr = std::make_shared<game::DecorationTile>(); std::shared_ptr<game::DecorationTile> tilePtr = std::make_shared<game::DecorationTile>();
buffer >> tilePtr->color_palette_ref; buffer >> tilePtr->color_palette_ref;
tile = tilePtr; tile = tilePtr;
@@ -67,17 +67,17 @@ DataBuffer& operator>>(DataBuffer& buffer, game::TilePtr& tile){
return buffer; return buffer;
} }
DataBuffer PlayerLoginPacket::Serialize() const{ DataBuffer PlayerLoginPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_PlayerName; data << getID() << m_PlayerName;
return data; return data;
} }
void PlayerLoginPacket::Deserialize(DataBuffer& data){ void PlayerLoginPacket::Deserialize(DataBuffer& data) {
data >> m_PlayerName; data >> m_PlayerName;
} }
DataBuffer WorldBeginDataPacket::Serialize() const{ DataBuffer WorldBeginDataPacket::Serialize() const {
DataBuffer data; DataBuffer data;
const game::TowerTileColorPalette towerTilePalette = m_World->getTowerTileColorPalette(); const game::TowerTileColorPalette towerTilePalette = m_World->getTowerTileColorPalette();
const std::vector<game::Color>& decoTilePalette = m_World->getDecorationPalette(); const std::vector<game::Color>& decoTilePalette = m_World->getDecorationPalette();
@@ -100,7 +100,7 @@ DataBuffer WorldBeginDataPacket::Serialize() const{
// tile palette // tile palette
data << m_World->getTilePalette().size(); data << m_World->getTilePalette().size();
for (game::TilePtr tile : m_World->getTilePalette()){ for (game::TilePtr tile : m_World->getTilePalette()) {
data << tile; data << tile;
} }
@@ -109,7 +109,7 @@ DataBuffer WorldBeginDataPacket::Serialize() const{
return data; return data;
} }
void WorldBeginDataPacket::Deserialize(DataBuffer& data){ void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
data >> m_TowerPlacePalette >> m_WalkablePalette; data >> m_TowerPlacePalette >> m_WalkablePalette;
std::uint16_t decoPaletteSize; std::uint16_t decoPaletteSize;
@@ -131,7 +131,7 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data){
m_TilePalette.reserve(tilePaletteSize); m_TilePalette.reserve(tilePaletteSize);
for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++){ for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++) {
game::TilePtr tile; game::TilePtr tile;
data >> tile; data >> tile;
m_TilePalette.push_back(tile); m_TilePalette.push_back(tile);
@@ -142,14 +142,14 @@ void WorldBeginDataPacket::Deserialize(DataBuffer& data){
typedef std::vector<uint64_t> ChunkPackedData; typedef std::vector<uint64_t> ChunkPackedData;
DataBuffer WorldDataPacket::Serialize() const{ DataBuffer WorldDataPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_World->getChunks().size(); data << getID() << m_World->getChunks().size();
for (const auto& pair : m_World->getChunks()){ for (const auto& pair : m_World->getChunks()) {
game::ChunkCoord coords = pair.first; game::ChunkCoord coords = pair.first;
game::ChunkPtr chunk = pair.second; game::ChunkPtr chunk = pair.second;
data << coords.first << coords.second << (std::uint64_t) chunk->palette.size(); data << coords.first << coords.second << (std::uint64_t)chunk->palette.size();
std::size_t bufferSize = data.GetSize(); std::size_t bufferSize = data.GetSize();
data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type)); data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
@@ -161,7 +161,7 @@ DataBuffer WorldDataPacket::Serialize() const{
ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0); ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++){ for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG; int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG; int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG; int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
@@ -173,7 +173,7 @@ DataBuffer WorldDataPacket::Serialize() const{
chunkData[startLong] |= (value << startOffset); chunkData[startLong] |= (value << startOffset);
if (startLong != endLong){ if (startLong != endLong) {
chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset)); chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset));
} }
} }
@@ -185,11 +185,11 @@ DataBuffer WorldDataPacket::Serialize() const{
return data; return data;
} }
void WorldDataPacket::Deserialize(DataBuffer& data){ void WorldDataPacket::Deserialize(DataBuffer& data) {
std::uint64_t chunkCount; std::uint64_t chunkCount;
data >> chunkCount; data >> chunkCount;
for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++){ for (std::uint64_t chunkNumber = 0; chunkNumber < chunkCount; chunkNumber++) {
game::ChunkPtr chunk = std::make_shared<game::Chunk>(); game::ChunkPtr chunk = std::make_shared<game::Chunk>();
game::ChunkCoord::first_type chunkX, chunkY; game::ChunkCoord::first_type chunkX, chunkY;
@@ -215,16 +215,15 @@ void WorldDataPacket::Deserialize(DataBuffer& data){
memcpy((void*)chunkData.data(), data.data() + data.GetReadOffset(), chunkData.size() * sizeof(ChunkPackedData::value_type)); memcpy((void*)chunkData.data(), data.data() + data.GetReadOffset(), chunkData.size() * sizeof(ChunkPackedData::value_type));
data.SetReadOffset(data.GetReadOffset() + chunkData.size() * sizeof(ChunkPackedData::value_type)); data.SetReadOffset(data.GetReadOffset() + chunkData.size() * sizeof(ChunkPackedData::value_type));
for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++){ for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG; int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG; int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG; int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
game::ChunkData::value_type value; game::ChunkData::value_type value;
if (startLong == endLong){ if (startLong == endLong) {
value = (chunkData[startLong] >> startOffset); value = (chunkData[startLong] >> startOffset);
} } else {
else{
int endOffset = BITS_IN_LONG - startOffset; int endOffset = BITS_IN_LONG - startOffset;
value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset); value = (chunkData[startLong] >> startOffset | chunkData[endLong] << endOffset);
} }
@@ -234,180 +233,180 @@ void WorldDataPacket::Deserialize(DataBuffer& data){
} }
m_Chunks.insert({{chunkX, chunkY}, chunk}); m_Chunks.insert({ {chunkX, chunkY}, chunk });
} }
} }
DataBuffer KeepAlivePacket::Serialize() const{ DataBuffer KeepAlivePacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_AliveID; data << getID() << m_AliveID;
return data; return data;
} }
void KeepAlivePacket::Deserialize(DataBuffer& data){ void KeepAlivePacket::Deserialize(DataBuffer& data) {
data >> m_AliveID; data >> m_AliveID;
} }
DataBuffer UpdateMoneyPacket::Serialize() const{ DataBuffer UpdateMoneyPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_NewAmount; data << getID() << m_NewAmount;
return data; return data;
} }
void UpdateMoneyPacket::Deserialize(DataBuffer& data){ void UpdateMoneyPacket::Deserialize(DataBuffer& data) {
data >> m_NewAmount; data >> m_NewAmount;
} }
DataBuffer UpdateExpPacket::Serialize() const{ DataBuffer UpdateExpPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_NewAmount; data << getID() << m_NewAmount;
return data; return data;
} }
void UpdateExpPacket::Deserialize(DataBuffer& data){ void UpdateExpPacket::Deserialize(DataBuffer& data) {
data >> m_NewAmount; data >> m_NewAmount;
} }
DataBuffer UpdateLobbyTimePacket::Serialize() const{ DataBuffer UpdateLobbyTimePacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_RemainingTime; data << getID() << m_RemainingTime;
return data; return data;
} }
void UpdateLobbyTimePacket::Deserialize(DataBuffer& data){ void UpdateLobbyTimePacket::Deserialize(DataBuffer& data) {
data >> m_RemainingTime; data >> m_RemainingTime;
} }
DataBuffer UpdateGameStatePacket::Serialize() const{ DataBuffer UpdateGameStatePacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_GameState; data << getID() << m_GameState;
return data; return data;
} }
void UpdateGameStatePacket::Deserialize(DataBuffer& data){ void UpdateGameStatePacket::Deserialize(DataBuffer& data) {
data >> m_GameState; data >> m_GameState;
} }
DataBuffer PlayerListPacket::Serialize() const{ DataBuffer PlayerListPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << (std::uint8_t)m_Players.size(); data << getID() << (std::uint8_t)m_Players.size();
for (auto pair : m_Players){ for (auto pair : m_Players) {
data << pair.first << pair.second.name << pair.second.team; data << pair.first << pair.second.name << pair.second.team;
} }
return data; return data;
} }
void PlayerListPacket::Deserialize(DataBuffer& data){ void PlayerListPacket::Deserialize(DataBuffer& data) {
std::uint8_t playerCount; std::uint8_t playerCount;
data >> playerCount; data >> playerCount;
for (int i = 0; i < playerCount; i++){ for (int i = 0; i < playerCount; i++) {
std::uint8_t playerID; std::uint8_t playerID;
PlayerInfo playerInfo; PlayerInfo playerInfo;
data >> playerID >> playerInfo.name >> playerInfo.team; data >> playerID >> playerInfo.name >> playerInfo.team;
m_Players.insert({playerID, playerInfo}); m_Players.insert({ playerID, playerInfo });
} }
} }
DataBuffer PlayerJoinPacket::Serialize() const{ DataBuffer PlayerJoinPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_PlayerID << m_PlayerName; data << getID() << m_PlayerID << m_PlayerName;
return data; return data;
} }
void PlayerJoinPacket::Deserialize(DataBuffer& data){ void PlayerJoinPacket::Deserialize(DataBuffer& data) {
data >> m_PlayerID >> m_PlayerName; data >> m_PlayerID >> m_PlayerName;
} }
DataBuffer PlayerLeavePacket::Serialize() const{ DataBuffer PlayerLeavePacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_PlayerID; data << getID() << m_PlayerID;
return data; return data;
} }
void PlayerLeavePacket::Deserialize(DataBuffer& data){ void PlayerLeavePacket::Deserialize(DataBuffer& data) {
data >> m_PlayerID; data >> m_PlayerID;
} }
DataBuffer ConnexionInfoPacket::Serialize() const{ DataBuffer ConnexionInfoPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_ConnectionID; data << getID() << m_ConnectionID;
return data; return data;
} }
void ConnexionInfoPacket::Deserialize(DataBuffer& data){ void ConnexionInfoPacket::Deserialize(DataBuffer& data) {
data >> m_ConnectionID; data >> m_ConnectionID;
} }
DataBuffer SelectTeamPacket::Serialize() const{ DataBuffer SelectTeamPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_SelectedTeam; data << getID() << m_SelectedTeam;
return data; return data;
} }
void SelectTeamPacket::Deserialize(DataBuffer& data){ void SelectTeamPacket::Deserialize(DataBuffer& data) {
data >> m_SelectedTeam; data >> m_SelectedTeam;
} }
DataBuffer UpdatePlayerTeamPacket::Serialize() const{ DataBuffer UpdatePlayerTeamPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_PlayerID << m_SelectedTeam; data << getID() << m_PlayerID << m_SelectedTeam;
return data; return data;
} }
void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data){ void UpdatePlayerTeamPacket::Deserialize(DataBuffer& data) {
data >> m_PlayerID >> m_SelectedTeam; data >> m_PlayerID >> m_SelectedTeam;
} }
DataBuffer DisconnectPacket::Serialize() const{ DataBuffer DisconnectPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_Reason; data << getID() << m_Reason;
return data; return data;
} }
void DisconnectPacket::Deserialize(DataBuffer& data){ void DisconnectPacket::Deserialize(DataBuffer& data) {
data >> m_Reason; data >> m_Reason;
} }
DataBuffer ServerTpsPacket::Serialize() const{ DataBuffer ServerTpsPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_TPS << m_PacketSendTime; data << getID() << m_TPS << m_PacketSendTime;
return data; return data;
} }
void ServerTpsPacket::Deserialize(DataBuffer& data){ void ServerTpsPacket::Deserialize(DataBuffer& data) {
data >> m_TPS >> m_PacketSendTime; data >> m_TPS >> m_PacketSendTime;
} }
DataBuffer SpawnMobPacket::Serialize() const{ DataBuffer SpawnMobPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection
<< m_Sender << m_MobX << m_MobY; << m_Sender << m_MobX << m_MobY;
return data; return data;
} }
void SpawnMobPacket::Deserialize(DataBuffer& data){ void SpawnMobPacket::Deserialize(DataBuffer& data) {
data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection
>> m_Sender >> m_MobX >> m_MobY; >> m_Sender >> m_MobX >> m_MobY;
} }
DataBuffer PlaceTowerPacket::Serialize() const{ DataBuffer PlaceTowerPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_TowerX << m_TowerY << m_TowerType; data << getID() << m_TowerX << m_TowerY << m_TowerType;
return data; return data;
} }
void PlaceTowerPacket::Deserialize(DataBuffer& data){ void PlaceTowerPacket::Deserialize(DataBuffer& data) {
data >> m_TowerX >> m_TowerY >> m_TowerType; data >> m_TowerX >> m_TowerY >> m_TowerType;
} }
DataBuffer WorldAddTowerPacket::Serialize() const{ DataBuffer WorldAddTowerPacket::Serialize() const {
DataBuffer data; DataBuffer data;
data << getID() << m_TowerX << m_TowerY << m_TowerType << m_Builder; data << getID() << m_TowerX << m_TowerY << m_TowerType << m_Builder;
return data; return data;
} }
void WorldAddTowerPacket::Deserialize(DataBuffer& data){ void WorldAddTowerPacket::Deserialize(DataBuffer& data) {
data >> m_TowerX >> m_TowerY >> m_TowerType >> m_Builder; data >> m_TowerX >> m_TowerY >> m_TowerType >> m_Builder;
} }

44
src/render/Renderer.cpp
View File

@@ -14,18 +14,18 @@
using namespace gl; using namespace gl;
namespace td{ namespace td {
namespace render{ namespace render {
Renderer::Renderer(){ Renderer::Renderer() {
} }
Renderer::~Renderer(){ Renderer::~Renderer() {
} }
void Renderer::updateIsometricView(){ void Renderer::updateIsometricView() {
float isometricEased = utils::easeInOutExpo(m_IsometricShade); float isometricEased = utils::easeInOutExpo(m_IsometricShade);
m_WorldShader->start(); m_WorldShader->start();
m_WorldShader->setIsometricView(isometricEased); m_WorldShader->setIsometricView(isometricEased);
@@ -33,7 +33,7 @@ void Renderer::updateIsometricView(){
m_EntityShader->setIsometricView(isometricEased); m_EntityShader->setIsometricView(isometricEased);
} }
void Renderer::initShader(){ void Renderer::initShader() {
m_WorldShader = std::make_unique<WorldShader>(); m_WorldShader = std::make_unique<WorldShader>();
m_WorldShader->loadShader(); m_WorldShader->loadShader();
m_EntityShader = std::make_unique<EntityShader>(); m_EntityShader = std::make_unique<EntityShader>();
@@ -42,7 +42,7 @@ void Renderer::initShader(){
updateIsometricView(); updateIsometricView();
} }
bool Renderer::init(){ bool Renderer::init() {
glbinding::Binding::initialize(); glbinding::Binding::initialize();
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND); glEnable(GL_BLEND);
@@ -51,14 +51,14 @@ bool Renderer::init(){
return true; return true;
} }
void Renderer::renderVAO(const GL::VertexArray& vao){ void Renderer::renderVAO(const GL::VertexArray& vao) {
m_WorldShader->start(); m_WorldShader->start();
vao.bind(); vao.bind();
glDrawArrays(GL_TRIANGLES, 0, vao.getVertexCount()); glDrawArrays(GL_TRIANGLES, 0, vao.getVertexCount());
vao.unbind(); vao.unbind();
} }
void Renderer::renderModel(const Model& model){ void Renderer::renderModel(const Model& model) {
m_EntityShader->start(); m_EntityShader->start();
m_EntityShader->setModelPos(model.positon); m_EntityShader->setModelPos(model.positon);
model.vao->bind(); model.vao->bind();
@@ -66,13 +66,13 @@ void Renderer::renderModel(const Model& model){
model.vao->unbind(); model.vao->unbind();
} }
void Renderer::updateIsometricFade(){ void Renderer::updateIsometricFade() {
static std::uint64_t lastTime = utils::getTime(); static std::uint64_t lastTime = utils::getTime();
if(m_IsometricShade != (float) m_IsometricView){ if (m_IsometricShade != (float)m_IsometricView) {
float step = (float) (utils::getTime() - lastTime) / 1000.0f * m_AnimationSpeed; float step = (float)(utils::getTime() - lastTime) / 1000.0f * m_AnimationSpeed;
if(m_IsometricShade < m_IsometricView){ if (m_IsometricShade < m_IsometricView) {
m_IsometricShade += step; m_IsometricShade += step;
}else{ } else {
m_IsometricShade -= step; m_IsometricShade -= step;
} }
m_IsometricShade = std::min(m_IsometricShade, 1.0f); m_IsometricShade = std::min(m_IsometricShade, 1.0f);
@@ -82,13 +82,13 @@ void Renderer::updateIsometricFade(){
lastTime = utils::getTime(); lastTime = utils::getTime();
} }
void Renderer::prepare(){ void Renderer::prepare() {
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
glClearColor(0, 0, 0, 0); glClearColor(0, 0, 0, 0);
updateIsometricFade(); updateIsometricFade();
} }
void Renderer::resize(int width, int height){ void Renderer::resize(int width, int height) {
m_WorldShader->start(); m_WorldShader->start();
m_WorldShader->setAspectRatio((float)width / height); m_WorldShader->setAspectRatio((float)width / height);
m_EntityShader->start(); m_EntityShader->start();
@@ -96,20 +96,20 @@ void Renderer::resize(int width, int height){
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
} }
void Renderer::setZoom(float zoom){ void Renderer::setZoom(float zoom) {
m_WorldShader->start(); m_WorldShader->start();
m_WorldShader->setZoom(zoom); m_WorldShader->setZoom(zoom);
m_EntityShader->start(); m_EntityShader->start();
m_EntityShader->setZoom(zoom); 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.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; 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_CamPos = newPos;
m_WorldShader->start(); m_WorldShader->start();
m_WorldShader->setCamPos(newPos); m_WorldShader->setCamPos(newPos);
@@ -117,11 +117,11 @@ void Renderer::setCamPos(const glm::vec2& newPos){
m_EntityShader->setCamPos(newPos); m_EntityShader->setCamPos(newPos);
} }
void Renderer::setIsometricView(bool isometric){ void Renderer::setIsometricView(bool isometric) {
m_IsometricView = isometric; m_IsometricView = isometric;
} }
glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight){ glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRatio, float zoom, float windowWidth, float windowHeight) {
float isometricEased = utils::easeInOutExpo(m_IsometricShade); float isometricEased = utils::easeInOutExpo(m_IsometricShade);
float relativeX = (cursorPos.x / windowWidth * 2) - 1; float relativeX = (cursorPos.x / windowWidth * 2) - 1;
@@ -133,7 +133,7 @@ glm::vec2 Renderer::getCursorWorldPos(const glm::vec2& cursorPos, float aspectRa
float worldX = m_CamPos.x + deltaX * (1 - isometricEased) + (0.5 * deltaX + deltaY) * isometricEased; float worldX = m_CamPos.x + deltaX * (1 - isometricEased) + (0.5 * deltaX + deltaY) * isometricEased;
float worldY = m_CamPos.y + deltaY * (1 - isometricEased) + (-0.5 * deltaX + deltaY) * isometricEased; float worldY = m_CamPos.y + deltaY * (1 - isometricEased) + (-0.5 * deltaX + deltaY) * isometricEased;
return {worldX, worldY}; return { worldX, worldY };
} }

2
src/render/WorldRenderer.cpp
View File

@@ -157,7 +157,7 @@ glm::vec2 WorldRenderer::getCursorWorldPos() const {
return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight()); return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
} }
glm::vec2 WorldRenderer::getClickWorldPos() const{ glm::vec2 WorldRenderer::getClickWorldPos() const {
return m_Renderer->getCursorWorldPos(m_HoldCursorPos, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight()); return m_Renderer->getCursorWorldPos(m_HoldCursorPos, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
} }

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

@@ -20,7 +20,7 @@
#include <iostream> #include <iostream>
#include <cmath> #include <cmath>
namespace TowerGui{ namespace TowerGui {
static GLFWwindow* window; static GLFWwindow* window;
static std::unique_ptr<td::client::Client> client; static std::unique_ptr<td::client::Client> client;
@@ -29,7 +29,7 @@ static td::render::Renderer* renderer;
bool serverShouldStop = false; bool serverShouldStop = false;
void init(GLFWwindow* glfw_window, td::render::Renderer* render){ void init(GLFWwindow* glfw_window, td::render::Renderer* render) {
window = glfw_window; window = glfw_window;
IMGUI_CHECKVERSION(); IMGUI_CHECKVERSION();
ImGui::CreateContext(); ImGui::CreateContext();
@@ -44,47 +44,47 @@ void init(GLFWwindow* glfw_window, td::render::Renderer* render){
client = std::make_unique<td::client::Client>(render); client = std::make_unique<td::client::Client>(render);
} }
void beginFrame(){ void beginFrame() {
ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
} }
void endFrame(){ void endFrame() {
ImGui::EndFrame(); ImGui::EndFrame();
ImGui::Render(); ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
} }
void renderFPSCounter(){ void renderFPSCounter() {
ImGui::Begin("FPS Counter"); ImGui::Begin("FPS Counter");
ImGui::Text("FPS : %i", (int)ImGui::GetIO().Framerate); ImGui::Text("FPS : %i", (int)ImGui::GetIO().Framerate);
static bool vsync = true; static bool vsync = true;
if (ImGui::Checkbox("V-Sync", &vsync)){ if (ImGui::Checkbox("V-Sync", &vsync)) {
glfwSwapInterval(vsync); glfwSwapInterval(vsync);
} }
static bool isometric = true; static bool isometric = true;
if (ImGui::Checkbox("Vue Isometrique ?", &isometric)){ if (ImGui::Checkbox("Vue Isometrique ?", &isometric)) {
renderer->setIsometricView(isometric); renderer->setIsometricView(isometric);
} }
ImGui::End(); ImGui::End();
} }
bool startServer(int port, const std::string& worldFilePath){ bool startServer(int port, const std::string& worldFilePath) {
if (worldFilePath.empty()) if (worldFilePath.empty())
return false; return false;
std::shared_ptr<td::server::Server> server = std::make_shared<td::server::Server>(worldFilePath); std::shared_ptr<td::server::Server> server = std::make_shared<td::server::Server>(worldFilePath);
if (!server->start(port)){ if (!server->start(port)) {
return false; return false;
} }
serverThread = new std::thread([server](){ serverThread = new std::thread([server]() {
while (!serverShouldStop){ while (!serverShouldStop) {
static std::uint64_t lastTime = td::utils::getTime(); static std::uint64_t lastTime = td::utils::getTime();
std::uint64_t time = td::utils::getTime(); std::uint64_t time = td::utils::getTime();
std::uint64_t delta = time - lastTime; std::uint64_t delta = time - lastTime;
if (delta >= SERVER_TICK){ if (delta >= SERVER_TICK) {
server->tick(delta); server->tick(delta);
lastTime = td::utils::getTime(); lastTime = td::utils::getTime();
std::uint64_t sleepTime = SERVER_TICK - (delta - SERVER_TICK); std::uint64_t sleepTime = SERVER_TICK - (delta - SERVER_TICK);
@@ -97,38 +97,37 @@ bool startServer(int port, const std::string& worldFilePath){
return true; return true;
} }
void renderMainMenu(){ void renderMainMenu() {
ImGui::Begin("Main Menu"); ImGui::Begin("Main Menu");
if (ImGui::Button("Rejoindre une partie##join")){ if (ImGui::Button("Rejoindre une partie##join")) {
ImGui::OpenPopup("Rejoindre une partie##join_popup"); ImGui::OpenPopup("Rejoindre une partie##join_popup");
} }
if (ImGui::Button("Créer une partie")){ if (ImGui::Button("Créer une partie")) {
ImGui::OpenPopup("Créer une partie##create_popup"); ImGui::OpenPopup("Créer une partie##create_popup");
} }
if (ImGui::Button("Options")){ if (ImGui::Button("Options")) {
} }
static bool triedToConnect = false; static bool triedToConnect = false;
if (ImGui::BeginPopup("Rejoindre une partie##join_popup")){ if (ImGui::BeginPopup("Rejoindre une partie##join_popup")) {
static char buffer[512] = "localhost"; static char buffer[512] = "localhost";
static int port = 25565; static int port = 25565;
ImGui::InputText("Server Adress", buffer, sizeof(buffer)); ImGui::InputText("Server Adress", buffer, sizeof(buffer));
ImGui::InputInt("Port", &port, -1); ImGui::InputInt("Port", &port, -1);
if (ImGui::Button("Rejoindre")){ if (ImGui::Button("Rejoindre")) {
client->connect(buffer, port); client->connect(buffer, port);
triedToConnect = true; triedToConnect = true;
} }
if (triedToConnect){ if (triedToConnect) {
ImGui::Text("Impossible de se connecter"); ImGui::Text("Impossible de se connecter");
} }
ImGui::EndPopup(); ImGui::EndPopup();
} } else {
else{
triedToConnect = false; triedToConnect = false;
} }
static bool triedToCreate = false; static bool triedToCreate = false;
if (ImGui::BeginPopup("Créer une partie##create_popup")){ if (ImGui::BeginPopup("Créer une partie##create_popup")) {
static imgui_addons::ImGuiFileBrowser file_dialog; static imgui_addons::ImGuiFileBrowser file_dialog;
static int port = 25565; static int port = 25565;
static std::string worldFilePath; static std::string worldFilePath;
@@ -136,33 +135,31 @@ void renderMainMenu(){
ImGui::InputInt("Server Port", &port, -1); ImGui::InputInt("Server Port", &port, -1);
ImGui::Text(std::string("Fichier de monde sélectionné : " + (worldFilePath.empty() ? std::string("Aucun") : worldFilePath)).c_str()); ImGui::Text(std::string("Fichier de monde sélectionné : " + (worldFilePath.empty() ? std::string("Aucun") : worldFilePath)).c_str());
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button("Ouvrir un fichier")){ if (ImGui::Button("Ouvrir un fichier")) {
ImGui::OpenPopup("WorldFileDialog"); ImGui::OpenPopup("WorldFileDialog");
} }
if (file_dialog.showFileDialog("WorldFileDialog", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(600, 300), ".tdmap")){ if (file_dialog.showFileDialog("WorldFileDialog", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(600, 300), ".tdmap")) {
worldFilePath = file_dialog.selected_path; worldFilePath = file_dialog.selected_path;
} }
if (ImGui::Button("Créer")){ if (ImGui::Button("Créer")) {
if (!startServer(port, worldFilePath)){ if (!startServer(port, worldFilePath)) {
triedToCreate = true; triedToCreate = true;
} } else {
else{
client->connect("localhost", port); client->connect("localhost", port);
} }
} }
if (triedToCreate) if (triedToCreate)
ImGui::Text("Failed to launch server"); ImGui::Text("Failed to launch server");
ImGui::EndPopup(); ImGui::EndPopup();
} } else {
else{
triedToCreate = false; triedToCreate = false;
} }
ImGui::End(); ImGui::End();
} }
ImVec4 getImGuiTeamColor(td::game::TeamColor color){ ImVec4 getImGuiTeamColor(td::game::TeamColor color) {
switch (color){ switch (color) {
case td::game::TeamColor::None: case td::game::TeamColor::None:
break; break;
case td::game::TeamColor::Red: case td::game::TeamColor::Red:
@@ -173,9 +170,9 @@ ImVec4 getImGuiTeamColor(td::game::TeamColor color){
return ImVec4(1, 1, 1, 1); return ImVec4(1, 1, 1, 1);
} }
void showPlayers(){ void showPlayers() {
if (ImGui::TreeNode(std::string("Players (" + std::to_string(client->getGame().getPlayers().size()) + ")##player_list").c_str())){ if (ImGui::TreeNode(std::string("Players (" + std::to_string(client->getGame().getPlayers().size()) + ")##player_list").c_str())) {
for (auto pair : client->getGame().getPlayers()){ for (auto pair : client->getGame().getPlayers()) {
const td::game::Player& player = pair.second; const td::game::Player& player = pair.second;
ImGui::PushStyleColor(ImGuiCol_Text, getImGuiTeamColor(player.getTeamColor())); ImGui::PushStyleColor(ImGuiCol_Text, getImGuiTeamColor(player.getTeamColor()));
ImGui::Text(player.getName().c_str()); ImGui::Text(player.getName().c_str());
@@ -185,19 +182,19 @@ void showPlayers(){
} }
} }
void showTeamSelection(){ void showTeamSelection() {
if (client->getGame().getPlayer() == nullptr) if (client->getGame().getPlayer() == nullptr)
return; return;
td::game::TeamColor playerTeam = client->getGame().getPlayer()->getTeamColor(); td::game::TeamColor playerTeam = client->getGame().getPlayer()->getTeamColor();
if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Red ? "Leave" : "Join") + std::string(" Red Team")).c_str())){ if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Red ? "Leave" : "Join") + std::string(" Red Team")).c_str())) {
if (playerTeam == td::game::TeamColor::Red) if (playerTeam == td::game::TeamColor::Red)
client->selectTeam(td::game::TeamColor::None); client->selectTeam(td::game::TeamColor::None);
else else
client->selectTeam(td::game::TeamColor::Red); client->selectTeam(td::game::TeamColor::Red);
} }
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Blue ? "Leave" : "Join") + std::string(" Blue Team")).c_str())){ if (ImGui::Button(std::string((playerTeam == td::game::TeamColor::Blue ? "Leave" : "Join") + std::string(" Blue Team")).c_str())) {
if (playerTeam == td::game::TeamColor::Blue) if (playerTeam == td::game::TeamColor::Blue)
client->selectTeam(td::game::TeamColor::None); client->selectTeam(td::game::TeamColor::None);
else else
@@ -205,36 +202,35 @@ void showTeamSelection(){
} }
} }
void showLobbyProgress(){ void showLobbyProgress() {
const int timePassed = LOBBY_WAITING_TIME - client->getGame().getLobbyTime(); const int timePassed = LOBBY_WAITING_TIME - client->getGame().getLobbyTime();
const float progress = (float)timePassed / (float)(LOBBY_WAITING_TIME); const float progress = (float)timePassed / (float)(LOBBY_WAITING_TIME);
if (progress > 0 && progress < 1){ if (progress > 0 && progress < 1) {
ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f), std::string(std::to_string(client->getGame().getLobbyTime() / 1000) + "s").c_str()); ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f), std::string(std::to_string(client->getGame().getLobbyTime() / 1000) + "s").c_str());
ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x); ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
ImGui::Text("Time Remaining"); ImGui::Text("Time Remaining");
} } else {
else{
ImGui::Text("Waiting for players ...\n"); ImGui::Text("Waiting for players ...\n");
} }
} }
void showTPS(){ void showTPS() {
ImGui::Text("Server TPS : %.1f", client->getConnexion().getServerTPS()); ImGui::Text("Server TPS : %.1f", client->getConnexion().getServerTPS());
ImGui::Text("Server Ping : %i", client->getConnexion().getServerPing()); ImGui::Text("Server Ping : %i", client->getConnexion().getServerPing());
} }
void showStats(){ void showStats() {
ImGui::Text("Gold : %i", client->getGame().getPlayer()->getGold()); ImGui::Text("Gold : %i", client->getGame().getPlayer()->getGold());
} }
void renderSummonMenu(){ void renderSummonMenu() {
static bool menu_open = false; static bool menu_open = false;
if (menu_open){ if (menu_open) {
ImGui::Begin("Summon", &menu_open); ImGui::Begin("Summon", &menu_open);
static int width = 100; static int width = 100;
ImTextureID my_tex_id = ImGui::GetIO().Fonts->TexID; ImTextureID my_tex_id = ImGui::GetIO().Fonts->TexID;
for (int i = 0; i < 8; i++){ for (int i = 0; i < 8; i++) {
ImGui::SameLine(); ImGui::SameLine();
ImGui::PushID(i); ImGui::PushID(i);
ImGui::Image(my_tex_id, ImVec2(100, 100)); ImGui::Image(my_tex_id, ImVec2(100, 100));
@@ -243,7 +239,7 @@ void renderSummonMenu(){
ImGui::Separator(); ImGui::Separator();
static int values[16]; static int values[16];
ImGui::PushItemWidth(width); ImGui::PushItemWidth(width);
for (int i = 0; i < 8; i++){ for (int i = 0; i < 8; i++) {
ImGui::SameLine(); ImGui::SameLine();
ImGui::PushID(i); ImGui::PushID(i);
ImGui::InputInt("", values + i, 1, 10); ImGui::InputInt("", values + i, 1, 10);
@@ -251,7 +247,7 @@ void renderSummonMenu(){
} }
ImGui::PopItemWidth(); ImGui::PopItemWidth();
ImGui::Separator(); ImGui::Separator();
for (int i = 0; i < 8; i++){ for (int i = 0; i < 8; i++) {
ImGui::SameLine(); ImGui::SameLine();
ImGui::PushID(i); ImGui::PushID(i);
ImGui::Image(my_tex_id, ImVec2(100, 100)); ImGui::Image(my_tex_id, ImVec2(100, 100));
@@ -259,7 +255,7 @@ void renderSummonMenu(){
} }
ImGui::Separator(); ImGui::Separator();
ImGui::PushItemWidth(width); ImGui::PushItemWidth(width);
for (int i = 8; i < 16; i++){ for (int i = 8; i < 16; i++) {
ImGui::SameLine(); ImGui::SameLine();
ImGui::PushID(i); ImGui::PushID(i);
ImGui::InputInt("", values + i, 1, 10); ImGui::InputInt("", values + i, 1, 10);
@@ -270,8 +266,8 @@ void renderSummonMenu(){
} }
} }
void renderGame(){ void renderGame() {
if (client->getGame().getGameState() == td::game::GameState::Lobby){ if (client->getGame().getGameState() == td::game::GameState::Lobby) {
ImGui::Begin("Lobby"); ImGui::Begin("Lobby");
showTPS(); showTPS();
@@ -281,7 +277,7 @@ void renderGame(){
ImGui::End(); ImGui::End();
} }
if (client->getGame().getGameState() == td::game::GameState::Game){ if (client->getGame().getGameState() == td::game::GameState::Game) {
ImGui::Begin("Game"); ImGui::Begin("Game");
showTPS(); showTPS();
@@ -292,7 +288,7 @@ void renderGame(){
} }
} }
void tick(){ void tick() {
static std::uint64_t lastTime = td::utils::getTime(); static std::uint64_t lastTime = td::utils::getTime();
std::uint64_t time = td::utils::getTime(); std::uint64_t time = td::utils::getTime();
@@ -303,7 +299,7 @@ void tick(){
lastTime = td::utils::getTime(); lastTime = td::utils::getTime();
} }
void render(){ void render() {
tick(); tick();
beginFrame(); beginFrame();
client->render(); client->render();
@@ -319,11 +315,11 @@ void render(){
endFrame(); endFrame();
} }
void destroy(){ void destroy() {
client->closeConnection(); client->closeConnection();
client.reset(); client.reset();
serverShouldStop = true; serverShouldStop = true;
if (serverThread != nullptr){ if (serverThread != nullptr) {
serverThread->join(); serverThread->join();
delete serverThread; delete serverThread;
} }

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

@@ -11,64 +11,64 @@
using namespace gl; using namespace gl;
namespace GL{ namespace GL {
VertexArray::~VertexArray(){ VertexArray::~VertexArray() {
if(m_ID != 0) if (m_ID != 0)
glDeleteVertexArrays(1, &m_ID); glDeleteVertexArrays(1, &m_ID);
} }
VertexArray::VertexArray(unsigned int vertexCount) : m_VertexCount(vertexCount){ VertexArray::VertexArray(unsigned int vertexCount) : m_VertexCount(vertexCount) {
glGenVertexArrays(1, &m_ID); glGenVertexArrays(1, &m_ID);
} }
void VertexArray::bind() const{ void VertexArray::bind() const {
glBindVertexArray(m_ID); glBindVertexArray(m_ID);
} }
void VertexArray::unbind() const{ void VertexArray::unbind() const {
glBindVertexArray(0); glBindVertexArray(0);
} }
void VertexArray::bindVertexBuffer(VertexBuffer& VertexBuffer){ void VertexArray::bindVertexBuffer(VertexBuffer& VertexBuffer) {
VertexBuffer.bind(); VertexBuffer.bind();
VertexBuffer.bindVertexAttribs(); VertexBuffer.bindVertexAttribs();
m_VertexBuffers.push_back(std::move(VertexBuffer)); m_VertexBuffers.push_back(std::move(VertexBuffer));
} }
VertexBuffer::~VertexBuffer(){ VertexBuffer::~VertexBuffer() {
if(m_ID != 0) if (m_ID != 0)
glDeleteBuffers(1, &m_ID); glDeleteBuffers(1, &m_ID);
} }
VertexBuffer::VertexBuffer(const std::vector<float>& data, unsigned int stride) : m_DataStride(stride){ VertexBuffer::VertexBuffer(const std::vector<float>& data, unsigned int stride) : m_DataStride(stride) {
glGenBuffers(1, &m_ID); glGenBuffers(1, &m_ID);
bind(); bind();
glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), nullptr, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), nullptr, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, data.size() * sizeof(float), data.data()); glBufferSubData(GL_ARRAY_BUFFER, 0, data.size() * sizeof(float), data.data());
unbind(); unbind();
} }
void VertexBuffer::bind() const{ void VertexBuffer::bind() const {
glBindBuffer(GL_ARRAY_BUFFER, m_ID); glBindBuffer(GL_ARRAY_BUFFER, m_ID);
} }
void VertexBuffer::unbind() const{ void VertexBuffer::unbind() const {
glBindBuffer(GL_ARRAY_BUFFER, 0); 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; VertexAttribPointer pointer;
pointer.m_Index = index; pointer.m_Index = index;
pointer.m_Size = coordinateSize; pointer.m_Size = coordinateSize;
pointer.m_Offset = offset; pointer.m_Offset = offset;
m_VertexAttribs.push_back(pointer); m_VertexAttribs.push_back(pointer);
} }
void VertexBuffer::bindVertexAttribs() const{ void VertexBuffer::bindVertexAttribs() const {
for(const VertexAttribPointer& pointer : m_VertexAttribs){ for (const VertexAttribPointer& pointer : m_VertexAttribs) {
glEnableVertexAttribArray(pointer.m_Index); glEnableVertexAttribArray(pointer.m_Index);
glVertexAttribPointer(pointer.m_Index, pointer.m_Size, GL_FLOAT, false, m_DataStride * sizeof(float), (void*)(intptr_t) pointer.m_Offset); glVertexAttribPointer(pointer.m_Index, pointer.m_Size, GL_FLOAT, false, m_DataStride * sizeof(float), (void*)(intptr_t)pointer.m_Offset);
}
} }
} }
}

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

@@ -40,7 +40,7 @@ const unsigned int loadGLTexture(const char* fileName) {
GL_UNSIGNED_BYTE, image); GL_UNSIGNED_BYTE, image);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free((void*) image); stbi_image_free((void*)image);
return textureID; return textureID;
} }
} }

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

@@ -10,7 +10,7 @@ namespace render {
namespace WorldLoader { namespace WorldLoader {
GL::VertexArray loadMobModel(){ GL::VertexArray loadMobModel() {
std::vector<float> positions = { std::vector<float> positions = {
-0.5, -0.5, -0.5, -0.5,
0.5, -0.5, 0.5, -0.5,
@@ -48,19 +48,19 @@ GL::VertexArray loadMobModel(){
return mobVao; 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> positions;
std::vector<float> colors; std::vector<float> colors;
for (const auto& chunkInfo : world->getChunks()){ for (const auto& chunkInfo : world->getChunks()) {
const td::game::ChunkCoord& coords = chunkInfo.first; const td::game::ChunkCoord& coords = chunkInfo.first;
td::game::ChunkPtr chunk = chunkInfo.second; td::game::ChunkPtr chunk = chunkInfo.second;
std::int32_t chunkX = coords.first * td::game::Chunk::ChunkWidth; std::int32_t chunkX = coords.first * td::game::Chunk::ChunkWidth;
std::int32_t chunkY = coords.second * td::game::Chunk::ChunkHeight; std::int32_t chunkY = coords.second * td::game::Chunk::ChunkHeight;
for (int tileY = 0; tileY < td::game::Chunk::ChunkHeight; tileY++){ for (int tileY = 0; tileY < td::game::Chunk::ChunkHeight; tileY++) {
for (int tileX = 0; tileX < td::game::Chunk::ChunkWidth; tileX++){ for (int tileX = 0; tileX < td::game::Chunk::ChunkWidth; tileX++) {
int tileNumber = tileY * td::game::Chunk::ChunkWidth + tileX; int tileNumber = tileY * td::game::Chunk::ChunkWidth + tileX;
td::game::TileIndex tileIndex = chunk->getTileIndex(tileNumber); td::game::TileIndex tileIndex = chunk->getTileIndex(tileNumber);
td::game::TilePtr tile = world->getTilePtr(tileIndex); td::game::TilePtr tile = world->getTilePtr(tileIndex);
@@ -100,7 +100,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){
const td::game::Color* tileColor = world->getTileColor(tile); const td::game::Color* tileColor = world->getTileColor(tile);
for (int i = 0; i < 6; i++){ for (int i = 0; i < 6; i++) {
int color = 255; int color = 255;
color |= tileColor->r << 24; color |= tileColor->r << 24;
color |= tileColor->g << 16; color |= tileColor->g << 16;
@@ -115,7 +115,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){
} }
} }
for (int spawnColor = 0; spawnColor < 2; spawnColor++){ for (int spawnColor = 0; spawnColor < 2; spawnColor++) {
const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn(); const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn();
float fromX = spawn.x - 2, toX = spawn.x + 3; float fromX = spawn.x - 2, toX = spawn.x + 3;
float fromY = spawn.y - 2, toY = spawn.y + 3; float fromY = spawn.y - 2, toY = spawn.y + 3;
@@ -130,7 +130,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){
toX, fromY, toX, fromY,
}); });
for (int i = 0; i < 6; i++){ for (int i = 0; i < 6; i++) {
int color = 255; int color = 255;
color |= world->getSpawnColor(game::TeamColor(spawnColor)).r << 24; color |= world->getSpawnColor(game::TeamColor(spawnColor)).r << 24;
color |= world->getSpawnColor(game::TeamColor(spawnColor)).g << 16; color |= world->getSpawnColor(game::TeamColor(spawnColor)).g << 16;
@@ -156,7 +156,7 @@ GL::VertexArray loadWorldModel(const td::game::World* world){
return worldVao; return worldVao;
} }
GL::VertexArray loadTileSelectModel(){ GL::VertexArray loadTileSelectModel() {
std::vector<float> positions = { std::vector<float> positions = {
0, 0, 0, 0,
1, 0, 1, 0,
@@ -170,7 +170,7 @@ GL::VertexArray loadTileSelectModel(){
int color = 255 << 24 | 255 << 16 | 255 << 8 | 150; int color = 255 << 24 | 255 << 16 | 255 << 8 | 150;
float colorFloat; float colorFloat;
memcpy((std::uint8_t*) &colorFloat, &color, sizeof(float)); memcpy((std::uint8_t*)&colorFloat, &color, sizeof(float));
std::vector<float> colors(6, colorFloat); std::vector<float> colors(6, colorFloat);

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

@@ -49,13 +49,13 @@ void main(void){
} }
)"; )";
EntityShader::EntityShader(): ShaderProgram(){} EntityShader::EntityShader() : ShaderProgram() {}
void EntityShader::loadShader(){ void EntityShader::loadShader() {
ShaderProgram::loadProgram(vertexSource, fragmentSource); ShaderProgram::loadProgram(vertexSource, fragmentSource);
} }
void EntityShader::getAllUniformLocation(){ void EntityShader::getAllUniformLocation() {
location_aspect_ratio = getUniformLocation("aspectRatio"); location_aspect_ratio = getUniformLocation("aspectRatio");
location_zoom = getUniformLocation("zoom"); location_zoom = getUniformLocation("zoom");
location_cam = getUniformLocation("camPos"); location_cam = getUniformLocation("camPos");
@@ -63,18 +63,18 @@ void EntityShader::getAllUniformLocation(){
location_viewtype = getUniformLocation("isometricView"); location_viewtype = getUniformLocation("isometricView");
} }
void EntityShader::setCamPos(const glm::vec2& camPos){ void EntityShader::setCamPos(const glm::vec2& camPos) {
loadVector(location_cam, camPos); loadVector(location_cam, camPos);
} }
void EntityShader::setZoom(float zoom){ void EntityShader::setZoom(float zoom) {
loadFloat(location_zoom, zoom); loadFloat(location_zoom, zoom);
} }
void EntityShader::setAspectRatio(float aspectRatio){ void EntityShader::setAspectRatio(float aspectRatio) {
loadFloat(location_aspect_ratio, aspectRatio); loadFloat(location_aspect_ratio, aspectRatio);
} }
void EntityShader::setModelPos(const glm::vec2& modelPos){ void EntityShader::setModelPos(const glm::vec2& modelPos) {
loadVector(location_translation, modelPos); loadVector(location_translation, modelPos);
} }
void EntityShader::setIsometricView(float isometric){ void EntityShader::setIsometricView(float isometric) {
loadFloat(location_viewtype, isometric); loadFloat(location_viewtype, isometric);
} }

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

@@ -15,58 +15,58 @@
using namespace gl; using namespace gl;
ShaderProgram::ShaderProgram(): ShaderProgram::ShaderProgram() :
programID(0), vertexShaderID(0), fragmentShaderID(0){ programID(0), vertexShaderID(0), fragmentShaderID(0) {
} }
ShaderProgram::~ShaderProgram(){ ShaderProgram::~ShaderProgram() {
cleanUp(); cleanUp();
} }
void ShaderProgram::start() const{ void ShaderProgram::start() const {
glUseProgram(programID); glUseProgram(programID);
} }
void ShaderProgram::stop() const{ void ShaderProgram::stop() const {
glUseProgram(0); glUseProgram(0);
} }
int ShaderProgram::getUniformLocation(const std::string& uniformName) const{ int ShaderProgram::getUniformLocation(const std::string& uniformName) const {
const int location = glGetUniformLocation(programID, uniformName.c_str()); const int location = glGetUniformLocation(programID, uniformName.c_str());
if (location == -1){ if (location == -1) {
std::cout << "Warning ! Uniform variable " << uniformName << " not found !\n"; std::cout << "Warning ! Uniform variable " << uniformName << " not found !\n";
} }
return location; return location;
} }
void ShaderProgram::loadFloat(const int location, const float value) const{ void ShaderProgram::loadFloat(const int location, const float value) const {
glUniform1f(location, value); glUniform1f(location, value);
} }
void ShaderProgram::loadInt(const int& location, const int& value) const{ void ShaderProgram::loadInt(const int& location, const int& value) const {
glUniform1i(location, value); glUniform1i(location, value);
} }
void ShaderProgram::loadVector(const int& location, void ShaderProgram::loadVector(const int& location,
const glm::vec2& vector) const{ const glm::vec2& vector) const {
glUniform2f(location, vector.x, vector.y); glUniform2f(location, vector.x, vector.y);
} }
void ShaderProgram::loadVector(const int& location, void ShaderProgram::loadVector(const int& location,
const glm::vec3& vector) const{ const glm::vec3& vector) const {
glUniform3f(location, vector.x, vector.y, vector.z); glUniform3f(location, vector.x, vector.y, vector.z);
} }
void ShaderProgram::loadVector(const int& location, void ShaderProgram::loadVector(const int& location,
const glm::vec4& vector) const{ const glm::vec4& vector) const {
glUniform4f(location, vector.x, vector.y, vector.z, vector.w); glUniform4f(location, vector.x, vector.y, vector.z, vector.w);
} }
void ShaderProgram::loadBoolean(const int& location, const bool& value) const{ void ShaderProgram::loadBoolean(const int& location, const bool& value) const {
glUniform1i(location, value); glUniform1i(location, value);
} }
void ShaderProgram::cleanUp() const{ void ShaderProgram::cleanUp() const {
stop(); stop();
glDetachShader(programID, vertexShaderID); glDetachShader(programID, vertexShaderID);
glDetachShader(programID, fragmentShaderID); glDetachShader(programID, fragmentShaderID);
@@ -76,7 +76,7 @@ void ShaderProgram::cleanUp() const{
} }
void ShaderProgram::loadProgramFile(const std::string& vertexFile, void ShaderProgram::loadProgramFile(const std::string& vertexFile,
const std::string& fragmentFile){ const std::string& fragmentFile) {
vertexShaderID = loadShaderFromFile(vertexFile, GL_VERTEX_SHADER); vertexShaderID = loadShaderFromFile(vertexFile, GL_VERTEX_SHADER);
fragmentShaderID = loadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER); fragmentShaderID = loadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER);
programID = glCreateProgram(); programID = glCreateProgram();
@@ -88,7 +88,7 @@ void ShaderProgram::loadProgramFile(const std::string& vertexFile,
} }
void ShaderProgram::loadProgram(const std::string& vertexSource, void ShaderProgram::loadProgram(const std::string& vertexSource,
const std::string& fragmentSource){ const std::string& fragmentSource) {
vertexShaderID = loadShader(vertexSource, GL_VERTEX_SHADER); vertexShaderID = loadShader(vertexSource, GL_VERTEX_SHADER);
fragmentShaderID = loadShader(fragmentSource, GL_FRAGMENT_SHADER); fragmentShaderID = loadShader(fragmentSource, GL_FRAGMENT_SHADER);
programID = glCreateProgram(); programID = glCreateProgram();
@@ -99,7 +99,7 @@ void ShaderProgram::loadProgram(const std::string& vertexSource,
getAllUniformLocation(); getAllUniformLocation();
} }
int ShaderProgram::loadShader(const std::string& source, GLenum type){ int ShaderProgram::loadShader(const std::string& source, GLenum type) {
unsigned int shaderID = glCreateShader(type); unsigned int shaderID = glCreateShader(type);
const char* c_str = source.c_str(); const char* c_str = source.c_str();
@@ -108,7 +108,7 @@ int ShaderProgram::loadShader(const std::string& source, GLenum type){
glCompileShader(shaderID); glCompileShader(shaderID);
GLint compilesuccessful; GLint compilesuccessful;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful); glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful);
if (compilesuccessful == false){ if (compilesuccessful == false) {
std::cout << "Could not compile shader !\n"; std::cout << "Could not compile shader !\n";
GLsizei size; GLsizei size;
glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size); glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size);
@@ -119,12 +119,12 @@ int ShaderProgram::loadShader(const std::string& source, GLenum type){
return shaderID; return shaderID;
} }
int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){ int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type) {
std::string shaderSource = ""; std::string shaderSource = "";
std::ifstream fileStream(file); std::ifstream fileStream(file);
if (fileStream.is_open()){ if (fileStream.is_open()) {
std::string line; std::string line;
while (getline(fileStream, line)){ while (getline(fileStream, line)) {
shaderSource += line + "\n"; shaderSource += line + "\n";
} }
fileStream.close(); fileStream.close();
@@ -137,7 +137,7 @@ int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){
glCompileShader(shaderID); glCompileShader(shaderID);
GLint compilesuccessful; GLint compilesuccessful;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful); glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful);
if (compilesuccessful == false){ if (compilesuccessful == false) {
std::cout << "Could not compile shader !\n"; std::cout << "Could not compile shader !\n";
GLsizei size; GLsizei size;
glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size); glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size);
@@ -148,6 +148,6 @@ int ShaderProgram::loadShaderFromFile(const std::string& file, GLenum type){
return shaderID; return shaderID;
} }
void ShaderProgram::loadMatrix(const int& location, const glm::mat4& matrix){ void ShaderProgram::loadMatrix(const int& location, const glm::mat4& matrix) {
glUniformMatrix4fv(location, 1, false, glm::value_ptr(matrix)); glUniformMatrix4fv(location, 1, false, glm::value_ptr(matrix));
} }

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

@@ -46,28 +46,28 @@ void main(void){
} }
)"; )";
WorldShader::WorldShader(): ShaderProgram(){} WorldShader::WorldShader() : ShaderProgram() {}
void WorldShader::loadShader(){ void WorldShader::loadShader() {
ShaderProgram::loadProgram(vertexSource, fragmentSource); ShaderProgram::loadProgram(vertexSource, fragmentSource);
} }
void WorldShader::getAllUniformLocation(){ void WorldShader::getAllUniformLocation() {
location_aspect_ratio = getUniformLocation("aspectRatio"); location_aspect_ratio = getUniformLocation("aspectRatio");
location_zoom = getUniformLocation("zoom"); location_zoom = getUniformLocation("zoom");
location_cam = getUniformLocation("camPos"); location_cam = getUniformLocation("camPos");
location_viewtype = getUniformLocation("isometricView"); location_viewtype = getUniformLocation("isometricView");
} }
void WorldShader::setCamPos(const glm::vec2& camPos){ void WorldShader::setCamPos(const glm::vec2& camPos) {
loadVector(location_cam, camPos); loadVector(location_cam, camPos);
} }
void WorldShader::setZoom(float zoom){ void WorldShader::setZoom(float zoom) {
loadFloat(location_zoom, zoom); loadFloat(location_zoom, zoom);
} }
void WorldShader::setAspectRatio(float aspectRatio){ void WorldShader::setAspectRatio(float aspectRatio) {
loadFloat(location_aspect_ratio, aspectRatio); loadFloat(location_aspect_ratio, aspectRatio);
} }
void WorldShader::setIsometricView(float isometric){ void WorldShader::setIsometricView(float isometric) {
loadFloat(location_viewtype, isometric); loadFloat(location_viewtype, isometric);
} }

16
src/window/Display.cpp
View File

@@ -26,12 +26,12 @@ std::unique_ptr<td::render::Renderer> renderer = std::make_unique<td::render::Re
static int lastWidth = 0, lastHeight = 0; static int lastWidth = 0, lastHeight = 0;
static float aspectRatio; static float aspectRatio;
void error_callback(int error, const char* description){ void error_callback(int error, const char* description) {
std::cerr << "GLFW Error : " << description << std::endl; std::cerr << "GLFW Error : " << description << std::endl;
} }
void windowResizeEvent(GLFWwindow* window, int width, int height){ void windowResizeEvent(GLFWwindow* window, int width, int height) {
aspectRatio = (float) width / height; aspectRatio = (float)width / height;
renderer->resize(width, height); renderer->resize(width, height);
lastWidth = width; lastWidth = width;
lastHeight = height; lastHeight = height;
@@ -46,7 +46,7 @@ void create() {
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, nullptr, nullptr); window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, nullptr, nullptr);
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
if(!renderer->init()){ if (!renderer->init()) {
exit(1); exit(1);
} }
TowerGui::init(window, renderer.get()); TowerGui::init(window, renderer.get());
@@ -62,7 +62,7 @@ void update() {
glfwSwapBuffers(window); glfwSwapBuffers(window);
int windowWidth, windowHeight; int windowWidth, windowHeight;
glfwGetWindowSize(window, &windowWidth, &windowHeight); glfwGetWindowSize(window, &windowWidth, &windowHeight);
if(windowWidth != lastWidth || windowHeight != lastHeight){ if (windowWidth != lastWidth || windowHeight != lastHeight) {
windowResizeEvent(window, windowWidth, windowHeight); windowResizeEvent(window, windowWidth, windowHeight);
} }
} }
@@ -87,14 +87,14 @@ bool isMouseDown(int button) {
return glfwGetMouseButton(window, button); return glfwGetMouseButton(window, button);
} }
float getAspectRatio(){ float getAspectRatio() {
return aspectRatio; return aspectRatio;
} }
int getWindowWidth(){ int getWindowWidth() {
return lastWidth; return lastWidth;
} }
int getWindowHeight(){ int getWindowHeight() {
return lastHeight; return lastHeight;
} }