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,

64
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;
@@ -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; }
};

50
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){
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

270
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() {}
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; }
};
}

4
include/render/WorldRenderer.h
View File

@@ -8,7 +8,7 @@
namespace td {
namespace client{
namespace client {
class ClientGame;
@@ -17,7 +17,7 @@ class ClientGame;
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();

4
src/Tower Defense.cpp
View File

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

8
src/game/BaseGame.cpp
View File

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

22
src/game/Connexion.cpp
View File

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

14
src/game/Mobs.cpp
View File

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

10
src/game/Team.cpp
View File

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

26
src/game/Towers.cpp
View File

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

148
src/game/World.cpp
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
src/misc/Compression.cpp
View File

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

70
src/misc/Easing.cpp
View File

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

4
src/misc/Random.cpp
View File

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

16
src/misc/Time.cpp
View File

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

14
src/network/DataBuffer.cpp
View File

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

10
src/network/IPAddress.cpp
View File

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

4
src/network/Network.cpp
View File

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

4
src/network/Socket.cpp
View File

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

22
src/network/TCPListener.cpp
View File

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

14
src/network/TCPSocket.cpp
View File

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

10
src/protocol/PacketDispatcher.cpp
View File

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

6
src/protocol/PacketFactory.cpp
View File

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

133
src/protocol/Protocol.cpp
View File

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

44
src/render/Renderer.cpp
View File

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

4
src/render/WorldRenderer.cpp
View File

@@ -103,7 +103,7 @@ void WorldRenderer::changeZoom(float zoomStep) {
static float sensibility = 1.5f;
if (zoomStep < 0) {
m_Zoom /= -zoomStep * sensibility;
} else {
} else {
m_Zoom *= zoomStep * sensibility;
}
m_Renderer->setZoom(m_Zoom);
@@ -157,7 +157,7 @@ glm::vec2 WorldRenderer::getCursorWorldPos() const {
return m_Renderer->getCursorWorldPos({ io.MousePos.x, io.MousePos.y }, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
}
glm::vec2 WorldRenderer::getClickWorldPos() const{
glm::vec2 WorldRenderer::getClickWorldPos() const {
return m_Renderer->getCursorWorldPos(m_HoldCursorPos, Display::getAspectRatio(), m_Zoom, Display::getWindowWidth(), Display::getWindowHeight());
}

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

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

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

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

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

@@ -21,8 +21,8 @@ const unsigned int loadGLTexture(const char* fileName) {
const unsigned char* image = stbi_load(fileName, &width, &height, &comp, STBI_rgb_alpha);
if (image == nullptr) {
std::cerr << "Erreur lors du chargement de la texture !" << std::endl;
throw(std::runtime_error("Failed to load texture"));
std::cerr << "Erreur lors du chargement de la texture !" << std::endl;
throw(std::runtime_error("Failed to load texture"));
}
GLuint textureID;
@@ -34,13 +34,13 @@ const unsigned int loadGLTexture(const char* fileName) {
if (comp == 3)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
GL_UNSIGNED_BYTE, image);
GL_UNSIGNED_BYTE, image);
else if (comp == 4)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image);
GL_UNSIGNED_BYTE, image);
glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free((void*) image);
stbi_image_free((void*)image);
return textureID;
}
}

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

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

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

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

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

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

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

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

32
src/window/Display.cpp
View File

@@ -26,19 +26,19 @@ std::unique_ptr<td::render::Renderer> renderer = std::make_unique<td::render::Re
static int lastWidth = 0, lastHeight = 0;
static float aspectRatio;
void error_callback(int error, const char* description){
void error_callback(int error, const char* description) {
std::cerr << "GLFW Error : " << description << std::endl;
}
void windowResizeEvent(GLFWwindow* window, int width, int height){
aspectRatio = (float) width / height;
void windowResizeEvent(GLFWwindow* window, int width, int height) {
aspectRatio = (float)width / height;
renderer->resize(width, height);
lastWidth = width;
lastHeight = height;
}
void create() {
glfwSetErrorCallback(&error_callback);
glfwSetErrorCallback(&error_callback);
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
@@ -46,15 +46,15 @@ void create() {
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, nullptr, nullptr);
glfwMakeContextCurrent(window);
if(!renderer->init()){
exit(1);
}
TowerGui::init(window, renderer.get());
if (!renderer->init()) {
exit(1);
}
TowerGui::init(window, renderer.get());
windowResizeEvent(window, WINDOW_WIDTH, WINDOW_HEIGHT);
}
void render() {
renderer->prepare();
renderer->prepare();
TowerGui::render();
}
@@ -62,7 +62,7 @@ void update() {
glfwSwapBuffers(window);
int windowWidth, windowHeight;
glfwGetWindowSize(window, &windowWidth, &windowHeight);
if(windowWidth != lastWidth || windowHeight != lastHeight){
if (windowWidth != lastWidth || windowHeight != lastHeight) {
windowResizeEvent(window, windowWidth, windowHeight);
}
}
@@ -71,7 +71,7 @@ void destroy() {
renderer.reset(0);
TowerGui::destroy();
glfwDestroyWindow(window);
window = NULL;
window = NULL;
glfwTerminate();
}
@@ -80,21 +80,21 @@ void pollEvents() {
}
bool isCloseRequested() {
return glfwWindowShouldClose(window);
return glfwWindowShouldClose(window);
}
bool isMouseDown(int button) {
return glfwGetMouseButton(window, button);
return glfwGetMouseButton(window, button);
}
float getAspectRatio(){
float getAspectRatio() {
return aspectRatio;
}
int getWindowWidth(){
int getWindowWidth() {
return lastWidth;
}
int getWindowHeight(){
int getWindowHeight() {
return lastHeight;
}