BVB Source Codes

CRYENGINE Show Formation.h Source code

Return Download CRYENGINE: download Formation.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:
  6.    $Id$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    created by Petar
  12.    - 9:2:2005   Kirill  - moved FormationNode to <AIFormationDescriptor.h>
  13.    - 1:6:2005   Kirill  - serialization support added; clean-up: introduced CFormationPoint vector, instead of many separate vectors
  14.    - 2 Mar 2009: Evgeny Adamenkov: Removed IRenderer
  15.  *********************************************************************/
  16.  
  17. #ifndef _FORMATION_
  18. #define _FORMATION_
  19.  
  20. #if _MSC_VER > 1000
  21.         #pragma once
  22. #endif
  23.  
  24. #include <CryAISystem/AIFormationDescriptor.h>
  25. #include "PathMarker.h"
  26. #include <CrySystem/TimeValue.h>
  27. #include <vector>
  28.  
  29. class CAIObject;
  30. class CAIActor;
  31. class CAISystem;
  32.  
  33. #include "ObjectContainer.h"
  34.  
  35. struct CFormationPoint
  36. {
  37.         CFormationPoint();
  38.         ~CFormationPoint();
  39.         void Serialize(TSerialize ser);
  40.  
  41.         Vec3                   m_vPoint;                  //TVectorOfVectors m_vPoints;
  42.         Vec3                   m_vSight;                  //TVectorOfVectors m_vSights;
  43.         float                  m_FollowDistance;          //    std::vector<float> m_vFollowDistances;
  44.         float                  m_FollowOffset;            //std::vector<float> m_vFollowOffsets;
  45.         float                  m_FollowDistanceAlternate; //    std::vector<float> m_vFollowDistancesAlternate;
  46.         float                  m_FollowOffsetAlternate;   //std::vector<float> m_vFollowOffsetsAlternate;
  47.         float                  m_FollowHeightOffset;      //std::vector<float> m_vFollowOffsets;
  48.         float                  m_Speed;                   //    std::vector<float> m_Speeds;
  49.         CTimeValue             m_fLastUpdateSightTime;
  50.         Vec3                   m_LastPosition;   // TVectorOfVectors m_vLastPosition;
  51.         Vec3                   m_Dir;            //TVectorOfVectors m_vDir;
  52.         int                    m_Class;          //std::vector<int> m_vClasses;
  53.         CCountedRef<CAIObject> m_refWorldPoint;  //TFormationDummies m_vWorldPoints;
  54.         CWeakRef<CAIActor>     m_refReservation; //TFormationDummies m_vReservations;
  55.         CCountedRef<CAIObject> m_refDummyTarget; //TFormationDummies  m_vpDummyTargets;
  56.         bool                   m_FollowFlag;     //std::vector<bool> m_vFollowFlags;
  57.         Vec3                   m_DEBUG_vInitPos; // Initial position for debugging.
  58.  
  59.         void SetPos(Vec3 pos, const Vec3& startPos, bool force = false, bool bPlayerLeader = false);
  60. };
  61.  
  62. typedef std::vector<CFormationPoint> TFormationPoints;
  63.  
  64. class CFormation
  65. {
  66. public:
  67.         enum eOrientationType
  68.         {
  69.                 OT_MOVE,
  70.                 OT_VIEW
  71.         };
  72.  
  73.         typedef int TFormationID;
  74.         static const TFormationID INVALID_FORMATION_ID = -1;
  75.         static TFormationID       s_NextFormation;
  76.  
  77. private:
  78.         TFormationID     m_formationID;
  79.         TFormationPoints m_FormationPoints;
  80.  
  81.         //      Vec3 m_vPos;
  82.         //      Vec3 m_vAngles;
  83.  
  84.         bool                      m_bReservationAllowed;
  85.  
  86.         Vec3                      m_vLastUpdatePos;
  87.         Vec3                      m_vLastPos;
  88.         Vec3                      m_vLastTargetPos;
  89.         Vec3                      m_vLastMoveDir;
  90.         Vec3                      m_vInitialDir;
  91.         Vec3                      m_vBodyDir;
  92.         Vec3                      m_vMoveDir;
  93.         bool                      m_bInitMovement;
  94.         bool                      m_bFirstUpdate;
  95.         bool                      m_bUpdate;
  96.         bool                      m_bForceReachable;
  97.         bool                      m_bFollowingUnits;
  98.         bool                      m_bFollowPointInitialized;
  99.         float                     m_fUpdateThreshold;
  100.         float                     m_fDynamicUpdateThreshold;
  101.         float                     m_fStaticUpdateThreshold;
  102.         float                     m_fScaleFactor;
  103.         static const float        m_fDISTANCE_UPDATE_THR;
  104.         static const float        m_fSIGHT_WIDTH;
  105.         CPathMarker*              m_pPathMarker;
  106.         int                       m_iSpecialPointIndex;
  107.         float                     m_fMaxFollowDistance;
  108.         CTimeValue                m_fLastUpdateTime;
  109.         int                       m_maxUpdateSightTimeMs;
  110.         int                       m_minUpdateSightTimeMs;
  111.         float                     m_fSightRotationRange;
  112.         eOrientationType          m_orientationType;
  113.  
  114.         Vec3                      m_dbgVector1;
  115.         Vec3                      m_dbgVector2;
  116.         string                    m_szDescriptor;
  117.         CWeakRef<const CAIObject> m_refReferenceTarget;
  118.         CWeakRef<CAIObject>       m_refOwner;                   // (MATT) Could be a pipeuser or such? {2009/03/18}
  119.         float                     m_fRepositionSpeedWrefTarget;
  120.         Vec3                      m_vDesiredTargetPos;
  121.  
  122. public:
  123.         CFormation();
  124.         ~CFormation(void);
  125.         void         ReleasePoints();
  126.         void         OnObjectRemoved(CAIObject* pObject);
  127.         // fills the formation class with all necessary information and set the points in the world
  128.         void         Create(CFormationDescriptor& desc, CWeakRef<CAIObject> refOwner, Vec3 vTargetPos);
  129.         // Update of the formation (refreshes position of formation points)
  130.         void         Update(/*CAIObject *pOwner */);
  131.         // Changes the position of formation points
  132.         void         Change(CFormationDescriptor& desc, float fScale);
  133.  
  134.         float        GetMaxWidth();
  135.         TFormationID GetId() { return m_formationID; }
  136.  
  137.         // Init the world positions of the formation points
  138.         void           InitWorldPosition(Vec3 dir = ZERO);
  139.         // returns an available formation point, if that exists
  140.         CAIObject*     GetNewFormationPoint(CWeakRef<CAIActor> refRequester, int index = -1);
  141.         int            GetClosestPointIndex(CWeakRef<CAIActor> refRequester, bool bReserve = false, int maxSize = 0, int iClass = -1, bool bClosestToOwner = false);
  142.         CAIObject*     GetClosestPoint(CAIActor* pRequester, bool bReserve = false, int iClass = -1);
  143.         CAIObject*     GetFormationDummyTarget(CWeakRef<const CAIObject> refRequester) const;
  144.         inline int     GetSize() const { return static_cast<int>(m_FormationPoints.size()); }
  145.         inline Vec3    GetBodyDir()    { return m_vBodyDir;  }
  146.         inline Vec3    GetMoveDir()    { return m_vMoveDir;  }
  147.         inline string& GetDescriptor() { return m_szDescriptor; }
  148.         void           SetScale(float scale);
  149.  
  150.         // (MATT) This isn't actually called anywhere. Could surely go. {2009/03/23}
  151.         void                    SetReferenceTarget(const CAIObject* pTarget, float repositionSpeed = 0);
  152.  
  153.         inline const CAIObject* GetReferenceTarget() const { return m_refReferenceTarget.GetAIObject(); }
  154.         // if update=false, formation is not updated - it stays where it was last time
  155.         void                    SetUpdate(bool bUpdate);
  156.         inline void             ForceReachablePoints(bool force) { m_bForceReachable = force; }
  157.         inline bool             IsUpdated() const                { return m_bUpdate; }
  158.  
  159.         inline bool             IsPointFree(int i) const         { return static_cast<bool>(m_FormationPoints[i].m_refReservation.GetAIObject() == NULL); }
  160.         inline CAIActor*        GetPointOwner(int i) const       { return m_FormationPoints[i].m_refReservation.GetAIObject(); }
  161.         void                    Draw();
  162.         void                    FreeFormationPoint(CWeakRef<const CAIObject> refCurrentHolder);
  163.         void                    FreeFormationPoint(int i);
  164.         int                     CountFreePoints() const;
  165.         CAIObject*              GetFormationPoint(CWeakRef<const CAIObject> refRequester) const;
  166.         inline CAIObject*       GetFormationPoint(int index) const { return (index >= 0 && index < (int)m_FormationPoints.size() ? m_FormationPoints[index].m_refWorldPoint.GetAIObject() : NULL); };
  167.         float                   GetFormationPointSpeed(CWeakRef<const CAIObject> refRequester) const;
  168.         float                   GetDistanceToOwner(int i) const;
  169.         inline int              GetPointClass(int i) const { return m_FormationPoints[i].m_Class; }
  170.         //      inline Vec3 GetPointPosition(int i) {return m_vWorldPoints[i];}
  171.         void                    Reset();
  172.         void                    Serialize(TSerialize ser);
  173.         Vec3                    GetPredictedPointPosition(CWeakRef<const CAIObject> refRequestor, const Vec3& ownerPos, const Vec3& ownerLookDir, Vec3 ownerMoveDir) const;
  174.         void                    SetUpdateSight(float angleRange, float minTime = 0.0f, float maxTime = 0.0f);
  175.  
  176.         inline void             SetOrientationType(eOrientationType t) { m_orientationType = t; }
  177.  
  178.         bool                    GetPointOffset(int i, Vec3& ret);
  179.  
  180.         const CPathMarker*      GetPathMarker() const { return m_pPathMarker; }
  181.         CAIObject*              GetOwner();
  182.         int                     GetPointIndex(CWeakRef<const CAIObject> refRequester) const; // returns -1 if the requester has not acquired a slot in this formation
  183.  
  184. private:
  185.         //void UpdateOrientations();
  186.         void SetDummyTargetPosition(const Vec3& vPosition, CAIObject* pDummyTarget, const Vec3& vSight);
  187.         void InitFollowPoints(const Vec3& vDir = ZERO);//, const CAIObject* pRequestor);
  188.         void SetOffsetPointsPos(const Vec3& vMovedir);
  189.         void SetUpdateThresholds(float value);
  190.         Vec3 GetPointSmooth(const Vec3& headPos, float backDisr, float sideDist, float heightValue, int smoothValue, Vec3& pPointAlongCurve, CAIObject* pUser = NULL);
  191.         void AddPoint(FormationNode& desc);
  192. };
  193.  
  194. #endif
  195.  
downloadFormation.h 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