Пример #1
0
	void activateHealZone(unsigned int entityID)
	{
		Logic::CEntity *entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(entityID);

		Logic::MActivateHealZone *m = new Logic::MActivateHealZone();
		entity->emitMessage(m);
	}
Пример #2
0
	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
Пример #3
0
	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);
			}
		}
	}
Пример #4
0
	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
Пример #6
0
	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);
	}
Пример #8
0
	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);
	}
Пример #10
0
	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);
	}
Пример #12
0
	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);
	}
Пример #13
0
	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);
	}
Пример #14
0
	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);
	}
Пример #15
0
	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);
	}
Пример #16
0
	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);
	}
Пример #17
0
	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);
	}
Пример #18
0
	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);
	}
Пример #19
0
	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);
	}
Пример #20
0
	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
Пример #21
0
	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);
	}
Пример #22
0
	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);
		}
	}
Пример #23
0
	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
	}
Пример #24
0
	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());
			}
		}
	}
Пример #25
0
	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);

	}
Пример #29
0
	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
Пример #30
0
	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);
	}