void activateHealZone(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MActivateHealZone *m = new Logic::MActivateHealZone(); entity->emitMessage(m); }
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
void atacarJack(unsigned int entityID) { Logic::CEntity * jack = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::CEntity* * entidadesColision; int numColisiones = Physics::CServer::getSingletonPtr()->detectCollisions(jack->getPosition(), 40, entidadesColision); for(int i = 0; i < numColisiones; ++i) { if (!entidadesColision[i]->getTag().compare("enemy")) { //Entidad enemiga que atacará a Jack Logic::CEntity * entidad = entidadesColision[i]; std::stringstream script; script << "enemyEvent(\"AttackJack\", " << entidad->getEntityID() << ")"; ScriptManager::CServer::getSingletonPtr()->executeScript(script.str().c_str()); Logic::MAttackEntity *message = new Logic::MAttackEntity(); message->setAttack(true); message->setEntity(jack); entidad->emitMessage(message); } } }
std::pair<CVolumetricLightScattering::ScatteringParams, bool> CVolumetricLightScattering::getClosestLightSource(const std::list<ScatteringParams>& lightList) { std::pair<ScatteringParams, bool> closestLightSrc; closestLightSrc.second = false; // Obtenemos el puntero a la entidad del jugador que en este caso es lo que nos interesa Logic::CEntity* player = Input::CServer::getSingletonPtr()->getPlayerController()->getControllerAvatar(); if(player != NULL) { Vector3 playerPosition = player->getPosition(); Vector2 playerPos2d(playerPosition.x, playerPosition.z); auto it = lightList.begin(); Vector2 pos2d(it->lightPosition.x, it->lightPosition.z); auto closestLight = it++; float closestDist = (playerPos2d - pos2d).length(); float dist; for(; it != lightList.end(); ++it) { pos2d.x = it->lightPosition.x; pos2d.y = it->lightPosition.z; dist = (playerPos2d - pos2d).length(); if(dist < closestDist) { closestLight = it; closestDist = dist; } } closestLightSrc.second = true; closestLightSrc.first = *closestLight; } return closestLightSrc; }
void CSwordSlashController::process(const std::shared_ptr<Logic::IMessage> &message) { if((message->getType().compare("TOUCHED") == 0)) { Logic::CEntity *otherEntity = dynamic_cast<TOUCHED*>(message.get())->getEntidad(); if(otherEntity) { if (otherEntity->getTag() == "enemy") { if(_damage>0) { std::shared_ptr<DAMAGED> m(new DAMAGED()); m->setFloat(_damage); m->setString(_entity->getType()); otherEntity->emitMessage(m); std::shared_ptr<PUSH> pushMessage(new PUSH()); pushMessage->setDirection(_direction); pushMessage->setSpeed(0.5f); otherEntity->emitMessage(pushMessage, this); //BaseSubsystems::Log::Debug("ÑAPA: " + std::to_string(_damage)); } Logic::CEntityFactory::getSingletonPtr()->createEntityByType("ChispaDanhoEnemy", otherEntity->getCenterPosition(), _entity->getMap()); } } } } // process
void CTDMClient::dataPacketReceived(Net::CPaquete* packet) { CGameClientState::dataPacketReceived(packet); // Introducimos los datos recibidos en un buffer Net::CBuffer buffer( packet->getDataLength() ); buffer.write( packet->getData(), packet->getDataLength() ); buffer.reset(); // Obtenemos la cabecera del mensaje Net::NetMessageType netMsgType; buffer.read( &netMsgType, sizeof(netMsgType) ); // Dependiendo del tipo de mensaje switch (netMsgType) { case Net::END_GAME: { _inEndGame = true; // Desactivamos al jugador Logic::CEntity* player = Input::CServer::getSingletonPtr()->getPlayerController()->getControllerAvatar(); set<string> exceptionList; exceptionList.insert("CAnimationManager"); player->deactivateAllComponentsExcept(exceptionList); // Fijamos la cámara en el exterior para que rote a nuestro // alrededor Logic::CScoreboard::getSingletonPtr()->activate(); break; } } }
void IntantiateSoulAltar(Vector3 posDest, Vector3 posInit, Logic::CMap *map) { Logic::CEntity *ent = Logic::CEntityFactory::getSingletonPtr()->createEntityByType("AltarFeedback", posInit, map); Logic::CAltarFeedbackController *comp = (Logic::CAltarFeedbackController *) ent->getComponent("CAltarFeedbackController"); comp->Config(posDest); }
void empujarCircle(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MPushEntities *m = new Logic::MPushEntities(); entity->emitMessage(m); }
void SendMinionCreated(Logic::CEntity* minionCreated, std::string leaderName) { Logic::CEntity* leader = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName(leaderName); std::shared_ptr<Logic::GET_LOGIC_ENTITY>m(new Logic::GET_LOGIC_ENTITY()); m->setEntity(minionCreated); leader->emitMessage(m); }
void cancelCure(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MCureEntity *m = new Logic::MCureEntity(); m->setCure(false); entity->emitMessage(m); }
void shakeCamera(Logic::CEntity *entity, float max, float min) { Logic::CEntity* cam = entity->getMap()->getEntityByType("Camera"); std::shared_ptr<Logic::SHAKE> m(new Logic::SHAKE()); m->setMaxShake(max); m->setMinShake(min); cam->emitMessage(m); }
void detenerEnemigosContraEnemigos(unsigned int entityID) { //Mandamos un mensaje para que salga el icono de aturdido Logic::MAturdido *message = new Logic::MAturdido(); message->setAturdido(false); Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); if (entity) entity->emitMessage(message); }
void launchFlameThrower(unsigned int entityID, float point_x, float point_y, float point_z) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MLanzarLlamas *m = new Logic::MLanzarLlamas(); m->setPosition(Vector2(point_x, point_z)); m->setOrdenLlamas(Logic::OrdenLlamas::lanzarLlamas); entity->emitMessage(m); }
void cancelFlameThrower(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MLanzarLlamas *m = new Logic::MLanzarLlamas(); m->setPosition(Vector2(0, 0)); m->setOrdenLlamas(Logic::OrdenLlamas::ocultarBLamas); entity->emitMessage(m); }
void launchPowerShoot(unsigned int entityID, float point_x, float point_y, float point_z) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MDisparosPotentes *m = new Logic::MDisparosPotentes(); m->setPosition(Vector2(point_x, point_z)); m->setOrdenDisparos(Logic::OrdenDisparos::disparar); entity->emitMessage(m); }
void cancelPowerShoot(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MDisparosPotentes *m = new Logic::MDisparosPotentes(); m->setPosition(Vector2(0, 0)); m->setOrdenDisparos(Logic::OrdenDisparos::ocultarCono); entity->emitMessage(m); }
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 launchGrenade(unsigned int entityID, float point_x, float point_y, float point_z) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MLanzarGranada *m = new Logic::MLanzarGranada(); //m->setPosition(Vector2(entity->getPosition().x, entity->getPosition().y)); m->setPosition(Vector2(point_x, point_z)); m->setOrdenGranada(Logic::OrdenGranada::lanzar); entity->emitMessage(m); }
void startCure(unsigned int entityID, unsigned int entityIDTarget) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::CEntity *entityTarget = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityIDTarget); Logic::MCureEntity *m = new Logic::MCureEntity(); m->setEntity(entityTarget); m->setCure(true); entity->emitMessage(m); }
void CCameraFeedbackNotifier::damaged(Vector3 vEnemyPosition) { std::shared_ptr<Logic::CMessageCameraOffset> m3 = std::make_shared<Logic::CMessageCameraOffset>(); m3->setOffsetTimer(100.0f);//Timer Logic::CEntity * camera = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Camera"); assert(camera != NULL && "Error: Esto no se puede hacer asi que sois unos lamers, ahora el servidor que hace?"); camera->emitMessage(m3); _scene->setCompositorVisible(_effect, true); _effectIsActivated = true; _timestamp = 0; calculateEnemyPosition(vEnemyPosition); }// damaged
void activateBulletTime(unsigned int entityID) { Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::MActivarTiempoBala *m = new Logic::MActivarTiempoBala(); m->setTime(5.0f); unsigned int norah = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Norah")->getEntityID(); unsigned int jack = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Jack")->getEntityID(); unsigned int erick = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Erick")->getEntityID(); m->addEntity(norah); m->addEntity(jack); m->addEntity(erick); unsigned int playerGod = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("PlayerGod")->getEntityID(); m->addEntity(playerGod); entity->emitMessage(m); }
void activateMassHeal(unsigned int entityID, float heal) { Logic::CEntity *healer = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); /*Logic::CEntity *jackEntity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Jack"); Logic::CEntity *erickEntity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Erick"); Logic::CEntity *norahEntity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByName("Norah"); Logic::MHealed *m_heal = new Logic::MHealed(); m_heal->setHeal(heal); m_heal->setHealer(healer);*/ Logic::CEntity *playerEntity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByTag("Player"); while (playerEntity != NULL) { Logic::MHealed *m_heal = new Logic::MHealed(); m_heal->setHeal(heal); m_heal->setHealer(healer); playerEntity->emitMessage(m_heal); playerEntity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByTag("Player", playerEntity); } }
void CTDMServer::endGame() { _inEndGame = true; // Tiempo de espera hasta la siguiente partida _gameTime = _voteMap ? 40000 : 15000; // Notificar a los clientes de que estamos en la fase endGame Net::NetMessageType endGameMsg = Net::END_GAME; _netMgr->broadcast( &endGameMsg, sizeof(endGameMsg) ); // Desactivamos los componentes relevantes en el servidor para asegurarnos // de que aunque el cliente haga chetos no se muevan los jugadores sin permiso // ni se hagan daño. Logic::CEntity* player; std::vector<std::string> componentList; componentList.reserve(4); componentList.push_back("CAvatarController"); componentList.push_back("CPhysicController"); componentList.push_back("CLife"); componentList.push_back("CSpawnPlayer"); for(auto it = _playersMgr->begin(); it != _playersMgr->end(); ++it) { if( it->getEntityId().second ) { player = _map->getEntityByID( it->getEntityId().first ); player->deactivateComponents(componentList); } } // @todo // Parar la partida (el server y el cliente ya no hacen tick) // Poner la cámara mirando al jugador y que al girar el ratón rote alrededor // del player - cliente // Poner la cámara de los demás jugadores mirando al ganador - cliente // Mostrar el scoreboard durante unos 10 segundos - cliente // Si votemap está activo mostrar el menú de votemap durante unos 30 segs // Si votemap no está activo entonces pasar al siguiente mapa de los configurados // y si no ha habido ningun mapa puesto en lista salir }
void enemigosContraEnemigos(unsigned int entityID) { Logic::CEntity * norah = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID); Logic::CEntity* * entidadesColision; int numColisiones = Physics::CServer::getSingletonPtr()->detectCollisions( norah->getPosition(),80,entidadesColision); //Iniciamos la tabla de los enemigos afectados std::stringstream script1; script1 << "enemigosConfundidos = {}"; ScriptManager::CServer::getSingletonPtr()->executeScript(script1.str().c_str()); for(int i = 0; i < numColisiones; ++i) { if ( !entidadesColision[i]->getTag().compare("enemy") ) { //Entidad enemiga que atacara a otros enemigos Logic::CEntity * entidad = entidadesColision[i]; float distX = entidad->getPosition().x - norah->getPosition().x; float distZ = entidad->getPosition().z - norah->getPosition().z; float distance2 = distX * distX + distZ * distZ; //Solo entraran al estado los que esten a una distancia menor de 40 if (distance2 < 40 * 40) { std::stringstream script2; script2 << "enemyEvent(\"AttackOtherEnemies\", " << entidad->getEntityID() << ")"; ScriptManager::CServer::getSingletonPtr()->executeScript(script2.str().c_str()); //Mandamos un mensaje para que salga el icono de aturdido Logic::MAturdido *message = new Logic::MAturdido(); message->setAturdido(true); entidad->emitMessage(message); } //Atacaran hasta a los que esten a una distancia de 80 //Añadimos el enemigo a la tabla de los enemigos afectados entre los que se pueden atacar std::stringstream script3; script3 << "enemigosConfundidos[" << i+1 << "] = " << entidad->getEntityID(); ScriptManager::CServer::getSingletonPtr()->executeScript(script3.str().c_str()); } } }
void CTDMServer::gameEventOcurred(Logic::CEntity* emitter, const shared_ptr<Logic::CMessage>& msg) { switch( msg->getMessageType() ) { case Logic::Message::PLAYER_DEAD: { shared_ptr<Logic::CMessagePlayerDead> playerDeadMsg = static_pointer_cast<Logic::CMessagePlayerDead>(msg); Logic::CEntity* killer = playerDeadMsg->getKiller(); if(killer != NULL) { Logic::TEntityID killerID = killer->getEntityID(); Logic::TEntityID emitterID = emitter->getEntityID(); // Si no nos hemos suicidado (ya sea matandonos o muriendo en una trampa) Logic::CEntity* killer = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(killerID); if( emitter != killer && isPlayer(killer) ) { // Incrementamos el número de muertes del jugador _playersMgr->addFragUsingEntityID(killerID); // Obtenemos el equipo al que pertenece el jugador que acaba de hacer un frag Logic::TeamFaction::Enum team = _playersMgr->getTeamUsingEntityId(killerID); Logic::TeamFaction::Enum victimTeam = _playersMgr->getTeamUsingEntityId(emitterID); // Si matas a alguien de tu equipo te descuentas frags if(team == victimTeam) { if(team == Logic::TeamFaction::eRED_TEAM) { --_redTeamScore; } else if(team == Logic::TeamFaction::eBLUE_TEAM) { --_blueTeamScore; } } // Sino incrementas frags y compruebas si has ganado la partida else { if(team == Logic::TeamFaction::eRED_TEAM) { if(++_redTeamScore == _goalScore && !_unlimitedScore) { endGame(); cout << "RED TEAM WINS!" << endl; } } else if(team == Logic::TeamFaction::eBLUE_TEAM) { if(++_blueTeamScore == _goalScore && !_unlimitedScore) { endGame(); cout << "BLUE TEAM WINS!" << endl; } } } } else { _playersMgr->substractFragUsingEntityID(emitterID); // Obtenemos el equipo al que pertenece el jugador que acaba de suicidarse Logic::TeamFaction::Enum team = _playersMgr->getTeamUsingEntityId(emitterID); if(team == Logic::TeamFaction::eRED_TEAM) { --_redTeamScore; } else if(team == Logic::TeamFaction::eBLUE_TEAM) { --_blueTeamScore; } } _playersMgr->addDeathUsingEntityID(emitterID); } break; } } }
void openChestAnimation(Logic::CEntity &entity) { Logic::CAnimatedGraphics* cmp = (Logic::CAnimatedGraphics*) entity.getComponent("CAnimatedGraphics"); cmp->setAnimation("Open", "default", false, true, 0.0f, 2.0f); }
void sendCancelOpenChestMessage(Logic::CEntity &entity) { std::shared_ptr<Logic::CANCEL_OPEN> m (new Logic::CANCEL_OPEN()); entity.emitMessage(m); }
//Manda un mensaje de OPEN_CHEST desde LUA a la entidad indicada void sendOpenChestMessage(Logic::CEntity &entity) { std::shared_ptr<Logic::OPEN_CHEST> m (new Logic::OPEN_CHEST()); entity.emitMessage(m); }
void CGameServerState::dataPacketReceived(Net::CPaquete* packet) { // Obtenemos la id de la conexion por la que hemos recibido // el paquete (para identificar al cliente) Net::NetID playerNetId = packet->getConexion()->getId(); // Construimos un buffer para leer los datos que hemos recibido Net::CBuffer inBuffer( packet->getDataLength() ); inBuffer.write( packet->getData(), packet->getDataLength() ); inBuffer.reset(); // Desplazamos el puntero al principio para realizar la lectura // En primer lugar extraemos el tipo del mensaje que hemos recibido Net::NetMessageType msgType; inBuffer.read( &msgType, sizeof(msgType) ); switch(msgType) { case Net::PLAYER_INFO: { // Deserializamos el nombre del player std::string playerNick; inBuffer.deserialize(playerNick); //comprobamos si hay algún jugador con el mismo nombre en la partida, y si es así, //se lo cambiamos para que no haya problemas en el futuro if(_map->getEntityByName(playerNick)){ std::ostringstream convert; convert << playerNetId; std::string nameId = convert.str(); playerNick += nameId; } // Registramos al player en el gestor de jugadores _playersMgr->addPlayer(playerNetId, playerNick); // Enviamos la informacion de carga de mapa al cliente sendMapInfo(playerNetId); break; } case Net::MAP_LOADED: { Net::CBuffer gameSettingsBuffer; Net::NetMessageType msgType = Net::GAME_SETTINGS; gameSettingsBuffer.write(&msgType, sizeof(msgType)); gameSettingsBuffer.write(&_gameMode, sizeof(_gameMode)); gameSettingsBuffer.write(&_gameTime, sizeof(_gameTime)); gameSettingsBuffer.write(&_goalScore, sizeof(_goalScore)); _netMgr->sendTo( playerNetId, gameSettingsBuffer.getbuffer(), gameSettingsBuffer.getSize() ); break; } case Net::GAME_SETTINGS_LOADED: { // Una vez cargado el mapa, comienza la fase de carga de players. // El player que esta siendo conectado deberá cargar a todos los players que ya estaban online. sendWorldState(playerNetId); break; } case Net::WORLD_STATE_LOADED: { Net::NetMessageType startGameMsg = Net::START_GAME; _netMgr->sendTo(playerNetId, &startGameMsg, sizeof(startGameMsg)); break; } case Net::CLASS_SELECTED: { int race; inBuffer.deserialize(race); if(race == 5) { unsigned int nbSpectators = 0; for(auto it = _playersMgr->begin(); it != _playersMgr->end(); ++it) { std::pair<Logic::TEntityID, bool> id = _playersMgr->getPlayerId(playerNetId); if(id.second) { if(Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(id.first)->getType() == "Spectator") ++nbSpectators; } } if(nbSpectators < _maxSpectators) { // Creamos una entidad espectador y la replicamos en el cliente createAndMirrorSpectator(playerNetId); } else { // Mandamos un mensaje de que no existen slots disponibles // para jugar Net::NetMessageType noSlotsMsg = Net::NO_FREE_SPECTATOR_SLOTS; Net::CBuffer errorBuffer( sizeof(noSlotsMsg) ); errorBuffer.write( &noSlotsMsg, sizeof(noSlotsMsg) ); _netMgr->sendTo(playerNetId, errorBuffer.getbuffer(), errorBuffer.getSize()); } } else { // Si quedan slots para conectarse como jugador permitimos que // se conecte, sino le mandamos un mensaje bool isChanging = false; if( _playersMgr->existsByNetId(playerNetId) ) { isChanging = _playersMgr->getPlayer(playerNetId).isSpawned(); } // Si estamos cambiando de clase, consideramos un jugador menos, ya que // nosotros si no contariamos unsigned nbPlayersPlaying = _playersMgr->getNumberOfPlayersSpawned(); if(isChanging) --nbPlayersPlaying; if( nbPlayersPlaying < _maxPlayers) { Logic::TeamFaction::Enum team; if(_autoBalanceTeams) { if(_playersMgr->blueTeamPlayers() < _playersMgr->redTeamPlayers()) { team = Logic::TeamFaction::eBLUE_TEAM; } else { team = Logic::TeamFaction::eRED_TEAM; } } else { if(_gameMode == GameMode::eTEAM_DEATHMATCH || _gameMode == GameMode::eCAPTURE_THE_FLAG) { inBuffer.read(&team, sizeof(team)); } else { team = Logic::TeamFaction::eNONE; } } // Creamos una entidad jugador con la clase que nos hayan dicho // y la replicamos en el cliente createAndMirrorPlayer(race, playerNetId, team); } else { // Mandamos un mensaje de que no existen slots disponibles // para jugar Net::NetMessageType noSlotsMsg = Net::NO_FREE_PLAYER_SLOTS; Net::CBuffer errorBuffer( sizeof(noSlotsMsg) ); errorBuffer.write( &noSlotsMsg, sizeof(noSlotsMsg) ); _netMgr->sendTo(playerNetId, errorBuffer.getbuffer(), errorBuffer.getSize()); } } break; } case Net::PING: { Net::NetMessageType ackMsg = Net::PING; clock_t time = clock(); Net::CBuffer ackBuffer(sizeof(ackMsg) + sizeof(time)); ackBuffer.write(&ackMsg, sizeof(ackMsg)); ackBuffer.write(&time, sizeof(time)); _netMgr->sendTo(playerNetId, ackBuffer.getbuffer(), ackBuffer.getSize()); break; } case Net::LOCAL_PLAYER_LOADED: { Logic::TEntityID id; inBuffer.deserialize(id); Logic::CEntity* player = _map->getEntityByID(id); player->activate(); player->start(); break; } } } // dataPacketReceived
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); }