Persson-dev/Tower-Defense
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

GIGA REFACTOR

Browse Source
This commit is contained in:
Simon Pribylski
2022-03-02 18:51:42 +01:00
parent 553b2f6aad
commit 6df59b1487
92 changed files with 1807 additions and 1785 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -28,26 +28,26 @@ 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 >= LobbyWaitingTime) {
m_Server->getGame().notifyListeners(&game::GameListener::OnGameBegin);
if (utils::GetTime() - m_StartTimerTime >= LobbyWaitingTime) {
m_Server->GetGame().NotifyListeners(&game::GameListener::OnGameBegin);
m_GameStarted = true;
return;
}
m_Timer.update();
m_Timer.Update();
}
void Lobby::sendTimeRemaining() {
protocol::UpdateLobbyTimePacket packet(LobbyWaitingTime - (utils::getTime() - m_StartTimerTime)); // converting second to millis
m_Server->broadcastPacket(&packet);
void Lobby::SendTimeRemaining() {
protocol::UpdateLobbyTimePacket packet(LobbyWaitingTime - (utils::GetTime() - m_StartTimerTime)); // converting second to millis
m_Server->BroadcastPacket(&packet);
}
void Lobby::OnPlayerJoin(std::uint8_t playerID) {
@@ -56,9 +56,9 @@ void Lobby::OnPlayerJoin(std::uint8_t playerID) {
std::cout << "(Server) Player Joined Lobby !\n";
m_Players.push_back(playerID);
if (m_Players.size() == MIN_PLAYER_WAITING) { // start timer if a second player join the match
m_StartTimerTime = utils::getTime();
m_Timer.reset();
sendTimeRemaining();
m_StartTimerTime = utils::GetTime();
m_Timer.Reset();
SendTimeRemaining();
}
}
@@ -66,13 +66,15 @@ 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) {
protocol::UpdateLobbyTimePacket packet(0);
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
m_StartTimerTime = 0; // reset timer if there is only one player left
}
}

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

@@ -6,7 +6,7 @@ namespace td {
namespace server {
Server::Server(const std::string& worldFilePath) : m_ServerRunning(false) {
m_Game.getWorld()->loadMapFromFile(worldFilePath);
m_Game.GetWorld()->LoadMapFromFile(worldFilePath);
}
Server::~Server() {
@@ -14,117 +14,117 @@ Server::~Server() {
m_Thread.join();
}
void Server::startThread() {
void Server::StartThread() {
m_Thread = std::thread([this]() {
std::uint64_t lastTime = td::utils::getTime();
std::uint64_t lastTime = td::utils::GetTime();
while (m_ServerRunning) {
std::uint64_t time = td::utils::getTime();
std::uint64_t time = td::utils::GetTime();
std::uint64_t delta = time - lastTime;
if (delta >= SERVER_TICK) {
tick(delta);
lastTime = td::utils::getTime();
Tick(delta);
lastTime = td::utils::GetTime();
std::uint64_t sleepTime = SERVER_TICK - (delta - SERVER_TICK);
std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
}
}
clean();
Clean();
});
}
void Server::close() {
stopThread();
void Server::Close() {
StopThread();
}
void Server::stopThread() {
void Server::StopThread() {
m_ServerRunning = false;
}
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;
}
std::cout << "Server started at port " << port << " !\n";
m_TickCounter.reset();
m_TickCounter.Reset();
m_ServerRunning = true;
startThread();
StartThread();
return true;
}
void Server::clean() {
m_Listener.close();
m_Listener.destroy();
void Server::Clean() {
m_Listener.Close();
m_Listener.Destroy();
m_Connections.clear();
getPlayers().clear();
GetPlayers().clear();
std::cout << "Server successfully stopped !\n";
}
void Server::stop() {
void Server::Stop() {
if (!m_ServerRunning)
return;
protocol::DisconnectPacket packet("Server closed");
broadcastPacket(&packet);
BroadcastPacket(&packet);
stopThread();
StopThread();
}
void Server::tick(std::uint64_t delta) {
accept();
updateSockets();
m_Lobby.tick();
m_Game.tick(delta);
if (m_TickCounter.update()) {
protocol::ServerTpsPacket packet(m_TickCounter.getTPS(), utils::getTime());
broadcastPacket(&packet);
void Server::Tick(std::uint64_t delta) {
Accept();
UpdateSockets();
m_Lobby.Tick();
m_Game.Tick(delta);
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) }));
OnPlayerJoin(newPlayerID);
m_Connections[newPlayerID].setServer(this);
m_Connections[newPlayerID].SetServer(this);
newPlayerID++;
}
}
void Server::updateSockets() {
void Server::UpdateSockets() {
std::int16_t closedConnexionID = -1;
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 {
con.updateSocket();
con.UpdateSocket();
}
}
if (closedConnexionID != -1) {
removeConnexion(closedConnexionID);
RemoveConnexion(closedConnexionID);
}
}
void Server::broadcastPacket(const protocol::Packet* packet) {
void Server::BroadcastPacket(const protocol::Packet* packet) {
for (auto& connection : m_Connections) {
ServerConnexion& con = connection.second;
con.sendPacket(packet);
con.SendPacket(packet);
}
}
void Server::removeConnexion(std::uint8_t connexionID) {
getPlayers().erase(getPlayers().find(connexionID));
void Server::RemoveConnexion(std::uint8_t connexionID) {
GetPlayers().erase(GetPlayers().find(connexionID));
m_Connections.erase(connexionID);
m_Lobby.OnPlayerLeave(connexionID);
OnPlayerLeave(connexionID);
@@ -133,12 +133,12 @@ void Server::removeConnexion(std::uint8_t connexionID) {
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) {
protocol::PlayerLeavePacket packet(id);
broadcastPacket(&packet);
BroadcastPacket(&packet);
}
} // namespace server

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

@@ -23,17 +23,17 @@ 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) {
Connexion::updateSocket();
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) {
move.m_Server = nullptr;
registerHandlers();
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);
@@ -44,148 +44,148 @@ void ServerConnexion::registerHandlers() {
GetDispatcher()->RegisterHandler(protocol::PacketType::RemoveTower, this);
}
bool ServerConnexion::updateSocket() {
checkKeepAlive();
return Connexion::updateSocket();
bool ServerConnexion::UpdateSocket() {
CheckKeepAlive();
return Connexion::UpdateSocket();
}
void ServerConnexion::checkKeepAlive() {
std::uint64_t time = utils::getTime();
void ServerConnexion::CheckKeepAlive() {
std::uint64_t time = utils::GetTime();
if (time - m_KeepAlive.sendTime > KEEP_ALIVE_TIMEOUT) {
if (m_KeepAlive.recievedResponse) {
sendKeepAlive();
SendKeepAlive();
} else {
protocol::DisconnectPacket packet("Time out");
sendPacket(&packet);
closeConnection();
SendPacket(&packet);
CloseConnection();
}
}
}
void ServerConnexion::sendKeepAlive() {
m_KeepAlive.keepAliveID = utils::getRandomInt<std::uint64_t>(0, RAND_MAX);
void ServerConnexion::SendKeepAlive() {
m_KeepAlive.keepAliveID = utils::GetRandomInt<std::uint64_t>(0, RAND_MAX);
m_KeepAlive.recievedResponse = false;
protocol::KeepAlivePacket keepAlivePacket(m_KeepAlive.keepAliveID);
sendPacket(&keepAlivePacket);
SendPacket(&keepAlivePacket);
std::uint64_t time = utils::getTime();
std::uint64_t time = utils::GetTime();
m_KeepAlive.sendTime = time;
}
void ServerConnexion::HandlePacket(const protocol::PlayerLoginPacket* packet) {
if (m_Player->getName().empty() && !packet->getPlayerName().empty()) {
m_Player->setName(packet->getPlayerName());
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);
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 });
playerInfo.name = player.GetName();
playerInfo.team = player.GetTeamColor();
playerNames.insert({ player.GetID(), playerInfo });
}
}
protocol::PlayerListPacket listPacket(playerNames);
sendPacket(&listPacket);
SendPacket(&listPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::SelectTeamPacket* packet) {
if (m_Server->getGame().getGameState() != game::GameState::Lobby)
if (m_Server->GetGame().GetGameState() != game::GameState::Lobby)
return;
if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) {
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
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Player->setTeamColor(game::TeamColor::None);
if ((std::int8_t)packet->GetSelectedTeam() >= -1 || (std::int8_t)packet->GetSelectedTeam() <= 1) {
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
m_Server->GetGame().GetTeam(m_Player->GetTeamColor()).RemovePlayer(m_Player);
m_Player->SetTeamColor(game::TeamColor::None);
} else { // change team
m_Server->getGame().getTeam(m_Player->getTeamColor()).removePlayer(m_Player);
m_Server->getGame().getTeam(packet->getSelectedTeam()).addPlayer(m_Player);
m_Server->GetGame().GetTeam(m_Player->GetTeamColor()).RemovePlayer(m_Player);
m_Server->GetGame().GetTeam(packet->GetSelectedTeam()).AddPlayer(m_Player);
}
m_Player->setTeamColor(packet->getSelectedTeam());
protocol::UpdatePlayerTeamPacket updateTeamPacket(m_ID, packet->getSelectedTeam());
m_Server->broadcastPacket(&updateTeamPacket);
m_Player->SetTeamColor(packet->GetSelectedTeam());
protocol::UpdatePlayerTeamPacket updateTeamPacket(m_ID, packet->GetSelectedTeam());
m_Server->BroadcastPacket(&updateTeamPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
if (packet->getAliveID() == m_KeepAlive.keepAliveID)
if (packet->GetAliveID() == m_KeepAlive.keepAliveID)
m_KeepAlive.recievedResponse = true;
}
void ServerConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
closeConnection();
CloseConnection();
}
void ServerConnexion::setServer(Server* server) {
void ServerConnexion::SetServer(Server* server) {
m_Server = server;
m_Player = &m_Server->getPlayers().at(m_ID);
initConnection();
sendKeepAlive();
m_Player = &m_Server->GetPlayers().at(m_ID);
InitConnection();
SendKeepAlive();
}
void ServerConnexion::initConnection() {
protocol::UpdateGameStatePacket statePacket(m_Server->getGame().getGameState());
sendPacket(&statePacket);
void ServerConnexion::InitConnection() {
protocol::UpdateGameStatePacket statePacket(m_Server->GetGame().GetGameState());
SendPacket(&statePacket);
protocol::ConnexionInfoPacket conPacket(m_ID);
sendPacket(&conPacket);
SendPacket(&conPacket);
if (m_Server->getGame().getGameState() == game::GameState::Game) {
protocol::WorldBeginDataPacket headerDataPacket(m_Server->getGame().getWorld());
protocol::WorldBeginDataPacket dataPacket(m_Server->getGame().getWorld());
sendPacket(&headerDataPacket);
sendPacket(&dataPacket);
if (m_Server->GetGame().GetGameState() == game::GameState::Game) {
protocol::WorldBeginDataPacket headerDataPacket(m_Server->GetGame().GetWorld());
protocol::WorldBeginDataPacket dataPacket(m_Server->GetGame().GetWorld());
SendPacket(&headerDataPacket);
SendPacket(&dataPacket);
}
}
void ServerConnexion::HandlePacket(const protocol::PlaceTowerPacket* packet) {
game::TowerType towerType = packet->getTowerType();
const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
server::ServerWorld* world = m_Server->getGame().getServerWorld();
game::TowerType towerType = packet->GetTowerType();
const game::TowerInfo& towerInfo = game::GetTowerInfo(towerType);
server::ServerWorld* world = m_Server->GetGame().GetServerWorld();
if (!world->CanPlaceLittleTower({ packet->getTowerX(), packet->getTowerY() }, m_ID))
if (!world->CanPlaceLittleTower({ packet->GetTowerX(), packet->GetTowerY() }, m_ID))
return;
if (towerInfo.isBigTower())
if (!world->CanPlaceBigTower({ packet->getTowerX(), packet->getTowerY() }, m_ID))
if (towerInfo.IsBigTower())
if (!world->CanPlaceBigTower({ packet->GetTowerX(), packet->GetTowerY() }, m_ID))
return;
game::TowerPtr tower = world->placeTowerAt(towerType, packet->getTowerX(), packet->getTowerY(), m_ID);
game::TowerPtr tower = world->PlaceTowerAt(towerType, packet->GetTowerX(), packet->GetTowerY(), m_ID);
world->getWorldNotifier().notifyListeners(&game::WorldListener::OnTowerAdd, tower);
world->GetWorldNotifier().NotifyListeners(&game::WorldListener::OnTowerAdd, tower);
protocol::WorldAddTowerPacket addTowerPacket(tower->getID(), packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID);
m_Server->broadcastPacket(&addTowerPacket);
protocol::WorldAddTowerPacket addTowerPacket(tower->GetID(), packet->GetTowerX(), packet->GetTowerY(), packet->GetTowerType(), m_ID);
m_Server->BroadcastPacket(&addTowerPacket);
}
void ServerConnexion::HandlePacket(const protocol::SendMobsPacket* packet) {
const std::vector<protocol::MobSend>& mobSent = packet->getMobSends();
const std::vector<protocol::MobSend>& mobSent = packet->GetMobSends();
//TODO: verify the packet
for (protocol::MobSend mobSend : mobSent) {
m_Server->getGame().getServerWorld()->spawnMobs(mobSend.mobType, mobSend.mobLevel, m_ID, mobSend.mobCount);
m_Server->GetGame().GetServerWorld()->SpawnMobs(mobSend.mobType, mobSend.mobLevel, m_ID, mobSend.mobCount);
}
}
void ServerConnexion::HandlePacket(const protocol::UpgradeTowerPacket* packet) {
//TODO: verify the packet
m_Server->broadcastPacket(packet);
m_Server->BroadcastPacket(packet);
}
void ServerConnexion::HandlePacket(const protocol::RemoveTowerPacket* packet) {
//TODO: verify the packet
m_Server->broadcastPacket(packet);
m_Server->BroadcastPacket(packet);
}
ServerConnexion::~ServerConnexion() {

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

@@ -5,105 +5,105 @@ namespace td {
namespace server {
ServerGame::ServerGame(server::Server* server) : game::Game(&m_ServerWorld), m_Server(server), m_ServerWorld(server, this),
m_GoldMineTimer{ 1000, std::bind(&ServerGame::updateGoldMines, this) },
m_MobStatesTimer{ 5000, std::bind(&ServerGame::updateMobStates, this) },
m_EndGameCooldown{ 1000 * 10 } {
bindListener(this);
m_GoldMineTimer{ 1000, std::bind(&ServerGame::UpdateGoldMines, this) },
m_MobStatesTimer{ 5000, std::bind(&ServerGame::UpdateMobStates, this) },
m_EndGameCooldown{ 1000 * 10 } {
BindListener(this);
}
void ServerGame::tick(std::uint64_t delta) {
void ServerGame::Tick(std::uint64_t delta) {
if (m_GameState == game::GameState::Game) {
Game::tick(delta);
m_MobStatesTimer.update(delta);
updatePlayerStats();
Game::Tick(delta);
m_MobStatesTimer.Update(delta);
UpdatePlayerStats();
} else if (m_GameState == game::GameState::EndGame) {
if (m_EndGameCooldown.update(delta)) {
notifyListeners(&game::GameListener::OnGameClose);
if (m_EndGameCooldown.Update(delta)) {
NotifyListeners(&game::GameListener::OnGameClose);
}
}
}
void ServerGame::startGame() {
balanceTeams();
void ServerGame::StartGame() {
BalanceTeams();
protocol::WorldBeginDataPacket headerMapData(m_World);
m_Server->broadcastPacket(&headerMapData);
m_Server->BroadcastPacket(&headerMapData);
protocol::WorldDataPacket mapData(m_World);
m_Server->broadcastPacket(&mapData);
m_Server->BroadcastPacket(&mapData);
m_GameState = game::GameState::Game;
}
void ServerGame::updatePlayerStats() {
m_GoldMineTimer.update();
void ServerGame::UpdatePlayerStats() {
m_GoldMineTimer.Update();
}
void ServerGame::updateGoldMines() {
for (auto& pair : m_Server->getPlayers()) {
void ServerGame::UpdateGoldMines() {
for (auto& pair : m_Server->GetPlayers()) {
game::Player* player = &pair.second;
player->addGold(player->getGoldPerSecond());
player->AddGold(player->GetGoldPerSecond());
// Update player money and exp every second
protocol::UpdateMoneyPacket moneyPacket(player->getGold());
m_Server->getConnexions()[player->getID()].sendPacket(&moneyPacket);
protocol::UpdateMoneyPacket moneyPacket(player->GetGold());
m_Server->GetConnexions()[player->GetID()].SendPacket(&moneyPacket);
protocol::UpdateExpPacket expPacket(player->getExp());
m_Server->getConnexions()[player->getID()].sendPacket(&expPacket);
protocol::UpdateExpPacket expPacket(player->GetExp());
m_Server->GetConnexions()[player->GetID()].SendPacket(&expPacket);
}
}
void ServerGame::updateMobStates() {
void ServerGame::UpdateMobStates() {
protocol::UpdateMobStatesPacket packet;
for (auto mob : m_World->getMobList()) {
packet.addMobState({ mob->getMobID(), mob->getCenter(), mob->getHealth(), mob->getDirection() });
for (auto mob : m_World->GetMobList()) {
packet.addMobState({ mob->GetMobID(), mob->GetCenter(), mob->GetHealth(), mob->GetDirection() });
}
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
}
void ServerGame::balanceTeams() {
void ServerGame::BalanceTeams() {
for (auto& playerInfo : Game::m_Players) {
game::Player& player = playerInfo.second;
if (player.getTeamColor() == game::TeamColor::None) {
game::Team& redTeam = getRedTeam();
game::Team& blueTeam = getBlueTeam();
if (blueTeam.getPlayerCount() > redTeam.getPlayerCount()) {
player.setTeamColor(game::TeamColor::Red);
redTeam.addPlayer(&player);
if (player.GetTeamColor() == game::TeamColor::None) {
game::Team& redTeam = GetRedTeam();
game::Team& blueTeam = GetBlueTeam();
if (blueTeam.GetPlayerCount() > redTeam.GetPlayerCount()) {
player.SetTeamColor(game::TeamColor::Red);
redTeam.AddPlayer(&player);
} else {
player.setTeamColor(game::TeamColor::Blue);
blueTeam.addPlayer(&player);
player.SetTeamColor(game::TeamColor::Blue);
blueTeam.AddPlayer(&player);
}
protocol::UpdatePlayerTeamPacket packet(player.getID(), player.getTeamColor());
m_Server->broadcastPacket(&packet);
protocol::UpdatePlayerTeamPacket packet(player.GetID(), player.GetTeamColor());
m_Server->BroadcastPacket(&packet);
}
}
}
void ServerGame::OnGameStateUpdate(game::GameState newState) {
setGameState(newState);
SetGameState(newState);
protocol::UpdateGameStatePacket packet(newState);
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
}
void ServerGame::OnGameBegin() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Game);
startGame();
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Game);
StartGame();
}
void ServerGame::OnGameEnd() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::EndGame);
m_EndGameCooldown.applyCooldown();
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::EndGame);
m_EndGameCooldown.ApplyCooldown();
}
void ServerGame::OnGameClose() {
notifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Closed);
NotifyListeners(&game::GameListener::OnGameStateUpdate, game::GameState::Closed);
// Disconnect clients
protocol::DisconnectPacket packet("Game finished");
m_Server->broadcastPacket(&packet);
m_Server->BroadcastPacket(&packet);
// Closing server
m_Server->close();
m_Server->Close();
}
} // namespace game

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

@@ -11,25 +11,25 @@ ServerWorld::ServerWorld(Server* server, ServerGame* game) : game::World(game),
}
void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::PlayerID sender, std::uint8_t count) {
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::TeamColor senderTeam = m_Game->GetPlayers().at(sender).GetTeamColor();
game::Spawn* enemyMobSpawn;
if (senderTeam == game::TeamColor::Red) {
enemyMobSpawn = &getTeam(game::TeamColor::Blue).getSpawn();
enemyMobSpawn = &GetTeam(game::TeamColor::Blue).GetSpawn();
} else {
enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn();
enemyMobSpawn = &GetTeam(game::TeamColor::Red).GetSpawn();
}
float spawnWidth = enemyMobSpawn->getWidth();
float spawnHeight = enemyMobSpawn->getHeight();
float spawnWidth = enemyMobSpawn->GetWidth();
float spawnHeight = enemyMobSpawn->GetHeight();
float spawnCenterX = enemyMobSpawn->getCenterX();
float spawnCenterY = enemyMobSpawn->getCenterY();
float spawnCenterX = enemyMobSpawn->GetCenterX();
float spawnCenterY = enemyMobSpawn->GetCenterY();
auto mobStats = getMobStats(type, level);
auto mobSize = mobStats->getSize();
auto mobStats = GetMobStats(type, level);
auto mobSize = mobStats->GetSize();
float minSpawnX = spawnCenterX - spawnWidth / 2.0f + mobSize.x / 2.0f;
float maxSpawnX = spawnCenterX + spawnWidth / 2.0f - mobSize.x / 2.0f;
@@ -37,20 +37,20 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
float minSpawnY = spawnCenterY - spawnHeight / 2.0f + mobSize.y / 2.0f;
float maxSpawnY = spawnCenterY + spawnHeight / 2.0f - mobSize.y / 2.0f;
float mobX = utils::getRandomReal<float>(minSpawnX + MobSpawnBorder, maxSpawnX - MobSpawnBorder);
float mobY = utils::getRandomReal<float>(minSpawnY + MobSpawnBorder, maxSpawnY - MobSpawnBorder);
float mobX = utils::GetRandomReal<float>(minSpawnX + MobSpawnBorder, maxSpawnX - MobSpawnBorder);
float mobY = utils::GetRandomReal<float>(minSpawnY + MobSpawnBorder, maxSpawnY - MobSpawnBorder);
spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
SpawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->GetDirection());
protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
m_Server->broadcastPacket(&packet);
protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->GetDirection());
m_Server->BroadcastPacket(&packet);
m_CurrentMobID++;
}
}
game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder) {
game::TowerPtr tower = World::placeTowerAt(m_CurrentTowerID, type, x, y, builder);
game::TowerPtr ServerWorld::PlaceTowerAt(game::TowerType type, std::int32_t x, std::int32_t y, game::PlayerID builder) {
game::TowerPtr tower = World::PlaceTowerAt(m_CurrentTowerID, type, x, y, builder);
m_CurrentTowerID++;
return tower;
}
@@ -58,11 +58,11 @@ game::TowerPtr ServerWorld::placeTowerAt(game::TowerType type, std::int32_t x, s
void ServerWorld::OnMobDie(game::Mob* mob) {
if (mob->OnDeath(this)) { // check if the mob is actually dead (slimes ...)
//reward players
game::Player* sender = m_Game->getPlayerById(mob->getSender());
sender->addExp(mob->getStats()->getExpReward());
game::Player* sender = m_Game->GetPlayerById(mob->GetSender());
sender->AddExp(mob->GetStats()->GetExpReward());
game::Player* killer = m_Game->getPlayerById(mob->getLastDamageTower()->getBuilder());
killer->addGold(mob->getStats()->getMoneyCost());
game::Player* killer = m_Game->GetPlayerById(mob->GetLastDamageTower()->GetBuilder());
killer->AddGold(mob->GetStats()->GetMoneyCost());
}
}
@@ -70,8 +70,8 @@ void ServerWorld::OnMobCastleDamage(game::Mob* damager, game::TeamCastle* enemyC
// calling base class event
World::OnMobCastleDamage(damager, enemyCastle, damage);
protocol::UpdateCastleLifePacket packet(enemyCastle->getLife(), enemyCastle->getTeam()->getColor());
m_Server->broadcastPacket(&packet);
protocol::UpdateCastleLifePacket packet(enemyCastle->GetLife(), enemyCastle->GetTeam()->GetColor());
m_Server->BroadcastPacket(&packet);
}
} // namespace server