//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::Init( XmlNodeRef xml )
{
	const int numChildren = xml->getChildCount();
	for (int childIdx = 0; childIdx < numChildren; ++ childIdx)
	{
		XmlNodeRef xmlChild = xml->getChild(childIdx);
		if (!stricmp(xmlChild->getTag(), "SpawnParams"))
		{
			const char *pType = 0;
			if (xmlChild->getAttr("type", &pType))
			{
				if (!stricmp(pType, "avoid"))
				{
					m_spawnPOIType = eSPT_Avoid;
				}
				else
				{
					CryLog("CGameRulesHoldObjectiveBase::Init: ERROR: Unknown spawn point of interest type ('%s')", pType);
				}
				xmlChild->getAttr("distance", m_spawnPOIDistance);
			}
		}
		else if (!stricmp(xmlChild->getTag(), "EffectData"))
		{
			InitEffectData(xmlChild);
		}
	}

	for (int i = 0; i < HOLD_OBJECTIVE_MAX_ENTITIES; ++ i)
	{
		m_entities[i].Reset();
	}
}
void CForceFeedBackSystem::LoadXmlData()
{
	const char* xmlDataFile = "Libs/GameForceFeedback/ForceFeedbackEffects.xml";
	XmlNodeRef rootNode = gEnv->pSystem->LoadXmlFromFile(xmlDataFile);

	if (!rootNode || strcmpi(rootNode->getTag(), "ForceFeedback"))
	{
		FORCEFEEDBACK_LOG("Could not load force feedback system data. Invalid XML file '%s'! ", xmlDataFile);
		return;
	}

	const int childCount = rootNode->getChildCount();
	for (int i = 0; i < childCount; ++i)
	{
		XmlNodeRef childNode = rootNode->getChild(i);

		const char* childTag = childNode->getTag();
		if (strcmp(childTag, "Patterns") == 0)
		{
			LoadPatters(childNode);
		}
		else if (strcmp(childTag, "Envelopes") == 0)
		{
			LoadEnvelopes(childNode);
		}
		else if (strcmp(childTag, "Effects") == 0)
		{
			LoadEffects(childNode);
		}
	}	
}
void CEditorGame::InitGlobalFileEnums(IGameToEditorInterface *pGTE)
{
	// Read in enums stored offline XML. Format is
	// <GlobalEnums>
	//   <EnumName>
	//     <entry enum="someName=someValue" />  <!-- displayed name != value -->
	// 	   <entry enum="someNameValue" />       <!-- displayed name == value -->
	//   </EnumName>
	// </GlobalEnums>
	//
	XmlNodeRef rootNode = GetISystem()->LoadXmlFromFile("Libs/GlobalEnums.xml");

	if (!rootNode || !rootNode->getTag() || stricmp(rootNode->getTag(), "GlobalEnums") != 0)
	{
		// GameWarning("CEditorGame::InitUIEnums: File 'Libs/GlobalEnums.xml' is not a GlobalEnums file");
		return;
	}

	for (int i = 0; i < rootNode->getChildCount(); ++i)
	{
		XmlNodeRef enumNameNode = rootNode->getChild(i);
		const char *enumId = enumNameNode->getTag();

		if (enumId == 0 || *enumId == '\0')
		{
			continue;
		}

		int maxChilds = enumNameNode->getChildCount();

		if (maxChilds > 0)
		{
			// allocate enough space to hold all strings
			const char **nameValueStrings = new const char*[maxChilds];
			int curEntryIndex = 0;

			for (int j = 0; j < maxChilds; ++j)
			{
				XmlNodeRef enumNode = enumNameNode->getChild(j);
				const char *nameValue = enumNode->getAttr("enum");

				if (nameValue != 0 && *nameValue != '\0')
				{
					// put in the nameValue pair
					nameValueStrings[curEntryIndex++] = nameValue;
				}
			}

			// if we found some entries inform CUIDataBase about it
			if (curEntryIndex > 0)
			{
				pGTE->SetUIEnums(enumId, nameValueStrings, curEntryIndex);
			}

			// be nice and free our array
			delete[] nameValueStrings;
		}
	}
}
Exemplo n.º 4
0
void CMovementTransitions::Load()
{
	Reset();

	if (!g_pGame->GetCVars()->g_movementTransitions_enable)
		return;

	string filename = GetXMLFilename();
	XmlNodeRef rootNode = gEnv->pSystem->LoadXmlFromFile(filename.c_str());

	if (!rootNode || strcmpi(rootNode->getTag(), "MovementTransitions"))
	{
		GameWarning("Could not load movement transition data. Invalid XML file '%s'! ", filename.c_str());
		return;
	}

	IItemParamsNode *paramNode = g_pGame->GetIGameFramework()->GetIItemSystem()->CreateParams();
	paramNode->ConvertFromXML(rootNode);

	ReadGeneralParams(paramNode->GetChild("General"));
	bool success = ReadTransitionsParams(paramNode->GetChild("Transitions"));

	paramNode->Release();

	m_isDataValid = success;
}
Exemplo n.º 5
0
	virtual bool Execute(SActivationInfo *pActInfo)
	{
		bool bResult = false;

		SXmlDocument *doc;
		if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
		{
			const char* childName = GetPortString(pActInfo, EIP_Name);
			const int childIndex = GetPortInt(pActInfo, EIP_Index);
			const int childCount = doc->active->getChildCount();
			XmlNodeRef ref = NULL;
			for (int i = 0, realCount = 0; i < childCount; ++i)
			{
				ref = doc->active->getChild(i);
				if (ref && strcmp(ref->getTag(), childName) == 0)
				{
					if (++realCount >= childIndex)
					{
						doc->active->deleteChildAt(i);
						bResult = true;
						break;
					}
				}
			}
		}

		return bResult;
	}
Exemplo n.º 6
0
	virtual bool Execute(SActivationInfo *pActInfo)
	{
		bool bResult = false;

		SXmlDocument *doc;
		if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
		{
			char const* name = GetPortString(pActInfo, EIP_Name);
			if (!name || !name[0])
			{
				doc->active->removeAllChilds();
			}
			else
			{
				const int childCount = doc->active->getChildCount();
				XmlNodeRef ref = NULL;
				for (int i = 0; i < childCount; ++i)
				{
					ref = doc->active->getChild(i);
					if (ref && strcmp(ref->getTag(), name) == 0)
					{
						doc->active->deleteChildAt(i);
					}
				}
			}
			bResult = true;
		}

		return bResult;
	}
void CMFXParticleEffect::LoadParamsFromXml(const XmlNodeRef& paramsNode)
{
	// Xml data format
	/*
	<Particle>
		<Name userdata="..." scale="..." maxdist="..." minscale="..." maxscale="..." maxscaledist="..." attach="...">particle.name</Name>
		<Direction>DirectionType</Direction>
	</Particle>
	*/

  for (int i=0; i<paramsNode->getChildCount(); ++i)
  {
    XmlNodeRef child = paramsNode->getChild(i);
    if (!strcmp(child->getTag(), "Name"))
    {
      SMFXParticleEntry entry;            
      entry.name = child->getContent();

			if (child->haveAttr("userdata"))
				entry.userdata = child->getAttr("userdata");
	      
			if (child->haveAttr("scale"))
				child->getAttr("scale", entry.scale);

			if (child->haveAttr("maxdist"))
				child->getAttr("maxdist", entry.maxdist);

			if (child->haveAttr("minscale"))
				child->getAttr("minscale", entry.minscale);

			if (child->haveAttr("maxscale"))
				child->getAttr("maxscale", entry.maxscale);

			if (child->haveAttr("maxscaledist"))
				child->getAttr("maxscaledist", entry.maxscaledist);

			if (child->haveAttr("attach"))
				child->getAttr("attach", entry.attachToTarget);
	      
			m_particleParams.m_entries.push_back(entry);
    }
  }
  
  SMFXParticleParams::EDirectionType directionType = SMFXParticleParams::eDT_Normal;
	XmlNodeRef dirType = paramsNode->findChild("Direction");
	if (dirType)
	{
		const char *val = dirType->getContent();
		if (!strcmp(val, "Normal"))
		{
			directionType = SMFXParticleParams::eDT_Normal;
		}
		else if (!strcmp(val, "Ricochet"))
		{
			directionType = SMFXParticleParams::eDT_Ricochet;
		}
	}
	m_particleParams.directionType = directionType;
	
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
0
void CWorldState::SetString(const char * entityName,  char * valueName , string value)
{
//	CryLog("CWorldState::SetString()");
	if(worldStateXml)
	{
		XmlNodeRef entityNode = worldStateXml->findChild(entityName);

		if(!entityNode)
		{
			CreateChild(entityName);
			entityNode = worldStateXml->findChild(entityName);
		}
		const uint32 Count = entityNode->getChildCount();

		for (uint32 Index = 0; Index < Count; ++Index)
		{
			XmlNodeRef child = entityNode->getChild(Index);

			if(strcmp(child->getTag(),valueName)==0)
			{
				child->setAttr("value",value);
				worldStateXml->saveToFile(szSaveFile);
				return;
			}
		}

		//CryLog("CWorldState::CreateString()");

		XmlNodeRef child = entityNode->newChild(valueName);
		child->setAttr("value",value);
		worldStateXml->saveToFile(szSaveFile);
	}
	else
		return;
}
void CMFXContainer::BuildChildEffects( const XmlNodeRef& paramsNode )
{
	const CGameXmlParamReader reader(paramsNode);
	const int totalChildCount = reader.GetUnfilteredChildCount();
	const int filteredChildCount = reader.GetFilteredChildCount();

	m_effects.reserve(filteredChildCount);

	for(int i = 0; i < totalChildCount; i++)
	{
		XmlNodeRef currentEffectNode = reader.GetFilteredChildAt(i);
		if (currentEffectNode == NULL)
			continue;

		const char* nodeName = currentEffectNode->getTag();
		if (nodeName == 0 || *nodeName==0)
			continue;

		TMFXEffectBasePtr pEffect = MaterialEffectsUtils::CreateEffectByName(nodeName);
		if (pEffect != NULL)
		{
			pEffect->LoadParamsFromXml(currentEffectNode);
			m_effects.push_back(pEffect);
		}
	}
}
Exemplo n.º 11
0
//-------------------------------------------------------------------------
void CGameRulesStandardState::Init( XmlNodeRef xml )
{
	m_pGameRules = g_pGame->GetGameRules();

	m_state = EGRS_Intro; 
	m_lastReceivedServerState = m_state; 
	m_timeInPostGame = 0.f;
	m_introMessageShown = false;
	m_isStarting = false;
	m_isWaitingForOverrideTimer = false;
	m_startTimerOverrideWait = 0.0f;
	m_timeInCurrentPostGameState = 0.f;
	m_postGameState = ePGS_Unknown;
	m_bHaveNotifiedIntroListeners = false; 
	m_bHasShownHighlightReel = false;

	ChangeState(EGRS_Intro);

	int numChildren = xml->getChildCount();
	for (int i = 0; i < numChildren; ++ i)
	{
		XmlNodeRef xmlChild = xml->getChild(i);
		if (!stricmp(xmlChild->getTag(), "StartStrings"))
		{
			const char *pString = 0;
			if (xmlChild->getAttr("startMatch", &pString))
			{
				m_startMatchString.Format("@%s", pString);
			}
		}
	}
}
Exemplo n.º 12
0
void CAntiCheatManager::LoadAntiCheatVars(XmlNodeRef child)
{
	int numVars = child->getChildCount();
	for (int i=0; i<numVars; ++i)
	{
		XmlNodeRef varsChild = child->getChild(i);
		if (varsChild->isTag("Var"))
		{
			const char* sVarName = varsChild->getAttr("name");
			TAntiCheatVarIdx antiCheatVarIdx = FindAntiCheatVarIdx_Float(sVarName);
			if (antiCheatVarIdx != eAV_Invalid_Float)
			{
				varsChild->getAttr("value", m_cheatVarsFloat[antiCheatVarIdx]);
			}
			else
			{
				antiCheatVarIdx = FindAntiCheatVarIdx_Int(sVarName);
				if (antiCheatVarIdx != eAV_Invalid_Int)
				{
					varsChild->getAttr("value", m_cheatVarsInt[antiCheatVarIdx]);
				}
				else
				{
					CryLog("Unrecognised anti cheat var '%s'", sVarName);
				}
			}
		}
		else
		{
			CryLog("Unrecognised child node '%s'", varsChild->getTag());
		}
	}
}
Exemplo n.º 13
0
void SAmmoParams::LoadExplosion(const XmlNodeRef& ammoParamsNode)
{
	static const int maxExplosions = 4;

	CGameXmlParamReader reader(ammoParamsNode);

	const int childCount = ammoParamsNode->getChildCount();
	//int explosionCount = 0;
	XmlNodeRef explosions[maxExplosions];
	
	int finalExplosionCount = 0;
	for (int i= 0; (i < childCount) && (finalExplosionCount < maxExplosions); ++i)
	{
		XmlNodeRef child = reader.GetFilteredChildAt(i);
		if(child && stricmp(child->getTag(), "explosion") == 0)
		{
			explosions[finalExplosionCount] = child;			
			++finalExplosionCount;
		}
	}

	m_explosion_count = finalExplosionCount;

	if(m_explosion_count)
	{
		pExplosions = new SExplosionParams*[m_explosion_count];
		for(int i = 0; i < m_explosion_count; ++i)
		{
			pExplosions[i] = new SExplosionParams(explosions[i]);
		}

		pExplosion = pExplosions[0];
	}
}
Exemplo n.º 14
0
EAudioRequestStatus CAudioSystemImpl_sdlmixer::ParseAudioFileEntry(XmlNodeRef const pAudioFileEntryNode, SATLAudioFileEntryInfo* const pFileEntryInfo)
{
	EAudioRequestStatus eResult = eARS_FAILURE;

	if ((_stricmp(pAudioFileEntryNode->getTag(), ms_sSDLFileTag) == 0) && (pFileEntryInfo != NPTR))
	{
		char const* const sFileName = pAudioFileEntryNode->getAttr(ms_sSDLCommonAttribute);

		// Currently the SDLMixer Implementation does not support localized files.
		pFileEntryInfo->bLocalized = false;

		if (sFileName != NPTR && sFileName[0] != '\0')
		{
			pFileEntryInfo->sFileName = sFileName;
			pFileEntryInfo->nMemoryBlockAlignment	= m_nMemoryAlignment;
			POOL_NEW(SSDLMixerAudioFileEntryData, pFileEntryInfo->pImplData);

			eResult = eARS_SUCCESS;
		}
		else
		{
			pFileEntryInfo->sFileName = NPTR;
			pFileEntryInfo->nMemoryBlockAlignment	= 0;
			pFileEntryInfo->pImplData = NPTR;
		}
	}

	return eResult;
}
Exemplo n.º 15
0
void CScriptProperties::Assign( XmlNodeRef &propsNode,IScriptTable* pPropsTable )
{
	const char* key    = "";
	const char* value  = "";
	int         nAttrs = propsNode->getNumAttributes();
	for (int attr = 0; attr < nAttrs; attr++)
	{
		if (!propsNode->getAttributeByIndex( attr,&key,&value ))
			continue;

		ScriptVarType varType = pPropsTable->GetValueType(key);
		switch (varType)
		{
		case svtNull:
			break;
		case svtString:
			pPropsTable->SetValue( key,value );
			break;
		case svtNumber:
		{
			float fValue = (float)atof(value);
			pPropsTable->SetValue( key,fValue );
		}
		break;
		case svtBool:
		{
			bool const bValue = (stricmp(value, "true") == 0) || (stricmp(value, "1") == 0);
			pPropsTable->SetValue(key, bValue);
		}
		break;
		case svtObject:
		{
			Vec3 vec;
			propsNode->getAttr(key,vec);
			CScriptVector vecTable;
			pPropsTable->GetValue( key,vecTable );
			vecTable.Set( vec );
			//pPropsTable->SetValue( key,vec );
		}
		break;
		case svtPointer:
		case svtUserData:
		case svtFunction:
			// Ignore invalid property types.
			break;
		}
	}

	for (int i = 0; i < propsNode->getChildCount(); i++)
	{
		XmlNodeRef       childNode = propsNode->getChild(i);
		SmartScriptTable pChildPropTable;
		if (pPropsTable->GetValue(childNode->getTag(),pChildPropTable))
		{
			// Recurse.
			Assign( childNode,pChildPropTable );
		}
	}
}
Exemplo n.º 16
0
//------------------------------------------------------------------------
bool CPlayerProfile::LoadAttributes(const XmlNodeRef& root, int requiredVersion)
{
	int version = 0;
	const bool bHaveVersion = root->getAttr(VERSION_TAG, version);
	
	if (requiredVersion > 0)
	{
		if (bHaveVersion && version < requiredVersion)
		{
			GameWarning("CPlayerProfile::LoadAttributes: Attributes of profile '%s' have different version (%d != %d). Updated.", GetName(), version, requiredVersion);
			return false;
		}
		else if (!bHaveVersion)
		{
			GameWarning("CPlayerProfile::LoadAttributes: Attributes of legacy profile '%s' has no version (req=%d). Loading anyway.", GetName(), requiredVersion);
		}
		m_attributesVersion = requiredVersion;
	}
	else
		// for default profile we set the version we found in the rootNode
		m_attributesVersion = version;

	int nChilds = root->getChildCount();
	for (int i=0; i<nChilds; ++i)
	{
		XmlNodeRef child = root->getChild(i);
		if (child && strcmp(child->getTag(), "Attr") == 0)
		{
			const char* name = child->getAttr("name");
			const char* value = child->getAttr("value");
			const char* platform = child->getAttr("platform");

			bool platformValid = true;
			if(platform != NULL && platform[0])
			{
#if defined(DURANGO)
				platformValid = (strstr(platform, "xbox")!=0);
#elif defined(ORBIS)
				platformValid = (strstr(platform, "ps4")!=0);
#else
				platformValid = (strstr(platform, "pc")!=0);
#endif
			}

			if (name && value && platformValid)
			{
				m_attributeMap[name] = TFlowInputData(string(value));
			}
		}
	}

	if(m_pManager->HasEnabledOnlineAttributes() && m_pManager->CanProcessOnlineAttributes() && !IsDefault())
	{
		m_pManager->LoadOnlineAttributes(this);
	}

	return true;
}
//------------------------------------------------------------------------
void CGameRulesCommonDamageHandling::Init( XmlNodeRef xml )
{
	m_pGameRules = g_pGame->GetGameRules();

	// Reserved hit types - in sync with RESERVED_HIT_TYPES
	/*00*/ //m_pGameRules->RegisterHitType("invalid",							CGameRules::EHitTypeFlag::None);
	/*01*/ m_pGameRules->RegisterHitType("melee",								CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*02*/ m_pGameRules->RegisterHitType("collision",						CGameRules::EHitTypeFlag::Server);
	/*03*/ m_pGameRules->RegisterHitType("frag",								CGameRules::EHitTypeFlag::Server | CGameRules::EHitTypeFlag::AllowPostDeathDamage);
	/*04*/ m_pGameRules->RegisterHitType("explosion",						CGameRules::EHitTypeFlag::Server | CGameRules::EHitTypeFlag::AllowPostDeathDamage);
	/*05*/ m_pGameRules->RegisterHitType("stealthKill",					CGameRules::EHitTypeFlag::Server | CGameRules::EHitTypeFlag::AllowPostDeathDamage);
	/*06*/ m_pGameRules->RegisterHitType("silentMelee",					CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::SinglePlayerOnly | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*07*/ m_pGameRules->RegisterHitType("punish",							CGameRules::EHitTypeFlag::ClientSelfHarm);
	/*08*/ m_pGameRules->RegisterHitType("punishFall",					CGameRules::EHitTypeFlag::ClientSelfHarm);
	/*10*/ m_pGameRules->RegisterHitType("fall",								CGameRules::EHitTypeFlag::ClientSelfHarm);
	/*11*/ m_pGameRules->RegisterHitType("normal",							CGameRules::EHitTypeFlag::Server);	//Used for killing players so they can switch teams
	/*12*/ m_pGameRules->RegisterHitType("fire",								CGameRules::EHitTypeFlag::Server); // used by PressurizedObject.lua
	/*14*/ m_pGameRules->RegisterHitType("heavyBullet",					CGameRules::EHitTypeFlag::ValidationRequired);
	/*18*/ m_pGameRules->RegisterHitType("environmentalThrow",	CGameRules::EHitTypeFlag::CustomValidationRequired | CGameRules::EHitTypeFlag::AllowPostDeathDamage | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*19*/ m_pGameRules->RegisterHitType("meleeLeft",						CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::SinglePlayerOnly | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*20*/ m_pGameRules->RegisterHitType("meleeRight",					CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::SinglePlayerOnly | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*21*/ m_pGameRules->RegisterHitType("meleeKick",						CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::SinglePlayerOnly | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*22*/ m_pGameRules->RegisterHitType("meleeUppercut",				CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::SinglePlayerOnly | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	/*23*/ m_pGameRules->RegisterHitType("vehicleDestruction",	CGameRules::EHitTypeFlag::Server | CGameRules::EHitTypeFlag::AllowPostDeathDamage);
	/*27*/ m_pGameRules->RegisterHitType("eventDamage",					CGameRules::EHitTypeFlag::ClientSelfHarm);
	/*29*/ m_pGameRules->RegisterHitType("environmentalMelee",	CGameRules::EHitTypeFlag::IsMeleeAttack | CGameRules::EHitTypeFlag::CustomValidationRequired | CGameRules::EHitTypeFlag::AllowPostDeathDamage | CGameRules::EHitTypeFlag::IgnoreHeadshots);
	
	CRY_ASSERT(m_pGameRules->GetHitTypesCount() == CGameRules::EHitType::Unreserved);

	// Read any non-native hit_types from the HitTypes.xml file!
	XmlNodeRef xmlNode = gEnv->pSystem->LoadXmlFromFile( "Scripts/Entities/Items/HitTypes.xml" );

	if( xmlNode )
	{
		const int numEntries = xmlNode->getChildCount();
		for (int i = 0; i < numEntries; ++i)
		{
			XmlNodeRef hitTypeXML = xmlNode->getChild(i);

			if (strcmp(hitTypeXML->getTag(), "hit_type") != 0)
				continue;

			if( const char* pHitType = hitTypeXML->getAttr("name") )
			{
				TBitfield flags = CGameRules::EHitTypeFlag::None;

				if( const char * pHitTypeFlags = hitTypeXML->getAttr("flags"))
				{
					flags = AutoEnum_GetBitfieldFromString(pHitTypeFlags, CGameRules::s_hitTypeFlags, CGameRules::EHitTypeFlag::HIT_TYPES_FLAGS_numBits);
				}

				m_pGameRules->RegisterHitType( pHitType, flags );
			}
		}
	}
	m_scriptHitInfo.Create(gEnv->pScriptSystem);
}
Exemplo n.º 18
0
bool CFlowGraphModule::PreLoadModule(const char* fileName)
{
	m_fileName = fileName;

	XmlNodeRef moduleRef = gEnv->pSystem->LoadXmlFromFile(fileName);

	if (!moduleRef)
	{
		CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Unable to preload Flowgraph Module: %s", PathUtil::GetFileName(fileName).c_str());
		return false;
	}

	assert(!stricmp(moduleRef->getTag(), "Graph"));

	bool module = false;
	moduleRef->getAttr("isModule", module);
	assert(module);

	XmlString tempName;
	if (moduleRef->getAttr("moduleName", tempName))
		m_name = tempName;

	bool bResult = (m_pRootGraph != NULL);
	assert(m_pRootGraph == NULL);

	// first handle module ports
	XmlNodeRef modulePorts = moduleRef->findChild("ModuleInputsOutputs");
	RemoveModulePorts();
	if (modulePorts)
	{
		int nPorts = modulePorts->getChildCount();
		for (int i = 0; i < nPorts; ++i)
		{
			XmlString portName;
			int       portType;
			bool      isInput;

			XmlNodeRef port = modulePorts->getChild(i);
			port->getAttr("Name", portName);
			port->getAttr("Type", portType);
			port->getAttr("Input", isInput);

			IFlowGraphModule::SModulePortConfig portConfig;
			portConfig.name  = portName.c_str();
			portConfig.type  = (EFlowDataTypes)portType;
			portConfig.input = isInput;

			AddModulePort(portConfig);
		}
	}

	// and create nodes for this module (needs to be done before actual graph load, so that the
	//	nodes can be created there)
	RegisterNodes();

	return bResult;
}
Exemplo n.º 19
0
void CHUD::LoadWeaponAccessories(XmlNodeRef weaponXmlNode)
{
	if(weaponXmlNode)
	{
		TMapWeaponAccessoriesHelperOffsets mapWeaponAccessoriesHelpersOffsets;

		int iNumChildren = weaponXmlNode->getChildCount();
		for(int iChild=0; iChild<iNumChildren; iChild++)
		{
			XmlNodeRef helperXmlNode = weaponXmlNode->getChild(iChild);
			SWeaponAccessoriesHelpersOffsets offsets;
			offsets.iX = atoi(helperXmlNode->getAttr("X"));
			offsets.iY = atoi(helperXmlNode->getAttr("Y"));
			mapWeaponAccessoriesHelpersOffsets.insert(std::make_pair(helperXmlNode->getTag(),offsets));
		}

		m_mapWeaponAccessoriesHelpersOffsets.insert(std::make_pair(weaponXmlNode->getTag(),mapWeaponAccessoriesHelpersOffsets));
	}
}
Exemplo n.º 20
0
void CD6ArmorManager::LoadFromXML(XmlNodeRef& rootNode)
{
	int childCount = rootNode->getChildCount();
	for (int i = 0; i < childCount; ++i)
	{
		XmlNodeRef node = rootNode->getChild(i);
		if (NULL == node)
			continue;

		if (0 == strcmp(node->getTag(), "Armor"))
		{
			XmlString armorName;
			SArmorDef armorDef;

			// Read the Armor tag's name attribute
			if (!node->getAttr("name", armorName))
				continue;
			armorDef.szArmorName = armorName;

			// Read warheads
			int childCount = node->getChildCount();
			for (int i = 0; i < childCount; ++i)
			{
				XmlNodeRef warhead = node->getChild(i);
				if (0 == strcmp(warhead->getTag(), "Warhead"))
				{
					SArmorWarheadDef warheadDef;
					XmlString name;

					if (!warhead->getAttr("name", name))
						break;
					warheadDef.szWarheadName = name;
					if (!warhead->getAttr("multiplier", warheadDef.fMultiplier))
						warheadDef.fMultiplier = 1.0f;

					armorDef.warheads.push_back(warheadDef);
				}
			}

			m_ArmorDefs.insert(std::make_pair(m_NextArmorId++, armorDef));
		}
	}
}
Exemplo n.º 21
0
SUnlock::SUnlock(XmlNodeRef node, int rank)
{
	m_name[0] = '\0';
	m_rank = rank;
	m_reincarnation = 0;
	m_unlocked = false;
	m_type = eUT_Invalid;

	DesignerWarning(strcmpi(node->getTag(), "unlock") == 0 || strcmpi(node->getTag(), "allow") == 0, "expect tag of unlock or allow at %d", node->getLine());

	const char * theName = node->getAttr("name");
	const char * theType = node->getAttr("type");
	const char * theReincarnationLevel = node->getAttr("reincarnation");

	// These pointers should always be valid... if an attribute isn't found, getAttr returns a pointer to an empty string [TF]
	assert (theName && theType);

	if (theType && theType[0] != '\0')
	{
		m_type = SUnlock::GetUnlockTypeFromName(theType);
		cry_strcpy(m_name, theName);

		bool expectName = (m_type == eUT_Loadout || m_type == eUT_Weapon || m_type == eUT_Attachment || m_type == eUT_Playlist || m_type == eUT_CreateCustomClass);
		bool gotName = (theName[0] != '\0');

		if (expectName != gotName && m_type != eUT_Invalid) // If it's invalid, we'll already have displayed a warning...
		{
			GameWarning("[PROGRESSION] An unlock of type '%s' %s have a name but XML says name='%s'", theType, expectName ? "should" : "shouldn't", theName);
		}
	}
	else
	{
		GameWarning("[PROGRESSION] XML node contains an 'unlock' tag with no type (name='%s')", theName);
	}

	if (theReincarnationLevel != NULL && theReincarnationLevel[0] != '\0')
	{
		m_reincarnation = atoi(theReincarnationLevel);
		CPlayerProgression *pPlayerProgression = CPlayerProgression::GetInstance();
		DesignerWarning(m_reincarnation > 0 && m_reincarnation < pPlayerProgression->GetMaxReincarnations()+1, "Unlock %s reincarnation parameter is outside of the range 0 - %d", theName, pPlayerProgression->GetMaxReincarnations()+1);
	}
}
Exemplo n.º 22
0
//------------------------------------------------------------------------
bool CPlayerProfileImplFS::LoginUser(SUserEntry* pEntry)
{
	// lookup stored profiles of the user (pEntry->userId) and fill in the pEntry->profileDesc
	// vector 
	pEntry->profileDesc.clear();

	// scan directory for profiles

	string path;
	InternalMakeFSPath(pEntry, "", path);  // no profile name -> only path

	ICryPak * pCryPak = gEnv->pCryPak;
	_finddata_t fd;

	path.TrimRight("/\\");
	string search = path + "/*.xml";
	intptr_t handle = pCryPak->FindFirst( search.c_str(), &fd );
	if (handle != -1)
	{
		do
		{
			// fd.name contains the profile name
			string filename = path;
			filename += "/" ;
			filename += fd.name;
			XmlNodeRef rootNode = LoadXMLFile(filename.c_str());

			// see if the root tag is o.k.
			if (rootNode && stricmp(rootNode->getTag(), PROFILE_ROOT_TAG) == 0)
			{
				string profileName = fd.name;
				PathUtil::RemoveExtension(profileName);
				if (rootNode->haveAttr(PROFILE_NAME_TAG))
				{
					const char* profileHumanName = rootNode->getAttr(PROFILE_NAME_TAG);
					if (profileHumanName!=0 && stricmp(profileHumanName, profileName) == 0)
					{
						profileName = profileHumanName;
					}
				}
				pEntry->profileDesc.push_back(SLocalProfileInfo(profileName));
			}
			else
			{
				GameWarning("CPlayerProfileImplFS::LoginUser: Profile '%s' of User '%s' seems to exist, but is invalid (File '%s). Skipped", fd.name, pEntry->userId.c_str(), filename.c_str());
			}
		} while ( pCryPak->FindNext( handle, &fd ) >= 0 );

		pCryPak->FindClose( handle );
	}

	return true;
}
Exemplo n.º 23
0
//--------------------------------------------------------------------------------------------
void CUIObjectives::UpdateObjectiveInfo()
{
	m_ObjectiveMap.clear();

	string path = "Libs/UI/Objectives_new.xml";
	XmlNodeRef missionObjectives = GetISystem()->LoadXmlFromFile( path.c_str() );
	if (missionObjectives == 0)
	{
		gEnv->pLog->LogError("Error while loading MissionObjective file '%s'", path.c_str() );
		return;
	}

	for(int tag = 0; tag < missionObjectives->getChildCount(); ++tag)
	{
		XmlNodeRef mission = missionObjectives->getChild(tag);
		const char* attrib;
		const char* objective;
		const char* text;
		for(int obj = 0; obj < mission->getChildCount(); ++obj)
		{
			XmlNodeRef objectiveNode = mission->getChild(obj);
			string id(mission->getTag());
			id += ".";
			id += objectiveNode->getTag();
			if(objectiveNode->getAttributeByIndex(0, &attrib, &objective) && objectiveNode->getAttributeByIndex(1, &attrib, &text))
			{
				m_ObjectiveMap[ id ].Name = objective;
				m_ObjectiveMap[ id ].Desc = text;
			}
			else
			{
				gEnv->pLog->LogError("Error while loading MissionObjective file '%s'", path.c_str() );
				return;
			}
		}
	}
}
Exemplo n.º 24
0
//---------------------------------------
void CMiscAnnouncer::InitXML(XmlNodeRef root)
{
	IEntityClassRegistry *pEntityClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
	XmlNodeRef onWeaponFiringRoot = root->findChild("OnWeaponFiring");

	CryLog("CMiscAnnouncer::InitXML()");

	if(onWeaponFiringRoot)
	{
		const int numChildren = onWeaponFiringRoot->getChildCount();

		CryLog("CMiscAnnouncer::InitXML() found OnWeaponFiringRoot with %d children", numChildren);
	
		for(int i=0; i<numChildren; ++i)
		{
			XmlNodeRef child = onWeaponFiringRoot->getChild(i);
			if(child->isTag("OnWeaponFired"))
			{
				const char *pWeaponClassName = child->getAttr("weaponClass");
				CRY_ASSERT(pWeaponClassName && pWeaponClassName[0] != 0);

				CryLog("CMiscAnnouncer::InitXML() OnWeaponFired tag - pWeaponClassName=%s", pWeaponClassName ? pWeaponClassName : "NULL");

				if(IEntityClass* pWeaponEntityClass = pEntityClassRegistry->FindClass(pWeaponClassName))
				{
					const char *pAnnouncement = child->getAttr("announcement");
					CRY_ASSERT(pAnnouncement && pAnnouncement[0] != 0);

					EAnnouncementID announcementID = CAnnouncer::NameToID(pAnnouncement);
					
					CryLog("CMiscAnnouncer::InitXML() found weapon entity class for pWeaponClassName=%s; found pAnnouncement=%s announcementID=%x", pWeaponClassName, pAnnouncement ? pAnnouncement : "NULL", announcementID);

					SOnWeaponFired newWeaponFired(pWeaponEntityClass, pAnnouncement, announcementID);
					m_weaponFiredMap.insert(TWeaponFiredMap::value_type(pWeaponEntityClass, newWeaponFired));
				}
				else
				{
					CryLog("CMiscAnnouncer::InitXML() failed to find entityClass for pWeaponClassName=%s", pWeaponClassName);
					CRY_ASSERT_MESSAGE(0, string().Format("CMiscAnnouncer::InitXML() failed to find entityClass for pWeaponClassName=%s", pWeaponClassName));
				}
			}
			else
			{
				CryLog("CMiscAnnouncer::InitXML() unhandled childtag of %s found", child->getTag());
			}
		}
	}
}
Exemplo n.º 25
0
bool CItemParamsNode::ConvertFromXMLWithFiltering(const XmlNodeRef &root, const char * keepWithThisAttrValue)
{
	bool filteringRequired = false;
	int nattributes = root->getNumAttributes();
	m_attributes.reserve(nattributes);
	for (int a=0; a<nattributes; a++)
	{
		const char *name=0;
		const char *value=0;
		if (root->getAttributeByIndex(a, &name, &value))
		{
			float f;
			int i;
			Vec3 v;
			if (!stricmp(value, "true"))
				SetAttribute(name, 1);
			else if (!stricmp(value, "false"))
				SetAttribute(name, 0);
			else if (IsInteger(value, &i))
				SetAttribute(name, i);
			else if (IsFloat(value, &f))
				SetAttribute(name, f);
			else if (IsVec3(value, &v))
				SetAttribute(name, v);
			else
				SetAttribute(name, value);
		}
	}

	int nchildren = root->getChildCount();
	m_children.reserve(nchildren);
	for (int c=0; c<nchildren; c++)
	{
		XmlNodeRef child = root->getChild(c);
		EXMLFilterType filterType = ShouldConvertNodeFromXML(child, keepWithThisAttrValue);
		filteringRequired = (filterType != eXMLFT_none) || filteringRequired ? true : false;

		if(filterType != eXMLFT_remove)
		{
			filteringRequired = (InsertChild(child->getTag())->ConvertFromXMLWithFiltering(child, keepWithThisAttrValue) || filteringRequired);
		}		
	}

	return filteringRequired;
}
Exemplo n.º 26
0
bool CFlowGraphModule::LoadModuleGraph(const char* moduleName, const char* fileName)
{
	assert(m_name == moduleName);
	assert(m_fileName == fileName);

	XmlNodeRef moduleRef = gEnv->pSystem->LoadXmlFromFile(fileName);

	if (!moduleRef)
	{
		CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Unable to load Flowgraph Module Graph: %s", moduleName);
		return false;
	}

	assert(!stricmp(moduleRef->getTag(), "Graph"));

	bool module = false;
	moduleRef->getAttr("isModule", module);
	assert(module);

	bool bResult = (m_pRootGraph != NULL);
	assert(m_pRootGraph == NULL);

	if (!m_pRootGraph)
	{
		IFlowSystem* pSystem = gEnv->pFlowSystem;
		assert(pSystem);

		// Create graph
		m_pRootGraph = pSystem->CreateFlowGraph();
		if (m_pRootGraph)
		{
			m_pRootGraph->SerializeXML(moduleRef, true);

			// Root graph is for cloning, so not active!
			m_pRootGraph->UnregisterFromFlowSystem();
			m_pRootGraph->SetEnabled(false);
			m_pRootGraph->SetActive(false);
			bResult = true;
		}
	}

	return bResult;
}
Exemplo n.º 27
0
void GetArchetypesFromLevelLib(XmlNodeRef root, std::vector<string>* archetypeNames)
{
	if (!root)
		return;

	string sRootName;
	sRootName = root->getTag();

	XmlNodeRef pLevelNode = root->findChild("EntityPrototypesLibs");
	
	if (!pLevelNode)
		return;

	XmlNodeRef pLevelLibrary = pLevelNode->findChild("LevelLibrary");
	
	if (!pLevelLibrary)
		return;

	GetArchetypesFromLib(pLevelLibrary, sRootName, archetypeNames);
}
Exemplo n.º 28
0
void GetArchetypesFromLib(XmlNodeRef root, string& name, std::vector<string>* archetypeNames)
{
	if (!root)
		return;

	const int iChildCount = root->getChildCount();
	for (int iChild = 0; iChild < iChildCount; ++iChild)
	{
		XmlNodeRef pChild = root->getChild(iChild);
		if (!pChild || stricmp(pChild->getTag(), "EntityPrototype"))
			continue;

		XmlString sChildName;
		pChild->getAttr("Name", sChildName);

		string sFullName;
		sFullName.Format("%s.%s", name.c_str(), sChildName.c_str());
		archetypeNames->push_back(sFullName);
	}
}
Exemplo n.º 29
0
bool CEntityPoolSignature::CompareNodes(const XmlNodeRef &a, const XmlNodeRef &b, bool bRecursive)
{
	FUNCTION_PROFILER(GetISystem(), PROFILE_ENTITY);

	assert(bool(a));
	assert(bool(b));

	bool bResult = (a && b && a->isTag(b->getTag()));

	// Check value
	bResult &= (bResult && 0 == strcmp(a->getContent(), b->getContent()));

	// Check attributes
	bResult &= (bResult && CompareNodeAttributes(a, b));

	// Check children if recursive
	if (bResult && bRecursive)
	{
		const int childCount_a = a->getChildCount();
		const int childCount_b = b->getChildCount();
		bResult &= (childCount_a == childCount_b);

		if (bResult)
		{
			for (int child = 0; bResult && child < childCount_a; ++child)
			{
				XmlNodeRef child_a = a->getChild(child);
				XmlNodeRef child_b = b->getChild(child);
				if (child_a && child_b)
				{
					bResult &= CompareNodes(child_a, child_b, true);
				}
			}
		}
	}

	return bResult;
}
Exemplo n.º 30
0
void CWorldState::RemoveEntity(const char * entityName)
{
	if(worldStateXml)
	{
		CryLog("CWorldState::RemoveEntity()");

		const uint32 Count = worldStateXml->getChildCount();

		for (uint32 Index = 0; Index < Count; ++Index)
		{
			XmlNodeRef child = worldStateXml->getChild(Index);

			if(strcmp(child->getTag(),entityName)==0)
			{
				worldStateXml->deleteChildAt(Index);
			}
		}

		worldStateXml->saveToFile(szSaveFile);
	}
	else
		return;
}