Code/CryEngine/CryAction/ActorSystem.h

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 /*************************************************************************
   4    -------------------------------------------------------------------------
   5    $Id$
   6    $DateTime$
   7    Description: Manages and controls player spawns.
   8
   9    -------------------------------------------------------------------------
  10    History:
  11    - 23:8:2004   15:52 : Created by Márcio Martins
  12
  13 *************************************************************************/
  14 #ifndef __ACTORSYSTEM_H__
  15 #define __ACTORSYSTEM_H__
  16
  17 #if _MSC_VER > 1000
  18         #pragma once
  19 #endif
  20
  21 #include "IActorSystem.h"
  22 #include <CryGame/IGameFramework.h>
  23 #include "ItemParams.h"
  24
  25 typedef std::map<EntityId, IActor*> TActorMap;
  26
  27 struct IScriptTable;
  28 class CPlayerEntityProxy;
  29
  30 class CActorSystem :
  31         public IActorSystem,
  32         public IEntitySystemSink
  33 {
  34         struct DemoSpectatorSystem
  35         {
  36                 EntityId m_originalActor;
  37                 EntityId m_currentActor;
  38
  39                 void     SwitchSpectator(TActorMap* pActors, EntityId id = 0);
  40
  41         }        m_demoSpectatorSystem;
  42
  43         EntityId m_demoPlaybackMappedOriginalServerPlayer;
  44
  45 public:
  46         CActorSystem(ISystem* pSystem, IEntitySystem* pEntitySystem);
  47         virtual ~CActorSystem();
  48
  49         void         Release() { delete this; };
  50
  51         virtual void Reset();
  52         virtual void Reload();
  53
  54         // IActorSystem
  55         virtual IActor*                GetActor(EntityId entityId);
  56         virtual IActor*                GetActorByChannelId(uint16 channelId);
  57         virtual IActor*                CreateActor(uint16 channelId, const char* name, const char* actorClass, const Vec3& pos, const Quat& rot, const Vec3& scale, EntityId id);
  58
  59         virtual int                    GetActorCount() const { return (int)m_actors.size(); };
  60         virtual IActorIteratorPtr      CreateActorIterator();
  61
  62         virtual void                   SetDemoPlaybackMappedOriginalServerPlayer(EntityId id);
  63         virtual EntityId               GetDemoPlaybackMappedOriginalServerPlayer() const;
  64         virtual void                   SwitchDemoSpectator(EntityId id = 0);
  65         virtual IActor*                GetCurrentDemoSpectator();
  66         virtual IActor*                GetOriginalDemoSpectator();
  67
  68         virtual void                   Scan(const char* folderName);
  69         virtual const IItemParamsNode* GetActorParams(const char* actorClass) const;
  70
  71         virtual bool                   IsActorClass(IEntityClass* pClass) const;
  72
  73         // ~IActorSystem
  74
  75         // IEntitySystemSink
  76         virtual bool OnBeforeSpawn(SEntitySpawnParams& params);
  77         virtual void OnSpawn(IEntity* pEntity, SEntitySpawnParams& params);
  78         virtual bool OnRemove(IEntity* pEntity);
  79         virtual void OnReused(IEntity* pEntity, SEntitySpawnParams& params);
  80         virtual void GetMemoryUsage(class ICrySizer* pSizer) const;
  81         // ~IEntitySystemSink
  82
  83         void         RegisterActorClass(const char* name, IGameFramework::IActorCreator*, bool isAI);
  84         void         AddActor(EntityId entityId, IActor* pProxy);
  85         void         RemoveActor(EntityId entityId);
  86
  87         void         GetMemoryStatistics(ICrySizer* s);
  88
  89         virtual bool ScanXML(const XmlNodeRef& root, const char* xmlFile);
  90
  91 private:
  92
  93         //      static IEntityComponent *CreateActor(IEntity *pEntity, SEntitySpawnParams &params, void *pUserData);
  94         static bool HookCreateActor(IEntity*, IGameObject*, void*);
  95
  96         static void ActorSystemErrorMessage(const char* fileName, const char* errorInfo, bool displayErrorDialog);
  97
  98         struct SSpawnUserData
  99         {
 100                 SSpawnUserData(const char* cls, uint16 channel) : className(cls), channelId(channel) {}
 101                 const char* className;
 102                 uint16      channelId;
 103         };
 104
 105         struct SActorUserData
 106         {
 107                 SActorUserData(const char* cls, CActorSystem* pNewActorSystem) : className(cls), pActorSystem(pNewActorSystem) {};
 108                 CActorSystem* pActorSystem;
 109                 string        className;
 110         };
 111
 112         struct SActorClassDesc
 113         {
 114                 IEntityClass*                  pEntityClass;
 115                 IGameFramework::IActorCreator* pCreator;
 116
 117                 SActorClassDesc() : pEntityClass(), pCreator() {}
 118         };
 119
 120         class CActorIterator : public IActorIterator
 121         {
 122         public:
 123                 CActorIterator(CActorSystem* pAS)
 124                 {
 125                         m_pAS = pAS;
 126                         m_cur = m_pAS->m_actors.begin();
 127                         m_nRefs = 0;
 128                 }
 129                 void AddRef()
 130                 {
 131                         ++m_nRefs;
 132                 }
 133                 void Release()
 134                 {
 135                         if (--m_nRefs <= 0)
 136                         {
 137                                 assert(std::find(m_pAS->m_iteratorPool.begin(),
 138                                                  m_pAS->m_iteratorPool.end(), this) == m_pAS->m_iteratorPool.end());
 139                                 // Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/09})
 140                                 this->~CActorIterator();
 141                                 m_pAS->m_iteratorPool.push_back(this);
 142                         }
 143                 }
 144                 IActor* Next()
 145                 {
 146                         if (m_cur == m_pAS->m_actors.end())
 147                                 return 0;
 148                         IActor* pActor = m_cur->second;
 149                         ++m_cur;
 150                         return pActor;
 151                 }
 152                 size_t Count()
 153                 {
 154                         return m_pAS->m_actors.size();
 155                 }
 156                 CActorSystem*       m_pAS;
 157                 TActorMap::iterator m_cur;
 158                 int                 m_nRefs;
 159         };
 160
 161         typedef struct SActorParamsDesc
 162         {
 163                 SActorParamsDesc() : params(0) {};
 164                 ~SActorParamsDesc()
 165                 {
 166                         if (params)
 167                                 params->Release();
 168                 };
 169
 170                 CItemParamsNode* params;
 171
 172         } SItemParamsDesc;
 173
 174         typedef std::map<string, SActorClassDesc> TActorClassMap;
 175         typedef std::map<string, SItemParamsDesc> TActorParamsMap;
 176
 177         ISystem*                     m_pSystem;
 178         IEntitySystem*               m_pEntitySystem;
 179
 180         TActorMap                    m_actors;
 181         TActorClassMap               m_classes;
 182
 183         std::vector<CActorIterator*> m_iteratorPool;
 184
 185         TActorParamsMap              m_actorParams;
 186         string                       m_actorParamsFolder;
 187 };
 188
 189 #endif //__ACTORSYSTEM_H__