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

4
include/game/Connexion.h
View File

@@ -8,7 +8,7 @@
namespace td {
namespace protocol {
class Connexion : public protocol::PacketHandler{
class Connexion : public protocol::PacketHandler {
protected:
protocol::PacketDispatcher m_Dispatcher;
private:
@@ -25,7 +25,7 @@ public:
bool connect(const std::string& address, std::uint16_t port);
network::Socket::Status getSocketStatus() const{return m_Socket.GetStatus();}
network::Socket::Status getSocketStatus() const { return m_Socket.GetStatus(); }
void sendPacket(protocol::Packet* packet);

2
include/game/GameManager.h
View File

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

74
include/game/Mobs.h
View File

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

26
include/game/Player.h
View File

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

16
include/game/Team.h
View File

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

126
include/game/Towers.h
View File

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

2
include/game/Types.h
View File

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

66
include/game/World.h
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
include/misc/Easing.h
View File

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

52
include/network/DataBuffer.h
View File

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

10
include/network/TCPListener.h
View File

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

46
include/protocol/PacketHandler.h
View File

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

272
include/protocol/Protocol.h
View File

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

6
include/render/WorldRenderer.h
View File

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

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

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

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

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

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

@@ -2,7 +2,7 @@
#include "ShaderProgram.h"
class EntityShader : public ShaderProgram{
class EntityShader : public ShaderProgram {
private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_translation = 0, location_viewtype = 0;
protected:
@@ -13,6 +13,6 @@ public:
void setCamPos(const glm::vec2& camPos);
void setZoom(float zoom);
void setAspectRatio(float aspectRatio);
void setModelPos(const glm::vec2& modelPos);
void setIsometricView(float isometric);
void setModelPos(const glm::vec2& modelPos);
void setIsometricView(float isometric);
};

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

@@ -11,8 +11,8 @@
#include <string>
#include <glm/glm.hpp>
namespace gl{
enum class GLenum : unsigned int;
namespace gl {
enum class GLenum : unsigned int;
}
class ShaderProgram {
@@ -22,7 +22,7 @@ public:
void start() const;
void stop() const;
void loadProgramFile(const std::string& vertexFile, const std::string& fragmentFile);
void loadProgram(const std::string& vertexSource, const std::string& fragmentSource);
void loadProgram(const std::string& vertexSource, const std::string& fragmentSource);
protected:
virtual void getAllUniformLocation() = 0;
@@ -41,7 +41,7 @@ private:
unsigned int vertexShaderID;
unsigned int fragmentShaderID;
int loadShaderFromFile(const std::string& file, gl::GLenum type);
int loadShader(const std::string& source, gl::GLenum type);
int loadShader(const std::string& source, gl::GLenum type);
};
#endif /* RENDER_SHADERS_SHADERPROGRAM_H_ */

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

@@ -10,7 +10,7 @@
#include "ShaderProgram.h"
class WorldShader : public ShaderProgram{
class WorldShader : public ShaderProgram {
private:
unsigned int location_cam = 0, location_zoom = 0, location_aspect_ratio = 0, location_viewtype = 0;
protected:
@@ -21,7 +21,7 @@ public:
void setCamPos(const glm::vec2& camPos);
void setZoom(float zoom);
void setAspectRatio(float aspectRatio);
void setIsometricView(float isometric);
void setIsometricView(float isometric);
};
#endif /* RENDER_SHADERS_GAMESHADER_H_ */

2
include/window/Display.h
View File

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