//------------------------------------------------------------------------
bool CVehicleActionEntityAttachment::Init(IVehicle *pVehicle, const CVehicleParams &table)
{
	m_pVehicle = pVehicle;

	CVehicleParams entityAttachmentTable = table.findChild("EntityAttachment");

	if(!entityAttachmentTable)
		return false;

	if(entityAttachmentTable.haveAttr("helper"))
		m_pHelper = m_pVehicle->GetHelper(entityAttachmentTable.getAttr("helper"));

	if(entityAttachmentTable.haveAttr("class"))
	{
		IEntityClassRegistry *pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
		assert(pClassRegistry);

		m_entityClassName = entityAttachmentTable.getAttr("class");

		if(IEntityClass *pEntityClass = pClassRegistry->FindClass(m_entityClassName.c_str()))
		{
			SpawnEntity();
			return true;
		}
	}

	return false;
}
//------------------------------------------------------------------------
bool CVehicleActionEntityAttachment::Init(IVehicle* pVehicle, const SmartScriptTable &table)
{
	m_pVehicle = pVehicle;

	SmartScriptTable entityAttachmentTable;
	if (!table->GetValue("EntityAttachment", entityAttachmentTable))
		return false;

	char* pHelperName;
	if (entityAttachmentTable->GetValue("helper", pHelperName))
		m_pHelper = m_pVehicle->GetHelper(pHelperName);

	char* pEntityClassName;
	if (entityAttachmentTable->GetValue("class", pEntityClassName))
	{
		IEntityClassRegistry* pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
		assert(pClassRegistry);

		if (IEntityClass* pEntityClass = pClassRegistry->FindClass(pEntityClassName))
		{
			m_entityClassName = pEntityClassName;

			SpawnEntity();

			return true;
		}
	}

	return false;
}
//------------------------------------------------------------------------
void CVehicleActionEntityAttachment::SpawnEntity()
{
	IEntitySystem* pEntitySystem = gEnv->pEntitySystem;
	assert(pEntitySystem);

	IEntityClassRegistry* pClassRegistry = pEntitySystem->GetClassRegistry();
	assert(pClassRegistry);

	IEntityClass* pEntityClass = pClassRegistry->FindClass(m_entityClassName.c_str());
	if (!pEntityClass)
		return;

	char pEntityName[256];
	_snprintf(pEntityName, 256, "%s_%s", m_pVehicle->GetEntity()->GetName(), m_entityClassName.c_str());
	pEntityName[sizeof(pEntityName)-1] = '\0';

	SEntitySpawnParams params;
	params.sName = pEntityName;
	params.nFlags = ENTITY_FLAG_CLIENT_ONLY;
	params.pClass = pEntityClass;

	IEntity* pEntity = pEntitySystem->SpawnEntity(params, true);
	if (!pEntity)
	{
		m_entityId = 0;
		return;
	}

	m_entityId = pEntity->GetId();

	m_pVehicle->GetEntity()->AttachChild(pEntity);
	pEntity->SetLocalTM(m_pHelper->GetVehicleTM());

	m_isAttached = true;
}
//------------------------------------------------------------------------
CGameRulesCommonDamageHandling::CGameRulesCommonDamageHandling()
: m_pGameRules(NULL)
{
	CryLog("GameRulesCommonDamageHandling::GameRulesCommonDamageHandling()");
	
	IEntityClassRegistry * pClassReg = gEnv->pEntitySystem->GetClassRegistry();
	m_pEnvironmentalWeaponClass = pClassReg->FindClass("EnvironmentalWeapon");
}
Exemplo n.º 5
0
void CMPTutorial::InitEntityClasses()
{
	IEntityClassRegistry* classReg = gEnv->pEntitySystem->GetClassRegistry();
	m_pHQClass = classReg->FindClass("HQ");
	m_pFactoryClass = classReg->FindClass("Factory");
	m_pAlienEnergyPointClass = classReg->FindClass("AlienEnergyPoint");
	m_pPlayerClass = classReg->FindClass("Player");
	m_pTankClass = classReg->FindClass("US_tank");
	m_pTechChargerClass = classReg->FindClass("TechCharger");
	m_pSpawnGroupClass = classReg->FindClass("SpawnGroup");
	m_pSUVClass = classReg->FindClass("Civ_car1");
}
void CFlashUIInventoryNode::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
	if(event == eFE_Activate && IsPortActive(pActInfo, 0))
	{
		IActor* pActor = GetInputActor( pActInfo );
		if(pActor)
		{
			IInventory* pInventory = pActor->GetInventory();
			if(pInventory)
			{
				string weapons = "";
				bool first = true;
				int inv_cap = gEnv->pConsole->GetCVar("i_inventory_capacity")->GetIVal();
				for (int i = 0; i < inv_cap; i++)
				{
					const char* weaponName = pInventory->GetItemString(i);

					if(strcmp(weaponName, "") != 0)
					{
						bool selectable = false;

						//Get the weapon and check if it is a selectable item
						IEntityClassRegistry *pRegistry = gEnv->pEntitySystem->GetClassRegistry();
						EntityId item = pInventory->GetItemByClass(pRegistry->FindClass(weaponName));
						IEntity* pEntity = gEnv->pEntitySystem->GetEntity(item);

						if(pEntity)
						{
							CGameObject * pGameObject = (CGameObject*)pEntity->GetProxy(ENTITY_PROXY_USER);
							CItem* pItem = (CItem*)pGameObject->QueryExtension(pGameObject->GetEntity()->GetClass()->GetName());
							if(pItem)
							{
								selectable = pItem->CanSelect();
							}
						}
						if(selectable)
						{
							if(!first)
								weapons.append(",");
							first = false;
							weapons.append(weaponName);
						}
					}

				}

				ActivateOutput(pActInfo, eO_OnCall, true);
				ActivateOutput(pActInfo, eO_Args, weapons);
			}
		}
	}
}
void CFlashUIGetCompatibleAccessoriesNode ::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
	if(event == eFE_Activate && IsPortActive(pActInfo, 0))
	{
		string accessories = "";
		IActor* pActor = GetInputActor( pActInfo );

		if(pActor)
		{
			IInventory* pInventory = pActor->GetInventory();
			if(pInventory)
			{
				//Get the item ID via the Input string
				const string weapon_name = GetPortString(pActInfo, eI_Weapon);
				IEntityClassRegistry *pRegistery = gEnv->pEntitySystem->GetClassRegistry();
				EntityId item = pInventory->GetItemByClass(pRegistery->FindClass(weapon_name));

				//Fetch the actual weapon via the ID
				IEntity* pEntity = gEnv->pEntitySystem->GetEntity(item);
				if(pEntity)
				{

					CGameObject * pGameObject = (CGameObject*)pEntity->GetProxy(ENTITY_PROXY_USER);
					const char* ext = pGameObject->GetEntity()->GetClass()->GetName();
					CWeapon* pWeapon = (CWeapon*)pGameObject->QueryExtension(pGameObject->GetEntity()->GetClass()->GetName());

					//If the weapon exists, ask for all compatible accessories
					if(pWeapon)
					{
						//All compatible accessories for this weapon
						const DynArray<string> pCompatibleAccessoriesVec = pWeapon->GetCompatibleAccessories();

						bool first = true;
						DynArray<string>::const_iterator it;
						for (it = pCompatibleAccessoriesVec.begin(); it != pCompatibleAccessoriesVec.end(); it++)
						{
							if (!first)
								accessories.append(",");
							accessories.append((*it));
							first = false;
						}
					}
				}
			}
		}

		//return, if 'accessories' is empty, it has no compatible attachments, or the weapon/inventory was invalid
		ActivateOutput(pActInfo, eO_OnCall, true);
		ActivateOutput(pActInfo, eO_Args, accessories);
	}
}
Exemplo n.º 8
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());
			}
		}
	}
}
void CFlashUIGetEquippedAccessoriesNode::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
	if(event == eFE_Activate && IsPortActive(pActInfo, 0))
	{
		string accessories = "";
		IActor* pActor = GetInputActor( pActInfo );

		if(pActor)
		{
			IInventory* pInventory = pActor->GetInventory();
			if(pInventory)
			{

				//Get the item ID via the Input string
				const string weapon_name = GetPortString(pActInfo, eI_Weapon);
				IEntityClassRegistry *pRegistery = gEnv->pEntitySystem->GetClassRegistry();
				EntityId item = pInventory->GetItemByClass(pRegistery->FindClass(weapon_name));

				//Fetch the actual object via the ID
				CGameObject * pGameObject = (CGameObject*)gEnv->pEntitySystem->GetEntity(item)->GetProxy(ENTITY_PROXY_USER);
				const char* ext = pGameObject->GetEntity()->GetClass()->GetName();
				IItem* pWeapon = (IItem*)pGameObject->QueryExtension(pGameObject->GetEntity()->GetClass()->GetName());

				//If the weapon exists, return all equipped attachments in a comma seperated string
				if(pWeapon)
				{
					//All equipped accessories for this weapon weapons
					accessories = static_cast<CItem*>(pWeapon)->GetAttachedAccessoriesString();
				}
			}
		}

		//return, if 'accesories' is empty, it has no attachments, or something was invalid
		ActivateOutput(pActInfo, eO_OnCall, true);
		ActivateOutput(pActInfo, eO_Args, accessories);
	}
}
void CFlashUICheckAccessoryState ::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
	if(event == eFE_Activate && IsPortActive(pActInfo, 0))
	{
		IActor* pActor = GetInputActor( pActInfo );
		bool is_equipped = false;
		bool is_inInventory = false;

		if(pActor)
		{
			IInventory* pInventory = pActor->GetInventory();

			if(pInventory)
			{
				IEntityClassRegistry *pRegistry = gEnv->pEntitySystem->GetClassRegistry();

				//Find the accessory's class in the registry
				const string accessory_name = GetPortString(pActInfo, eI_Accessory);				
				IEntityClass* pClass = pRegistry->FindClass(accessory_name);

				//Check if its in inventory
				if(pInventory->HasAccessory(pClass) != 0)
				{
					is_inInventory = true;
				}	

				//if it is, check if its equipped as well
				if(is_inInventory)
				{
					//Get the weapon ID via the Input string
					const char* weapon_name = GetPortString(pActInfo, eI_Weapon).c_str();
					EntityId item = pInventory->GetItemByClass(pRegistry->FindClass(weapon_name));

					//Fetch the actual weapon via the ID
					IEntity* pEntity = gEnv->pEntitySystem->GetEntity(item);
					if(pEntity)
					{

						CGameObject * pGameObject = (CGameObject*)pEntity->GetProxy(ENTITY_PROXY_USER);
						const char* ext = pGameObject->GetEntity()->GetClass()->GetName();
						CWeapon* pWeapon = (CWeapon*)pGameObject->QueryExtension(pGameObject->GetEntity()->GetClass()->GetName());
						bool selectable = pWeapon->CanSelect();
						if(pWeapon)
						{
							if(pWeapon->GetAccessory(pClass->GetName()) != 0)
							{
								is_equipped = true;
							}					
						}
					}
				}
			}
		}

		if(!is_inInventory)
			ActivateOutput(pActInfo, eO_DontHave, true);
		else if(is_equipped)
			ActivateOutput(pActInfo, eO_Equipped, true);
		else
			ActivateOutput(pActInfo, eO_InInventory, true);

	}
}
Exemplo n.º 11
0
void CClientHitEffectsMP::ProcessEffectInfo(SHitEffectInfoSet& hitEffectSet, XmlNodeRef xmlNode, const char* libraryName)
{
    bool foundDefault = false;
    bool foundMelee = false;
    const uint numEffects = xmlNode->getChildCount();
    IMaterialEffects* pMaterialEffects = gEnv->pMaterialEffects;
    IEntityClassRegistry* pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();

    hitEffectSet.m_effectInfos.reserve(numEffects);

    for (uint i = 0; i < numEffects; i++)
        {
            if(XmlNodeRef childNode = xmlNode->getChild(i))
                {
                    if(const char* nameTag = childNode->getTag())
                        {
                            if(!foundDefault && !strcmp("default", nameTag))
                                {
                                    const char* effectName = childNode->getAttr("effect");

                                    if(effectName)
                                        {
                                            hitEffectSet.m_default = pMaterialEffects->GetEffectIdByName(libraryName, effectName);
                                        }

                                    foundDefault = true;
                                }
                            else if(!foundMelee && !strcmp("melee", nameTag))
                                {
                                    const char* effectName = childNode->getAttr("effect");

                                    if(effectName)
                                        {
                                            hitEffectSet.m_melee = pMaterialEffects->GetEffectIdByName(libraryName, effectName);
                                        }

                                    foundMelee = true;
                                }
                            else
                                {
                                    SHitEffectInfo newInfo;

                                    newInfo.pAmmoClass = pClassRegistry->FindClass(nameTag);

                                    const char* effectName = childNode->getAttr("effect");

                                    if(effectName)
                                        {
                                            newInfo.effectId = pMaterialEffects->GetEffectIdByName(libraryName, effectName);
                                        }

                                    if(newInfo.pAmmoClass && newInfo.effectId)
                                        {
                                            hitEffectSet.m_effectInfos.push_back(newInfo);
                                        }
                                    else
                                        {
                                            if(!newInfo.pAmmoClass)
                                                {
                                                    GameWarning("Class type %s does not exist", nameTag);
                                                }

                                            if(!newInfo.effectId)
                                                {
                                                    GameWarning("Material Effect %s does not exist", effectName ? effectName : "");
                                                }
                                        }
                                }
                        }
                }
        }

    if(!hitEffectSet.m_melee)
        {
            hitEffectSet.m_melee = hitEffectSet.m_default;
        }
}
void CTacticalManager::Serialize(TSerialize ser)
{
	if (ser.IsReading())
	{
		// Serialize tactical points
		ClearAllTacticalPoints();

		uint32 numTacInfoPointsGroups = 0;
		STacticalInterestPoint interestPoint;
		ser.Value("numTacInfoPointsGroups", numTacInfoPointsGroups);
		for (uint32 i = 0; i < numTacInfoPointsGroups; i++) // Reads in according to ETacticalEntityType
		{
			ser.BeginGroup("TacInfoPointsGroup");
			uint32 numTacInfoPoints = 0;
			ser.Value("numTacInfoPoints", numTacInfoPoints);
			if (numTacInfoPoints > 0)
			{
				// Go through all the tac points
				for (size_t j = 0; j < numTacInfoPoints; j++)
				{
					ser.BeginGroup("TacInfoPoint");
					interestPoint.Serialize(ser);
					ser.EndGroup();
					AddTacticalInfoPointData((ETacticalEntityType)i, interestPoint);
				}
			}

			ser.EndGroup();
		}

		// Serialize tac override entities
		m_tacEntityToOverrideEntities.clear();
		uint32 numTacOverrideData = 0;
		ser.Value("numTacOverrideData", numTacOverrideData);
		for (uint32 i = 0; i < numTacOverrideData; i++)
		{
			ser.BeginGroup("TacOverrideData");
			EntityId origEntity = 0;
			EntityId overrideEntity = 0;
			ser.Value("origEntity", origEntity);
			ser.Value("overrideEntity", overrideEntity);
			AddOverrideEntity(origEntity, overrideEntity);

			ser.EndGroup();
		}		

		// Serialize class scanned data
		m_classes.clear();
		uint32 numInterestClasses = 0;
		string interestClassName;
		ser.Value("numInterestClasses", numInterestClasses);
		for (uint32 i = 0; i < numInterestClasses; i++)
		{
			TScanningCount scanningCount;
			ser.BeginGroup("InterestClassData");
			ser.Value("name", interestClassName);
			ser.Value("scanningCount", scanningCount);

			IEntityClassRegistry* pEntityClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
			CRY_ASSERT(pEntityClassRegistry != NULL);
			IEntityClass* pEntityClass = pEntityClassRegistry->FindClass(interestClassName);
			CRY_ASSERT(pEntityClass);
			if (pEntityClass)
			{
				m_classes[pEntityClass] = scanningCount;
			}

			ser.EndGroup();
		}
	}
	else
	{
		// Serialize tactical points
		uint32 numTacInfoPointsGroups = eTacticalEntity_Last;
		ser.Value("numTacInfoPointsGroups", numTacInfoPointsGroups);
		for (uint32 i = 0; i < numTacInfoPointsGroups; i++) // Writes in according to ETacticalEntityType
		{
			ser.BeginGroup("TacInfoPointsGroup");
			TInterestPoints& interestPoints = m_allTacticalPoints[i];
			uint32 numTacInfoPoints = interestPoints.size();
			ser.Value("numTacInfoPoints", numTacInfoPoints);
			if (numTacInfoPoints > 0)
			{
				// Go through all the tac points
				for (uint32 j = 0; j < numTacInfoPoints; j++)
				{
					ser.BeginGroup("TacInfoPoint");
					STacticalInterestPoint& interestPoint = interestPoints[j];
					interestPoint.Serialize(ser);
					ser.EndGroup();
				}
			}

			ser.EndGroup();
		}

		// Serialize tac override entities
		uint32 numTacOverrideData = m_tacEntityToOverrideEntities.size();
		ser.Value("numTacOverrideData", numTacOverrideData);
		TTacticalEntityToOverrideEntities::iterator tactOverrideDataIter = m_tacEntityToOverrideEntities.begin();
		const TTacticalEntityToOverrideEntities::const_iterator tactOverrideDataIterEnd = m_tacEntityToOverrideEntities.end();
		while (tactOverrideDataIter != tactOverrideDataIterEnd)
		{
			EntityId origEntity = tactOverrideDataIter->first;
			EntityId overrideEntity = tactOverrideDataIter->second;
			ser.BeginGroup("TacOverrideData");
			ser.Value("origEntity", origEntity);
			ser.Value("overrideEntity", overrideEntity);
			ser.EndGroup();
			++tactOverrideDataIter;
		}

		// Serialize class scanned data
		uint32 numInterestClasses = m_classes.size();
		ser.Value("numInterestClasses", numInterestClasses);
		TInterestClasses::iterator interestClassesIter = m_classes.begin();
		const TInterestClasses::const_iterator interestClassesIterEnd = m_classes.end();
		while (interestClassesIter != interestClassesIterEnd)
		{
			const IEntityClass* pEntityClass = interestClassesIter->first;
			CRY_ASSERT(pEntityClass);
			TScanningCount scanningCount = interestClassesIter->second;
			ser.BeginGroup("InterestClassData");
			ser.Value("name", pEntityClass->GetName());
			ser.Value("scanningCount", scanningCount);
			ser.EndGroup();
			++interestClassesIter;
		}
	}
}