示例#1
0
static void Skins_SetSurfacePrefs(ModelContainer_t *pContainer, StringVector_t &SurfaceNames, SurfaceOnOff_t eStatus)
{
	bool bFailureOccured = false;

	for (int i=0; i<SurfaceNames.size() && !bFailureOccured; i++)
	{
		string strSurfaceName = SurfaceNames[i];

		if (!Model_GLMSurface_SetStatus( pContainer->hModel, strSurfaceName.c_str(), eStatus))
			bFailureOccured = true;
	}
}
bool ConsoleCommandParser::performParsing(const NetworkId & /* track */, const StringVector_t & argv, const String_t &, String_t & result, const CommandParser *)
{
	bool successResult = false;

	if(isCommand(argv[0], "planet"))
	{
		if(argv.size() > 2)
		{
			if(isCommand(argv[2], "runState"))
			{
				successResult = true;
				result += Unicode::narrowToWide("running");
			}
		}
	}
		
	return successResult;
}
bool ConsoleCommandParser::performParsing(const NetworkId & track, const StringVector_t & argv, const String_t &, String_t & result, const CommandParser *)
{
	bool successResult = false;

	if(isCommand(argv[0], "transfer"))
	{
		if(isCommand(argv[1], "requestMove"))
		{
			if(argv.size() > 5)
			{
				std::string stationIdString = Unicode::wideToNarrow(argv[2]);
				std::string characterName = Unicode::wideToNarrow(argv[3]);
				std::string sourceServer = Unicode::wideToNarrow(argv[4]);
				std::string destinationServer = Unicode::wideToNarrow(argv[5]);
				
				LOG("CustomerService", ("CharacterTransfer: received console request to transfer %s, belonging to %s from %s to %s", characterName.c_str(), stationIdString.c_str(), sourceServer.c_str(), destinationServer.c_str()));

				result += Unicode::narrowToWide("Received request to move ");
				result += Unicode::narrowToWide(characterName);
				result += Unicode::narrowToWide(" owned by station ID ");
				result += Unicode::narrowToWide(stationIdString);
				result += Unicode::narrowToWide(" on cluster ");
				result += Unicode::narrowToWide(sourceServer);
				result += Unicode::narrowToWide(" to cluster ");
				result += Unicode::narrowToWide(destinationServer);

				const unsigned int stationId = static_cast<const unsigned int>(atoi (stationIdString.c_str()));
				const unsigned int trackId = static_cast<const unsigned int>(track.getValue());

				//todo : drive these through the command handler, just testing
				// basic functionality for now.
				const bool withItems = true;
				const bool allowOverride = true;
				
				TransferServer::requestMove(trackId, "en", sourceServer, destinationServer, characterName, characterName, stationId, stationId, trackId, withItems, allowOverride);
				successResult = true;
			}
			else
			{
				std::string messageString = "not enough arguments to 'requestMove <station id> <character name> <source server> <destination server>'";
				StringVector_t::const_iterator i;
				
				for(i = argv.begin(); i != argv.end(); ++i)
				{
					messageString = messageString + Unicode::wideToNarrow(*i) + " | ";
				}
				LOG("CustomerService", ("CharacterTransfer: %s", messageString.c_str()));
				result += Unicode::narrowToWide(messageString);
			}
		}
		else if (isCommand(argv[1], "requestAccountMove"))
		{
			if (argv.size() > 3)
			{
				std::string sourceStationIdString      = Unicode::wideToNarrow(argv[2]);
				std::string destinationStationIdString = Unicode::wideToNarrow(argv[3]);

				LOG("CustomerService", ("CharacterTransfer: received console request to transfer account from station ID %s to station ID %s", sourceStationIdString.c_str(), destinationStationIdString.c_str()));

				result += Unicode::narrowToWide("Received request to move from station ID ");
				result += Unicode::narrowToWide(sourceStationIdString);
				result += Unicode::narrowToWide(" to station ID ");
				result += Unicode::narrowToWide(destinationStationIdString);
				result += Unicode::narrowToWide("\n");

				const unsigned int sourceStationId      = static_cast<const unsigned int>(atoi (sourceStationIdString.c_str()));
				const unsigned int destinationStationId = static_cast<const unsigned int>(atoi (destinationStationIdString.c_str()));
				const unsigned int trackId              = static_cast<const unsigned int>(track.getValue());

				TransferServer::requestTransferAccount(trackId, sourceStationId, destinationStationId, trackId);
				successResult = true;
			}
			else
			{
				std::string messageString = "not enough arguments to 'requestAccountMove <source station id> <destination station id>'";
				StringVector_t::const_iterator i;
				
				for(i = argv.begin(); i != argv.end(); ++i)
				{
					messageString = messageString + Unicode::wideToNarrow(*i) + " | ";
				}
				LOG("CustomerService", ("CharacterTransfer: %s\n", messageString.c_str()));
				result += Unicode::narrowToWide(messageString);
				result += Unicode::narrowToWide("\n");
			}
		}
	}
		
	return successResult;
}
bool ConsoleCommandParserGame::performParsing(const NetworkId & track, const StringVector_t & argv,const String_t & originalCommand,String_t & result,const CommandParser *)
{
	bool successResult = false;

	if(isCommand(argv[0], CommandNames::game))
	{
		if(argv.size() > 1)
		{
			std::string cmd = Unicode::wideToNarrow(argv[1]);
			if(cmd == "any")
			{
				// grab a random game server to execute this command
				GameServerConnection * gameConn = CentralServer::getInstance().getRandomGameServer();
				if(gameConn)
				{
					ConGenericMessage cm(Unicode::wideToNarrow(originalCommand), static_cast<unsigned int>(track.getValue()));
					gameConn->send(cm, true);
					successResult = true;
				}
				else
				{
					result += Unicode::narrowToWide("No game servers available to service request");
					ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
				}

			}
			else if(cmd == "kill")
			{
				// kill the game server process specified (by disconnecting it from central)
				if(argv.size() > 2)
				{
					unsigned int pid;
					sscanf(Unicode::wideToNarrow(argv[2]).c_str(), "%d", &pid);
					GameServerConnection * gameConn = CentralServer::getInstance().getGameServer(pid);
					if(gameConn)
					{
						gameConn->setDisconnectReason("Central ConsoleCommandParserGame kill command");
						gameConn->disconnect();
						successResult = true;
						ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));

					}
				}
			}
			else if(cmd == "enumerate")
			{
				std::vector<const GameServerConnection *> gameServers = CentralServer::getInstance().getGameServers();
				std::vector<const GameServerConnection *>::const_iterator i;
				for(i = gameServers.begin(); i != gameServers.end(); ++i)
				{
					char entry[256] = {"\0"};
					IGNORE_RETURN(snprintf(entry, sizeof(entry), "%lu, %lu, %s, %s\n", (*i)->getProcessId(), (*i)->getOsProcessId(), (*i)->getRemoteAddress().c_str(), (*i)->getSceneId().c_str()));
					result += Unicode::narrowToWide(entry);
				}
				ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
			}
			else if( cmd == "abortShutdown" )
			{
				LOG("ServerConsole", ("Received command to abort the current shutdown sequence."));
				CentralServer::getInstance().abortShutdownProcess();
				result += Unicode::narrowToWide("Instructing Central Server to abort shutdown sequence.\n");
				successResult = true;
				ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
			}
			// starts the shutdown process
			else if(cmd == "shutdown")
			{
				if( argv.size() > 4 )
				{
					LOG("ServerConsole", ("Received command to shutdown the cluster."));
					uint32 timeToShutdown = strtoul(Unicode::wideToNarrow(argv[2]).c_str(), NULL, 10);
					uint32 maxTime = strtoul(Unicode::wideToNarrow(argv[3]).c_str(), NULL, 10);
					Unicode::String systemMessage = Unicode::narrowToWide("");
					for(unsigned int i = 4; i < argv.size(); ++i)
					{
						systemMessage += argv[i] + Unicode::narrowToWide(" ");
					}
					CentralServer::getInstance().startShutdownProcess(timeToShutdown, maxTime, systemMessage);
					result += Unicode::narrowToWide("Instructing Central Server to begin shutdown sequence.\n");
					successResult = true;
					ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
				}
				// failed to provide enough parameters
				else
				{
					LOG("ServerConsole", ("Received an improperly formatted shutdown command."));
					result += Unicode::narrowToWide("Not enough parameters specified. Usage is \"game shutdown <time to shutdown in seconds> <max time to wait in seconds> <system broadcast message>\"\n");
					ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
				}
			}
			else if(cmd == "authorizeTransfer")
			{
				if(argv.size() > 1)
				{
					unsigned int stationId = strtoul(Unicode::wideToNarrow(argv[2]).c_str(), NULL, 10);
					if(stationId > 0)
					{
						GenericValueTypeMessage<unsigned int> auth("AuthorizeDownload", stationId);
						CentralServer::getInstance().sendToTransferServer(auth);
						result += Unicode::narrowToWide("sent authorization request");
					}
				}
				ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
			}
			else if(cmd == "requestMove")
			{
				if(argv.size() > 5)
				{
					ConGenericMessage cm(Unicode::wideToNarrow(originalCommand), static_cast<unsigned int>(track.getValue()));
					CentralServer::getInstance().sendToTransferServer(cm);
				}
			}
			else
			{
				if(! isalpha(cmd.c_str()[0]))
				{
					// check to see if the next parameter is a pid to send the command to
					uint32 pid;
					sscanf(Unicode::wideToNarrow(argv[1]).c_str(), "%lu", &pid);
					GameServerConnection * gameConn = CentralServer::getInstance().getGameServer(pid);
					if(gameConn)
					{
						ConGenericMessage cm(Unicode::wideToNarrow(originalCommand), static_cast<unsigned int>(track.getValue()));
						gameConn->send(cm, true);
						successResult = true;
					}
					else
					{
						result += Unicode::narrowToWide("No game servers available to service request");
						ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
					}
				}
				else
				{
					// a planet 
					GameServerConnection * gameConn = CentralServer::getInstance().getGameServer(Unicode::wideToNarrow(argv[1]));
					if(gameConn)
					{
						ConGenericMessage cm(Unicode::wideToNarrow(originalCommand), static_cast<unsigned int>(track.getValue()));
						gameConn->send(cm, true);
						successResult = true;
					}
					else
					{
						result += Unicode::narrowToWide("No game servers available to service request");
						ConsoleConnection::onCommandComplete(Unicode::wideToNarrow(result), static_cast<int>(track.getValue()));
					}
				}
			}
		}
		else
		{
			// select a game server to execute this command
			result += Unicode::narrowToWide("insufficient arguments");
			successResult = true;
		}
	}

	return successResult;
}
bool ConsoleCommandParserSpawner::performParsing (const NetworkId &, const StringVector_t & argv, const String_t & , String_t & result, const CommandParser *)
{			
	// ----------------------------------------------------------------
	
	if (isCommand (argv[0], CommandNames::showQueue))
	{
		CreatureObject::showSpawnQueue(result);
		return true;
	}

	else if(isCommand (argv[0], CommandNames::showCreatures))
	{
		bool npcOnly = false;
		bool pcOnly = false;
		if(argv.size() >= 2)
		{
			std::string arg2 = Unicode::wideToNarrow(argv[1]);
			if(arg2 == "npc")
			{
				npcOnly = true;
			}
			else if(arg2 == "pc")
			{
				pcOnly = true;
			}
		}

		static const Unicode::String header(Unicode::narrowToWide(std::string("Creature Listing - ID: POS: Auth Server: Template Name\n")));
		result += header;
		const CreatureObject::AllCreaturesSet & creatureList = CreatureObject::getAllCreatures();
		CreatureObject::AllCreaturesSet::const_iterator i;
		int count = 0;
		for(i = creatureList.begin(); i != creatureList.end(); ++i)
		{
			const CreatureObject * creature = (*i);
			if(creature)
			{
				if(pcOnly && (!creature->isPlayerControlled()) )
					continue;
				if(npcOnly && creature->isPlayerControlled())
					continue;

				std::string creatureEntry = creature->getNetworkId().getValueString();
				creatureEntry += ": ";

				char locBuffer[32] = {"\0"};
				Vector loc = creature->getTransform_o2w().getPosition_p();
				snprintf(locBuffer, sizeof(locBuffer), "%.0f, %.0f: ", loc.x, loc.z);
				creatureEntry += locBuffer;

				snprintf(locBuffer, sizeof(locBuffer), "%lu: ", creature->getAuthServerProcessId());
				creatureEntry += locBuffer;
				creatureEntry += creature->getObjectTemplateName();

				creatureEntry += "\n";

				result += Unicode::narrowToWide(creatureEntry);
				count++;
			}
		}
		char countBuffer[32] = {"\0"};
		snprintf(countBuffer, sizeof(countBuffer), "%d creatures listed: ", count);
		result += Unicode::narrowToWide(std::string(countBuffer));
		return true;
	}

	
	else
	{
		result += getErrorMessage (argv[0], ERR_NO_HANDLER);
		return false;
	}
	
	return true;
}
bool ConsoleCommandParserResource::performParsing (const NetworkId & userId, const StringVector_t & argv, const String_t & originalCommand, String_t & result, const CommandParser * node)
{
	NOT_NULL (node);
	UNREF (userId);

	UNREF(originalCommand);

	//-----------------------------------------------------------------

	if (isCommand( argv [0], "activate"))
	{
		CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));

		ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
		if (harvesterObject == NULL)
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
			return true;
		}

		Controller *const controller = harvesterObject->getController();
		NOT_NULL(controller);
		controller->appendMessage(static_cast<int>(CM_activateInstallation),0.0f,new MessageQueueActivateInstallation(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER);
		result += getErrorMessage(argv[0], ERR_SUCCESS);
	}
		
	else if (isCommand( argv [0], "harvest"))
	{
		CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));

		ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
		if (harvesterObject == NULL)
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
			return true;
		}
			//TODO:  Make all of these into function calls instead of sending messages

		Controller *const controller = harvesterObject->getController();
		NOT_NULL(controller);
		controller->appendMessage(static_cast<int>(CM_installationHarvest),0.0f,new MessageQueueInstallationHarvest(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER); 
		result += getErrorMessage(argv[0], ERR_SUCCESS);
	}
	
	else if (isCommand( argv [0], "discardHopper"))
	{
		CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));
		
		HarvesterInstallationObject* harvesterObject = dynamic_cast<HarvesterInstallationObject*>(harvester.getObject());
		if (!harvesterObject)
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
			return true;
		}
		harvesterObject->discardAllHopperContents ();

		result += getErrorMessage(argv[0], ERR_SUCCESS);
	}

	else if (isCommand( argv [0], "deactivate"))
	{
		CachedNetworkId harvester(Unicode::wideToNarrow (argv[1]));

		ServerObject* harvesterObject = safe_cast<ServerObject*>(harvester.getObject());
		if (harvesterObject == NULL)
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
			return true;
		}
		Controller *const controller = harvesterObject->getController();
		NOT_NULL(controller);
		controller->appendMessage(static_cast<int>(CM_deactivateInstallation),0.0f,new MessageQueueDeactivateInstallation(), GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_SERVER);
		result += getErrorMessage(argv[0], ERR_SUCCESS);
	}

	else if (isCommand( argv [0], "tree"))
	{
		ServerUniverse & universe = ServerUniverse::getInstance();
		ResourceClassObject * root = 0;

		if (argv.size () > 1)
			root = universe.getResourceClassByName (Unicode::wideToNarrow (argv [1]));
		else
			root = universe.getResourceTreeRoot();

		if (root)
		{
			std::string temp;
			root->debugOutput(temp);
			result += Unicode::narrowToWide(temp);
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		}
		else
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);
		
	}
	
	else if (isCommand( argv [0], "pools"))
	{
		PlanetObject* planet=ServerUniverse::getInstance().getPlanetByName(Unicode::wideToNarrow(argv[1]));
		if (planet)
		{
			std::string temp;
			planet->debugOutputPools(temp);
			result += Unicode::narrowToWide(temp);
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		}
		else
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
		}
	}

	else if (isCommand( argv [0], "name"))
	{
		NetworkId resourceId(Unicode::wideToNarrow (argv[1]));
		ResourceTypeObject * const resource = ServerUniverse::getInstance().getResourceTypeById(resourceId);
		if (resource)
		{
			resource->setName(Unicode::wideToNarrow(argv[2]));
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		}
		else
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
		}
	}

	else if (isCommand( argv [0], "viewcontainer"))
	{
		CachedNetworkId contId (Unicode::wideToNarrow (argv[1]));
		ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(contId.getObject());
		if (container)
		{
			result += Unicode::narrowToWide(container->debugPrint()+'\n');
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		}
		else
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
		}
	}

	else if (isCommand( argv [0], "addtocontainer"))
	{
		NetworkId const contId (Unicode::wideToNarrow (argv[1]));
		ResourceContainerObject * const container = dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
		std::string const & resourcePath = Unicode::wideToNarrow(argv[2]);
		ResourceTypeObject * const resType = ServerUniverse::getInstance().getResourceTypeByName(resourcePath);
		int const amount = strtol(Unicode::wideToNarrow (argv[3]).c_str (), NULL, 10);
		NetworkId const source(Unicode::wideToNarrow (argv[4]));
		
		if (container && resType)
		{
			if (container->addResource(CachedNetworkId(resType->getNetworkId()),amount, source))
				result += getErrorMessage(argv[0], ERR_SUCCESS);
			else
				result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
		}
		else
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
		}
	}

	else if (isCommand( argv [0], "fillcontainer"))
	{
		NetworkId contId (Unicode::wideToNarrow (argv[1]));
		ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
		if (container != NULL)
		{
			NetworkId sourceId;
			if (argv.size() >= 3)
				sourceId = NetworkId(Unicode::wideToNarrow (argv[2]));

			if (container->addResource(container->getResourceType(), 
				container->getMaxQuantity() - container->getQuantity(), 
				sourceId))
			{
				result += getErrorMessage(argv[0], ERR_SUCCESS);
			}
			else
				result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
		}
		else
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
	}

	else if (isCommand( argv [0], "recycle"))
	{
		NetworkId contId (Unicode::wideToNarrow (argv[1]));
		ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(NetworkIdManager::getObjectById(contId));
		if (container != NULL)
		{
			if (container->debugRecycle())
					result += getErrorMessage(argv[0], ERR_SUCCESS);
			else
				result += Unicode::narrowToWide("The resource in the container could not be recycled.\n");
		}
		else
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
	}

	else if (isCommand( argv [0], "removefromcontainer"))
	{
		CachedNetworkId contId (Unicode::wideToNarrow (argv[1]));
		ResourceContainerObject* container=dynamic_cast<ResourceContainerObject*>(contId.getObject());
		ResourceTypeObject *resType=ServerUniverse::getInstance().getResourceTypeByName(Unicode::wideToNarrow(argv[2]));
		int amount=strtol(Unicode::wideToNarrow (argv[3]).c_str (), NULL, 10);
		
		if (container && resType)
		{
			NetworkId sourcePlayer(NetworkId::cms_invalid);

			typedef std::vector<std::pair<NetworkId, int> > SourcesType;
			SourcesType sources;
			if (container->removeResource(resType->getNetworkId(),amount,&sources))
			{
				char buffer[50];
				for(SourcesType::iterator i=sources.begin(); i!=sources.end(); ++i)
				{
					IGNORE_RETURN(snprintf(buffer,50,"%i",i->second));
					result += Unicode::narrowToWide(std::string("Removed ") + buffer + " resources harvested by player " + i->first.getValueString() + '\n');
				}
				result += getErrorMessage(argv[0], ERR_SUCCESS);
			}
			else
				result += getErrorMessage(argv[0], ERR_INVALID_CONTAINER_TRANSFER);
		}
		else
		{
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
		}
	}

	else if (isCommand( argv [0], "getSurveyList"))
	{
		std::string parentResourceClassName(Unicode::wideToNarrow(argv[1]));
		CachedNetworkId tool(Unicode::wideToNarrow (argv[2]));

		SurveySystem::getInstance().requestResourceListForSurvey(userId, tool, parentResourceClassName);
		result += getErrorMessage(argv[0], ERR_SUCCESS);
	}
	
	else if (isCommand( argv [0], "survey"))
	{
		const std::string       parentResourceClassName   (Unicode::wideToNarrow(argv[1]));
		const std::string       resourceTypeName          (Unicode::wideToNarrow(argv[2]));
		const int               surveyRange             = strtol(Unicode::wideToNarrow(argv[3]).c_str(),NULL,10);
		const int               numPoints               = strtol(Unicode::wideToNarrow(argv[4]).c_str(),NULL,10);
		const Object *          player                  = NetworkIdManager::getObjectById(userId);

		if (player)
		{
			SurveySystem::getInstance().requestSurvey(userId, parentResourceClassName, resourceTypeName, player->getPosition_w(), surveyRange, numPoints);
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		}
		else
			result += getErrorMessage(argv [0], ERR_INVALID_OBJECT);
	}

	else if (isCommand( argv [0], "deplete"))
	{
		NetworkId resourceId (Unicode::wideToNarrow (argv[1]));
		if (ServerUniverse::getInstance().manualDepleteResource(resourceId))
			result += getErrorMessage(argv[0], ERR_SUCCESS);
		else
			result += getErrorMessage (argv [0], ERR_INVALID_OBJECT);	
	}
	
	return true;
}	// ConsoleCommandParserResource::performParsing