BVB Source Codes

CRYENGINE Show EquipmentManager.h Source code

Return Download CRYENGINE: download EquipmentManager.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   EquipmentManager.h
  5. //  Version:     v1.00
  6. //  Created:     07/07/2006 by AlexL
  7. //  Compilers:   Visual Studio.NET
  8. //  Description: EquipmentManager to handle item packs
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef __EQUIPMENTMANAGER_H__
  15. #define __EQUIPMENTMANAGER_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <IItemSystem.h>
  22.  
  23. class CItemSystem;
  24.  
  25. class CEquipmentManager : public IEquipmentManager
  26. {
  27. public:
  28.         CEquipmentManager(CItemSystem* pItemSystem);
  29.         ~CEquipmentManager();
  30.  
  31.         void Reset();
  32.  
  33.         // Clear all equipment packs
  34.         virtual void DeleteAllEquipmentPacks();
  35.  
  36.         // Loads equipment packs from rootNode
  37.         virtual void LoadEquipmentPacks(const XmlNodeRef& rootNode);
  38.  
  39.         // Load all equipment packs from a certain path
  40.         virtual void LoadEquipmentPacksFromPath(const char* path);
  41.  
  42.         // Load an equipment pack from an XML node
  43.         virtual bool LoadEquipmentPack(const XmlNodeRef& rootNode, bool bOverrideExisting = true);
  44.  
  45.         // Give an equipment pack (resp. items/ammo) to an actor
  46.         virtual bool GiveEquipmentPack(IActor* pActor, const char* packName, bool bAdd, bool selectPrimary = false);
  47.  
  48.         // Pre-cache all resources needed for the items included in the given pack
  49.         virtual void PreCacheEquipmentPackResources(const char* packName, IEquipmentPackPreCacheCallback& preCacheCallback);
  50.  
  51.         // return iterator with all available equipment packs
  52.         virtual IEquipmentManager::IEquipmentPackIteratorPtr CreateEquipmentPackIterator();
  53.  
  54.         virtual void                                         RegisterListener(IListener* pListener);
  55.         virtual void                                         UnregisterListener(IListener* pListener);
  56.  
  57.         // listener callbacks
  58.         void OnBeginGiveEquipmentPack();
  59.         void OnEndGiveEquipmentPack();
  60.  
  61.         void DumpPacks();
  62.  
  63.         struct SEquipmentPack
  64.         {
  65.                 struct SEquipmentItem
  66.                 {
  67.                         typedef std::vector<IEntityClass*> TSetupVector;
  68.  
  69.                         SEquipmentItem(const char* name, const char* type, const char* setup)
  70.                                 : m_name(name), m_type(type)
  71.                         {
  72.                                 ParseSetup(setup);
  73.                         }
  74.  
  75.                         void ParseSetup(const char* setup)
  76.                         {
  77.                                 if (setup && (setup[0] != '\0'))
  78.                                 {
  79.                                         IEntityClassRegistry* pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
  80.                                         const char* cur = setup;
  81.  
  82.                                         if (cur[0] == '|')
  83.                                         {
  84.                                                 cur++;
  85.                                         }
  86.  
  87.                                         const char* nxt = strstr(cur, "|");
  88.                                         char stringBuffer[128];
  89.                                         while (nxt)
  90.                                         {
  91.                                                 cry_strcpy(stringBuffer, cur, (size_t)(nxt - cur));
  92.  
  93.                                                 if (stringBuffer[0] != '\0')
  94.                                                 {
  95.                                                         if (IEntityClass* pClass = pClassRegistry->FindClass(stringBuffer))
  96.                                                         {
  97.                                                                 m_setup.push_back(pClass);
  98.                                                         }
  99.                                                 }
  100.  
  101.                                                 cur = nxt + 1;
  102.                                                 nxt = strstr(nxt + 1, "|");
  103.                                         }
  104.  
  105.                                         if (*cur != '\0')
  106.                                         {
  107.                                                 if (IEntityClass* pClass = pClassRegistry->FindClass(cur))
  108.                                                 {
  109.                                                         m_setup.push_back(pClass);
  110.                                                 }
  111.                                         }
  112.                                 }
  113.                         }
  114.  
  115.                         string       m_name;
  116.                         string       m_type;
  117.                         TSetupVector m_setup;
  118.  
  119.                         void         GetMemoryUsage(ICrySizer* pSizer) const
  120.                         {
  121.                                 pSizer->AddObject(m_name);
  122.                                 pSizer->AddObject(m_type);
  123.                                 pSizer->AddObject(m_setup);
  124.                         }
  125.                 };
  126.  
  127.                 void Init(const char* name)
  128.                 {
  129.                         m_name.assign(name);
  130.                         m_primaryItem.assign("");
  131.                         m_items.clear();
  132.                         m_ammoCount.clear();
  133.                 }
  134.  
  135.                 void PrepareForItems(size_t count)
  136.                 {
  137.                         m_items.reserve(m_items.size() + count);
  138.                 }
  139.  
  140.                 bool AddItem(const char* name, const char* type, const char* setup)
  141.                 {
  142.                         if (HasItem(name))
  143.                                 return false;
  144.                         m_items.push_back(SEquipmentItem(name, type, setup));
  145.                         return true;
  146.                 }
  147.  
  148.                 bool HasItem(const char* name) const
  149.                 {
  150.                         for (std::vector<SEquipmentItem>::const_iterator iter = m_items.begin(), iterEnd = m_items.end();
  151.                              iter != iterEnd; ++iter)
  152.                         {
  153.                                 if (iter->m_name == name)
  154.                                         return true;
  155.                         }
  156.                         return false;
  157.                 }
  158.  
  159.                 inline int NumItems() const
  160.                 {
  161.                         return m_items.size();
  162.                 }
  163.  
  164.                 const SEquipmentItem* GetItemByIndex(int index) const
  165.                 {
  166.                         if (index < 0 || index >= (int)m_items.size())
  167.                                 return 0;
  168.                         return &m_items[index];
  169.                 }
  170.  
  171.                 void GetMemoryUsage(ICrySizer* pSizer) const
  172.                 {
  173.                         pSizer->AddObject(m_name);
  174.                         pSizer->AddObject(m_primaryItem);
  175.                         pSizer->AddObject(m_items);
  176.                         pSizer->AddObject(m_ammoCount);
  177.                 }
  178.                 string                      m_name;
  179.                 string                      m_primaryItem;
  180.                 std::vector<SEquipmentItem> m_items;
  181.                 std::map<string, int>       m_ammoCount;
  182.         };
  183.         typedef std::vector<SEquipmentPack*> TEquipmentPackVec;
  184.  
  185.         SEquipmentPack* GetPack(const char* packName) const;
  186.         void            DumpPack(const SEquipmentPack* pPack) const;
  187.  
  188.         void            GetMemoryUsage(ICrySizer* s) const;
  189.  
  190. protected:
  191.  
  192.         typedef std::vector<IEquipmentManager::IListener*> TListenerVec;
  193.  
  194.         friend class CScriptBind_ItemSystem;
  195.  
  196.         CItemSystem*      m_pItemSystem;
  197.         TEquipmentPackVec m_equipmentPacks;
  198.         TListenerVec      m_listeners;
  199. };
  200.  
  201. #endif
  202.  
downloadEquipmentManager.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