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

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