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

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