C++ CEntity::getEntityID方法代码示例

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

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