BVB Source Codes

CRYENGINE Show SmartObjects.h Source code

Return Download CRYENGINE: download SmartObjects.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:   SmartObjects.h
  6.    $Id$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - ?                                                  : Created by ?
  12.  
  13.  *********************************************************************/
  14. #ifndef _SMARTOBJECTS_H_
  15. #define _SMARTOBJECTS_H_
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <CryEntitySystem/IEntitySystem.h>
  22. #include <CryMemory/STLPoolAllocator.h>
  23. #include "Navigation/MNM/MNM.h"
  24.  
  25. // forward declaration
  26. class CAIActor;
  27. class CSmartObject;
  28. class CSmartObjectClass;
  29. struct CCondition;
  30.  
  31. struct OffMeshLink_SmartObject;
  32.  
  33. typedef std::vector<CSmartObjectClass*> CSmartObjectClasses;
  34.  
  35. struct SNavSOStates
  36. {
  37.         SNavSOStates() : objectEntId(0) {}
  38.  
  39.         void Clear()
  40.         {
  41.                 objectEntId = 0;
  42.                 sAnimationDoneUserStates.clear();
  43.                 sAnimationDoneObjectStates.clear();
  44.                 sAnimationFailUserStates.clear();
  45.                 sAnimationFailObjectStates.clear();
  46.         }
  47.  
  48.         bool IsEmpty() const { return objectEntId == 0; }
  49.  
  50.         void Serialize(TSerialize ser)
  51.         {
  52.                 ser.BeginGroup("SNavSOStates");
  53.                 ser.Value("objectEntId", objectEntId);
  54.                 ser.Value("sAnimationDoneUserStates", sAnimationDoneUserStates);
  55.                 ser.Value("sAnimationDoneObjectStates", sAnimationDoneObjectStates);
  56.                 ser.Value("sAnimationFailUserStates", sAnimationFailUserStates);
  57.                 ser.Value("sAnimationFailObjectStates", sAnimationFailObjectStates);
  58.                 ser.EndGroup();
  59.         }
  60.  
  61.         EntityId objectEntId;
  62.         string   sAnimationDoneUserStates;
  63.         string   sAnimationDoneObjectStates;
  64.         string   sAnimationFailUserStates;
  65.         string   sAnimationFailObjectStates;
  66. };
  67.  
  68. ///////////////////////////////////////////////
  69. // CSmartObjectEvent represents the priority of usage of some Smart Object
  70. ///////////////////////////////////////////////
  71. struct CSmartObjectEvent
  72. {
  73.         CSmartObject* m_pObject;
  74.         CCondition*   m_pCondition;
  75.  
  76.         // < 0 means this event should be removed
  77.         // 0 means just started
  78.         // 1 means ready to be used
  79.         float m_Delay;
  80. };
  81.  
  82. ///////////////////////////////////////////////
  83. // CSmartObjectBase will be the base for CSmartObject class
  84. ///////////////////////////////////////////////
  85. class CSmartObjectBase
  86. {
  87. protected:
  88.         EntityId m_entityId;
  89.  
  90. public:
  91.         explicit CSmartObjectBase(EntityId entityId) : m_entityId(entityId) {}
  92.  
  93.         ILINE EntityId         GetEntityId() const { return m_entityId; }
  94.         ILINE IEntity*         GetEntity() const;
  95.  
  96.         void                   SetEntityId(EntityId id) { m_entityId = id; }
  97.  
  98.         Vec3                   GetPos() const;
  99.         Vec3                   GetHelperPos(const SmartObjectHelper* pHelper) const;
  100.         Vec3                   GetOrientation(const SmartObjectHelper* pHelper) const;
  101.         ILINE const char*      GetName() const;
  102.         ILINE IPhysicalEntity* GetPhysics() const;
  103.         ILINE CAIObject*       GetAI() const;
  104.         CPipeUser*             GetPipeUser() const;
  105.         CAIActor*              GetAIActor() const;
  106.  
  107.         void                   OnReused(IEntity* pEntity);
  108. };
  109.  
  110. enum ESO_Validate
  111. {
  112.         eSOV_Unknown,
  113.         eSOV_InvalidStatic,
  114.         eSOV_InvalidDynamic,
  115.         eSOV_Valid,
  116. };
  117.  
  118. ///////////////////////////////////////////////
  119. // Class Template
  120. ///////////////////////////////////////////////
  121. class CClassTemplateData
  122. {
  123.         IStatObj* m_pStatObj;
  124.  
  125. public:
  126.         CClassTemplateData() : m_pStatObj(0) {}
  127.         ~CClassTemplateData() { if (m_pStatObj) m_pStatObj->Release(); }
  128.  
  129.         string name;
  130.  
  131.         struct CTemplateHelper
  132.         {
  133.                 CTemplateHelper()
  134.                         : name("")
  135.                         , qt(IDENTITY)
  136.                         , radius(.0f)
  137.                         , project(false)
  138.                 {}
  139.  
  140.                 string name;
  141.                 QuatT  qt;
  142.                 float  radius;
  143.                 bool   project;
  144.         };
  145.         typedef std::vector<CTemplateHelper> TTemplateHelpers;
  146.  
  147.         string           model;
  148.         TTemplateHelpers helpers;
  149.  
  150.         const CTemplateHelper* GetHelper(const char* helperName) const
  151.         {
  152.                 TTemplateHelpers::const_iterator it, itEnd = helpers.end();
  153.                 for (it = helpers.begin(); it != itEnd; ++it)
  154.                         if (it->name == helperName)
  155.                                 return &*it;
  156.                 return NULL;
  157.         }
  158.  
  159.         IStatObj* GetIStateObj()
  160.         {
  161.                 if (m_pStatObj)
  162.                         return m_pStatObj;
  163.  
  164.                 if (!model.empty())
  165.                 {
  166.                         m_pStatObj = gEnv->p3DEngine->LoadStatObj("Editor/Objects/" + model, NULL, NULL, false);
  167.                         if (m_pStatObj)
  168.                         {
  169.                                 m_pStatObj->AddRef();
  170.                                 if (GetHelperMaterial())
  171.                                         m_pStatObj->SetMaterial(GetHelperMaterial());
  172.                         }
  173.                 }
  174.  
  175.                 return m_pStatObj;
  176.         }
  177.  
  178.         static IMaterial* m_pHelperMtl;
  179.         static IMaterial* GetHelperMaterial()
  180.         {
  181.                 if (!m_pHelperMtl)
  182.                         m_pHelperMtl = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial("Editor/Objects/Helper");
  183.                 return m_pHelperMtl;
  184.         };
  185. };
  186. // MapClassTemplateData contains all class templates indexed by name
  187. typedef std::map<string, CClassTemplateData> MapClassTemplateData;
  188.  
  189. ///////////////////////////////////////////////
  190. // CSmartObject contains a pointer to the entity used as smart object and its additional info
  191. ///////////////////////////////////////////////
  192. class CSmartObject : public CSmartObjectBase
  193. {
  194. public:
  195.         class CState;
  196.         typedef std::set<CState> SetStates;
  197.  
  198.         ///////////////////////////////////////////////
  199.         // States internally are represented with IDs
  200.         ///////////////////////////////////////////////
  201.         class CState
  202.         {
  203.                 typedef std::map<string, int>    MapSmartObjectStateIds;
  204.                 typedef std::vector<const char*> MapSmartObjectStates;
  205.  
  206.                 static MapSmartObjectStateIds g_mapStateIds;
  207.                 static MapSmartObjectStates   g_mapStates;
  208.                 static SetStates              g_defaultStates;
  209.  
  210.                 void Assign(const char* state)
  211.                 {
  212.                         if (*state)
  213.                         {
  214.                                 std::pair<MapSmartObjectStateIds::iterator, bool> pr = g_mapStateIds.insert(std::make_pair(state, g_mapStates.size()));
  215.                                 if (pr.second)   // was insertion made?
  216.                                         g_mapStates.push_back(pr.first->first.c_str());
  217.                                 m_StateId = pr.first->second;
  218.                         }
  219.                         else
  220.                         {
  221.                                 m_StateId = -1;
  222.                         }
  223.                 }
  224.  
  225.         protected:
  226.                 int m_StateId;
  227.  
  228.         public:
  229.                 explicit CState(const char* state)
  230.                 {
  231.                         Assign(state);
  232.                 }
  233.  
  234.                 CState() : m_StateId(-1) {}
  235.  
  236.                 static void Reset()
  237.                 {
  238.                         stl::free_container(g_mapStates);
  239.                         stl::free_container(g_mapStateIds);
  240.                         stl::free_container(g_defaultStates);
  241.                 }
  242.  
  243.                 static const SetStates& GetDefaultStates();
  244.  
  245.                 void                    Serialize(TSerialize ser)
  246.                 {
  247.                         string value = c_str();
  248.                         ser.ValueWithDefault("Value", value, "Idle");
  249.  
  250.                         if (ser.IsReading())
  251.                         {
  252.                                 Assign(value.c_str());
  253.                         }
  254.                 }
  255.  
  256.                 bool               operator<(const CState& other) const  { return m_StateId < other.m_StateId; }
  257.                 bool               operator==(const CState& other) const { return m_StateId == other.m_StateId; }
  258.                 bool               operator!=(const CState& other) const { return m_StateId != other.m_StateId; }
  259.  
  260.                 int                asInt() const                         { return m_StateId; }
  261.                 const char*        c_str() const                         { return (m_StateId >= 0 && m_StateId < (int)g_mapStates.size()) ? g_mapStates[m_StateId] : ""; }
  262.  
  263.                 static int         GetNumStates()                        { return g_mapStates.size(); }
  264.                 static const char* GetStateName(int i)                   { return i >= 0 && i < (int)g_mapStates.size() ? g_mapStates[i] : NULL; }
  265.         };
  266.  
  267.         typedef std::vector<CState> VectorStates;
  268.  
  269.         class DoubleVectorStates
  270.         {
  271.         public:
  272.                 VectorStates positive;
  273.                 VectorStates negative;
  274.  
  275.                 string AsString() const
  276.                 {
  277.                         string temp;
  278.                         for (uint32 i = 0; i < positive.size(); ++i)
  279.                         {
  280.                                 if (i) temp += ',';
  281.                                 temp += positive[i].c_str();
  282.                         }
  283.                         if (!negative.empty())
  284.                         {
  285.                                 temp += '-';
  286.                                 for (uint32 i = 0; i < negative.size(); ++i)
  287.                                 {
  288.                                         if (i) temp += ',';
  289.                                         temp += negative[i].c_str();
  290.                                 }
  291.                         }
  292.                         return temp;
  293.                 }
  294.  
  295.                 string AsUndoString() const
  296.                 {
  297.                         string temp;
  298.                         for (uint32 i = 0; i < negative.size(); ++i)
  299.                         {
  300.                                 if (i) temp += ',';
  301.                                 temp += negative[i].c_str();
  302.                         }
  303.                         if (!positive.empty())
  304.                         {
  305.                                 temp += '-';
  306.                                 for (uint32 i = 0; i < positive.size(); ++i)
  307.                                 {
  308.                                         if (i) temp += ',';
  309.                                         temp += positive[i].c_str();
  310.                                 }
  311.                         }
  312.                         return temp;
  313.                 }
  314.  
  315.                 bool empty() const { return positive.empty() && negative.empty(); }
  316.  
  317.                 bool operator==(const DoubleVectorStates& other) const
  318.                 {
  319.                         return positive == other.positive && negative == other.negative;
  320.                 }
  321.                 bool operator!=(const DoubleVectorStates& other) const
  322.                 {
  323.                         return positive != other.positive || negative != other.negative;
  324.                 }
  325.  
  326.                 bool Matches(const SetStates& states, const SetStates* exceptions = NULL) const
  327.                 {
  328.                         SetStates::const_iterator statesEnd = states.end();
  329.                         VectorStates::const_iterator it, itEnd = positive.end();
  330.  
  331.                         // Check if a required state is missing
  332.                         for (it = positive.begin(); it != itEnd; ++it)
  333.                                 if (states.find(*it) == statesEnd && (!exceptions || (exceptions->find(*it) == exceptions->end())))
  334.                                         return false;
  335.  
  336.                         itEnd = negative.end();
  337.  
  338.                         // Check if a failing state is present
  339.                         for (it = negative.begin(); it != itEnd; ++it)
  340.                                 if (states.find(*it) != statesEnd && (!exceptions || (exceptions->find(*it) == exceptions->end())))
  341.                                         return false;
  342.  
  343.                         return true;
  344.                 }
  345.  
  346.                 bool ChecksState(CState state) const
  347.                 {
  348.                         if (std::find(positive.begin(), positive.end(), state) != positive.end())
  349.                                 return true;
  350.                         if (std::find(negative.begin(), negative.end(), state) != negative.end())
  351.                                 return true;
  352.                         return false;
  353.                 }
  354.         };
  355.  
  356.         class CStatePattern : public std::vector<DoubleVectorStates>
  357.         {
  358.         public:
  359.                 bool Matches(const SetStates& states, const SetStates* pStatesToNotMatch = NULL) const
  360.                 {
  361.                         const_iterator it, itEnd = end();
  362.                         for (it = begin(); it != itEnd; ++it)
  363.                                 if (it->Matches(states, pStatesToNotMatch))
  364.                                         return true;
  365.                         return empty();
  366.                 }
  367.  
  368.                 string AsString() const
  369.                 {
  370.                         string temp;
  371.                         for (uint32 i = 0; i < size(); ++i)
  372.                         {
  373.                                 if (i)
  374.                                         temp += " | ";
  375.                                 temp += at(i).AsString();
  376.                         }
  377.                         return temp;
  378.                 }
  379.  
  380.                 bool ChecksState(CState state) const
  381.                 {
  382.                         const_iterator it, itEnd = end();
  383.                         for (it = begin(); it != itEnd; ++it)
  384.                                 if (it->ChecksState(state))
  385.                                         return true;
  386.                         return false;
  387.                 }
  388.         };
  389.  
  390. protected:
  391.         friend class CSmartObjectClass;
  392.         friend class CSmartObjectManager;
  393.  
  394.         CSmartObjectClasses m_vClasses;
  395.  
  396.         SetStates           m_States;
  397.  
  398.         float               m_fKey;
  399.  
  400.         typedef std::vector<CSmartObjectEvent>             VectorEvents;
  401.         typedef std::map<CSmartObjectClass*, VectorEvents> MapEventsByClass;
  402.         MapEventsByClass m_Events;
  403.         float            m_fRandom;
  404.  
  405.         typedef std::map<CSmartObjectClass*, CTimeValue> MapTimesByClass;
  406.         MapTimesByClass m_mapLastUpdateTimes;
  407.  
  408.         // LookAt helpers
  409.         float m_fLookAtLimit;
  410.         Vec3  m_vLookAtPos;
  411.  
  412.         typedef std::map<const SmartObjectHelper*, unsigned> MapNavNodes;
  413.  
  414.         // Cached results for GetEnclosingNavNode, which looks for enclosing nav nodes of types SMART_OBJECT_ENCLOSING_NAV_TYPES (does NOT include smartobject nav type!)
  415.         MapNavNodes m_enclosingNavNodes;
  416.  
  417.         // The navgraph nodes created by this smartobject (one per helper)
  418.         MapNavNodes m_correspondingNavNodes;
  419.  
  420.         // Links from the navgraph nodes created by this smartobject (one per helper) to other connected (non-smartobject) nodes
  421.         typedef std::vector<unsigned> VectorNavLinks;
  422.         VectorNavLinks m_navLinks;
  423.  
  424.         ESO_Validate   m_eValidationResult;
  425.  
  426.         bool           m_bHidden;
  427.  
  428.         // returns the size of the AI puppet (or Vec3(ZERO) if it isn't a puppet)
  429.         // x - radius, y - height, z - offset from the ground
  430.         Vec3 MeasureUserSize() const;
  431.  
  432.         void Reset();
  433.  
  434.         void UnregisterFromAllClasses();
  435.  
  436.         // Used with entity reloading
  437.         void OnReused(IEntity* pEntity);
  438.  
  439. public:
  440.         struct CTemplateHelperInstance
  441.         {
  442.                 Vec3         position;
  443.                 ESO_Validate validationResult;
  444.         };
  445.         typedef std::vector<CTemplateHelperInstance> TTemplateHelperInstances;
  446.  
  447. protected:
  448.         struct CTemplateData
  449.         {
  450.                 CSmartObjectClass*       pClass;
  451.                 float                    userRadius;
  452.                 float                    userTop;
  453.                 float                    userBottom;
  454.                 bool                     staticTest;
  455.                 TTemplateHelperInstances helperInstances;
  456.  
  457.                 CTemplateData() : pClass(NULL), userRadius(0.f), userTop(0.f), userBottom(0.f), staticTest(false) {}
  458.         };
  459.         typedef std::map<CClassTemplateData*, CTemplateData> MapTemplates;
  460.         std::unique_ptr<MapTemplates> m_pMapTemplates;
  461.  
  462. public:
  463.         explicit CSmartObject(EntityId entityId);
  464.         ~CSmartObject();
  465.  
  466.         void Register();
  467.  
  468.         void Hide(bool hide)  { m_bHidden = hide; }
  469.         bool IsHidden() const { return m_bHidden; }
  470.  
  471.         void Serialize(TSerialize ser);
  472.         void SerializePointer(TSerialize ser, const char* name, CSmartObject*& pSmartObject);
  473.  
  474.         bool operator<(const CSmartObject& other) const  { return m_entityId < other.m_entityId; }
  475.         bool operator==(const CSmartObject& other) const { return m_entityId == other.m_entityId; }
  476.  
  477.         //Adds a class to the current set
  478.         void RegisterSmartObjectClass(CSmartObjectClass* pClass) { m_vClasses.push_back(pClass); }
  479.  
  480.         //Removes a class from the current set
  481.         void UnregisterSmartObjectClass(CSmartObjectClass* pClass)
  482.         {
  483.                 const bool foundClass = stl::find_and_erase(m_vClasses, pClass);
  484.                 AIAssert(foundClass);
  485.         }
  486.  
  487.         CSmartObjectClasses& GetClasses()      { return m_vClasses; }
  488.         const SetStates& GetStates() const { return m_States; }
  489.  
  490.         void             Use(CSmartObject* pObject, CCondition* pCondition, int eventId = 0, bool bForceHighPriority = false) const;
  491.  
  492.         /// Measures the user size and applies value to all associated smart object classes
  493.         void ApplyUserSize();
  494.  
  495.         /// Calculates the navigation node that we're, or else a particular helper is, attached to.
  496.         /// If already attached it does nothing - the result is cached
  497.         unsigned GetEnclosingNavNode(const SmartObjectHelper* pHelper);
  498.  
  499.         /// Returns the navigation node which was created for this helper
  500.         unsigned      GetCorrespondingNavNode(const SmartObjectHelper* pHelper);
  501.  
  502.         MapTemplates& GetMapTemplates();
  503.  
  504.         ESO_Validate  GetValidationResult() const { return m_eValidationResult; }
  505. };
  506.  
  507. typedef std::pair<CSmartObjectClass*, CSmartObject::CState> PairClassState;
  508.  
  509. ///////////////////////////////////////////////
  510. // CSmartObjectClass maps entities to smart objects
  511. ///////////////////////////////////////////////
  512. class CSmartObjectClass
  513. {
  514. protected:
  515.         typedef std::vector<CSmartObject*> VectorSmartObjects;
  516.         VectorSmartObjects m_allSmartObjectInstances;
  517.         unsigned int       m_indexNextObject;
  518.  
  519.         const string       m_sName;
  520.  
  521.         bool               m_bSmartObjectUser;
  522.         bool               m_bNeeded;
  523.  
  524. public:
  525.  
  526.         // classes now keep track of all their instances
  527.         typedef std::multimap<float, CSmartObject*, std::less<float>, stl::STLPoolAllocator<std::pair<const float, CSmartObject*>, stl::PoolAllocatorSynchronizationSinglethreaded>> MapSmartObjectsByPos;
  528.         MapSmartObjectsByPos m_MapObjectsByPos; // map of all smart objects indexed by their position
  529.  
  530.         typedef std::vector<SmartObjectHelper*> VectorHelpers;
  531.         VectorHelpers m_vHelpers;
  532.  
  533.         typedef std::map<string, CSmartObjectClass*> MapClassesByName;
  534.         static MapClassesByName g_AllByName;
  535.  
  536.         typedef std::vector<CSmartObjectClass*> VectorClasses;
  537.         static VectorClasses           g_AllUserClasses;
  538.         static VectorClasses::iterator g_itAllUserClasses;
  539.  
  540.         CSmartObjectClass(const char* className);
  541.         ~CSmartObjectClass();
  542.  
  543.         static CSmartObjectClass* find(const char* sClassName);
  544.  
  545.         const string              GetName() const { return m_sName; }
  546.  
  547.         void                      RegisterSmartObject(CSmartObject* pSmartObject);
  548.         void                      UnregisterSmartObject(CSmartObject* pSmartObject);
  549.         bool                      RemoveSmartObject(CSmartObject* pSmartObject, bool bCanDelete);
  550.  
  551.         void                      MarkAsSmartObjectUser()
  552.         {
  553.                 m_bSmartObjectUser = true;
  554.                 if (m_bNeeded)
  555.                 {
  556.                         if (std::find(g_AllUserClasses.begin(), g_AllUserClasses.end(), this) == g_AllUserClasses.end())
  557.                                 g_AllUserClasses.push_back(this);
  558.                         g_itAllUserClasses = g_AllUserClasses.end();
  559.                 }
  560.         }
  561.         bool IsSmartObjectUser() const { return m_bSmartObjectUser; }
  562.  
  563.         void MarkAsNeeded()
  564.         {
  565.                 m_bNeeded = true;
  566.                 if (m_bSmartObjectUser)
  567.                 {
  568.                         if (std::find(g_AllUserClasses.begin(), g_AllUserClasses.end(), this) == g_AllUserClasses.end())
  569.                                 g_AllUserClasses.push_back(this);
  570.                         g_itAllUserClasses = g_AllUserClasses.end();
  571.                 }
  572.         }
  573.         bool          IsNeeded() const { return m_bNeeded; }
  574.  
  575.         void          FirstObject()    { m_indexNextObject = 0; }
  576.         CSmartObject* NextObject()
  577.         {
  578.                 if (m_indexNextObject >= m_allSmartObjectInstances.size())
  579.                         return NULL;
  580.                 return m_allSmartObjectInstances[m_indexNextObject++];
  581.         }
  582.         CSmartObject* NextVisibleObject()
  583.         {
  584.                 unsigned int size = m_allSmartObjectInstances.size();
  585.                 while (m_indexNextObject < size && m_allSmartObjectInstances[m_indexNextObject]->IsHidden())
  586.                         ++m_indexNextObject;
  587.                 if (m_indexNextObject >= size)
  588.                         return NULL;
  589.                 return m_allSmartObjectInstances[m_indexNextObject++];
  590.         }
  591.  
  592.         void               AddHelper(SmartObjectHelper* pHelper) { m_vHelpers.push_back(pHelper); }
  593.         SmartObjectHelper* GetHelper(const char* name) const
  594.         {
  595.                 VectorHelpers::const_iterator it, itEnd = m_vHelpers.end();
  596.                 for (it = m_vHelpers.begin(); it != itEnd; ++it)
  597.                         if ((*it)->name == name)
  598.                                 return *it;
  599.                 return NULL;
  600.         }
  601.  
  602.         struct HelperLink
  603.         {
  604.                 float              passRadius;
  605.                 SmartObjectHelper* from;
  606.                 SmartObjectHelper* to;
  607.                 CCondition*        condition;
  608.         };
  609.         typedef std::vector<HelperLink> THelperLinks;
  610.         THelperLinks m_vHelperLinks;
  611.  
  612.         typedef std::set<SmartObjectHelper*> SetHelpers;
  613.         SetHelpers m_setNavHelpers;
  614.  
  615.         void ClearHelperLinks();
  616.         bool AddHelperLink(CCondition* condition);
  617.         int  FindHelperLinks(const SmartObjectHelper* from, const SmartObjectHelper* to, const CSmartObjectClass* pClass, float radius,
  618.                              CSmartObjectClass::HelperLink** pvHelperLinks, int iCount = 1);
  619.         int  FindHelperLinks(const SmartObjectHelper* from, const SmartObjectHelper* to, const CSmartObjectClass* pClass, float radius,
  620.                              const CSmartObject::SetStates& userStates, const CSmartObject::SetStates& objectStates,
  621.                              CSmartObjectClass::HelperLink** pvHelperLinks, int iCount = 1, const CSmartObject::SetStates* pObjectStatesToExcludeFromMatches = NULL);
  622.  
  623.         struct UserSize
  624.         {
  625.                 float radius;
  626.                 float bottom;
  627.                 float top;
  628.  
  629.                 UserSize() : radius(0), top(0), bottom(FLT_MAX) {}
  630.                 UserSize(float r, float t, float b) : radius(r), top(t), bottom(b) {}
  631.                 operator bool() const { return radius > 0 && top > bottom; }
  632.                 const UserSize& operator+=(const UserSize& other)
  633.                 {
  634.                         if (*this)
  635.                         {
  636.                                 if (other)
  637.                                 {
  638.                                         if (other.radius > radius)
  639.                                                 radius = other.radius;
  640.                                         if (other.top > top)
  641.                                                 top = other.top;
  642.                                         if (other.bottom < bottom)
  643.                                                 bottom = other.bottom;
  644.                                 }
  645.                         }
  646.                         else
  647.                                 *this = other;
  648.                         return *this;
  649.                 }
  650.         };
  651.         UserSize m_StanceMaxSize;
  652.         UserSize m_NavUsersMaxSize;
  653.         void AddNavUserClass(CSmartObjectClass* pUserClass)
  654.         {
  655.                 m_NavUsersMaxSize += pUserClass->m_StanceMaxSize;
  656.         }
  657.  
  658.         CClassTemplateData* m_pTemplateData;
  659.  
  660.         // optimization: each user class keeps a list of active update rules
  661.         typedef std::vector<CCondition*> VectorRules;
  662.         VectorRules m_vActiveUpdateRules[3]; // three vectors - one for each alertness level (0 includes all in 1 and 2; 1 includes all in 2)
  663.  
  664. private:
  665.         void RemoveFromPositionMap(CSmartObject* pSmartObject);
  666. };
  667.  
  668. ///////////////////////////////////////////////
  669. // CCondition defines conditions under which a smart object should be used.
  670. // It defines everything except conditions about the user, because user's condition will be the key of a map later...
  671. ///////////////////////////////////////////////
  672. struct CCondition
  673. {
  674.         int                              iTemplateId;
  675.  
  676.         CSmartObjectClass*               pUserClass;
  677.         CSmartObject::CStatePattern      userStatePattern;
  678.  
  679.         CSmartObjectClass*               pObjectClass;
  680.         CSmartObject::CStatePattern      objectStatePattern;
  681.  
  682.         string                           sUserHelper;
  683.         SmartObjectHelper*               pUserHelper;
  684.         string                           sObjectHelper;
  685.         SmartObjectHelper*               pObjectHelper;
  686.  
  687.         float                            fDistanceFrom;
  688.         float                            fDistanceTo;
  689.         float                            fOrientationLimit;
  690.         bool                             bHorizLimitOnly;
  691.         float                            fOrientationToTargetLimit;
  692.  
  693.         float                            fMinDelay;
  694.         float                            fMaxDelay;
  695.         float                            fMemory;
  696.  
  697.         float                            fProximityFactor;
  698.         float                            fOrientationFactor;
  699.         float                            fVisibilityFactor;
  700.         float                            fRandomnessFactor;
  701.  
  702.         float                            fLookAtPerc;
  703.         CSmartObject::DoubleVectorStates userPreActionStates;
  704.         CSmartObject::DoubleVectorStates objectPreActionStates;
  705.         EActionType                      eActionType;
  706.         string                           sAction;
  707.         CSmartObject::DoubleVectorStates userPostActionStates;
  708.         CSmartObject::DoubleVectorStates objectPostActionStates;
  709.  
  710.         int                              iMaxAlertness;
  711.         bool                             bEnabled;
  712.  
  713.         int                              iRuleType; // 0 - normal rule; 1 - navigational rule;
  714.         string                           sEvent;
  715.         string                           sChainedUserEvent;
  716.         string                           sChainedObjectEvent;
  717.         string                           sEntranceHelper;
  718.         string                           sExitHelper;
  719.  
  720.         string                           sName;
  721.         string                           sDescription;
  722.         string                           sFolder;
  723.         int                              iOrder;
  724.  
  725.         // exact positioning related
  726.         float  fApproachSpeed;
  727.         int    iApproachStance;
  728.         string sAnimationHelper;
  729.         string sApproachHelper;
  730.         float  fStartWidth;
  731.         float  fDirectionTolerance;
  732.         float  fStartArcAngle;
  733.  
  734.         bool operator==(const CCondition& other) const;
  735. };
  736.  
  737. typedef std::multimap<CSmartObjectClass*, CCondition>  MapConditions;
  738. typedef std::multimap<CSmartObjectClass*, CCondition*> MapPtrConditions;
  739.  
  740. ///////////////////////////////////////////////
  741. // Smart Object Event
  742. ///////////////////////////////////////////////
  743. class CEvent
  744. {
  745. public:
  746.         const string     m_sName;        // event name
  747.         string           m_sDescription; // description of this event
  748.         MapPtrConditions m_Conditions;   // map of all conditions indexed by user's class
  749.  
  750.         CEvent(const string& name) : m_sName(name) {}
  751. };
  752.  
  753. ///////////////////////////////////////////////
  754. // CQueryEvent
  755. ///////////////////////////////////////////////
  756.  
  757. class CQueryEvent
  758. {
  759. public:
  760.         CSmartObject* pUser;
  761.         CSmartObject* pObject;
  762.         CCondition*   pRule;
  763.         CQueryEvent*  pChainedUserEvent;
  764.         CQueryEvent*  pChainedObjectEvent;
  765.  
  766.         CQueryEvent() : pUser(0), pObject(0), pRule(0), pChainedUserEvent(0), pChainedObjectEvent(0)
  767.         {}
  768.  
  769.         CQueryEvent(const CQueryEvent& other)
  770.         {
  771.                 *this = other;
  772.         }
  773.  
  774.         ~CQueryEvent()
  775.         {
  776.                 if (pChainedUserEvent)
  777.                         delete pChainedUserEvent;
  778.                 if (pChainedObjectEvent)
  779.                         delete pChainedObjectEvent;
  780.         }
  781.  
  782.         void Clear()
  783.         {
  784.                 pUser = NULL;
  785.                 pObject = NULL;
  786.                 pRule = NULL;
  787.                 if (pChainedUserEvent)
  788.                         delete pChainedUserEvent;
  789.                 if (pChainedObjectEvent)
  790.                         delete pChainedObjectEvent;
  791.                 pChainedUserEvent = NULL;
  792.                 pChainedObjectEvent = NULL;
  793.         }
  794.  
  795.         const CQueryEvent& operator=(const CQueryEvent& other)
  796.         {
  797.                 pUser = other.pUser;
  798.                 pObject = other.pObject;
  799.                 pRule = other.pRule;
  800.                 pChainedUserEvent = other.pChainedUserEvent ? new CQueryEvent(*other.pChainedUserEvent) : NULL;
  801.                 pChainedObjectEvent = other.pChainedObjectEvent ? new CQueryEvent(*other.pChainedObjectEvent) : NULL;
  802.                 return *this;
  803.         }
  804.  
  805.         void Serialize(TSerialize ser);
  806.  
  807. };
  808.  
  809. // while querying matches the events will be stored in a container of this type sorted by priority
  810. typedef std::multimap<float, CQueryEvent> QueryEventMap;
  811.  
  812. ///////////////////////////////////////////////
  813. // CSmartObjectManager receives notifications from entity system about entities being spawned and deleted.
  814. // Keeps track of registered classes, and automatically creates smart object representation for every instance belonging to them.
  815. ///////////////////////////////////////////////
  816. class CSmartObjectManager
  817.         : public IEntitySystemSink
  818.           , public ISmartObjectManager
  819. {
  820. private:
  821.         CSmartObject::CState    m_StateAttTarget;
  822.         CSmartObject::CState    m_StateSameGroup;
  823.         CSmartObject::CState    m_StateSameFaction;
  824.         CSmartObject::CState    m_StateBusy;
  825.  
  826.         CSmartObject::SetStates m_statesToExcludeForPathfinding;
  827.  
  828.         MapConditions           m_Conditions; // map of all conditions indexed by user's class
  829.  
  830.         // used for debug-drawing used smart objects
  831.         struct CDebugUse
  832.         {
  833.                 CTimeValue    m_Time;
  834.                 CSmartObject* m_pUser;
  835.                 CSmartObject* m_pObject;
  836.         };
  837.         typedef std::vector<CDebugUse> VectorDebugUse;
  838.         VectorDebugUse m_vDebugUse;
  839.  
  840.         // Implementation of IEntitySystemSink methods
  841.         ///////////////////////////////////////////////
  842.         virtual bool OnBeforeSpawn(SEntitySpawnParams& params) { return true; };
  843.         virtual void OnSpawn(IEntity* pEntity, SEntitySpawnParams& params);
  844.         virtual bool OnRemove(IEntity* pEntity);
  845.         virtual void OnReused(IEntity* pEntity, SEntitySpawnParams& params);
  846.         virtual void OnEvent(IEntity* pEntity, SEntityEvent& event);
  847.  
  848.         void         DoRemove(IEntity* pEntity, bool bDeleteSmartObject = true);
  849.  
  850.         void         AddSmartObjectClass(CSmartObjectClass* soClass);
  851.  
  852.         bool m_bRecalculateUserSize;
  853.         void RecalculateUserSize();
  854.  
  855.         bool m_initialized;
  856.  
  857. public:
  858.         friend class CSmartObject;
  859.         friend class CSmartObjectBase;
  860.         friend class CQueryEvent;
  861.  
  862.         //////////////////////////////////////////////////////////////////////////
  863.         //ISmartObjectManager/////////////////////////////////////////////////////
  864.         virtual void               RemoveSmartObject(IEntity* pEntity);
  865.  
  866.         virtual const char*        GetSmartObjectStateName(int id) const;
  867.  
  868.         virtual void               RegisterSmartObjectState(const char* sStateName);
  869.         virtual void               AddSmartObjectState(IEntity* pEntity, const char* sState);
  870.         virtual void               RemoveSmartObjectState(IEntity* pEntity, const char* sState);
  871.         virtual bool               CheckSmartObjectStates(const IEntity* pEntity, const char* patternStates) const;
  872.         virtual void               SetSmartObjectState(IEntity* pEntity, const char* sStateName);
  873.  
  874.         virtual void               ModifySmartObjectStates(IEntity* pEntity, const char* listStates);
  875.  
  876.         virtual void               DrawSOClassTemplate(IEntity* pEntity);
  877.         virtual bool               ValidateSOClassTemplate(IEntity* pEntity);
  878.  
  879.         virtual uint32             GetSOClassTemplateIStatObj(IEntity* pEntity, IStatObjPtr* ppStatObjectPtrs, uint32& numAllocStatObjects);
  880.  
  881.         virtual void               ReloadSmartObjectRules();
  882.  
  883.         virtual int                SmartObjectEvent(const char* sEventName, IEntity*& pUser, IEntity*& pObject, const Vec3* pExtraPoint = NULL, bool bHighPriority = false);
  884.  
  885.         virtual SmartObjectHelper* GetSmartObjectHelper(const char* className, const char* helperName) const;
  886.         //ISmartObjectManager/////////////////////////////////////////////////////
  887.         //////////////////////////////////////////////////////////////////////////
  888.  
  889.         CSmartObjectManager();
  890.         ~CSmartObjectManager();
  891.  
  892.         bool LoadSmartObjectsLibrary();
  893.         bool IsInitialized() const;//TODO fix initialization of this and CAISystem so this is not needed!
  894.  
  895.         void DebugDraw();
  896.         void DebugDrawValidateSmartObjectArea() const;
  897.         void DebugDrawBannedNavsos();
  898.  
  899.         void SoftReset();
  900.  
  901.         void Update();
  902.         void UpdateBannedSOs(float frameDeltaTime);
  903.         void ResetBannedSOs();
  904.  
  905.         void Serialize(TSerialize ser);
  906.  
  907.         // returns the id of the inserted goal pipe if a rule was found or 0 if no rule
  908.         int TriggerEvent(const char* sEventName, IEntity*& pUser, IEntity*& pObject, QueryEventMap* pQueryEvents = NULL, const Vec3* pExtraPoint = NULL, bool bHighPriority = false);
  909.  
  910.         /// used by heuristic to check is this link passable by current pathfind requester
  911.         float GetSmartObjectLinkCostFactor(const GraphNode* nodes[2], const CAIObject* pRequester, float* fCostMultiplier) const;
  912.         bool  GetSmartObjectLinkCostFactorForMNM(const OffMeshLink_SmartObject* pSmartObjectLink, IEntity* pRequesterEntity, float* fCostMultiplier) const;
  913.  
  914.         // used by COPTrace to use smart objects in navigation
  915.         int                  GetNavigationalSmartObjectActionType(CPipeUser* pPipeUser, const GraphNode* pFromNode, const GraphNode* pToNode);
  916.         int                  GetNavigationalSmartObjectActionTypeForMNM(CPipeUser* pPipeUser, CSmartObject* pSmartObject, CSmartObjectClass* pSmartObjectClass, SmartObjectHelper* pFromHelper, SmartObjectHelper* pToHelper);
  917.         bool                 PrepareNavigateSmartObject(CPipeUser* pPipeUser, const GraphNode* pFromNode, const GraphNode* pToNode);
  918.         bool                 PrepareNavigateSmartObject(CPipeUser* pPipeUser, CSmartObject* pObject, CSmartObjectClass* pObjectClass, SmartObjectHelper* pFromHelper, SmartObjectHelper* pToHelper);
  919.         void                 UseSmartObject(CSmartObject* pSmartObjectUser, CSmartObject* pObject, CCondition* pCondition, int eventId = 0, bool bForceHighPriority = false);
  920.         /// Used by COPTrace to detect busy state of SO allowing agents to wait instead of simply failing the movement request.
  921.         bool                 IsSmartObjectBusy(const CSmartObject* pSmartObject) const;
  922.  
  923.         void                 MapPathTypeToSoUser(const string& soUser, const string& pathType);
  924.         bool                 CheckSmartObjectStates(const IEntity* pEntity, const CSmartObject::CStatePattern& pattern) const;
  925.  
  926.         static CSmartObject* GetSmartObject(EntityId id);
  927.         static void          BindSmartObjectToEntity(EntityId id, CSmartObject* pSO);
  928.         static bool          RemoveSmartObjectFromEntity(EntityId id, CSmartObject* pSO = NULL);
  929.  
  930. private:
  931.         struct SSOTemplateArea
  932.         {
  933.                 Vec3  pt;
  934.                 float radius;
  935.                 bool  projectOnGround;
  936.         };
  937.         struct SSOUser
  938.         {
  939.                 IEntity* entity;
  940.                 float    radius;
  941.                 float    height;
  942.                 float    groundOffset;
  943.         };
  944.  
  945.         typedef VectorMap<CSmartObject*, float> SmartObjectFloatMap;
  946.         SmartObjectFloatMap                      m_bannedNavSmartObjects;
  947.         std::map<string, string>                 m_MappingSOUserPathType;
  948.         static std::map<EntityId, CSmartObject*> g_smartObjectEntityMap;
  949.  
  950.         const AgentPathfindingProperties* GetPFPropertiesOfSoUser(const string& soUser);
  951.  
  952.         static bool                       ValidateSmartObjectArea(const SSOTemplateArea& templateArea, const SSOUser& user, EAICollisionEntities collEntities, Vec3& groundPos);
  953.         int                               FindSmartObjectLinks(const CPipeUser* pPipeUser, CSmartObject* pObject, CSmartObjectClass* pObjectClass,
  954.                                                                SmartObjectHelper* pFromHelper, SmartObjectHelper* pToHelper, CSmartObjectClass::HelperLink** pvHelperLinks,
  955.                                                                int iCount = 1, const IEntity* pAdditionalEntity = NULL, const CSmartObject::SetStates* pStatesExcludedFromMatchingTheObjectState = NULL) const;
  956.  
  957.         typedef std::set<CSmartObject*> SmartObjects;
  958.         static SmartObjects g_AllSmartObjects;
  959.  
  960.         typedef std::pair<CSmartObject*, CCondition*> PairObjectCondition;
  961.         typedef std::pair<PairObjectCondition, float> PairDelayTime;
  962.         typedef std::vector<PairDelayTime>            VecDelayTimes;
  963.  
  964.         struct Pred_IgnoreSecond
  965.         {
  966.                 bool operator()(const PairDelayTime& A, const PairDelayTime& B) const
  967.                 {
  968.                         return A.first < B.first;
  969.                 }
  970.         };
  971.  
  972.         // define a map of event updates
  973.         VecDelayTimes m_tmpVecDelayTimes;
  974.  
  975.         // MapSOHelpers contains all smart object helpers sorted by name of the smart object class to which they belong
  976.         typedef std::multimap<string, SmartObjectHelper> MapSOHelpers;
  977.         MapSOHelpers m_mapHelpers;
  978.  
  979.         typedef std::map<string, CEvent> MapEvents;
  980.         MapEvents            m_mapEvents; // map of all smart object events indexed by name
  981.  
  982.         MapClassTemplateData m_mapClassTemplates;
  983.         void               LoadSOClassTemplates();
  984.  
  985.         void               RescanSOClasses(IEntity* pEntity);
  986.  
  987.         void               String2Classes(const string& sClass, CSmartObjectClasses& vClasses);
  988.         static void        String2States(const char* listStates, CSmartObject::DoubleVectorStates& states);
  989.         static void        String2StatePattern(const char* sPattern, CSmartObject::CStatePattern& pattern);
  990.  
  991.         static void        SerializePointer(TSerialize ser, const char* name, CSmartObject*& pSmartObject);
  992.         static void        SerializePointer(TSerialize ser, const char* name, CCondition*& pRule);
  993.  
  994.         CSmartObjectClass* GetSmartObjectClass(const char* className);
  995.  
  996.         void               AddSmartObjectCondition(const SmartObjectCondition& conditionData);
  997.  
  998.         bool               ParseClassesFromProperties(const IEntity* pEntity, CSmartObjectClasses& vClasses);
  999.  
  1000.         void               ClearConditions();
  1001.         void               Reset();
  1002.  
  1003.         float              CalculateDelayTime(CSmartObject* pUser, const Vec3& posUser,
  1004.                                               CSmartObject* pObject, const Vec3& posObject, CCondition* pCondition) const;
  1005.         float              CalculateDot(CCondition* condition, const Vec3& dir, CSmartObject* user) const;
  1006.         int                Process(CSmartObject* pSmartObjectUser, CSmartObjectClass* pClass);
  1007.         bool               PrepareUseNavigationSmartObject(SAIActorTargetRequest& pReq, SNavSOStates& states, CSmartObject* pSmartObjectUser, CSmartObject* pSmartObject, const CCondition* pCondition, SmartObjectHelper* pFromHelper, SmartObjectHelper* pToHelper);
  1008.  
  1009.         void               SetSmartObjectState(IEntity* pEntity, CSmartObject::CState state) const;
  1010.         void               SetSmartObjectState(CSmartObject* pSmartObject, CSmartObject::CState state) const;
  1011.         void               AddSmartObjectState(IEntity* pEntity, CSmartObject::CState state) const;
  1012.         void               AddSmartObjectState(CSmartObject* pSmartObject, CSmartObject::CState state) const;
  1013.         void               RemoveSmartObjectState(IEntity* pEntity, CSmartObject::CState state) const;
  1014.         void               RemoveSmartObjectState(CSmartObject* pSmartObject, CSmartObject::CState state) const;
  1015.         void               ModifySmartObjectStates(IEntity* pEntity, const CSmartObject::DoubleVectorStates& states);
  1016.         void               ModifySmartObjectStates(CSmartObject* pSmartObject, const CSmartObject::DoubleVectorStates& states) const;
  1017.  
  1018.         void               RebuildNavigation();
  1019.         bool               RegisterInNavigation(CSmartObject* pSmartObject, CSmartObjectClass* pClass);
  1020.         void               UnregisterFromNavigation(CSmartObject* pSmartObject) const;
  1021.  
  1022.         void               RemoveEntity(IEntity* pEntity);
  1023.  
  1024.         CEvent*            String2Event(const string& name)
  1025.         {
  1026.                 MapEvents::iterator it = m_mapEvents.insert(MapEvents::value_type(name, name)).first;
  1027.                 return &it->second;
  1028.         }
  1029.  
  1030.         // SOClass template related
  1031.         void GetTemplateIStatObj(IEntity* pEntity, std::vector<IStatObj*>& statObjects);
  1032.         bool ValidateTemplate(IEntity* pEntity, bool bStaticOnly, IEntity* pUserEntity = NULL, int fromTemplateHelperIdx = -1, int toTemplateHelperIdx = -1);
  1033.         bool ValidateTemplate(CSmartObject* pSmartObject, bool bStaticOnly, IEntity* pUserEntity = NULL, int fromTemplateHelperIdx = -1, int toTemplateHelperIdx = -1);
  1034.         void DrawTemplate(IEntity* pEntity);
  1035.         void DrawTemplate(CSmartObject* pSmartObject, bool bStaticOnly);
  1036.  
  1037. private:
  1038.         IEntity* m_pPreOnSpawnEntity; // the entity for which OnSpawn was called just right before the current OnSpawn call
  1039.  
  1040.         void DeleteFromNavigation(CSmartObject* pSmartObject) const;
  1041.  
  1042.         int  TriggerEventUserObject(const char* sEventName, CSmartObject* pUser, CSmartObject* pObject, QueryEventMap* pQueryEvents, const Vec3* pExtraPoint, bool bHighPriority);
  1043.         int  TriggerEventUser(const char* sEventName, CSmartObject* pUser, QueryEventMap* pQueryEvents, IEntity** ppObjectEntity, const Vec3* pExtraPoint, bool bHighPriority);
  1044.         int  TriggerEventObject(const char* sEventName, CSmartObject* pObject, QueryEventMap* pQueryEvents, IEntity** ppUserEntity, const Vec3* pExtraPoint, bool bHighPriority);
  1045. };
  1046.  
  1047. IEntity* CSmartObjectBase::GetEntity() const
  1048. {
  1049.         AIAssert(gEnv);
  1050.         AIAssert(gEnv->pEntitySystem);
  1051.         return gEnv->pEntitySystem->GetEntity(m_entityId);
  1052. }
  1053.  
  1054. const char* CSmartObjectBase::GetName() const
  1055. {
  1056.         const IEntity* pEntity = GetEntity();
  1057.         return pEntity ? pEntity->GetName() : "<NONE>";
  1058. }
  1059.  
  1060. IPhysicalEntity* CSmartObjectBase::GetPhysics() const
  1061. {
  1062.         const IEntity* pEntity = GetEntity();
  1063.         return pEntity ? pEntity->GetPhysics() : NULL;
  1064. }
  1065.  
  1066. CAIObject* CSmartObjectBase::GetAI() const
  1067. {
  1068.         if (IEntity* pEntity = GetEntity())
  1069.         {
  1070.                 return static_cast<CAIObject*>(pEntity->GetAI());
  1071.         }
  1072.  
  1073.         return NULL;
  1074. }
  1075.  
  1076. //////////////////////////////////////////////////////////////////////////
  1077. /// MNM integration
  1078.  
  1079. struct OffMeshLink_SmartObject : public MNM::OffMeshLink
  1080. {
  1081.         OffMeshLink_SmartObject()
  1082.                 : MNM::OffMeshLink(eLinkType_SmartObject, 0)
  1083.                 , m_pSmartObject(NULL)
  1084.                 , m_pSmartObjectClass(NULL)
  1085.                 , m_pFromHelper(NULL)
  1086.                 , m_pToHelper(NULL)
  1087.         {
  1088.         }
  1089.  
  1090.         OffMeshLink_SmartObject(const EntityId objectId, CSmartObject* _smartObject, CSmartObjectClass* _smartObjectClass, SmartObjectHelper* _fromHelper, SmartObjectHelper* _toHelper)
  1091.                 : MNM::OffMeshLink(eLinkType_SmartObject, objectId)
  1092.                 , m_pSmartObject(_smartObject)
  1093.                 , m_pSmartObjectClass(_smartObjectClass)
  1094.                 , m_pFromHelper(_fromHelper)
  1095.                 , m_pToHelper(_toHelper)
  1096.         {
  1097.  
  1098.         }
  1099.  
  1100.         virtual ~OffMeshLink_SmartObject() {};
  1101.  
  1102.         virtual MNM::OffMeshLink* Clone() const
  1103.         {
  1104.                 return new OffMeshLink_SmartObject(GetEntityIdForOffMeshLink(), m_pSmartObject, m_pSmartObjectClass, m_pFromHelper, m_pToHelper);
  1105.         }
  1106.  
  1107.         virtual Vec3 GetStartPosition() const
  1108.         {
  1109.                 return m_pSmartObject->GetHelperPos(m_pFromHelper);
  1110.         }
  1111.  
  1112.         virtual Vec3 GetEndPosition() const
  1113.         {
  1114.                 return m_pSmartObject->GetHelperPos(m_pToHelper);
  1115.         }
  1116.  
  1117.         virtual bool CanUse(IEntity* pRequester, float* costMultiplier) const
  1118.         {
  1119.                 return gAIEnv.pSmartObjectManager->GetSmartObjectLinkCostFactorForMNM(this, pRequester, costMultiplier);
  1120.         }
  1121.  
  1122.         static LinkType GetType() { return eLinkType_SmartObject; }
  1123.  
  1124.         CSmartObject*      m_pSmartObject;
  1125.         CSmartObjectClass* m_pSmartObjectClass;
  1126.         SmartObjectHelper* m_pFromHelper;
  1127.         SmartObjectHelper* m_pToHelper;
  1128. };
  1129.  
  1130. #endif
  1131.  
downloadSmartObjects.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