void ServerPacketHandlerSystem::handleLobby()
{
while( m_server->hasNewPackets() )
{
Packet packet = m_server->popNewPacket();
char packetType;
packetType = packet.getPacketType();
if(packetType == (char)PacketType::ChangeStatePacket){
ChangeStatePacket statePacket;
statePacket.unpack(packet);
if(statePacket.m_gameState == GameStates::INITGAME){
ChangeStatePacket newState;
newState.m_serverState = ServerStates::LOADING;
m_stateSystem->setQueuedState(ServerStates::LOADING);
m_server->broadcastPacket(newState.pack());
}
}
else if(packetType == (char)PacketType::PlayerInfo){
PlayerInfo playerInfo;
playerInfo.unpack(packet);
PlayerSystem* playerSystem = static_cast<PlayerSystem*>
(m_world->getSystem(SystemType::PlayerSystem));
vector<Entity*> connectedPlayers = playerSystem->getActiveEntities();
//Add the entity here to be used by other systems
Entity* newPlayer = m_world->createEntity();
PlayerComponent* newComp = new PlayerComponent();
if( playerInfo.playerName == "brightestmind" && playerInfo.playerID == 0){
newComp->setAbsoluteScore(9001);
}
else if(playerInfo.playerName=="judas"){
newComp->setAbsoluteScore(-9001);
}
newComp->m_playerName = playerInfo.playerName;
newComp->m_playerID = playerInfo.playerID; //connectedPlayers.size();
newComp->m_networkID = packet.getSenderId();
newPlayer->addComponent(newComp);
m_world->addEntity(newPlayer);
NewlyConnectedPlayerPacket connectedPlayer;
connectedPlayer.playerName = newComp->m_playerName;
connectedPlayer.playerID = newComp->m_playerID;
connectedPlayer.score = newComp->getScore();
connectedPlayer.networkID = newComp->m_networkID;
// Broadcast the player to all clients.
m_server->broadcastPacket(connectedPlayer.pack());
for (unsigned int i = 0; i < connectedPlayers.size(); i++){
NewlyConnectedPlayerPacket alreadyConnectedPlayers;
PlayerComponent* playerComp;
playerComp = static_cast<PlayerComponent*>
(connectedPlayers[i]->getComponent(ComponentType::PlayerComponent));
alreadyConnectedPlayers.playerID = playerComp->m_playerID;
alreadyConnectedPlayers.playerName = playerComp->m_playerName;
alreadyConnectedPlayers.networkID = playerComp->m_networkID;
// Send all the existing players to the new client.
m_server->unicastPacket(alreadyConnectedPlayers.pack(), newComp->m_networkID);
//m_server->broadcastPacket(alreadyConnectedPlayers.pack());
}
// Force all players to be set unready.
memset(&m_lobbyPlayerReadyStates, 0, sizeof(m_lobbyPlayerReadyStates));
}
else if(packetType == (char)PacketType::ClientDisconnect){
DisconnectPacket dcPacket;
dcPacket.unpack(packet);
// Remove client!
PlayerSystem* playerSystem = static_cast<PlayerSystem*>
(m_world->getSystem(SystemType::PlayerSystem));
playerSystem->deletePlayerEntity(dcPacket.playerID);
// Broadcast the dc packet back to all clients, including the one who sent it.
m_server->broadcastPacket(packet);
// Force all players to be set unready.
memset(&m_lobbyPlayerReadyStates, 0, sizeof(m_lobbyPlayerReadyStates));
m_world->getOutputLogger()->write(("Server detected a disconnect packet for player: " + toString(dcPacket.playerID) + "\n").c_str());
}
else if(packetType == (char)PacketType::PlayerReadyPacket){
// Broadcast the ready packet back to all clients, including the one who sent it.
m_server->broadcastPacket(packet);
PlayerReadyPacket readyPacket;
readyPacket.unpack(packet);
m_lobbyPlayerReadyStates[readyPacket.playerId] = readyPacket.ready;
// Check so that all players are ready!
m_readyLobbyPlayers = 0;
for (int i = 0; i < MAXPLAYERS; i++)
{
if (m_lobbyPlayerReadyStates[i])
m_readyLobbyPlayers++;
}
m_world->getOutputLogger()->write( ("Players ready: " + toString(m_readyLobbyPlayers) + "\n").c_str() );
PlayerSystem* playerSystem = static_cast<PlayerSystem*>
(m_world->getSystem(SystemType::PlayerSystem));
if (m_readyLobbyPlayers >= playerSystem->getActiveEntities().size())
{
ChangeStatePacket newState;
newState.m_serverState = ServerStates::LOADING;
m_stateSystem->setQueuedState(ServerStates::LOADING);
m_server->broadcastPacket(newState.pack());
}
}
else if( packetType == (char)PacketType::Ping )
{
// =========================================
// PINGPACKET
// =========================================
PingPacket pingPacket;
pingPacket.unpack( packet );
Packet response((char)PacketType::Pong);
response << pingPacket.timeStamp;
m_server->unicastPacket( response, packet.getSenderId() );
}
else if( packetType == (char)PacketType::Pong)
{
// =========================================
// PONGPACKET
// =========================================
//auto clientInfo = static_cast<ClientInfo*>(m_world->getEntityManager()->get)
float totalElapsedTime = m_world->getElapsedTime();
float timeWhenSent;
PongPacket pongPacket;
pongPacket.unpack( packet );
timeWhenSent = pongPacket.timeStamp;
/************************************************************************/
/* Convert from seconds to milliseconds. */
/************************************************************************/
float ping = (totalElapsedTime - timeWhenSent)*1000.0f;
//m_clients[packet.getSenderId()] = info;
auto playerSys = static_cast<PlayerSystem*>(
m_world->getSystem(SystemType::PlayerSystem));
PlayerComponent* playerComp = playerSys->findPlayerComponentFromNetworkID(packet.getSenderId());
if (playerComp)
playerComp->m_ping = ping;
}
else
{
printPacketTypeNotHandled("Lobby", (int)packetType);
}
}
}
