virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Activate: if (IsPortActive(pActInfo, 0)) { IActor* pActor = GetAIActor(pActInfo); if(pActor) { float health = pActor->GetHealth(); float minH = GetPortFloat(pActInfo, 1); float maxH = GetPortFloat(pActInfo, 2); ActivateOutput(pActInfo, 0, minH <= health && health <= maxH); } else { CryLogAlways("CFlowActorCheckHealth - No Entity or Entity not an Actor!"); } } } }
void Init(SActivationInfo* const pActInfo) { if (gEnv->pAudioSystem != NULL) { GetRtpcID(pActInfo); m_oRequest.pData = &m_oRequestData; m_oRequestData.nControlID = m_nRtpcID; float fValue = GetPortFloat(pActInfo, eIn_RtpcValue); SetValue(pActInfo->pEntity, fValue, true); } }
virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) { #if !defined(_RELEASE) if (event == eFE_Activate) { if (IsPortActive(pActInfo, eIP_Draw)) { IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug(); if (pPersistentDebug) { const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos); const float radius = GetPortFloat(pActInfo, eIP_Radius); const float time = GetPortFloat(pActInfo, eIP_Time); const ColorF color = GetPortVec3(pActInfo, eIP_Color); pPersistentDebug->Begin("FG_Sphere", false); pPersistentDebug->AddSphere(pos, radius, color, time); } } } #endif }
void Start( SActivationInfo* pActInfo ) { IEntity *pEnt = pActInfo->pEntity; if(!pEnt) return; m_bForceFinishAsTooNear = false; m_position = m_coorSys==CS_WORLD ? pEnt->GetWorldPos() : pEnt->GetPos(); m_startPos = m_position; m_lastFrameTime = gEnv->pTimer->GetFrameStartTime().GetSeconds(); m_startTime = m_lastFrameTime; ReadDestinationPosFromInput( pActInfo ); m_easeOutDistance = GetPortFloat(pActInfo, IN_EASEOUT); m_easeInDistance = GetPortFloat(pActInfo, IN_EASEIN); ReadSpeedFromInput( pActInfo ); if(m_easeOutDistance < 0.0f) m_easeOutDistance = 0.0f; m_stopping = false; pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); m_bActive = true; ActivateOutput(pActInfo, OUT_START, true); }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Activate: { ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay(); if (pTOD == 0) return; if (IsPortActive(pActInfo,IN_SET)) { const bool bForceUpdate = GetPortBool(pActInfo, IN_FORCEUPDATE); pTOD->SetTime(GetPortFloat(pActInfo, IN_TIME), bForceUpdate); ActivateOutput(pActInfo, OUT_CURTIME, pTOD->GetTime()); } if (IsPortActive(pActInfo,IN_GET)) { ActivateOutput(pActInfo, OUT_CURTIME, pTOD->GetTime()); } if (IsPortActive(pActInfo,IN_SET_SPEED)) { ITimeOfDay::SAdvancedInfo info; pTOD->GetAdvancedInfo(info); info.fAnimSpeed = GetPortFloat(pActInfo, IN_SPEED); pTOD->SetAdvancedInfo(info); ActivateOutput(pActInfo, OUT_CURSPEED, info.fAnimSpeed); } if (IsPortActive(pActInfo,IN_GET_SPEED)) { ITimeOfDay::SAdvancedInfo info; pTOD->GetAdvancedInfo(info); ActivateOutput(pActInfo, OUT_CURSPEED, info.fAnimSpeed); } } break; } }
void ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo) { if (event == eFE_Activate) { RadioChatterModule* radioChatterModule = gGameAIEnv.radioChatterModule; if (IsPortActive(pActInfo, IN_Enable)) { radioChatterModule->SetEnabled(true); ActivateOutput(pActInfo, OUT_Enabled, true); } if (IsPortActive(pActInfo, IN_Disable)) { radioChatterModule->SetEnabled(false); ActivateOutput(pActInfo, OUT_Disabled, true); } if (IsPortActive(pActInfo, IN_Set) || IsPortActive(pActInfo, IN_Enable)) { const float minimumSilenceDuration = GetPortFloat(pActInfo, IN_MinimumSilenceDuration); const float maximumSilenceDuration = GetPortFloat(pActInfo, IN_MaximumSilenceDuration); const string& chatterSoundName = GetPortString(pActInfo, IN_SoundName); if (minimumSilenceDuration < 0.0f || maximumSilenceDuration < 0.0f) radioChatterModule->SetDefaultSilenceDuration(); else radioChatterModule->SetSilenceDuration(minimumSilenceDuration, maximumSilenceDuration); if (chatterSoundName.empty()) radioChatterModule->SetDefaultSound(); else radioChatterModule->SetSound(chatterSoundName); ActivateOutput(pActInfo, OUT_Set, true); } } }
virtual void ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo ) { CCamera camera(gEnv->pSystem->GetViewCamera()); Vec3 pos(camera.GetPosition()); Vec3 dir(camera.GetViewdir()); float roll(camera.GetAngles().z); // GetAngles() returns YPR angles - roll is in z component switch (event) { case eFE_Initialize: pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, GetPortBool(pActInfo, 3)); break; case eFE_Activate: { if (InputEntityIsLocalPlayer( pActInfo )) { if (IsPortActive(pActInfo, 0)) pos = GetPortVec3(pActInfo, 0); if (IsPortActive(pActInfo, 1)) dir = GetPortVec3(pActInfo, 1); if (IsPortActive(pActInfo, 2)) roll = GetPortFloat(pActInfo, 2); if (IsPortActive(pActInfo, 3)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, GetPortBool(pActInfo, 3)); } if (dir.len2() > 0.0f) { dir.Normalize(); camera.SetMatrix(CCamera::CreateOrientationYPR(CCamera::CreateAnglesYPR(dir, roll))); camera.SetPosition(pos); gEnv->pSystem->SetViewCamera(camera); } } } break; case eFE_Update: { if (InputEntityIsLocalPlayer( pActInfo )) { ActivateOutput(pActInfo, 0, pos); ActivateOutput(pActInfo, 1, dir); ActivateOutput(pActInfo, 2, roll); } } break; } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); } break; case eFE_Update: { float fPeriod = GetPortFloat(pActInfo,IN_PERIOD); CTimeValue time = gEnv->pTimer->GetFrameStartTime(); CTimeValue dt = time - m_lastTickTime; if (dt.GetSeconds() >= fPeriod) { m_lastTickTime = time; ++m_count; ActivateOutput( pActInfo, OUT_COUNT, m_count ); if (m_count >= GetPortInt( pActInfo, IN_LIMIT )) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); ActivateOutput( pActInfo, OUT_FINISHED, GetPortAny( pActInfo, IN_START )); } } } break; case eFE_Activate: { if (IsPortActive(pActInfo,IN_START)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); m_count = 0; m_lastTickTime = gEnv->pTimer->GetFrameStartTime(); } if (IsPortActive(pActInfo,IN_STOP)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); } if (IsPortActive(pActInfo,IN_CONTINUE)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); } } break; } }
virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) { switch (event) { case eFE_Initialize: { break; } case eFE_Activate: { if (IsPortActive(pActInfo, eIn_Set)) { const string& variableName = GetPortString(pActInfo, eIn_VariableName); if (variableName.empty()) { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CAction:DRS_SetVariable: Cannot be executed without a Variable Name."); return; } const string& collectionName = GetPortString(pActInfo, eIn_VariableCollectionName); EntityId entityID = GetPortEntityId(pActInfo, eIn_EntityID); DRS::IVariableCollection* variableCollection = GetVariableCollection(entityID, collectionName); if (variableCollection) { float newVariableValue = GetPortFloat(pActInfo, eIn_FloatValue); variableCollection->SetVariableValue(variableName, newVariableValue, true, GetPortFloat(pActInfo, eIn_ResetTime)); ActivateOutput(pActInfo, eOut_VariableCollectionName, variableCollection->GetName().GetText()); } } break; } } }
void CFlashUIMCVisibleBaseNode::ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo ) { if (event == eFE_Initialize) { UpdateObjectDesc( GetPortString( pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate ); } else if (event == eFE_Activate) { if (IsPortActive( pActInfo, GetInputPort(eI_UIMovieClip))) { UpdateObjectDesc( GetPortString( pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate ); } if (IsTemplate() && !UpdateTmplDesc( GetPortString( pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo )) return; if (GetElement()) { const int instanceId = GetPortInt( pActInfo, GetInputPort(eI_InstanceID)); if (IsPortActive ( pActInfo, GetInputPort(eI_Set))) { const bool bVis = GetPortBool( pActInfo, GetInputPort(eI_Visible)); const float alpha = clamp_tpl( GetPortFloat( pActInfo, GetInputPort(eI_Alpha)), 0.0f, 1.f ); SPerInstanceCall2< bool, float > caller; caller.Execute( GetElement(), instanceId, functor(*this, &CFlashUIMCVisibleBaseNode::SetValues), bVis, alpha ); ActivateOutput( pActInfo, eO_OnSet, true ); ActivateOutput( pActInfo, eO_Visible, bVis ); ActivateOutput( pActInfo, eO_Alpha, alpha ); } else if (IsPortActive( pActInfo, GetInputPort(eI_Get))) { bool bVis = false; float alpha = 0.f; SPerInstanceCall2< bool &, float & > caller; if (!caller.Execute( GetElement(), instanceId, functor(*this, &CFlashUIMCVisibleBaseNode::GetValues), bVis, alpha, false )) { UIACTION_WARNING( "FG: UIElement \"%s\" called get Array for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(),instanceId, pActInfo->pGraph->GetNodeTypeName( pActInfo->myID )); } ActivateOutput( pActInfo, eO_Visible, bVis ); ActivateOutput( pActInfo, eO_Alpha, alpha ); } } } }
virtual void ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo ) { switch (event) { case eFE_Initialize: { CreateView(); return; } break; case eFE_Activate: { if (IsPortActive(pActInfo, EIP_Enable)) { if (m_pView == NULL) CreateView(); if (m_pView == NULL) return; if (pActInfo->pEntity == NULL) return; SViewParams params; params.justActivated = true; params.fov = DEG2RAD(GetPortFloat(pActInfo, EIP_FOV)); params.blend = GetPortBool(pActInfo, EIP_Blend); params.blendFOVOffset = DEG2RAD(GetPortFloat(pActInfo, EIP_BlendFOVOffset)); params.blendFOVSpeed = GetPortFloat(pActInfo, EIP_BlendFOVSpeed); params.blendPosOffset = GetPortVec3(pActInfo, EIP_BlendPosOffset); params.blendPosSpeed = GetPortFloat(pActInfo, EIP_BlendPosSpeed); params.blendRotSpeed = GetPortFloat(pActInfo, EIP_BlendRotSpeed); params.blendRotOffset = Quat::CreateRotationXYZ(static_cast<Ang3>(GetPortVec3(pActInfo, EIP_BlendRotOffset))); m_pView->SetCurrentParams(params); m_pView->LinkTo(pActInfo->pEntity); m_pViewSystem->SetActiveView(m_pView); } else if (IsPortActive(pActInfo, EIP_Disable)) { if (m_pLocalPlayerView) m_pViewSystem->SetActiveView(m_pLocalPlayerView); } else if (IsPortActive(pActInfo, EIP_FOV)) { SViewParams params; params.fov = DEG2RAD(GetPortFloat(pActInfo, EIP_FOV)); m_pView->SetCurrentParams(params); } } break; } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: { bool bPaused = GetPortBool(pActInfo,IN_PAUSED); pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, !bPaused ); m_last = gEnv->pTimer->GetFrameStartTime(); } break; case eFE_Update: { if (GetPortBool(pActInfo,IN_PAUSED)) return; float fPeriod = GetPortFloat(pActInfo,IN_PERIOD); CTimeValue time = gEnv->pTimer->GetFrameStartTime(); CTimeValue dt = time - m_last; if (dt.GetSeconds() >= fPeriod) { m_last = time; int nMin = GetPortInt(pActInfo,IN_MIN); int nMax = GetPortInt(pActInfo,IN_MAX); m_nCurrentCount++; if (m_nCurrentCount < nMin) m_nCurrentCount = nMin; if (m_nCurrentCount > nMax) { m_nCurrentCount = nMin; } ActivateOutput( pActInfo,OUT_OUT,m_nCurrentCount ); } } break; case eFE_Activate: { if (IsPortActive(pActInfo,IN_PAUSED)) { bool bPaused = GetPortBool(pActInfo,IN_PAUSED); pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, !bPaused ); } } break; } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: m_errorLogSent = false; break; case eFE_Activate: if (IsPortActive(pActInfo, 0)) { IEntitySystem* pESys = gEnv->pEntitySystem; EntityId id1 = GetPortEntityId(pActInfo, 1); EntityId id2 = GetPortEntityId(pActInfo, 2); IEntity* pEnt1 = pESys->GetEntity( id1 ); IEntity* pEnt2 = pESys->GetEntity( id2 ); IEntity* pGraphEntity = pESys->GetEntity( pActInfo->pGraph->GetGraphEntity( 0 ) ); if (pEnt1==NULL || pEnt2==NULL) { if (!m_errorLogSent) { GameWarning("[flow] Entity::EntitiesInRange - flowgraph entity: %d:'%s' - at least one of the input entities is invalid!. Entity1: %d:'%s' Entity2: %d:'%s'", pActInfo->pGraph->GetGraphEntity( 0 ), pGraphEntity ? pGraphEntity->GetName() : "<NULL>", id1, pEnt1 ? pEnt1->GetName() : "<NULL>", id2, pEnt2 ? pEnt2->GetName() : "<NULL>" ); m_errorLogSent = true; } } else { const float range = GetPortFloat(pActInfo, 3); const float distance = pEnt1->GetWorldPos().GetDistance(pEnt2->GetWorldPos()) ; const bool inRange = (distance <= range); ActivateOutput(pActInfo, 0, inRange); ActivateOutput(pActInfo, 1 + (inRange ? 1 : 0), true); ActivateOutput(pActInfo, 3, distance); const Vec3 distVector = pEnt2->GetPos() - pEnt1->GetPos(); ActivateOutput(pActInfo, 4, distVector); m_errorLogSent = false; } } break; } }
void ProcessEvent(EFlowEvent event, SActivationInfo* pActivationInfo) { switch (event) { case eFE_Initialize: { SetAutoUpdate(pActivationInfo, GetPortBool(pActivationInfo, eIP_Auto)); break; } case eFE_Activate: { if (IsPortActive(pActivationInfo, eIP_Auto)) { SetAutoUpdate(pActivationInfo, GetPortBool(pActivationInfo, eIP_Auto)); } else if (IsPortActive(pActivationInfo, eIP_Freq)) { m_frequency = GetPortFloat(pActivationInfo, eIP_Freq); } else if (IsPortActive(pActivationInfo, eIP_Sync)) { Sync(pActivationInfo); } break; } case eFE_Update: { CTimeValue delta = gEnv->pTimer->GetFrameStartTime() - m_prevTime; if (delta.GetSeconds() >= m_frequency) { Sync(pActivationInfo); } break; } } }
////////////////////////////////////////////////////////////////////////// // when the inputs are set to work with "time" instead of speed, we just calculate speed from that time value void CalcSpeedFromTimeInput( SActivationInfo* pActInfo ) { assert( GetPortInt(pActInfo, IN_VALUETYPE)==VT_TIME ); float movementDuration = GetPortFloat( pActInfo, IN_VALUE ); float timePassed = gEnv->pTimer->GetFrameStartTime().GetSeconds() - m_startTime; float movementDurationLeft = movementDuration - timePassed; if (movementDurationLeft < 0.0001f) movementDurationLeft = 0.0001f; Vec3 movement = m_destination - m_position; float distance = movement.len(); if ( m_easeInDistance + m_easeOutDistance > distance ) // make sure they dont overlap m_easeInDistance = distance - m_easeOutDistance; float distanceNoEase = distance - ( m_easeInDistance + m_easeOutDistance ); const float factorAverageSpeedEase = 0.5f; // not real because is not lineal, but is good enough for this float realEaseInDistance = max( m_easeInDistance - m_easeInDistance * EASE_MARGIN_FACTOR, 0.f ); float realEaseOutDistance = max( m_easeOutDistance - m_easeOutDistance * EASE_MARGIN_FACTOR, 0.f ); m_topSpeed = ( ( realEaseInDistance / factorAverageSpeedEase ) + distanceNoEase + ( realEaseOutDistance / factorAverageSpeedEase ) ) / movementDurationLeft; // this comes just from V = S / T; }
void CFlashUIDelayNode::ProcessEvent( EFlowEvent event, SActivationInfo * pActInfo ) { switch (event) { case eFE_Initialize: pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false); break; case eFE_Activate: pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true); m_fTime = gEnv->pTimer->GetAsyncCurTime(); break; case eFE_Update: if (m_fTime + GetPortFloat(pActInfo, eI_Delay) < gEnv->pTimer->GetAsyncCurTime()) { ActivateOutput(pActInfo, eO_Done, GetPortAny(pActInfo, eI_Start)); pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false); } break; } }
void StartFader(SActivationInfo * pActInfo) { CHUDFader* pFader = GetFader(pActInfo); if (pFader != 0) { const float fDuration = GetPortFloat(pActInfo, m_direction < 0 ? EIP_InTime : EIP_OutTime); ColorF col; const Vec3 fadeColor = GetPortVec3(pActInfo, EIP_Color); const bool bUseCurColor = GetPortBool(pActInfo, EIP_UseCurrentColor); col.r = fadeColor[0]; col.g = fadeColor[1]; col.b = fadeColor[2]; col.a = m_direction < 0 ? 0.0f : 1.0f; if (m_direction < 0) m_ticket = pFader->FadeIn(col, fDuration, bUseCurColor); else m_ticket =pFader->FadeOut(col, fDuration, GetPortString(pActInfo, EIP_TextureName), bUseCurColor); m_bNeedFaderStop = true; } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: { m_bActive = false; m_actInfo = *pActInfo; Register(true); } break; case eFE_Activate: { if (IsPortActive(pActInfo, EIP_Enable)) Register(true); if (IsPortActive(pActInfo, EIP_Disable)) Register(false); } break; case eFE_Update: { if (!m_bFinished) { float fTimeout = GetPortFloat(&m_actInfo, EIP_Timeout); CTimeValue curTime = gEnv->pTimer->GetFrameStartTime(); float elapsedTime = (curTime - m_activationTime).GetSeconds(); if (elapsedTime > fTimeout) { Finish(); ActivateOutput(&m_actInfo, EOP_TimedOut, true); } } } break; } }
void CFlowNode_ColorGradient::ProcessEvent(EFlowEvent event, SActivationInfo* activationInformation) { //Preload texture if(event==IFlowNode::eFE_PrecacheResources && m_pTexture==NULL) { const string texturePath = GetPortString(activationInformation, eInputPorts_TexturePath); const uint32 COLORCHART_TEXFLAGS = FT_NOMIPS | FT_DONT_STREAM | FT_DONT_RESIZE | FT_STATE_CLAMP; m_pTexture = gEnv->pRenderer->EF_LoadTexture(texturePath.c_str(), COLORCHART_TEXFLAGS); //CryLogAlways("CFlowNode_ColorGradient 0x%p: Precache texture %s", this, texturePath.c_str()); } if (event==IFlowNode::eFE_Activate && IsPortActive(activationInformation, eIP_Trigger)) { const string texturePath = GetPortString(activationInformation, eInputPorts_TexturePath); const float timeToFade = GetPortFloat(activationInformation, eInputPorts_TransitionTime); g_pGame->GetColorGradientManager().TriggerFadingColorGradient(texturePath, timeToFade); } }
/// Actually runs the test bool CFlowNode_FeatureTest::Start() { bool result = false; if(!m_ready) CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Test %s is being forced to run despite not being ready.", Name()); if(!m_running) { if(m_labelProfileData) { string labelName = Name(); labelName += "_start"; AddUserMarker(labelName.c_str()); } result = StartNextTestRun(); if(result) { // Check the max time value to ensure a timeout is set float maxTime = GetPortFloat(&m_actInfo, eInputPorts_MaxTime); if(maxTime <= 0.0f) CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Test %s is been run with max time set to %f - test may never end!", Name(), maxTime); } else { CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "Test %s failed to start! Have you already run it?", Name()); } } else { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "Feature test %s already running (ignoring run request).", Name()); } return result; }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Activate: if (IsPortActive(pActInfo, 0)) { IActor* pActor = GetAIActor(pActInfo); if(pActor) { if (!pActor->IsDead()) { pActor->SetHealth( GetPortFloat(pActInfo, 1) ); ActivateOutput(pActInfo, 0, pActor->GetHealth()); // use pActor->GetHealth (might have been clamped to maxhealth] } } else { GameWarning("CFlowActorSetHealth - No Entity or Entity not an actor!"); } } } }
virtual void OnIterStart(SActivationInfo *pActInfo) { const int type = GetPortInt(pActInfo, EIP_Type); const Vec3& center(GetPortVec3(pActInfo, EIP_Pos)); const float range = GetPortFloat(pActInfo, EIP_Range); const float rangeSq = range * range; const Vec3 min(center.x-range, center.y-range, center.z-range); const Vec3 max(center.x+range, center.y+range, center.z+range); IPhysicalWorld *pWorld = gEnv->pPhysicalWorld; IPhysicalEntity **ppList = NULL; int numEnts = pWorld->GetEntitiesInBox(min,max,ppList,ent_all); for (int i = 0; i < numEnts; ++i) { const EntityId id = pWorld->GetPhysicalEntityId(ppList[i]); const EEntityType entityType = GetEntityType(id); if (IsValidType(type, entityType)) { AddEntity(id); } } }
void CFlashUIDisplayConfigNode::ProcessEvent( EFlowEvent event,SActivationInfo *pActInfo ) { if ( event == eFE_Initialize ) { UpdateUIElement( GetPortString( pActInfo, eI_UIElement ), pActInfo ); } else if ( event == eFE_Activate ) { if ( IsPortActive( pActInfo, eI_UIElement ) ) { UpdateUIElement( GetPortString( pActInfo, eI_UIElement ), pActInfo ); } const int instanceId = GetPortInt( pActInfo, eI_InstanceID ); if ( IsPortActive( pActInfo, eI_Get ) ) { SPerInstanceCall1< SActivationInfo* > caller; if ( !caller.Execute( GetElement(), instanceId, functor(*this, &CFlashUIDisplayConfigNode::GetFromInstance), pActInfo, false) ) { UIACTION_WARNING( "FG: UIElement \"%s\" called get flags for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str() ,instanceId, pActInfo->pGraph->GetNodeTypeName( pActInfo->myID ) ); } ActivateOutput( pActInfo, eO_OnGet, true ); } if ( IsPortActive( pActInfo, eI_Set ) ) { const float alpha = GetPortFloat( pActInfo, eI_Alpha ); const int layer = GetPortInt( pActInfo, eI_Layer ); const uint64 flags = GetFlags( pActInfo ); SPerInstanceCall3< uint64, float, int > caller; caller.Execute( GetElement(), instanceId, functor(*this, &CFlashUIDisplayConfigNode::SetToInstance), flags, alpha, layer ); ActivateOutput( pActInfo, eO_OnSet, true ); } } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { if (event == eFE_Activate && IsPortActive(pActInfo, GO)) { IEntity * pEntity = pActInfo->pEntity; if (pEntity) { ray_hit hit; IPhysicalEntity *pSkip = pEntity->GetPhysics(); Vec3 direction = GetPortVec3(pActInfo, DIR).GetNormalized(); if(GetPortBool(pActInfo, TRANSFORM_DIRECTION)) direction = pEntity->GetWorldTM().TransformVector( GetPortVec3(pActInfo, DIR).GetNormalized() ); IPhysicalWorld * pWorld = gEnv->pPhysicalWorld; int numHits = pWorld->RayWorldIntersection( pEntity->GetPos() + GetPortVec3(pActInfo, POS), direction * GetPortFloat(pActInfo, MAXLENGTH), ent_all, rwi_stop_at_pierceable|rwi_colltype_any, &hit, 1, &pSkip, 1 ); if (numHits) { pEntity = (IEntity*)hit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY); ActivateOutput( pActInfo, HIT,(bool)true ); ActivateOutput( pActInfo, DIROUT, direction ); ActivateOutput( pActInfo, DISTANCE, hit.dist ); ActivateOutput( pActInfo, HITPOINT, hit.pt ); ActivateOutput( pActInfo, NORMAL, hit.n ); ActivateOutput( pActInfo, SURFTYPE, (int)hit.surface_idx ); ActivateOutput( pActInfo, HIT_ENTITY, pEntity ? pEntity->GetId() : 0); } else ActivateOutput( pActInfo, NOHIT, false); } } }
virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) { switch (event) { case eFE_Initialize: { break; } case eFE_Activate: { if (pActInfo->pEntity) { const string& signalName = GetPortString(pActInfo, eIn_SignalName); const float signalDelay = GetPortFloat(pActInfo, eIn_SignalDelay); IEntityDynamicResponseProxyPtr const pIEntityDrsProxy = crycomponent_cast<IEntityDynamicResponseProxyPtr>(pActInfo->pEntity->CreateProxy(ENTITY_PROXY_DYNAMICRESPONSE)); if (IsPortActive(pActInfo, eIn_Send)) { //DRS::IVariableCollectionSharedPtr contextCondition = gEnv->pDynamicResponseSystem->CreateContextCollection(); //add if context collections are needed pIEntityDrsProxy->QueueSignal(signalName.c_str(), nullptr, signalDelay); ActivateOutput(pActInfo, eOut_Done, true); } else if (IsPortActive(pActInfo, eIn_Cancel)) { gEnv->pDynamicResponseSystem->CancelSignalProcessing(signalName, pIEntityDrsProxy->GetResponseActor(), signalDelay); ActivateOutput(pActInfo, eOut_Done, true); } break; } else { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CAction:DRS_SendSignal: Cannot send a signal without an specified EntityID."); } } } }
virtual void ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo) { switch (event) { case eFE_Initialize: { pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID,false); } case eFE_Activate: { if(GetPortBool(pActInfo, 1)) { EntityId id = GetPortEntityId(pActInfo,EIP_EntityID); IEntity * entity = gEnv->pEntitySystem->GetEntity(id); if(entity) { Matrix34 trans; // = entity->GetWorldTM(); trans.CreateIdentity(); Quat quat = entity->GetRotation(); quat.v = GetPortVec3( pActInfo, EIP_Rotation_XYZ); quat.w = GetPortFloat( pActInfo, EIP_Rotation_W); //quat.NormalizeFast(); Vec3 position = entity->GetPos(); trans.Set(Vec3(1,1,1),quat.GetNormalized(),position); entity->SetPosRotScale(position,quat,Vec3(1,1,1)); } } } } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { if (event == eFE_Activate && IsPortActive(pActInfo, GO)) { IEntity * pEntity = pActInfo->pEntity; // if (pEntity) { ray_hit hit; CCamera& cam = GetISystem()->GetViewCamera(); Vec3 pos = cam.GetPosition()+cam.GetViewdir(); Vec3 direction = cam.GetViewdir(); IPhysicalWorld * pWorld = gEnv->pPhysicalWorld; // IPhysicalEntity *pSkip = 0; // pEntity->GetPhysics(); int numHits = pWorld->RayWorldIntersection( pos + GetPortVec3(pActInfo, POS), direction * GetPortFloat(pActInfo, MAXLENGTH), ent_all, rwi_stop_at_pierceable|rwi_colltype_any, &hit, 1 /* ,&pSkip, 1 */ ); if (numHits) { pEntity = (IEntity*)hit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY); ActivateOutput( pActInfo, HIT,(bool)true ); ActivateOutput( pActInfo, DIROUT, direction ); ActivateOutput( pActInfo, DISTANCE, hit.dist ); ActivateOutput( pActInfo, HITPOINT, hit.pt ); ActivateOutput( pActInfo, NORMAL, hit.n ); ActivateOutput( pActInfo, SURFTYPE, (int)hit.surface_idx ); ActivateOutput( pActInfo, HIT_ENTITY, pEntity ? pEntity->GetId() : 0); } else ActivateOutput( pActInfo, NOHIT, false ); } } }
void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: { CGameRules* pGameRules = g_pGame->GetGameRules(); if(pGameRules) pGameRules->AddGameRulesListener(this); CPlayer* pPlayer = static_cast<CPlayer*>(g_pGame->GetIGameFramework()->GetClientActor()); if(pPlayer) m_localPlayerSpectatorMode = pPlayer->GetSpectatorMode(); m_actInfo = *pActInfo; } break; case eFE_Activate: break; case eFE_Update: { CPlayer* pPlayer = static_cast<CPlayer*>(g_pGame->GetIGameFramework()->GetClientActor()); if(!pPlayer) return; // first check: tac weapons trigger endgamenear / endgameinvalid if(m_MDList.empty() && m_endGameNear) { // if less than 3 min remaining don't return to normal bool cancel = true; if(g_pGame && g_pGame->GetGameRules() && g_pGame->GetGameRules()->IsTimeLimited() && m_timeRemainingTriggered) { float timeRemaining = g_pGame->GetGameRules()->GetRemainingGameTime(); if(timeRemaining < GetPortFloat(pActInfo, EIP_GameEndTime) ) cancel = false; } if(cancel) { if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0) { CryLog("MP flowgraph: EndGameInvalid"); } ActivateOutput(&m_actInfo, EOP_EndGameInvalid, true); m_endGameNear = false; } } else if(!m_MDList.empty()) { // go through the list of tac/sing weapons and check if they are still present std::list<EntityId>::iterator next; std::list<EntityId>::iterator it = m_MDList.begin(); for(; it != m_MDList.end(); it = next) { next = it; ++next; if(gEnv->pEntitySystem->GetEntity(*it)) { // entity exists so trigger loud music if not already done if(!m_endGameNear) { if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0) { CryLog("--MP flowgraph: EndGameNear"); } ActivateOutput(&m_actInfo, EOP_EndGameNear, true); m_endGameNear = true; } // in the case of tanks, entity isn't removed for quite some time after destruction. // Check vehicle health directly here... IVehicle* pVehicle = g_pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(*it); if(pVehicle && pVehicle->IsDestroyed()) { m_MDList.erase(it); } } else { // entity no longer exists - remove from list. m_MDList.erase(it); } } } // get the remaining time from game rules if(!m_timeRemainingTriggered && g_pGame->GetGameRules() && g_pGame->GetGameRules()->IsTimeLimited() && pPlayer->GetSpectatorMode() == 0 && !m_endGameNear) { float timeRemaining = g_pGame->GetGameRules()->GetRemainingGameTime(); if(timeRemaining < GetPortFloat(pActInfo, EIP_GameEndTime) ) { if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0) { CryLog("--MP flowgraph: EndGameNear"); } ActivateOutput(&m_actInfo, EOP_EndGameNear, timeRemaining); m_timeRemainingTriggered = true; m_endGameNear = true; } } // also check whether the local player is in game yet if(pPlayer->GetSpectatorMode() == 0 && m_localPlayerSpectatorMode != 0) { if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0) { CryLog("--MP flowgraph: EnteredGame"); } ActivateOutput(&m_actInfo, EOP_EnteredGame, true); m_localPlayerSpectatorMode = pPlayer->GetSpectatorMode(); } } break; } }
virtual void ProcessEvent( EFlowEvent evt, SActivationInfo* pActInfo ) { switch ( evt ) { case eFE_Suspend: if ( m_pVideo && m_pVideo->IsPlaying() ) { m_pVideo->Pause(); m_bWasPlaying = true; } pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); break; case eFE_Resume: if ( m_pVideo && m_bWasPlaying ) { m_pVideo->Resume(); m_bWasPlaying = false; } pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); break; case eFE_Initialize: INITIALIZE_OUTPUTS( pActInfo ); break; case eFE_Activate: if ( !m_pVideo ) { m_pVideo = gVideoplayerSystem->CreateVideoplayer(); if ( m_pVideo ) { m_pVideo->RegisterListener( this ); pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); } } if ( !m_pVideo ) { return; } if ( IsPortActive( pActInfo, EIP_CLOSE ) ) { m_pVideo->Close(); INITIALIZE_OUTPUTS( pActInfo ); } if ( IsPortActive( pActInfo, EIP_PAUSE ) ) { m_pVideo->Pause(); ActivateOutput<float>( pActInfo, EOP_POSITION, m_pVideo->GetPosition() ); ActivateOutput<bool>( pActInfo, EOP_PLAYING, m_pVideo->IsPlaying() ); } if ( IsPortActive( pActInfo, EIP_OPEN ) ) { if ( m_pVideo->Open( GetPortString( pActInfo, EIP_FILE ).c_str(), GetPortString( pActInfo, EIP_SOUND ).c_str(), GetPortBool( pActInfo, EIP_LOOP ), GetPortBool( pActInfo, EIP_SKIPPABLE ), GetPortBool( pActInfo, EIP_BLOCKGAME ), eTimeSource( GetPortInt( pActInfo, EIP_TIMESOURCE ) ), eDropMode( GetPortInt( pActInfo, EIP_DROPMODE ) ), GetPortFloat( pActInfo, EIP_STARTAT ), GetPortFloat( pActInfo, EIP_ENDAFTER ), GetPortInt( pActInfo, EIP_CUSTOMWIDTH ), GetPortInt( pActInfo, EIP_CUSTOMHEIGHT ) ) ) { ActivateOutput<int>( pActInfo, EOP_VIDEOID, m_pVideo->GetId() ); ActivateOutput<float>( pActInfo, EOP_POSITION, m_pVideo->GetPosition() ); ActivateOutput<float>( pActInfo, EOP_DURATION, m_pVideo->GetDuration() ); ActivateOutput<float>( pActInfo, EOP_FPS, m_pVideo->GetFPS() ); ActivateOutput<int>( pActInfo, EOP_WIDTH, m_pVideo->GetWidth() ); ActivateOutput<int>( pActInfo, EOP_HEIGHT, m_pVideo->GetHeight() ); ActivateOutput<bool>( pActInfo, EOP_PLAYING, m_pVideo->IsPlaying() ); m_pVideo->SetSpeed( GetPortFloat( pActInfo, EIP_SPEED ) ); } else { INITIALIZE_OUTPUTS( pActInfo ); } } if ( IsPortActive( pActInfo, EIP_RESUME ) ) { m_pVideo->SetSpeed( GetPortFloat( pActInfo, EIP_SPEED ) ); m_pVideo->Resume(); ActivateOutput<float>( pActInfo, EOP_POSITION, m_pVideo->GetPosition() ); ActivateOutput<bool>( pActInfo, EOP_PLAYING, m_pVideo->IsPlaying() ); m_bStart = m_pVideo->IsPlaying(); } if ( IsPortActive( pActInfo, EIP_SEEK ) ) { m_pVideo->Seek( GetPortFloat( pActInfo, EIP_POSTION ) ); ActivateOutput<float>( pActInfo, EOP_POSITION, m_pVideo->GetPosition() ); } if ( IsPortActive( pActInfo, EIP_SPEED ) ) { m_pVideo->SetSpeed( GetPortFloat( pActInfo, EIP_SPEED ) ); } if ( IsPortActive( pActInfo, EIP_TIMESOURCE ) ) { m_pVideo->SetTimesource( eTimeSource( GetPortInt( pActInfo, EIP_TIMESOURCE ) ) ); } break; case eFE_Update: if ( m_bEnd ) { m_bEnd = false; ActivateOutput( pActInfo, EOP_ONEND, true ); } else if ( m_bStart ) { m_bStart = false; ActivateOutput( pActInfo, EOP_ONSTART, true ); } if ( m_bFrame ) { m_bFrame = false; ActivateOutput<float>( pActInfo, EOP_POSITION, m_pVideo->GetPosition() ); } break; } }
void CFlowNode_AIStateGuard::OnEndActGoto() { ResetGoalpipe(); m_State = CryGetTicks() + GetPortFloat(&m_ActInfo, INPORT_DELAY) * gEnv->pTimer->GetTicksPerSecond(); //Pause SetIdle(); }