BVB Source Codes

CRYENGINE Show GoalOp_G04.cpp Source code

Return Download CRYENGINE: download GoalOp_G04.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   GoalOp_G04.cpp
  6.    Description: Game 04 goalops
  7.              These should move into GameDLL when interfaces allow!
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 21:02:2008 - Created by Matthew Jack
  11.  *********************************************************************/
  12.  
  13. #include "StdAfx.h"
  14. #if 0
  15. // deprecated and won't compile at all...
  16.  
  17.         #include "GoalOp_G04.h"
  18.         #include "GoalOpTrace.h"
  19.  
  20.         #include "TacticalPointSystem/TacticalPointSystem.h"
  21.         #include "PipeUser.h"
  22.         #include "NavRegion.h"
  23.  
  24.         #define RETURN_SUCCEED     { Reset(pOperand); return eGOR_SUCCEEDED; }
  25.         #define RETURN_FAILED      { Reset(pOperand); return eGOR_FAILED; }
  26.         #define RETURN_IN_PROGRESS return eGOR_IN_PROGRESS;
  27.  
  28. // Ugly
  29.         #define C_MaxDistanceForPathOffset 2 // threshold (in m) used in COPStick and COPApproach, to detect if the returned path
  30. // is bringing the agent too far from the expected destination
  31.  
  32. IGoalOp* CGoalOpFactoryG04::GetGoalOp(const char* sGoalOpName, IFunctionHandler* pH, int nFirstParam, GoalParameters& params) const
  33. {
  34.         // For now, we look up the central enum - but this should become totally localised
  35.         EGoalOperations op = CGoalPipe::GetGoalOpEnum(sGoalOpName);
  36.  
  37.         // Should really check these params before passing them on
  38.         // So far all ops use similar params, so don't need switch here
  39.         bool bOk = true;
  40.  
  41.         switch (op)
  42.         {
  43.         case eGO_G4APPROACH:
  44.                 bOk &= pH->GetParam(nFirstParam, params.fValue);
  45.                 bOk &= pH->GetParam(nFirstParam + 1, params.fValueAux);
  46.  
  47.                 // Optional parameter forces a direct approach
  48.                 params.bValue = false;
  49.                 if (pH->GetParamCount() > nFirstParam + 1)
  50.                         pH->GetParam(nFirstParam + 2, params.bValue);
  51.  
  52.                 // Fetch register parameter, if any
  53.                 params.nValueAux = AI_REG_ATTENTIONTARGET;
  54.                 if (pH->GetParamCount() > nFirstParam + 2)
  55.                         pH->GetParam(nFirstParam + 3, params.nValueAux);
  56.  
  57.                 break;
  58.         default:
  59.                 break;
  60.         }
  61.  
  62.         if (!bOk) return NULL;
  63.  
  64.         return GetGoalOp(op, params);
  65. }
  66.  
  67. IGoalOp* CGoalOpFactoryG04::GetGoalOp(EGoalOperations op, GoalParameters& params) const
  68. {
  69.         IGoalOp* pResult = NULL;
  70.  
  71.         switch (op)
  72.         {
  73.         case eGO_G4APPROACH:
  74.                 pResult = new COPG4Approach(params.fValue, params.fValueAux, params.bValue, static_cast<EAIRegister>(params.nValueAux));
  75.                 break;
  76.         default:
  77.                 // We don't know this goalop, but another factory might
  78.                 return NULL;
  79.         }
  80.  
  81.         return pResult;
  82. }
  83.  
  84. ////////////////////////////////////////////////////////////////////////////
  85. //
  86. //                              G4APPROACH - makes agent approach a target using his environment
  87. //
  88. ////////////////////////////////////////////////////////////////////////////
  89.  
  90. COPG4Approach::COPG4Approach(float fMinEndDistance, float fMaxEndDistance, bool bForceDirect, EAIRegister nReg) :
  91.         m_fMinEndDistance(fMinEndDistance)
  92.         , m_fMaxEndDistance(fMaxEndDistance)
  93.         , m_pTraceDirective(NULL)
  94.         , m_pPathfindDirective(NULL)
  95.         , m_fLastTime(-1.0f)
  96.         , m_bForceDirect(bForceDirect)
  97.         , m_nReg(nReg)
  98. {
  99.         m_fEndAccuracy = 0.1f;
  100.         m_bNeedHidespot = true;
  101.         m_eApproachMode = EOPG4AS_Evaluate;
  102.         m_fNotMovingTime = 0.0f;
  103.  
  104.         CTacticalPointSystem* pTPS = gAIEnv.pTacticalPointSystem;
  105.         m_iApproachQueryID = pTPS->GetQueryID("G4Approach");
  106.         if (!m_iApproachQueryID)
  107.         {
  108.                 AIError("G4Approach TPS query does not exist - failed script load?");
  109.                 assert(false); // Pretty major issue, but fix the script, AIReload, and all should be dandy
  110.         }
  111.  
  112.         m_iRegenerateCurrentQueryID = pTPS->GetQueryID("AdjustCurrent");
  113.         if (!m_iRegenerateCurrentQueryID)
  114.         {
  115.                 AIError("AdjustCurrent TPS query does not exist - failed script load?");
  116.                 assert(false); // Pretty major issue, but fix the script, AIReload, and all should be dandy
  117.         }
  118. }
  119.  
  120. COPG4Approach::COPG4Approach(const XmlNodeRef& node) :
  121.         m_fMinEndDistance(0.f),
  122.         m_fMaxEndDistance(0.f),
  123.         m_pTraceDirective(0),
  124.         m_pPathfindDirective(0),
  125.         m_fLastTime(-1.f),
  126.         m_bForceDirect(s_xml.GetBool(node, "forceDirect")),
  127.         m_nReg(AI_REG_NONE),
  128.         m_fEndAccuracy(0.1f),
  129.         m_bNeedHidespot(true),
  130.         m_eApproachMode(EOPG4AS_Evaluate),
  131.         m_fNotMovingTime(0.f)
  132. {
  133.         s_xml.GetMandatory(node, "minEndDistance", m_fMinEndDistance);
  134.         s_xml.GetMandatory(node, "maxEndDistance", m_fMaxEndDistance);
  135.  
  136.         s_xml.GetRegister(node, "register", m_nReg);
  137.         if (m_nReg == AI_REG_NONE)
  138.         {
  139.                 m_nReg = AI_REG_ATTENTIONTARGET;
  140.         }
  141.  
  142.         CTacticalPointSystem* pTPS = gAIEnv.pTacticalPointSystem;
  143.         m_iApproachQueryID = pTPS->GetQueryID("G4Approach");
  144.         if (!m_iApproachQueryID)
  145.         {
  146.                 AIError("G4Approach TPS query does not exist - failed script load?");
  147.                 assert(false); // Pretty major issue, but fix the script, AIReload, and all should be dandy
  148.         }
  149.  
  150.         m_iRegenerateCurrentQueryID = pTPS->GetQueryID("AdjustCurrent");
  151.         if (!m_iRegenerateCurrentQueryID)
  152.         {
  153.                 AIError("AdjustCurrent TPS query does not exist - failed script load?");
  154.                 assert(false); // Pretty major issue, but fix the script, AIReload, and all should be dandy
  155.         }
  156. }
  157.  
  158. COPG4Approach::COPG4Approach(const COPG4Approach& rhs) :
  159.         m_fMinEndDistance(rhs.m_fMinEndDistance),
  160.         m_fMaxEndDistance(rhs.m_fMaxEndDistance),
  161.         m_pTraceDirective(0),
  162.         m_pPathfindDirective(0),
  163.         m_fLastTime(-1.f),
  164.         m_bForceDirect(rhs.m_bForceDirect),
  165.         m_nReg(rhs.m_nReg),
  166.         m_fEndAccuracy(0.1f),
  167.         m_bNeedHidespot(true),
  168.         m_eApproachMode(EOPG4AS_Evaluate),
  169.         m_fNotMovingTime(0.f),
  170.         m_iApproachQueryID(rhs.m_iApproachQueryID),
  171.         m_iRegenerateCurrentQueryID(rhs.m_iRegenerateCurrentQueryID)
  172. {
  173. }
  174.  
  175. COPG4Approach::~COPG4Approach()
  176. {
  177.         Reset(NULL);
  178. }
  179.  
  180. void COPG4Approach::Reset(CPipeUser* pOperand)
  181. {
  182.         if (gAIEnv.CVars.DebugPathFinding)
  183.                 AILogAlways("COPG4Approach::Reset %s", pOperand ? pOperand->GetName() : "");
  184.  
  185.         delete m_pPathfindDirective;
  186.         m_pPathfindDirective = NULL;
  187.         delete m_pTraceDirective;
  188.         m_pTraceDirective = NULL;
  189.         m_bNeedHidespot = true;
  190.         m_eApproachMode = EOPG4AS_Evaluate;
  191.         m_fLastTime = -1.0f;
  192.         m_fNotMovingTime = 0.0f;
  193.  
  194.         m_refHideTarget.Release();
  195.  
  196.         if (pOperand)
  197.         {
  198.                 pOperand->ClearPath("COPG4Approach::Reset m_Path");
  199.         }
  200. }
  201.  
  202. void COPG4Approach::Serialize(TSerialize ser)
  203. {
  204.         ser.BeginGroup("COPG4Approach");
  205.         {
  206.                 ser.Value("m_fLastDistance", m_fLastDistance);
  207.                 ser.Value("m_fMinEndDistance", m_fMinEndDistance);
  208.                 ser.Value("m_fMaxEndDistance", m_fMaxEndDistance);
  209.                 ser.Value("m_bNeedHidespot", m_bNeedHidespot);
  210.                 ser.Value("m_fEndAccuracy", m_fEndAccuracy);
  211.  
  212.                 if (ser.IsWriting())
  213.                 {
  214.                         if (ser.BeginOptionalGroup("TraceDirective", m_pTraceDirective != NULL))
  215.                         {
  216.                                 assert(m_pTraceDirective);
  217.                                 m_pTraceDirective->Serialize(ser, objectTracker);
  218.                                 ser.EndGroup();
  219.                         }
  220.                 }
  221.                 else
  222.                 {
  223.                         SAFE_DELETE(m_pTraceDirective);
  224.                         if (ser.BeginOptionalGroup("TraceDirective", true))
  225.                         {
  226.                                 m_pTraceDirective = new COPTrace(true);
  227.                                 m_pTraceDirective->Serialize(ser, objectTracker);
  228.                                 ser.EndGroup();
  229.                         }
  230.                 }
  231.                 ser.EndGroup();
  232.         }
  233. }
  234.  
  235. EGoalOpResult COPG4Approach::Execute(CPipeUser* pOperand)
  236. {
  237.         CAISystem* pAISystem = GetAISystem();
  238.         bool bForceReturnPartialPath = false;
  239.  
  240.         // (MATT) Whether it should look this up once and stores it, or will reflect changes, is an open question {2008/08/09}
  241.  
  242.         // Get the target
  243.         CAIObject* pTarget = NULL;
  244.         switch (m_nReg)
  245.         {
  246.         case AI_REG_LASTOP:
  247.                 pTarget = pOperand->GetLastOpResult();
  248.                 break;
  249.         case AI_REG_REFPOINT:
  250.                 pTarget = pOperand->GetRefPoint();
  251.                 break;
  252.         case AI_REG_ATTENTIONTARGET:
  253.                 pTarget = static_cast<CAIObject*>(pOperand->GetAttentionTarget());
  254.                 break;
  255.         default:
  256.                 AIError("G4Approach failed - unknown AI register");
  257.         }
  258.  
  259.         if (!pTarget)
  260.         {
  261.                 pOperand->SetSignal(0, "OnApproachFailed", pOperand->GetEntity(), NULL, 0); // MTJ: Provide CRC
  262.                 AILogAlways("COPG4Approach::Execute - Error - No target: %s", pOperand->GetName());
  263.                 RETURN_FAILED;
  264.         }
  265.  
  266.         if (pOperand->m_nPathDecision != PATHFINDER_PATHFOUND) m_fLastTime = -1.0f;
  267.  
  268.         // Check for unsuitable agents
  269.         if (pOperand->GetSubType() == CAIObject::STP_HELI
  270.             || !pOperand->m_movementAbility.bUsePathfinder)
  271.         {
  272.                 AILogAlways("COPG4Approach::Execute - Error - Unsuitable agent: %s", pOperand->GetName());
  273.                 RETURN_FAILED;
  274.         }
  275.  
  276.         if (pTarget->GetSubType() == CAIObject::STP_ANIM_TARGET)
  277.         {
  278.                 AILogAlways("COPG4Approach::Execute - Error - Unsuitable target: %s", pOperand->GetName());
  279.                 RETURN_FAILED;
  280.         }
  281.  
  282.         // Move strictly to the target point.
  283.         // MTJ: Not sure this should stay
  284.         pOperand->m_bPathfinderConsidersPathTargetDirection = true;
  285.  
  286.         // Where are we heading eventually?
  287.         Vec3 vAgentPosition(pOperand->GetPos());
  288.         float fDistToEndTarget = vAgentPosition.GetDistance(pTarget->GetPos());
  289.  
  290.         // Should we just approach directly?
  291.         // Either because we have been forced to, or because we are too close to the target
  292.         if (m_bForceDirect || (m_eApproachMode != EOPG4AS_Direct && fDistToEndTarget < m_fMinEndDistance))
  293.         {
  294.                 // Could check if we're actually very close to a hidespot
  295.                 m_eApproachMode = EOPG4AS_Direct;
  296.                 pOperand->SetInCover(false);
  297.                 pOperand->m_CurrentHideObject.Invalidate();
  298.         }
  299.  
  300.         // Examine whether we should choose another hidepoint
  301.         // We only ever go forward, and pass back control to higher levels if that's not appropriate
  302.         if (m_eApproachMode == EOPG4AS_Evaluate)
  303.         {
  304.                 // Do we have a current point we are approaching?
  305.                 if (m_refHideTarget.IsSet())
  306.                 {
  307.                         if (fDistToEndTarget < m_fMaxEndDistance)
  308.                         {
  309.                                 // Point is in acceptable range to stop, so we should, ASAP
  310.                                 // However, we must regenerate the point to arrive at the best location
  311.                                 m_eApproachMode = EOPG4AS_GoToHidepoint;
  312.                                 // Fooo.
  313.  
  314.                                 // Could be more subtle here, perhaps moving further into the acceptable range
  315.                                 // or looking for a better hidespot
  316.                         }
  317.                         else
  318.                         {
  319.                                 // Let the AI know this is a nice moment to shoot etc
  320.                                 pOperand->SetSignal(0, "OnPassedCover", pOperand->GetEntity(), NULL, 0); // MTJ: Provide CRC
  321.                         }
  322.  
  323.                         // Dispose of current point
  324.                         m_refHideTarget.Release();
  325.                 }
  326.  
  327.                 // Do we need a new point?
  328.                 if (m_refHideTarget.IsNil())
  329.                 {
  330.                         // Can set to false...
  331.                         pOperand->SetInCover(false);
  332.  
  333.                         CTacticalPoint point;
  334.                         CTacticalPointSystem* pTPS = gAIEnv.pTacticalPointSystem;
  335.  
  336.                         QueryContext context;
  337.                         InitQueryContextFromActor(pOperand, context);
  338.  
  339.                         if (m_eApproachMode == EOPG4AS_GoToHidepoint)
  340.                         {
  341.                                 // First make a slightly more ambitious query
  342.                                 int queryID = pTPS->GetQueryID("G4ApproachSuperior");
  343.                                 // TODO(marcio): fix
  344.                                 pTPS->SyncQuery(queryID, /*pOperand->CastToCPuppet()*/ context, point);
  345.                                 if (!point.IsValid())
  346.                                 {
  347.                                         // Just regenerating our last spot
  348.                                         pTPS->SyncQuery(m_iRegenerateCurrentQueryID, /*pOperand->CastToCPuppet()*/ context, point);
  349.                                 }
  350.                         }
  351.                         else
  352.                         {
  353.                                 // Script-build query that should exclude current hidespot
  354.                                 pTPS->SyncQuery(m_iApproachQueryID, /*pOperand->CastToCPuppet()*/ context, point);
  355.                                 m_eApproachMode = EOPG4AS_GoNearHidepoint;
  356.                         }
  357.  
  358.                         if (!point.IsValid())
  359.                         {
  360.                                 // Can't find any hidespot that will work - switch to direct approach
  361.                                 m_eApproachMode = EOPG4AS_Direct;
  362.                                 pOperand->SetInCover(false);
  363.                                 pOperand->m_CurrentHideObject.Invalidate();
  364.                         }
  365.                         else
  366.                         {
  367.                                 pOperand->m_CurrentHideObject.Set(point.GetHidespot(), point.GetPos(), point.GetHidespot()->info.dir);
  368.                                 gAIEnv.pAIObjectManager->CreateDummyObject(m_refHideTarget, string(pOperand->GetName()) + "_HideTarget");
  369.                                 m_refHideTarget.GetAIObject()->SetPos(point.GetPos());
  370.                                 pOperand->SetInCover(false);
  371.                         }
  372.                 }
  373.         }
  374.  
  375.         // If we have a hidespot, that's our target
  376.         // Otherwise it's the register-derived end target
  377.         if (m_refHideTarget.IsSet()) pTarget = m_refHideTarget.GetAIObject();
  378.  
  379.         switch (m_pPathfindDirective ? pOperand->m_nPathDecision : PATHFINDER_MAXVALUE)
  380.         {
  381.         case PATHFINDER_MAXVALUE:
  382.                 {
  383.                         // Generate path to target
  384.                         float endTol = (bForceReturnPartialPath || m_fEndAccuracy < 0.0f ? std::numeric_limits<float>::max() : m_fEndAccuracy);
  385.                         m_pPathfindDirective = new COPPathFind("", pTarget, endTol);
  386.                         pOperand->m_nPathDecision = PATHFINDER_STILLFINDING;
  387.                         if (m_pPathfindDirective->Execute(pOperand) && pOperand->m_nPathDecision == PATHFINDER_NOPATH)
  388.                         {
  389.                                 // If special nopath signal is specified, send the signal.
  390.                                 pOperand->m_State.vMoveDir.Set(0, 0, 0);
  391.                                 RETURN_FAILED;
  392.                         }
  393.                         break;
  394.                 }
  395.         case PATHFINDER_PATHFOUND:
  396.                 {
  397.                         // if we have a path, trace it
  398.                         if (pOperand->m_OrigPath.Empty())
  399.                         {
  400.                                 AILogAlways("COPG4Approach::Execute - Origpath is empty: %s", pOperand->GetName());
  401.                                 RETURN_FAILED;
  402.                         }
  403.  
  404.                         // If we need a tracer, create one
  405.                         if (!m_pTraceDirective)
  406.                         {
  407.                                 // MTJ: We create another goalop to achieve this? Hmm.
  408.                                 bool bExact = false;
  409.  
  410.                                 m_pTraceDirective = new COPTrace(bExact, m_fEndAccuracy, bForceReturnPartialPath);
  411.                                 TPathPoints::const_reference lastPathNode = pOperand->m_OrigPath.GetPath().back();
  412.                                 Vec3 vLastPos = lastPathNode.vPos;
  413.                                 Vec3 vRequestedLastNodePos = pOperand->m_Path.GetParams().end;
  414.                                 float dist = Distance::Point_Point(vLastPos, vRequestedLastNodePos);
  415.  
  416.                                 // MTJ: What is this for?
  417.                                 if (lastPathNode.navType != IAISystem::NAV_SMARTOBJECT && dist > C_MaxDistanceForPathOffset)// && pOperand->m_Path.GetPath().size() == 1 )
  418.                                 {
  419.                                         AISignalExtraData* pData = new AISignalExtraData;
  420.                                         pData->fValue = dist - m_fMinEndDistance;
  421.                                         pOperand->SetSignal(0, "OnEndPathOffset", pOperand->GetEntity(), pData, gAIEnv.SignalCRCs.m_nOnEndPathOffset);
  422.                                 }
  423.                                 else
  424.                                 {
  425.                                         pOperand->SetSignal(0, "OnPathFound", NULL, 0, gAIEnv.SignalCRCs.m_nOnPathFound);
  426.                                 }
  427.                         }
  428.  
  429.                         // Check if we have finished tracing to the end of our path
  430.                         bool bTraceDone = (m_pTraceDirective->Execute(pOperand) != eGOR_IN_PROGRESS);
  431.  
  432.                         CTimeValue time(pAISystem->GetFrameStartTime());
  433.                         if (m_fLastTime >= 0.0f)
  434.                         {
  435.                                 // HACK: The following code together with some logic in the execute tries to keep track
  436.                                 // if the agent is not moving for some time (is stuck), and pathfinds back to the path. [Mikko]
  437.                                 float dt((time - m_fLastTime).GetSeconds());
  438.                                 float speed = pOperand->GetVelocity().GetLength();
  439.                                 float desiredSpeed = pOperand->m_State.fDesiredSpeed;
  440.                                 if (desiredSpeed > 0.0f)
  441.                                 {
  442.                                         float ratio = clamp_tpl(speed / desiredSpeed, 0.0f, 1.0f);
  443.                                         if (ratio < 0.1f)
  444.                                                 m_fNotMovingTime += dt;
  445.                                         else
  446.                                                 m_fNotMovingTime -= dt;
  447.                                         if (m_fNotMovingTime < 0.0f)
  448.                                                 m_fNotMovingTime = 0.0f;
  449.                                 }
  450.                                 if (m_fNotMovingTime > 0.5f)
  451.                                         pOperand->SetSignal(0, "OnStuck", NULL, 0, 0);
  452.                         }
  453.                         m_fLastTime = time;
  454.  
  455.                         // If this goal gets reseted during m_pTraceDirective->Execute it means that
  456.                         // a smart object was used for navigation which inserts a goal pipe which
  457.                         // does Reset on this goal which sets m_pTraceDirective to NULL! In this case
  458.                         // we should just report that this goal pipe isn't finished since it will be
  459.                         // reexecuted after finishing the inserted goal pipe
  460.                         // MTJ: WTF?
  461.                         if (!m_pTraceDirective)
  462.                         {
  463.                                 AILogAlways("COPG4Approach::Execute - Why am I here?: %s", pOperand->GetName());
  464.                                 RETURN_FAILED;
  465.                         }
  466.  
  467.                         Vec3 vTargetPos = pTarget->GetPos();
  468.                         float fDistToHopTarget = vAgentPosition.GetDistance(vTargetPos);
  469.                         if (m_eApproachMode == EOPG4AS_GoNearHidepoint)
  470.                         {
  471.                                 if (bTraceDone || fDistToHopTarget < 2.0f)
  472.                                 {
  473.                                         m_eApproachMode = EOPG4AS_Evaluate; // Check where we are now
  474.                                         delete m_pPathfindDirective;
  475.                                         m_pPathfindDirective = NULL;
  476.                                 }
  477.  
  478.                         }
  479.                         else if (m_eApproachMode == EOPG4AS_GoToHidepoint)
  480.                         {
  481.                                 if (bTraceDone)
  482.                                 {
  483.                                         pOperand->SetSignal(0, "OnApproachedToCover", pOperand->GetEntity(), NULL, 0); // MTJ: Provide CRC
  484.                                         RETURN_SUCCEED;
  485.                                 }
  486.                         }
  487.                         else if (m_eApproachMode == EOPG4AS_Direct)
  488.                         {
  489.                                 if (bTraceDone || fDistToHopTarget < m_fMinEndDistance)
  490.                                 {
  491.                                         pOperand->SetSignal(0, "OnApproachedToOpen", pOperand->GetEntity(), NULL, 0); // MTJ: Provide CRC
  492.                                         RETURN_SUCCEED;
  493.                                 }
  494.  
  495.                                 // Otherwise, consider regenerating, stick-style
  496.                                 if (!pOperand->m_Path.Empty())
  497.                                 {
  498.                                         // Where does our current path end?
  499.                                         Vec3 pathEnd = pOperand->m_Path.GetLastPathPoint()->vPos;
  500.                                         // How far is that from our target?
  501.                                         float fTolerance = m_fMinEndDistance * 0.8f;
  502.                                         float fDrift = pathEnd.GetDistance(pTarget->GetPos());
  503.                                         if (fDrift > fTolerance)
  504.                                         {
  505.                                                 // Reset for new pathfinding
  506.                                                 m_pPathfindDirective->Reset(pOperand);
  507.                                                 m_pTraceDirective->m_fEndAccuracy = m_fEndAccuracy;
  508.                                                 pOperand->m_nPathDecision = PATHFINDER_STILLFINDING;
  509.  
  510.                                                 // Try to shortcut that with a direct connection to avoid the 4-frame lag
  511.                                                 bool bOk = true;
  512.                                                 int nbid;
  513.                                                 IAISystem::ENavigationType navType = gAIEnv.pNavigation->CheckNavigationType(pOperand->GetPos(), nbid,
  514.                                                                                                                              pOperand->m_movementAbility.pathfindingProperties.navCapMask);
  515.                                                 CNavRegion* pRegion = gAIEnv.pNavigation->GetNavRegion(navType, gAIEnv.pGraph);
  516.                                                 if (!pRegion) bOk = false;
  517.  
  518.                                                 NavigationBlockers navBlocker;
  519.                                                 bOk = bOk && pRegion->CheckPassability(vAgentPosition, vTargetPos, pOperand->GetParameters().m_fPassRadius, navBlocker, pOperand->GetMovementAbility().pathfindingProperties.navCapMask);
  520.  
  521.                                                 if (navType == IAISystem::NAV_TRIANGULAR)
  522.                                                 {
  523.                                                         // Make sure not to enter forbidden area.
  524.                                                         bOk = bOk && !gAIEnv.pNavigation->IsPathForbidden(vAgentPosition, vTargetPos);
  525.                                                         bOk = bOk && !gAIEnv.pNavigation->IsPointForbidden(vTargetPos, pOperand->GetParameters().m_fPassRadius);
  526.                                                 }
  527.  
  528.                                                 if (bOk)
  529.                                                 {
  530.                                                         pOperand->ClearPath("COPG4Approach::Clearing m_Path for shortcut");
  531.  
  532.                                                         PathPointDescriptor pt;
  533.                                                         pt.navType = navType;
  534.                                                         pt.vPos = vAgentPosition;
  535.                                                         pOperand->m_Path.PushBack(pt);
  536.  
  537.                                                         pt.vPos = vTargetPos;
  538.                                                         pOperand->m_Path.PushBack(pt);
  539.  
  540.                                                         // Double-check that we aren't already at the end, in which case won't have minimal path
  541.                                                         if (pOperand->m_Path.Empty())
  542.                                                                 RETURN_FAILED;
  543.  
  544.                                                         // Effectively cancel our own decision to pathfind, as we've done it ourselves
  545.                                                         // Could perhaps mention end distance, but shoudl really do it everywhere, not just here
  546.                                                         pOperand->m_Path.SetParams(SNavPathParams(vAgentPosition, vTargetPos, Vec3(ZERO), Vec3(ZERO), -1, false, 0.0f, true));
  547.                                                         pOperand->m_OrigPath = pOperand->m_Path;
  548.                                                         pOperand->m_nPathDecision = PATHFINDER_PATHFOUND;
  549.                                                 }
  550.                                                 else
  551.                                                 {
  552.                                                         // Shortcutting failed, but we've already started changing the path, which isn't good
  553.                                                         // At least try to go back to consistent state
  554.                                                         pOperand->ClearPath("COPG4Approach::Clearing m_Path from failed shortcut");
  555.                                                 }
  556.                                         }
  557.                                 }
  558.                         }
  559.                         break;
  560.                 }
  561.         case PATHFINDER_NOPATH:
  562.                 {
  563.                         pOperand->SetSignal(0, "OnApproachFailed", pOperand->GetEntity(), NULL, 0); // MTJ: Provide CRC
  564.                         RETURN_FAILED;
  565.                 }
  566.         default:
  567.                 {
  568.                         // MTJ: Still pathfinding I guess?
  569.                         m_pPathfindDirective->Execute(pOperand);
  570.                         break;
  571.                 }
  572.         }
  573.         // Run me again next tick
  574.         RETURN_IN_PROGRESS;
  575. }
  576.  
  577. void COPG4Approach::DebugDraw(CPipeUser* pOperand) const
  578. {
  579.         if (m_pTraceDirective)
  580.                 m_pTraceDirective->DebugDraw(pOperand);
  581.         if (m_pPathfindDirective)
  582.                 m_pPathfindDirective->DebugDraw(pOperand);
  583. }
  584.  
  585. void COPG4Approach::ExecuteDry(CPipeUser* pOperand)
  586. {
  587.         if (m_pTraceDirective)
  588.                 m_pTraceDirective->ExecuteTrace(pOperand, false);
  589. }
  590. #endif // 0
  591.  
downloadGoalOp_G04.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top