bool CScriptRMI::SerializeScript( TSerialize ser, IEntity * pEntity ) { SSerializeFunctionParams p( ser, pEntity ); ScriptHandle hdl( &p ); IScriptTable * pTable = pEntity->GetScriptTable(); if (pTable) { SmartScriptTable serTable; SmartScriptTable synchedTable; pTable->GetValue( "synched", synchedTable ); if (synchedTable.GetPtr()) { synchedTable->GetValue( HIDDEN_FIELD, serTable ); if (serTable.GetPtr()) { IScriptSystem * pScriptSystem = pTable->GetScriptSystem(); pScriptSystem->BeginCall( serTable.GetPtr(), SERIALIZE_FUNCTION ); pScriptSystem->PushFuncParam( serTable ); pScriptSystem->PushFuncParam( hdl ); return pScriptSystem->EndCall(); } } } return true; }
void CBaseManagerEntitySink::OnSpawn(IEntity *pEntity, SEntitySpawnParams ¶ms) { // Check if it has a CNC Table. If it does, manually add it to the controller IScriptTable *pTable; if (NULL != pEntity && NULL != (pTable = pEntity->GetScriptTable())) { // Get property table SmartScriptTable props, cncbuilding; if (true == pTable->GetValue("Properties", props) && true == props->GetValue("CNCBuilding", cncbuilding)) { // Extract and build GUID char const* szTeam = 0; char const* szClass = 0; cncbuilding->GetValue("Team", szTeam); cncbuilding->GetValue("Class", szClass); BuildingGUID GUID = m_pManager->GenerateGUID(szTeam, szClass); if (GUID_INVALID != GUID) { // Get controller and manually add it IBuildingController *pController = m_pManager->FindBuildingController(GUID); if (NULL != pController) pController->AddInterface(pEntity); } } } }
const char *CAnimatedCharacterSample::GetCharacterModelNameFromScriptTable() const { IEntity *pEntity = GetEntity(); IScriptTable *pScriptTable = pEntity->GetScriptTable(); if(pScriptTable == NULL) { return NULL; } SmartScriptTable propertiesTable; const bool hasPropertiesTable = pScriptTable->GetValue("Properties", propertiesTable); if(! hasPropertiesTable) { return NULL; } const char *modelName = NULL; const bool hasModelName = propertiesTable->GetValue("objModel", modelName); if(! hasModelName) { return NULL; } return modelName; }
static bool GetTeamRadioTable(CGameRules *gr, const string &team_name, SmartScriptTable &out_table) { if(!gr) { return false; } IScriptTable *pTable = gr->GetEntity()->GetScriptTable(); if(!pTable) { return false; } SmartScriptTable pTeamRadio; if(!pTable->GetValue("teamRadio", pTeamRadio)) { return false; } if(!pTeamRadio->GetValue(team_name, out_table)) { return false; } return true; }
//------------------------------------------------------------------------ void CScriptBind_Inventory::DetachFrom(CInventory* pInventory) { IScriptTable *pScriptTable = pInventory->GetEntity()->GetScriptTable(); if (pScriptTable) pScriptTable->SetToNull("inventory"); }
IScriptTable* ScriptSystem::createScriptTable() { IScriptTable* table = new IScriptTable; table->mKeyTable = &mKeyTable; table->addRef(); return table; }
void CProceduralContextAim::InitialisePoseBlenderAim() { CRY_ASSERT( m_entity ); const int slot = 0; ICharacterInstance* pCharacterInstance = m_entity->GetCharacter( slot ); if ( pCharacterInstance == NULL ) { return; } ISkeletonPose* pSkeletonPose = pCharacterInstance->GetISkeletonPose(); if ( pSkeletonPose == NULL ) { return; } m_pPoseBlenderAim = pSkeletonPose->GetIPoseBlenderAim(); if ( m_pPoseBlenderAim ) { m_defaultPolarCoordinatesSmoothTimeSeconds = 0.1f; float polarCoordinatesMaxYawDegreesPerSecond = 360.f; float polarCoordinatesMaxPitchDegreesPerSecond = 360.f; float fadeInSeconds = 0.25f; float fadeOutSeconds = 0.25f; float fadeOutMinDistance = 0.f; IScriptTable* pScriptTable = m_entity->GetScriptTable(); if ( pScriptTable ) { SmartScriptTable pProceduralContextAimTable; pScriptTable->GetValue( "ProceduralContextAim", pProceduralContextAimTable ); if ( pProceduralContextAimTable ) { pProceduralContextAimTable->GetValue( "polarCoordinatesSmoothTimeSeconds", m_defaultPolarCoordinatesSmoothTimeSeconds ); pProceduralContextAimTable->GetValue( "polarCoordinatesMaxYawDegreesPerSecond", polarCoordinatesMaxYawDegreesPerSecond ); pProceduralContextAimTable->GetValue( "polarCoordinatesMaxPitchDegreesPerSecond", polarCoordinatesMaxPitchDegreesPerSecond ); pProceduralContextAimTable->GetValue( "fadeInSeconds", fadeInSeconds ); pProceduralContextAimTable->GetValue( "fadeOutSeconds", fadeOutSeconds ); pProceduralContextAimTable->GetValue( "fadeOutMinDistance", fadeOutMinDistance ); } } m_defaultPolarCoordinatesMaxSmoothRateRadiansPerSecond = Vec2( DEG2RAD( polarCoordinatesMaxYawDegreesPerSecond ), DEG2RAD( polarCoordinatesMaxPitchDegreesPerSecond ) ); m_pPoseBlenderAim->SetPolarCoordinatesSmoothTimeSeconds( m_defaultPolarCoordinatesSmoothTimeSeconds ); m_pPoseBlenderAim->SetPolarCoordinatesMaxRadiansPerSecond( m_defaultPolarCoordinatesMaxSmoothRateRadiansPerSecond ); m_pPoseBlenderAim->SetFadeInSpeed( fadeInSeconds ); m_pPoseBlenderAim->SetFadeOutSpeed( fadeOutSeconds ); m_pPoseBlenderAim->SetFadeOutMinDistance( fadeOutMinDistance ); m_pPoseBlenderAim->SetState( false ); } }
bool CTornado::Reset() { //Initialize default values before (in case ScriptTable fails) m_wanderSpeed = 10.0f; m_cloudHeight = 376.0f; m_radius = 300.0f; m_spinImpulse = 9.0f; m_attractionImpulse = 13.0f; m_upImpulse = 18.0f; const char* funnelEffect = 0; SmartScriptTable props; IScriptTable* pScriptTable = GetEntity()->GetScriptTable(); if(!pScriptTable || !pScriptTable->GetValue("Properties", props)) return false; props->GetValue("fWanderSpeed", m_wanderSpeed); props->GetValue("fCloudHeight", m_cloudHeight); props->GetValue("Radius", m_radius); props->GetValue("fSpinImpulse", m_spinImpulse); props->GetValue("fAttractionImpulse", m_attractionImpulse); props->GetValue("fUpImpulse", m_upImpulse); props->GetValue("FunnelEffect", funnelEffect); if (!UseFunnelEffect(funnelEffect)) return false; Matrix34 m = GetEntity()->GetWorldTM(); m_wanderDir = m.GetColumn(1)*0.414214f; m_isOnWater = false; m_isInAir = false; m_nextEntitiesCheck = 0; Vec3 pos = GetEntity()->GetWorldPos(); gEnv->pLog->Log("TORNADO INIT POS: %f %f %f", pos.x, pos.y, pos.z); m_points[0] = pos; m_points[1] = pos + Vec3(0,0,m_cloudHeight/8.0f); m_points[2] = pos + Vec3(0,0,m_cloudHeight/2.0f); m_points[3] = pos + Vec3(0,0,m_cloudHeight); for (int i=0; i<4; ++i) m_oldPoints[i] = m_points[i]; m_currentPos = GetEntity()->GetWorldPos(); CHANGED_NETWORK_STATE(this, POSITION_ASPECT); UpdateTornadoSpline(); return true; }
//------------------------------------------------------------------------ void CScriptBind_MatchMaking::AttachTo( CMatchMakingHandler* pMatchMaking, CGameLobbyManager *pLobbyManager ) { m_pLobbyManager = pLobbyManager; IScriptTable *pScriptTable = pMatchMaking->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("bindings", thisTable); } }
bool CSmartMine::ShouldStartTrackingEntity( const EntityId entityId ) const { // Always track player... if (entityId == g_pGame->GetIGameFramework()->GetClientActorId()) { return true; } // ... or any AI const SAutoaimTarget* pTargetInfo = g_pGame->GetAutoAimManager().GetTargetInfo( entityId ); if(pTargetInfo != NULL) { return (pTargetInfo->pActorWeak.lock() != NULL); } // Also track kickable and pickable objects IEntity* pEntity = gEnv->pEntitySystem->GetEntity( entityId ); IScriptTable* pScriptTable = (pEntity != NULL) ? pEntity->GetScriptTable() : NULL; if(pScriptTable != NULL) { SmartScriptTable propertiesTable; if(pScriptTable->GetValue("Properties", propertiesTable)) { int pickable = 0, kickable = 0; propertiesTable->GetValue("bPickable", pickable); propertiesTable->GetValue("bInteractLargeObject", kickable); if(pickable) { // Filter out items/weapons pickable = (g_pGame->GetIGameFramework()->GetIItemSystem()->GetItem(entityId) == NULL); } if (pickable || kickable) { //Check if object is moving IPhysicalEntity* pEntityPhysics = pEntity->GetPhysics(); if(pEntityPhysics != NULL) { pe_status_dynamics entityDynamics; if(pEntityPhysics->GetStatus(&entityDynamics)) { return (entityDynamics.v.len2() > 0.1f); } } } } } return false; }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Activate: { IActor* pActor = GetAIActor(pActInfo); if (!pActor) break; IEntity* pEnt = pActor->GetEntity(); if (!pEnt) break; HSCRIPTFUNCTION func = 0; int ret = 0; IScriptTable* pTable = pEnt->GetScriptTable(); if (!pTable) break; if (IsPortActive(pActInfo, 1) && pTable->GetValue("GrabObject", func)) { IEntity* pObj = gEnv->pEntitySystem->GetEntity( GetPortEntityId(pActInfo, 0) ); if (pObj) { IScriptTable* pObjTable = pObj->GetScriptTable(); Script::CallReturn(gEnv->pScriptSystem, func, pTable, pObjTable, ret); } ActivateOutput(pActInfo, 0, ret); } else if (IsPortActive(pActInfo, 2) && pTable->GetValue("DropObject", func)) { bool bThrow = GetPortBool(pActInfo, 3); Script::CallReturn(gEnv->pScriptSystem, func, pTable, bThrow, ret); ActivateOutput(pActInfo, 0, ret); } if (pTable->GetValue("GetGrabbedObject", func)) { ScriptHandle sH(0); Script::CallReturn(gEnv->pScriptSystem, func, pTable, sH); ActivateOutput(pActInfo, 1, EntityId(sH.n)); } if(func) gEnv->pScriptSystem->ReleaseFunc(func); break; } } }
// for editor only static void OnSysSpecLightChange( ICVar *pVar ) { IEntityItPtr it = GetIEntitySystem()->GetEntityIterator(); it->MoveFirst(); while(IEntity *pEntity = it->Next()) { IScriptTable *pScriptTable = pEntity->GetScriptTable(); if (pScriptTable && pScriptTable->HaveValue("OnSysSpecLightChanged")) { Script::CallMethod( pScriptTable, "OnSysSpecLightChanged" ); } } }
void CVicinityDependentObjectMover::SetupEntity() { const char* szModelName = VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL; float fMoveToDistance = 10.0f; float fAreaTriggerRange = 10.0f; float fBackAreaTriggerRange = 10.0f; float fForceMoveCompleteDistance = 1.0f; IEntity* pEntity = GetEntity(); CRY_ASSERT( pEntity != NULL ); IScriptTable* pScriptTable = pEntity->GetScriptTable(); if ( pScriptTable != NULL ) { SmartScriptTable propertiesTable; if ( pScriptTable->GetValue( "Properties", propertiesTable) ) { propertiesTable->GetValue( "objModel", szModelName ); propertiesTable->GetValue( "fMoveToDistance", fMoveToDistance ); propertiesTable->GetValue( "fMoveToSpeed", m_fMoveToSpeed ); propertiesTable->GetValue( "fMoveBackSpeed", m_fMoveBackSpeed ); propertiesTable->GetValue( "fAreaTriggerRange", fAreaTriggerRange ); propertiesTable->GetValue( "fBackAreaTriggerRange", fBackAreaTriggerRange ); propertiesTable->GetValue( "fForceMoveCompleteDistance", fForceMoveCompleteDistance ); propertiesTable->GetValue( "bUseAreaTrigger", m_bUseAreaTrigger ); propertiesTable->GetValue( "bDisableAreaTriggerOnMoveComplete", m_bDisableAreaTriggerOnMoveComplete ); } } m_fMoveToDistance = fMoveToDistance; m_fMoveToDistanceSq = fMoveToDistance*fMoveToDistance; m_fAreaTriggerRange = fAreaTriggerRange; m_fAreaTriggerRangeSq = fAreaTriggerRange*fAreaTriggerRange; m_fBackAreaTriggerRange = fBackAreaTriggerRange; m_fBackAreaTriggerRangeSq = fBackAreaTriggerRange*fBackAreaTriggerRange; m_fForceMoveCompleteDistanceSq = fForceMoveCompleteDistance*fForceMoveCompleteDistance; // Load model pEntity->LoadGeometry( VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT, szModelName ); // Draw slot and physicalize it DrawSlot( VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT, true ); SEntityPhysicalizeParams physicalizeParams; physicalizeParams.nSlot = VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT; physicalizeParams.type = PE_RIGID; physicalizeParams.mass = 0; GetEntity()->Physicalize( physicalizeParams ); }
//------------------------------------------------------------------------ void CScriptBind_Item::AttachTo(CItem *pItem) { IScriptTable *pScriptTable = pItem->GetEntity()->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->SetValue("__this", ScriptHandle(pItem->GetEntityId())); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("item", thisTable); } }
//------------------------------------------------------------------------ void CScriptBind_Actor::AttachTo(CActor *pActor) { IScriptTable *pScriptTable = pActor->GetEntity()->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->SetValue("__this", ScriptHandle(pActor->GetEntityId())); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("actor", thisTable); } }
//------------------------------------------------------------------------ void CScriptBind_Weapon::AttachTo(CWeapon *pWeapon) { IScriptTable *pScriptTable = ((CItem *)pWeapon)->GetEntity()->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->SetValue("__this", ScriptHandle(pWeapon->GetEntityId())); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("weapon", thisTable); } }
//------------------------------------------------------------------------ void CScriptBind_Inventory::AttachTo(CInventory* pInventory) { IScriptTable *pScriptTable = pInventory->GetEntity()->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->SetValue("__this", ScriptHandle(pInventory)); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("inventory", thisTable); } }
//------------------------------------------------------------------------ void CVehicleDamageBehaviorBlowTire::OnVehicleEvent(EVehicleEvent event, const SVehicleEventParams& params) { assert(event == eVE_Timer); // notify AI passengers IScriptTable* pTable = m_pVehicle->GetEntity()->GetScriptTable(); HSCRIPTFUNCTION scriptFunction(NULL); if (pTable && pTable->GetValue("OnVehicleImmobilized", scriptFunction) && scriptFunction) { Script::Call(gEnv->pScriptSystem, scriptFunction, pTable); gEnv->pScriptSystem->ReleaseFunc(scriptFunction); } }
//------------------------------------------------------------------------ void CGameRulesHoldObjectiveBase::CleanUpEntity(SHoldEntityDetails *pDetails) { CCCPOINT(HoldObjective_CleanUpActiveCaptureEntity); if (pDetails->m_localPlayerIsWithinRange) { CHUDEventDispatcher::CallEvent(SHUDEvent(eHUDEvent_OnSiteAboutToExplode)); } OnRemoveHoldEntity(pDetails); gEnv->pEntitySystem->RemoveEntityEventListener(pDetails->m_id, ENTITY_EVENT_ENTERAREA, this); gEnv->pEntitySystem->RemoveEntityEventListener(pDetails->m_id, ENTITY_EVENT_LEAVEAREA, this); if (m_spawnPOIType == eSPT_Avoid) { IGameRulesSpawningModule *pSpawningModule = g_pGame->GetGameRules()->GetSpawningModule(); if (pSpawningModule) { pSpawningModule->RemovePOI(pDetails->m_id); } } IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pDetails->m_id); if (pEntity) { IScriptTable *pScript = pEntity->GetScriptTable(); if (pScript != NULL && pScript->GetValueType("DeactivateCapturePoint") == svtFunction) { IScriptSystem *pScriptSystem = gEnv->pScriptSystem; pScriptSystem->BeginCall(pScript, "DeactivateCapturePoint"); pScriptSystem->PushFuncParam(pScript); pScriptSystem->PushFuncParam(true); pScriptSystem->EndCall(); } CGameRules *pGameRules = g_pGame->GetGameRules(); EGameMode gamemode = pGameRules->GetGameMode(); if (gamemode == eGM_CrashSite) { Announce("Destruct", k_announceType_CS_Destruct); } } pDetails->Reset(); // Fade out effect m_effectData.alphaLerp.Set(1.0f,0.0f,0.0f); }
//------------------------------------------------------------------------ void CScriptBind_Vehicle::AttachTo(IVehicle *pVehicle) { IScriptTable *pScriptTable = pVehicle->GetEntity()->GetScriptTable(); if (!pScriptTable) return; SmartScriptTable thisTable(gEnv->pScriptSystem); thisTable->SetValue("vehicleId", ScriptHandle(pVehicle->GetEntityId())); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("vehicle", thisTable); SmartScriptTable seatTable(gEnv->pScriptSystem); pScriptTable->SetValue("Seats", seatTable); }
void CScriptBind_NetworkBuilding::AttachTo( CNetworkBuilding *pInteractiveObject ) { IScriptTable *pScriptTable = pInteractiveObject->GetEntity()->GetScriptTable(); if (pScriptTable) { SmartScriptTable thisTable(m_pSS); thisTable->SetValue("__this", ScriptHandle(pInteractiveObject->GetEntityId())); thisTable->Delegate(GetMethodsTable()); pScriptTable->SetValue("networkBuilding", thisTable); } m_NetworkBuildingMap.insert(TNetworkBuildingMap::value_type(pInteractiveObject->GetEntityId(), pInteractiveObject)); }
void CLuaRemoteDebug::SendVariables() { m_sendBuffer.Write((char)ePT_LuaVariables); m_sendBuffer.Write((uint8)sizeof(void*)); // Serialise out the size of pointers to cope with 32 and 64 bit systems // Local variables IScriptTable* pLocalVariables = m_pScriptSystem->GetLocalVariables(); if (pLocalVariables) { SerializeLuaTable(pLocalVariables, m_sendBuffer, 8); pLocalVariables->Release(); pLocalVariables = NULL; } SendBuffer(); }
void CDangerousRigidBody::Reset() { IScriptTable* pTable = GetEntity()->GetScriptTable(); if (pTable != NULL) { SmartScriptTable propertiesTable; if (pTable->GetValue("Properties", propertiesTable)) { propertiesTable->GetValue("bCurrentlyDealingDamage", m_dangerous); propertiesTable->GetValue("bDoesFriendlyFireDamage", m_friendlyFireEnabled); propertiesTable->GetValue("fDamageToDeal", m_damageDealt); propertiesTable->GetValue("fTimeBetweenHits", m_timeBetweenHits); } } m_activatorTeam = 0; m_lastHitTime = 0; }
void CBoidFish::SpawnParticleEffect( const Vec3 &pos,SBoidContext &bc,int nEffect ) { if (!bc.entity) return; IScriptTable *pEntityTable = bc.entity->GetScriptTable(); if (!pEntityTable) return; if (!m_pOnSpawnBubbleFunc) { pEntityTable->GetValue( "OnSpawnBubble",m_pOnSpawnBubbleFunc ); } if (!m_pOnSpawnSplashFunc) { pEntityTable->GetValue( "OnSpawnSplash",m_pOnSpawnSplashFunc ); } HSCRIPTFUNCTION pScriptFunc = NULL; switch (nEffect) { case SPAWN_BUBBLE: pScriptFunc = m_pOnSpawnBubbleFunc; break; case SPAWN_SPLASH: pScriptFunc = m_pOnSpawnSplashFunc; break; } if (pScriptFunc) { if (!vec_Bubble) { vec_Bubble = gEnv->pScriptSystem->CreateTable(); } { CScriptSetGetChain bubbleChain(vec_Bubble); bubbleChain.SetValue( "x",pos.x ); bubbleChain.SetValue( "y",pos.y ); bubbleChain.SetValue( "z",pos.z ); } Script::Call( gEnv->pScriptSystem,pScriptFunc,pEntityTable,pos ); } }
const char* CDoorPanelBehavior::GetDestroyedExplosionType( IEntity* pEntity ) { CRY_ASSERT(pEntity != NULL); const char* szModelDestroyedName = DOOR_PANEL_MODEL_DESTROYED; IScriptTable* pScriptTable = pEntity->GetScriptTable(); if (pScriptTable != NULL) { SmartScriptTable propertiesTable; if (pScriptTable->GetValue("Properties", propertiesTable)) { propertiesTable->GetValue("DestroyedExplosionType", szModelDestroyedName); } } return szModelDestroyedName; }
//------------------------------------------------------------------------ bool CShake::Init(IGameObject *pGameObject) { SetGameObject(pGameObject); //Initialize default values before (in case ScriptTable fails) m_radius = 30.0f; m_shake = 0.05f; SmartScriptTable props; IScriptTable* pScriptTable = GetEntity()->GetScriptTable(); if(!pScriptTable || !pScriptTable->GetValue("Properties", props)) return false; props->GetValue("Radius", m_radius); props->GetValue("Shake", m_shake); return true; }
//------------------------------------------------------------------------ void CGameRulesKingOfTheHillObjective::OnChangedTeam( EntityId entityId, int oldTeamId, int newTeamId ) { BaseType::OnChangedTeam(entityId, oldTeamId, newTeamId); if ((g_pGame->GetIGameFramework()->GetClientActorId() == entityId) && newTeamId) { // Local player has changed teams, reset icons int currActiveIndex = -1; for (int i = 0; i < HOLD_OBJECTIVE_MAX_ENTITIES; ++ i) { SHoldEntityDetails *pDetails = &m_entities[i]; if (pDetails->m_id) { SKotHEntity *pKotHEntity = static_cast<SKotHEntity *>(pDetails->m_pAdditionalData); CRY_ASSERT(pKotHEntity); pKotHEntity->m_needsIconUpdate = true; ++currActiveIndex; if (pDetails->m_controllingTeamId == 1 || pDetails->m_controllingTeamId == 2) { CRY_TODO( 23,03,2010, "HUD: OnSiteCaptured events are being sent multiple times from multiple places. /FH"); SHUDEvent siteIsCaptured(eHUDEvent_OnSiteCaptured); siteIsCaptured.eventIntData = currActiveIndex; siteIsCaptured.eventIntData2 = pDetails->m_controllingTeamId; CHUDEventDispatcher::CallEvent(siteIsCaptured); } IEntity *pEntity = gEnv->pEntitySystem->GetEntity(pDetails->m_id); if (pEntity) { IScriptTable *pScript = pEntity->GetScriptTable(); if (pScript && pScript->GetValueType("LocalPlayerChangedTeam") == svtFunction) { IScriptSystem *pScriptSystem = gEnv->pScriptSystem; pScriptSystem->BeginCall(pScript, "LocalPlayerChangedTeam"); pScriptSystem->PushFuncParam(pScript); pScriptSystem->EndCall(); } } } } } }
void CAutoAimManager::RegisterCharacterTargetInfo(const CActor& targetActor, const SAutoaimTargetRegisterParams& registerParams) { SAutoaimTarget aimTarget; aimTarget.entityId = targetActor.GetEntityId(); aimTarget.pActorWeak = targetActor.GetWeakPtr(); aimTarget.fallbackOffset = registerParams.fallbackOffset; aimTarget.primaryBoneId = registerParams.primaryBoneId; aimTarget.physicsBoneId = registerParams.physicsBoneId; aimTarget.secondaryBoneId = registerParams.secondaryBoneId; aimTarget.innerRadius = registerParams.innerRadius; aimTarget.outerRadius = registerParams.outerRadius; aimTarget.snapRadius = registerParams.snapRadius; aimTarget.snapRadiusTagged = registerParams.snapRadiusTagged; if (!gEnv->bMultiplayer) { IEntity* pTargetEntity = targetActor.GetEntity(); aimTarget.aiFaction = IFactionMap::InvalidFactionID; //Instance properties, other stuff could be added here easily (grab enemy, sliding hit, etc) SmartScriptTable props; SmartScriptTable propsPlayerInteractions; IScriptTable* pScriptTable = pTargetEntity->GetScriptTable(); if (pScriptTable && pScriptTable->GetValue("Properties", props)) { if (props->GetValue("PlayerInteractions", propsPlayerInteractions)) { int stealhKill = 0; if (propsPlayerInteractions->GetValue("bStealthKill", stealhKill) && (stealhKill != 0)) { aimTarget.SetFlag(eAATF_StealthKillable); } int canBeGrabbed = 0; if (propsPlayerInteractions->GetValue("bCanBeGrabbed", canBeGrabbed) && (canBeGrabbed != 0)) { aimTarget.SetFlag(eAATF_CanBeGrabbed); } } } } m_autoaimTargets.push_back(aimTarget); }
void CFrogBoid::OnEnteringWater(const SBoidContext &bc) { if (!bc.entity) return; IScriptTable *pEntityTable = bc.entity->GetScriptTable(); if (!pEntityTable) return; // Calling script function if(!m_pOnWaterSplashFunc) { pEntityTable->GetValue( "OnWaterSplash",m_pOnWaterSplashFunc ); } if(m_pOnWaterSplashFunc) Script::Call( gEnv->pScriptSystem,m_pOnWaterSplashFunc,pEntityTable,m_pos ); }
void CAreaProxy::OnEnable(bool bIsEnable, bool bIsCallScript) { m_bIsEnable = bIsEnable; if(m_pArea->GetAreaType()==ENTITY_AREA_TYPE_GRAVITYVOLUME) { SEntityPhysicalizeParams physparams; if(bIsEnable && m_bIsEnableInternal) { physparams.pAreaDef = &m_areaDefinition; m_areaDefinition.areaType = SEntityPhysicalizeParams::AreaDefinition::AREA_SPLINE; m_bezierPointsTmp.resize(m_bezierPoints.size()); memcpy( &m_bezierPointsTmp[0],&m_bezierPoints[0],m_bezierPoints.size()*sizeof(Vec3) ); m_areaDefinition.pPoints = &m_bezierPointsTmp[0]; m_areaDefinition.nNumPoints = m_bezierPointsTmp.size(); m_areaDefinition.fRadius = m_fRadius; m_gravityParams.gravity = Vec3(0,0,m_fGravity); m_gravityParams.falloff0 = m_fFalloff; m_gravityParams.damping = m_fDamping; physparams.type = PE_AREA; m_areaDefinition.pGravityParams = &m_gravityParams; m_pEntity->SetTimer(0, 11000); } m_pEntity->Physicalize(physparams); if(bIsCallScript) { //call the OnEnable function in the script, to set game flags for this entity and such. IScriptTable *pScriptTable = m_pEntity->GetScriptTable(); if (pScriptTable) { HSCRIPTFUNCTION scriptFunc(NULL); pScriptTable->GetValue("OnEnable", scriptFunc); if (scriptFunc) Script::Call(gEnv->pScriptSystem,scriptFunc,pScriptTable,bIsEnable); gEnv->pScriptSystem->ReleaseFunc(scriptFunc); } } } }