C++ CryWarning函数代码示例

bool CProceduralClipFactory::Register( const char* const typeName, const SProceduralClipFactoryRegistrationInfo& registrationInfo )
{
	CRY_ASSERT( typeName );
	CRY_ASSERT( registrationInfo.pProceduralClipCreator != NULL );
	CRY_ASSERT( registrationInfo.pProceduralParamsCreator != NULL );

	const THash typeNameHash( typeName );

	const char* const registeredTypeNameForHash = FindTypeName( typeNameHash );
	const bool alreadyRegistered = ( registeredTypeNameForHash != NULL );
	if ( alreadyRegistered )
	{
		const bool namesMatch = ( strcmp( typeName, registeredTypeNameForHash ) == 0 );
		if ( namesMatch )
		{
			CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CProceduralClipFactory::Register: Register called more than once for type with name '%s'.", typeName );
		}
		else
		{
			CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CProceduralClipFactory::Register: Trying to register type with name '%s' and hash '%u', but hash collides with already registered type with name '%s'. Choose a different name for the type.", typeName, typeNameHash.ToUInt32(), registeredTypeNameForHash );
			// TODO: FatalError?
		}

		CRY_ASSERT( false );
		return false;
	}

#if defined(_DEBUG)
	CryLogAlways( "CProceduralClipFactory: Registering procedural clip with name '%s'.", typeName );
#endif
	m_typeHashToName[ typeNameHash ] = string( typeName );
	m_typeHashToRegistrationInfo[ typeNameHash ] = registrationInfo;

	return true;
}

//------------------------------------------------------------------------------------------------------------------------
bool CCustomEventManager::UnregisterEventListener( ICustomEventListener* pListener, const TCustomEventId eventId )
{
	TCustomEventsMap::iterator eventsDataIter = m_customEventsData.find( eventId );
	if (eventsDataIter != m_customEventsData.end())
	{
		SCustomEventData &     eventData = eventsDataIter->second;
		TCustomEventListeners &listeners = eventData.m_listeners;

		if (listeners.Contains( pListener ))
		{
			listeners.Remove( pListener );
			return true;
		}
		else
		{
			CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CCustomEventManager::UnregisterEventListener: Listener isn't registered for event id: %u", eventId );
		}
	}
	else
	{
		CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CCustomEventManager::UnregisterEventListener: No event data exists for event id: %u", eventId );
	}

	return false;
}

float CWorldState::GetFloat(const char * entityName, char * valueName)
{
//	CryLog("CWorldState::GetFloat()");
	float result = 0.f;

	if(worldStateXml)
	{

		XmlNodeRef entityNode = worldStateXml->findChild(entityName);

		if(entityNode)
		{
			const uint32 Count = entityNode->getChildCount();
			for (uint32 Index = 0; Index < Count; ++Index)
			{
				const XmlNodeRef currentNode = entityNode->getChild(Index);
				if(strcmp(currentNode->getTag(),valueName)==0)
				{
					currentNode->getAttr("value",result);
					break;
				}
			}
		}
		else
			CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CWorldState::Failed to get world state value!");
	}
	else
		CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CWorldState::Failed to get world state value!");

	return result;
}

void CEditorGame::InitDialogBuffersEnum( IGameToEditorInterface* pGTE )
{
	static const char* BUFFERS_FILENAME = "Libs/FlowNodes/DialogFlowNodeBuffers.xml";

	XmlNodeRef xmlNodeRoot = gEnv->pSystem->LoadXmlFromFile( BUFFERS_FILENAME );
	if (xmlNodeRoot==NULL)
	{
		CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CEditorGame::InitDialogBuffersEnum() - Failed to load '%s'. flownode dialog buffers drop down list will be empty.", BUFFERS_FILENAME);
		return;
	}

	uint32 count = xmlNodeRoot->getChildCount();

	const char** bufferNames = new const char*[count];
	bool bOk = true;

	for (uint32 i=0; i<count; ++i)
	{
		XmlNodeRef xmlNode = xmlNodeRoot->getChild( i );
		bufferNames[i] = xmlNode->getAttr("name");
		if (!bufferNames[i])
		{
			CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CEditorGame::InitDialogBuffersEnum() - file: '%s' child: %d is missing the 'name' field. flownode dialog buffers drop down list will be empty", BUFFERS_FILENAME, i);
			bOk = false;
		}
	}
	if (bOk)
		pGTE->SetUIEnums("dialogBuffers", bufferNames, count);
	delete[] bufferNames;
}

/// Force running of the defined test case (ignores dependencies)
void CFeatureTestMgr::ForceRun(const char* testNameFilter)
{
	if (!IsRunning())
	{
		// Ensure no other tests run apart from the selected one
		ResetAllTests(eFTS_Disabled);

		size_t firstTestIndex = ~0;

		for (TFeatureTestVec::iterator iter(m_featureTests.begin()); iter != m_featureTests.end(); ++iter)
		{
			FeatureTestState& ftState = *iter;

			const char* testName = ftState.m_pTest->Name();

			// If test name contains the filter string
			if (strstr(testName, testNameFilter) != NULL)
			{
				ftState.m_state = eFTS_Scheduled;
				
				CryLogAlways("Scheduling test: %s", testName);

				// Store the first valid test found as the one to run first
				if (firstTestIndex == ~0)
					firstTestIndex = std::distance(m_featureTests.begin(), iter);
			}
		}

		if (firstTestIndex != ~0)
		{
			FeatureTestState& ftState = m_featureTests[firstTestIndex];
			ftState.m_state = eFTS_Running;
			m_runningTestIndex = firstTestIndex;
			m_pRunningTest = ftState.m_pTest;
			m_running = true;

			CryLogAlways("Forcefully running Map Tests: %s", m_pRunningTest->Name());

			const float currTime = gEnv->pTimer->GetCurrTime();

			// If test doesn't start
			if (!m_pRunningTest->Start())
			{
				// Reset state
				m_running = false;
				ResetAllTests(eFTS_Disabled);
			}
		}
		else
		{
			CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Unable to find test(s) to run: %s", testNameFilter);
		}
	}
	else
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Tests are already running, can't start: %s", testNameFilter);
	}
}

/// Runs all registered tests (if they meet their dependencies)
void CFeatureTestMgr::RunAll()
{
	// Writing the list of the active registered tests. 
	// This can be useful to later check, when a crash occurs, 
	// which tests were executed and which are skipped 
	// (We will have no valid results for them)
	{
		if(m_pAutoTester && !m_testManifestWritten)
		{
			XmlNodeRef testManifest = GetISystem()->CreateXmlNode("testManifest");
			testManifest->setTag("testmanifest");		

			CryLogAlways("About to dump out the testmanifest xml...");

			for (TFeatureTestVec::iterator iter(m_featureTests.begin()); iter != m_featureTests.end(); ++iter)
			{
				FeatureTestState& fTest = *iter;
				XmlNodeRef testDescrNode = fTest.m_pTest->XmlDescription();
				if(testDescrNode)
				{
					testManifest->addChild(testDescrNode);
				}
				
			}

			m_pAutoTester->WriteTestManifest(testManifest);
			m_testManifestWritten = true;
		}
	}



	if (!IsRunning())
	{
		// Ensure all tests are cleaned up and scheduled to run
		ResetAllTests(eFTS_Scheduled);

		if (StartNextTest() || WaitingForScheduledTests())
		{
			CryLog("Running all map feature tests...");
		}
		else
		{
			CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "No tests available to run!");
		}
	}
	else
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Tests are already running, can't start more until tests are complete.");
	}
}

bool CCheckpointSystem::SaveExternalEntity(EntityId id)
{
	//this function allows external logic (flowgraph) to save specific entities
	if(!CHECKPOINT_SAVE_XML_NODE)
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Tried writing external entity %i while savegame was not open.", (int)id);
		return false;
	}

	//find entity and access external section
	IEntity *pEntity = gEnv->pEntitySystem->GetEntity(id);
	if(pEntity)
	{
		XmlNodeRef externalEntities = CHECKPOINT_SAVE_XML_NODE->findChild(EXTERNAL_ENTITIES_SECTION);
		if(!externalEntities)
		{
			externalEntities = GetISystem()->CreateXmlNode(EXTERNAL_ENTITIES_SECTION);
			CHECKPOINT_SAVE_XML_NODE->addChild(externalEntities);
		}

		IActor *pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pEntity->GetId());
		if(pActor)
		{
			CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "The actor %s is additionally saved as external entity.", pEntity->GetName());
		}

		//create entity data
		char entityId[16];
		_snprintf(entityId, sizeof(entityId), "%s%i", "id", id);
		XmlNodeRef nextEntity = GetISystem()->CreateXmlNode(entityId);
		if(nextEntity)
		{
			nextEntity->setAttr("id", pEntity->GetId());
			nextEntity->setAttr("name", pEntity->GetName());
			//save active / hidden
			nextEntity->setAttr("active", pEntity->IsActive());
			nextEntity->setAttr("hidden", pEntity->IsHidden());
			//save translation and rotation (complete tm matrix for simplicity)
			SerializeWorldTM(pEntity, nextEntity, true);
			//add new entity to checkpoint
			externalEntities->addChild(nextEntity);

			return true;
		}

		return false;
	}

	return false;
}

void CGameQueryListener::ConnectToServer(const char* server)
{
	//first check the version of the server ...
	char myVersion[32];
	GetISystem()->GetProductVersion().ToShortString(myVersion);
	string version(myVersion);

	SGameServer* targetServer = FindServer(server);
	if(!targetServer)
	{
		CryWarning(VALIDATOR_MODULE_NETWORK, VALIDATOR_WARNING, "Selected server not found in list!");
		return;
	}

	if(version.compare(targetServer->GetServerGameVersion()) != 0)
	{
		CryWarning(VALIDATOR_MODULE_NETWORK, VALIDATOR_WARNING, "Game versions differ - not connecting!");
		return;
	}

	string addr(server);
	string port;
	int pos = addr.find(":");
	if(pos != string::npos)	//space for port
	{
		port = addr.substr(pos+1, addr.size()-pos);
		addr.erase(pos, addr.size()-pos);
	}

	IConsole* pConsole = gEnv->pConsole;

	pConsole->GetCVar("cl_serveraddr")->Set(addr.c_str());
	if(port.size() > 0)
		pConsole->GetCVar("cl_serverport")->Set(port.c_str());

	string tempHost = pConsole->GetCVar("cl_serveraddr")->GetString();

	SGameStartParams params;	//this would connect to a server
	params.flags = eGSF_Client;
	params.hostname = tempHost.c_str();
	params.pContextParams = NULL;
	params.port = pConsole->GetCVar("cl_serverport")->GetIVal();

	CCryAction *action = (CCryAction*) (gEnv->pGame->GetIGameFramework());
	if(action)
	{
		gEnv->pConsole->ExecuteString("net_lanbrowser 0");
		action->StartGameContext(&params);
	}
}

    virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
    {
        switch (event)
        {
        case eFE_Initialize:
            break;
        case eFE_Activate:
        {
            if(!IsPortActive(pActInfo, EIP_Load))
                return;

            // get the file name
            string pathAndfileName;
            const string fileName = GetPortString(pActInfo, EIP_FileName);
            if (fileName.empty())
                return;

            ILevelInfo* pCurrentLevel = gEnv->pGame->GetIGameFramework()->GetILevelSystem()->GetCurrentLevel();
            string path = pCurrentLevel ? pCurrentLevel->GetPath() : "";
            pathAndfileName.Format("%s/%s", path.c_str(), fileName.c_str());

            // try to load it
            XmlNodeRef root = GetISystem()->LoadXmlFromFile( pathAndfileName );
            if (root == NULL)
            {
                CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "FlowGraph: TimeOfDay Loading Node: Could not load tod file %s. Aborting.", pathAndfileName.c_str());
                ActivateOutput(pActInfo, EOP_Fail, true);
                return;
            }

            // get the TimeofDay interface
            ITimeOfDay *pTimeOfDay = gEnv->p3DEngine->GetTimeOfDay();
            if (pTimeOfDay == NULL)
            {
                CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "FlowGraph: TimeOfDay Loading Node: Could not obtain ITimeOfDay interface from engine. Aborting.");
                ActivateOutput(pActInfo, EOP_Fail, true);
                return;
            }

            // try to serialize from that file
            pTimeOfDay->Serialize( root,true );
            pTimeOfDay->Update(true, true);

            ActivateOutput(pActInfo, EOP_Success, true);
        }
        break;
        }
    }

	virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
	{
		switch (event)
		{
		case eFE_Initialize:
			break;
		case eFE_Activate:
			IGameFramework* const pGameFramework = gEnv->pGame->GetIGameFramework();
			IGameObject* const pGameObject = pGameFramework->GetGameObject(pActInfo->pEntity->GetId());

			if(IsPortActive(pActInfo, EIP_Enslave) || IsPortActive(pActInfo, EIP_UnEnslave) )
			{
				IAnimatedCharacter* const pAnimChar = pGameObject ? (IAnimatedCharacter*) pGameObject->QueryExtension("AnimatedCharacter") : NULL;
				if(pAnimChar && pAnimChar->GetActionController())
				{
					const EntityId slaveChar = GetPortEntityId(pActInfo, EIP_Slave);
					IGameObject* pSlaveGameObject = pGameFramework->GetGameObject(slaveChar);
					IAnimatedCharacter* pSlaveAnimChar = pSlaveGameObject ? (IAnimatedCharacter*) pSlaveGameObject->QueryExtension("AnimatedCharacter") : NULL;

					if(pSlaveAnimChar && pSlaveAnimChar->GetActionController())
					{
						IAnimationDatabaseManager &dbManager = gEnv->pGame->GetIGameFramework()->GetMannequinInterface().GetAnimationDatabaseManager();
						uint32 db_crc32 = CCrc32::ComputeLowercase(GetPortString(pActInfo, EIP_DB));
						const IAnimationDatabase* db = dbManager .FindDatabase(db_crc32);

						const string& scopeContextName = GetPortString(pActInfo, EIP_ScopeContext);
						const string& requestedScopeContext = scopeContextName.empty() ? "SlaveChar" : scopeContextName;
						const TagID scopeContext = pAnimChar->GetActionController()->GetContext().controllerDef.m_scopeContexts.Find(scopeContextName.c_str());

						pAnimChar->GetActionController()->SetSlaveController(*pSlaveAnimChar->GetActionController(), scopeContext, IsPortActive(pActInfo, EIP_Enslave) ? true : false, db);
						ActivateOutput(pActInfo, EOP_Success, 1 );
					}
					else
					{
						CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "No GameObject or Animated character found for the slave");
						ActivateOutput(pActInfo, EOP_Fail, 1 );
					}
				}
				else
				{
					CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "No GameObject or AnimatedCharacter found");
					ActivateOutput(pActInfo, EOP_Fail, 1 );
				}
			}

			break;
		}
	}

bool CFlowGraphDebugger::RemoveAllBreakpointsForNode(IFlowGraphPtr pFlowgraph, TFlowNodeId nodeID)
{
	CRY_ASSERT(nodeID != InvalidFlowNodeId);

	if (nodeID == InvalidFlowNodeId)
		return false;

	TDebugInfo::iterator iterDebugInfo = m_DebugInfo.find(pFlowgraph);
	if (iterDebugInfo != m_DebugInfo.end())
	{
		TFlowNodesDebugInfo* flownodesDebugInfo = &(*iterDebugInfo).second;
		TFlowNodesDebugInfo::iterator iterNode = flownodesDebugInfo->find(nodeID);

		if (iterNode != flownodesDebugInfo->end())
		{
			flownodesDebugInfo->erase(iterNode);

			for (CListenerSet<IFlowGraphDebugListener*>::Notifier notifier(m_Listeners); notifier.IsValid(); notifier.Next())
			{
				notifier->OnAllBreakpointsRemovedForNode(pFlowgraph, nodeID);
			}

			return true;
		}
	}
	else
	{
		CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Flownode %d is not in debug list [CFlowgraphDebugger::RemoveBreakPointsForNode]", nodeID);
		return false;
	}

	return false;
}

void CFlowNode_AISequenceAction_WeaponHolster::HandleSequenceEvent(AIActionSequence::SequenceEvent sequenceEvent)
{
	switch(sequenceEvent)
	{
	case AIActionSequence::StartAction:
		{
			CRY_ASSERT_MESSAGE(m_actInfo.pEntity, "entity has magically gone");
			if (!m_actInfo.pEntity)
			{
				// the entity has gone for some reason, at least make sure the action gets finished properly and the FG continues
				CancelSequenceAndActivateOutputPort(OutputPort_Done);
				return;
			}

			assert(gEnv && gEnv->pGame && gEnv->pGame->GetIGameFramework() && gEnv->pGame->GetIGameFramework()->GetIActorSystem());
			IActor* pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(m_actInfo.pEntity->GetId());
			if (!pActor)
			{
				CRY_ASSERT_MESSAGE(0, "Provided entity must be an IActor");
				CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Provided entity %s must be an IActor", m_actInfo.pEntity->GetName());
				CancelSequenceAndActivateOutputPort(OutputPort_Done);
				return;
			}

			const bool skipHolsterAnimation = GetPortBool(&m_actInfo, InputPort_SkipHolsterAnimation);
			pActor->HolsterItem(true, !skipHolsterAnimation);
			FinishSequenceActionAndActivateOutputPort(OutputPort_Done);
		}
		break;
	}
}

bool CWriter::FinishWritingFile()
{
	// if this happens, most likely is an overflow of some of the hard coded limits ( which usually is caused by an error in game side ).
	if (m_hasInternalError)
		CryWarning( VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "XMLCPB: ERROR in binary save generation. The savegame is corrupted." );

	if (!m_compressor->m_errorWritingIntoFile)	
	{
		if (!m_rootAddr.IsValid())
			Done();

		assert( m_rootAddr.IsValid() );


		m_mainBuffer.WriteToFile(); // this actually writes only the last data remains, because it has been writing all along the process.
		m_tableTags.WriteToFile();
		m_tableAttrNames.WriteToFile();
		m_tableStrData.WriteToFile();
		m_tableAttrSets.WriteToFile();

		CreateFileHeader(m_compressor->GetFileHeader());

		m_compressor->FlushZLibBuffer();
	}	
	
		
	return !m_compressor->m_errorWritingIntoFile;
}

bool CWriter::WriteAllIntoMemory( uint8* &rpData, uint32& outSize )
{
	if (!m_rootAddr.IsValid())
		Done();

	SFileHeader fileHeader;
	CreateFileHeader(fileHeader);

	outSize = sizeof(fileHeader);
	outSize += m_tableTags.GetDataSize();
	outSize += m_tableAttrNames.GetDataSize();
	outSize += m_tableStrData.GetDataSize();
	outSize += m_tableAttrSets.GetDataSize();
	outSize += m_mainBuffer.GetDataSize();

	if (outSize > 0)
	{
		rpData = (uint8*)realloc((void*)rpData, outSize*sizeof(uint8));

		uint32 uWriteLoc = 0;
		WriteDataIntoMemory( rpData, &fileHeader, sizeof(fileHeader), uWriteLoc);
		m_mainBuffer.WriteToMemory( rpData, uWriteLoc );
		m_tableTags.WriteToMemory( rpData, uWriteLoc );
		m_tableAttrNames.WriteToMemory( rpData, uWriteLoc );
		m_tableStrData.WriteToMemory( rpData, uWriteLoc );
		m_tableAttrSets.WriteToMemory( rpData, uWriteLoc );
	}

	if (m_hasInternalError)
		CryWarning( VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "XMLCPB: ERROR in binary save-into-memory generation. (probably something wrong in a pooled entity). The data will be corrupted" );

	return (outSize > 0);
}

void CProfileOptions::Init()
{
	XmlNodeRef root = GetISystem()->LoadXmlFromFile("libs/config/profiles/default/attributes.xml");
	if(!root)
	{
		CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Failed loading attributes.xml");
		return;
	}

	CGameXmlParamReader reader(root);
	const int childCount = reader.GetUnfilteredChildCount();
	m_allOptions.reserve(childCount);


	for (int i = 0; i < childCount; ++i)
	{
		XmlNodeRef node = reader.GetFilteredChildAt(i);
		if(node)
		{
			AddOption(node);
		}
	}

	IPlayerProfileManager* const profileManager = g_pGame->GetIGameFramework()->GetIPlayerProfileManager();
	CRY_ASSERT_MESSAGE(profileManager != NULL, "IPlayerProfileManager doesn't exist - profile options will not be updated");
	if(profileManager)
		profileManager->AddListener(this, false);
}