BVB Source Codes

CRYENGINE Show ItemSystem.h Source code

Return Download CRYENGINE: download ItemSystem.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Manages items.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 29:9:2004   18:01 : Created by M谩rcio Martins
  12.  
  13. *************************************************************************/
  14. #ifndef __ITEMSYSTEM_H__
  15. #define __ITEMSYSTEM_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <CryGame/IGameFramework.h>
  22. #include "IItemSystem.h"
  23. #include "ILevelSystem.h"
  24. #include "ItemParams.h"
  25. #include "EquipmentManager.h"
  26.  
  27. #include <CryCore/Containers/CryListenerSet.h>
  28.  
  29. #define DEFAULT_ITEM_SCRIPT     "Scripts/Entities/Items/Item.lua"
  30. #define DEFAULT_ITEM_CREATEFUNC "CreateItemTable"
  31. //#define USE_LTL_PRECACHING
  32.  
  33. //#if defined(USER_benito)
  34. //#define ITEM_SYSTEM_DEBUG_MEMSTATS
  35. //#endif
  36.  
  37. class CItemSystem :
  38.         public ILevelSystemListener,
  39.         public IItemSystem
  40. {
  41. public:
  42.         CItemSystem(IGameFramework* pGameFramework, ISystem* pSystem);
  43.         virtual ~CItemSystem();
  44.  
  45.         void Release() { delete this; };
  46.         void Update();
  47.  
  48.         // IItemSystem
  49.         virtual void                   Reload();
  50.         virtual void                   Reset();
  51.         virtual void                   Scan(const char* folderName);
  52.         virtual IItemParamsNode*       CreateParams() { return new CItemParamsNode; };
  53.         virtual const IItemParamsNode* GetItemParams(const char* itemName) const;
  54.         virtual int                    GetItemParamsCount() const;
  55.         virtual const char*            GetItemParamName(int index) const;
  56.         virtual const char*            GetItemParamsDescriptionFile(const char* itemName) const;
  57.         virtual uint8                  GetItemPriority(const char* item) const;
  58.         virtual const char*            GetItemCategory(const char* item) const;
  59.         virtual uint8                  GetItemUniqueId(const char* item) const;
  60.  
  61.         virtual bool                   IsItemClass(const char* name) const;
  62.  
  63.         virtual const char*            GetFirstItemClass();
  64.         virtual const char*            GetNextItemClass();
  65.  
  66.         virtual void                   RegisterForCollection(EntityId itemId);
  67.         virtual void                   UnregisterForCollection(EntityId itemId);
  68.  
  69.         virtual void                   AddItem(EntityId itemId, IItem* pItem);
  70.         virtual void                   RemoveItem(EntityId itemId, const char* itemName = NULL);
  71.         virtual IItem*                 GetItem(EntityId itemId) const;
  72.  
  73.         virtual ICharacterInstance*    GetCachedCharacter(const char* fileName);
  74.         virtual IStatObj*              GetCachedObject(const char* fileName);
  75.         virtual void                   CacheObject(const char* fileName, bool useCgfStreaming);
  76.         virtual void                   CacheGeometry(const IItemParamsNode* geometry);
  77.         virtual void                   CacheItemGeometry(const char* className);
  78.         virtual void                   ClearGeometryCache();
  79.  
  80.         virtual void                   CacheItemSound(const char* className);
  81.         virtual void                   ClearSoundCache();
  82.  
  83.         virtual EntityId               GiveItem(IActor* pActor, const char* item, bool sound, bool select = true, bool keepHistory = true, const char* setup = NULL, EEntityFlags entityFlags = (EEntityFlags)0);
  84.         virtual void                   SetActorItem(IActor* pActor, EntityId itemId, bool keepHistory);
  85.         virtual void                   SetActorItem(IActor* pActor, const char* name, bool keepHistory);
  86.         virtual void                   SetActorAccessory(IActor* pActor, EntityId itemId, bool keepHistory);
  87.         virtual void                   DropActorItem(IActor* pActor, EntityId itemId);
  88.         virtual void                   DropActorAccessory(IActor* pActor, EntityId itemId);
  89.  
  90.         virtual void                   SetConfiguration(const char* name) { m_config = name; };
  91.         virtual const char*            GetConfiguration() const           { return m_config.c_str(); };
  92.  
  93.         virtual void*                  Query(IItemSystemQuery query, const void* param = NULL);
  94.  
  95.         virtual void                   RegisterListener(IItemSystemListener* pListener);
  96.         virtual void                   UnregisterListener(IItemSystemListener* pListener);
  97.  
  98.         virtual void                   Serialize(TSerialize ser);
  99.         virtual void                   SerializePlayerLTLInfo(bool bReading);
  100.  
  101.         virtual IEquipmentManager*     GetIEquipmentManager() { return m_pEquipmentManager; }
  102.  
  103.         virtual uint32                 GetItemSocketCount(const char* item) const;
  104.         virtual const char*            GetItemSocketName(const char* item, int idx) const;
  105.         virtual bool                   IsCompatible(const char* item, const char* attachment) const;
  106.         virtual bool                   GetItemSocketCompatibility(const char* item, const char* socket) const;
  107.         virtual bool                   CanSocketBeEmpty(const char* item, const char* socket) const;
  108.  
  109.         // ~IItemSystem
  110.  
  111.         // ILevelSystemListener
  112.         virtual void OnLevelNotFound(const char* levelName)          {};
  113.         virtual void OnLoadingLevelEntitiesStart(ILevelInfo* pLevel) {}
  114.         virtual void OnLoadingStart(ILevelInfo* pLevel);
  115.         virtual void OnLoadingComplete(ILevelInfo* pLevel);
  116.         virtual void OnLoadingError(ILevelInfo* pLevel, const char* error)     {};
  117.         virtual void OnLoadingProgress(ILevelInfo* pLevel, int progressAmount) {};
  118.         virtual void OnUnloadComplete(ILevelInfo* pLevel);
  119.         //~ILevelSystemListener
  120.  
  121.         bool ScanXML(XmlNodeRef& root, const char* xmlFile);
  122.  
  123.         void RegisterItemClass(const char* name, IGameFramework::IItemCreator* pCreator);
  124.         void PrecacheLevel();
  125.  
  126.         void GetMemoryUsage(ICrySizer* s) const;
  127.  
  128.         void PreReload();
  129.         void PostReload();
  130.  
  131. private:
  132.         void        CreateItemTable(const char* name);
  133.         void        RegisterCVars();
  134.         void        UnregisterCVars();
  135.         void        InsertFolder(const char* folder);
  136.  
  137.         static void GiveItemCmd(IConsoleCmdArgs* args);
  138.         static void DropItemCmd(IConsoleCmdArgs* args);
  139.         static void GiveItemsHelper(IConsoleCmdArgs* args, bool useGiveable, bool useDebug);
  140.         static void GiveAllItemsCmd(IConsoleCmdArgs* args);
  141.         static void GiveAmmoCmd(IConsoleCmdArgs* args);
  142.         static void GiveDebugItemsCmd(IConsoleCmdArgs* args);
  143.         static void ListItemNames(IConsoleCmdArgs* args);
  144.         static void SaveWeaponPositionCmd(IConsoleCmdArgs* args);
  145.  
  146.         static ICVar* m_pPrecache;
  147.         static ICVar* m_pItemLimitMP;
  148.         static ICVar* m_pItemLimitSP;
  149.  
  150.         void DisplayItemSystemStats();
  151.         void DumpItemList(const char* filter);
  152.         void FindItemName(const char* nameFilter);
  153.         void ItemSystemErrorMessage(const char* fileName, const char* errorInfo, bool displayErrorDialog);
  154.  
  155. #ifdef USE_LTL_PRECACHING
  156.         void PreCacheLevelToLevelLoadout();
  157.  
  158.         typedef CryFixedArray<const IEntityClass*, 64> TLevelToLevelItemArray;
  159.         TLevelToLevelItemArray m_precacheLevelToLevelItemList;
  160.         enum ELTLPreCacheState
  161.         {
  162.                 LTLCS_FORNEXTLEVELLOAD, // indicates that the caching has to be done right after the next level is loaded
  163.                 LTLCS_FORSAVEGAME       // indicates that the list is only used for creating saveloads. If a level has LTL items coming from a previous level, we need
  164.                                         // to save them on every savegame created in that level, because we need to recache them in case the player quits and then resume game.
  165.         };
  166.         ELTLPreCacheState m_LTLPrecacheState;
  167. #endif
  168.  
  169.         struct SSpawnUserData
  170.         {
  171.                 SSpawnUserData(const char* cls, uint16 channel) : className(cls), channelId(channel) {}
  172.                 const char* className;
  173.                 uint16      channelId;
  174.         };
  175.  
  176.         typedef std::map<string, IStatObj*>           TObjectCache;
  177.         typedef TObjectCache::iterator                TObjectCacheIt;
  178.  
  179.         typedef std::map<string, ICharacterInstance*> TCharacterCache;
  180.         typedef TCharacterCache::iterator             TCharacterCacheIt;
  181.  
  182.         typedef struct SItemParamsDesc
  183.         {
  184.                 enum ItemFlags
  185.                 {
  186.                         eIF_PreCached_Sound    = 1 << 0,
  187.                         eIF_PreCached_Geometry = 1 << 1
  188.                 };
  189.  
  190.                 SItemParamsDesc() : precacheFlags(0), params(0) {};
  191.                 ~SItemParamsDesc()
  192.                 {
  193.                         SAFE_RELEASE(params);
  194.  
  195.                         if (!configurations.empty())
  196.                         {
  197.                                 for (std::map<string, CItemParamsNode*>::iterator it = configurations.begin(); it != configurations.end(); ++it)
  198.                                 {
  199.                                         SAFE_RELEASE(it->second);
  200.                                 }
  201.                         }
  202.                         configurations.clear();
  203.                 };
  204.  
  205.                 void GetMemoryUsage(ICrySizer* pSizer) const
  206.                 {
  207.                         pSizer->AddObject(filePath);
  208.                         pSizer->AddObject(category);
  209.                         pSizer->AddObject(params);
  210.                         pSizer->AddObject(configurations);
  211.                 }
  212.  
  213.                 CItemParamsNode*                   params;
  214.                 string                             filePath;
  215.                 string                             category;
  216.                 uint8                              uniqueId;
  217.                 uint8                              priority;
  218.                 uint8                              precacheFlags;
  219.  
  220.                 std::map<string, CItemParamsNode*> configurations;
  221.  
  222.         } SItemParamsDesc;
  223.  
  224.         typedef struct SItemClassDesc
  225.         {
  226.                 SItemClassDesc() : pCreator(0) {};
  227.                 SItemClassDesc(IGameObjectExtensionCreatorBase* pCrtr) : pCreator(pCrtr) {};
  228.  
  229.                 IGameObjectExtensionCreatorBase* pCreator;
  230.                 void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  231.         } SItemClassDesc;
  232.  
  233.         typedef std::map<string, SItemClassDesc>   TItemClassMap;
  234.         typedef std::map<string, SItemParamsDesc>  TItemParamsMap;
  235.  
  236.         typedef std::map<string, int>              TItemSystemSpawnPolicy;
  237.  
  238.         typedef std::map<EntityId, IItem*>         TItemMap;
  239.         typedef CListenerSet<IItemSystemListener*> TListeners;
  240.  
  241.         typedef std::vector<string>                TFolderList;
  242.  
  243.         typedef std::map<EntityId, CTimeValue>     TCollectionMap;
  244.  
  245.         CTimeValue                     m_precacheTime;
  246.  
  247.         TObjectCache                   m_objectCache;
  248.         TCharacterCache                m_characterCache;
  249.  
  250.         ISystem*                       m_pSystem;
  251.         IGameFramework*                m_pGameFramework;
  252.         IEntitySystem*                 m_pEntitySystem;
  253.  
  254.         XmlNodeRef                     m_playerLevelToLevelSave;
  255.  
  256.         TItemClassMap                  m_classes;
  257.         TItemParamsMap                 m_params;
  258.         TItemMap                       m_items;
  259.         TListeners                     m_listeners;
  260.         uint32                         m_spawnCount;
  261.  
  262.         TCollectionMap                 m_collectionmap;
  263.  
  264.         TFolderList                    m_folders;
  265.         bool                           m_reloading;
  266.         bool                           m_recursing;
  267.         bool                           m_itemParamsFlushed;
  268.  
  269.         string                         m_config;
  270.  
  271.         CEquipmentManager*             m_pEquipmentManager;
  272.  
  273.         TItemParamsMap::const_iterator m_itemClassIterator;
  274.  
  275.         int                            i_inventory_capacity;
  276. };
  277.  
  278. #endif //__ITEMSYSTEM_H__
  279.  
downloadItemSystem.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