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

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

24
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,24 +52,24 @@ 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() {
}
} // namespace server

16
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 = {
@@ -215,6 +215,6 @@ MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerI
return mobFactory[type](id, level, sender);
}
} // namespace game
} // namespace td

14
src/game/Team.cpp
View File

@@ -3,23 +3,23 @@
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){
m_Players.erase(std::find(m_Players.begin(), m_Players.end(), 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{
return m_Players.size();
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) {
}

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

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

@@ -3,30 +3,30 @@
#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){
spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) {
spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
packet->getMobX(), packet->getMobY(), packet->getMobDirection());
}

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

@@ -22,51 +22,51 @@ 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;
m_Server->lauchGame();
return;
}
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);
}

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

@@ -4,21 +4,21 @@
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);
m_Server->broadcastPacket(&headerMapData);
protocol::WorldDataPacket mapData(m_World);
m_Server->broadcastPacket(&mapData);
@@ -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());

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

@@ -7,21 +7,21 @@
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();
}
std::int32_t spawnCenterX = enemyMobSpawn->x;
std::int32_t spawnCenterY = enemyMobSpawn->y;
@@ -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;

72
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,11 +193,11 @@ 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;
}
} // namespace utils
} // namespace td

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

12
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];

8
src/network/Socket.cpp
View File

@@ -13,10 +13,10 @@ namespace td {
namespace network {
Socket::Socket(Type type)
: m_Blocking(false),
: m_Blocking(false),
m_Type(type),
m_Status(Disconnected),
m_Handle((SocketHandle) INVALID_SOCKET)
m_Handle((SocketHandle)INVALID_SOCKET)
{
}
@@ -28,9 +28,9 @@ 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;
}
}
m_Blocking = block;

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;

139
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));
@@ -160,8 +160,8 @@ DataBuffer WorldDataPacket::Serialize() const{
game::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
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
data << getID() << m_MobID << m_MobType << m_MobLevel << m_MobDirection
<< m_Sender << m_MobX << m_MobY;
return data;
}
void SpawnMobPacket::Deserialize(DataBuffer& data){
data >> m_MobID >> m_MobType >> m_MobLevel >> m_MobDirection
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;
}

46
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,23 +42,23 @@ void Renderer::initShader(){
updateIsometricView();
}
bool Renderer::init(){
bool Renderer::init() {
glbinding::Binding::initialize();
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
initShader();
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;
}