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;