void CGameServerState::createAndMirrorSpectator(Net::NetID playerNetId) {
// Primero comprobamos si habia una entidad correspondiente a este jugador
// ya que durante el juego tambien podemos cambiar de clase.
// En caso de que la haya la eliminamos para crear la nueva
std::pair<Logic::TEntityID, bool> id = _playersMgr->getPlayerId(playerNetId);
if(id.second) { // Si el id devuelto es valido
Logic::CEntity* deletePlayer = _map->getEntityByID( id.first );
if(deletePlayer) {
Logic::CEntityFactory::getSingletonPtr()->deleteEntity(deletePlayer, true);
}
}
// Obtenemos el nickname del jugador que quiere espectar
std::string nickname = _playersMgr->getPlayerNickname(playerNetId);
// Creamos la entidad espectador con el nombre del jugador
Logic::CEntity* spectator = _map->createPlayer(nickname, "Spectator");
// Obtenemos la id logica de la entidad espectador
Logic::TEntityID spectatorId = spectator->getEntityID();
// Seteamos la id logica del jugador en el gestor de jugadores
_playersMgr->setEntityID(playerNetId, spectatorId);
// Escribimos el tipo de mensaje de red a enviar
Net::NetMessageType netMsg = Net::LOAD_PLAYERS;
int nbPlayers = 1;
// Serializamos toda la información que se necesita para la creación de la entidad
Net::CBuffer buffer;
buffer.write(&netMsg, sizeof(netMsg));
buffer.write(&nbPlayers, sizeof(nbPlayers));
buffer.write(&playerNetId, sizeof(playerNetId));
buffer.write(&spectatorId, sizeof(spectatorId));
buffer.serialize(nickname, false); // Nombre del player
buffer.serialize("Spectator", false); // Clase del player
// Enviamos la entidad nueva al resto de jugadores
_netMgr->broadcastIgnoring(playerNetId, buffer.getbuffer(), buffer.getSize());
buffer.reset();
// Enviamos la entidad nueva al jugador local
netMsg = Net::LOAD_LOCAL_PLAYER;
// Serializamos toda la información que se necesita para la creación de la entidad
buffer.write(&netMsg, sizeof(netMsg));
buffer.write(&playerNetId, sizeof(playerNetId));
buffer.write(&spectatorId, sizeof(spectatorId));
buffer.serialize(nickname, false); // Nombre del player
buffer.serialize("Spectator", false); // Clase del player
spectator->activate();
spectator->start();
_netMgr->sendTo(playerNetId, buffer.getbuffer(), buffer.getSize());
_playersMgr->setPlayerState(playerNetId, false);
_playersMgr->setPlayerTeam(playerNetId, Logic::TeamFaction::eNONE);
}
void CGameServerState::disconnectionPacketReceived(Net::CPaquete* packet) {
// Obtenemos el puntero al gestor de jugadores y el id de red del cliente que se quiere desconectar
Net::NetID playerNetId = packet->getConexion()->getId();
// Eliminamos la entidad manejada por el cliente que se quiere desconectar.
// Para ello comprobamos si tiene asignado un id de entidad. Si no lo tiene, es que
// no ha sido creada ninguna entidad (podria estar conectandose).
if( _playersMgr->existsByNetId(playerNetId) ) {
std::pair<Logic::TEntityID, bool> logicIdPair = _playersMgr->getPlayerId(playerNetId);
if(logicIdPair.second) {
Logic::CEntity* entityToBeDeleted = _map->getEntityByID(logicIdPair.first);
Logic::CEntityFactory::getSingletonPtr()->deferredDeleteEntity(entityToBeDeleted, true);
// A nivel logico, conviene que los clientes sepan quien se desconecta,
// especialmente para eliminar cosas del hud
Net::NetMessageType ackMsg = Net::PLAYER_OFF_MATCH;
Net::CBuffer disconnectMsg;
disconnectMsg.write(&ackMsg, sizeof(ackMsg));
disconnectMsg.write(&playerNetId, sizeof(playerNetId));
disconnectMsg.serialize(entityToBeDeleted->getName(), false);
_netMgr->broadcast(disconnectMsg.getbuffer(), disconnectMsg.getSize());
}
// Eliminamos el jugador que se desconecta del manager de jugadores
_playersMgr->removePlayer(playerNetId);
}
} // disconnexionPacketReceived
Net::CBuffer CMessageHoundCharge::serialize() {
Net::CBuffer buffer;
buffer.serialize( std::string("CMessageHoundCharge"), true );
buffer.write( &_isActive, sizeof(_isActive) );
// El resto de los atributos nos interesan solo si se
// activa la habilidad
if(_isActive) {
buffer.write( &_filterMask, sizeof(_filterMask) );
buffer.write( &_force, sizeof(_force) );
}
return buffer;
}//
void CGameServerState::createAndMirrorPlayer(int race, Net::NetID playerNetId, Logic::TeamFaction::Enum team) {
// Primero comprobamos si habia una entidad correspondiente a este jugador
// ya que durante el juego tambien podemos cambiar de clase.
// En caso de que la haya la eliminamos para crear la nueva
std::pair<Logic::TEntityID, bool> id = _playersMgr->getPlayerId(playerNetId);
if(id.second) { // Si el id devuelto es valido
Logic::CEntity* deletePlayer = _map->getEntityByID( id.first );
if(deletePlayer) {
Logic::CEntityFactory::getSingletonPtr()->deleteEntity(deletePlayer, true);
}
}
std::string name = _playersMgr->getPlayerNickname(playerNetId);
// Obtenemos el nombre de la clase a la que pertenece el player
std::string playerClass;
switch(race) {
case 1:
playerClass = "Screamer";
break;
case 2:
playerClass = "Hound";
break;
case 3:
playerClass = "Archangel";
break;
case 4:
playerClass = "Shadow";
break;
}
// Creamos el player
Logic::CEntity* player = _map->createPlayer(name, playerClass);
// Seteamos la id logica asociada al player
Logic::TEntityID playerId = player->getEntityID();
_playersMgr->setEntityID(playerNetId, playerId);
// Escribimos el tipo de mensaje de red a enviar
Net::NetMessageType netMsg = Net::LOAD_PLAYERS;
int nbPlayers = 1;
// Serializamos toda la información que se necesita para la creación de la entidad
Net::CBuffer buffer;
buffer.write(&netMsg, sizeof(netMsg));
buffer.write(&nbPlayers, sizeof(nbPlayers));
buffer.write(&playerNetId, sizeof(playerNetId));
buffer.write(&playerId, sizeof(playerId));
buffer.serialize(player->getName(), false); // Nombre del player
buffer.serialize(player->getType(), false); // Clase del player
buffer.write(&team, sizeof(team));
// Enviamos la entidad nueva al resto de jugadores
_netMgr->broadcastIgnoring(playerNetId, buffer.getbuffer(), buffer.getSize());
buffer.reset();
// Enviamos la entidad nueva al jugador local
netMsg = Net::LOAD_LOCAL_PLAYER;
// Serializamos toda la información que se necesita para la creación de la entidad
buffer.write(&netMsg, sizeof(netMsg));
buffer.write(&playerNetId, sizeof(playerNetId));
buffer.write(&playerId, sizeof(playerId));
buffer.serialize(player->getName(), false); // Nombre del player
buffer.serialize(player->getType(), false); // Clase del player
buffer.write(&team, sizeof(team));
std::cout << "el equipo que estoy enviando es ... " << team << std::endl;
player->activate();
player->start();
_netMgr->sendTo(playerNetId, buffer.getbuffer(), buffer.getSize());
_playersMgr->setPlayerState(playerNetId, true);
_playersMgr->setPlayerTeam(playerNetId, team);
}
Net::CBuffer CMessageParticleStop::serialize() {
Net::CBuffer buffer;
buffer.serialize( std::string("CMessageParticleStop"), true );
return buffer;
}//