BVB Source Codes

CRYENGINE Show Inventory.h Source code

Return Download CRYENGINE: download Inventory.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: Inventory GameObject Extension
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 29:8:2005   14:27 : Created by M谩rcio Martins
  12.  
  13. *************************************************************************/
  14. #ifndef __INVENTORY_H__
  15. #define __INVENTORY_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #if !defined(_RELEASE)
  22.         #define DEBUG_INVENTORY_ENABLED 1
  23. #else
  24.         #define DEBUG_INVENTORY_ENABLED 0
  25. #endif
  26.  
  27. #include "CryAction.h"
  28. #include "IGameObject.h"
  29. #include "IItemSystem.h"
  30. #include <CryEntitySystem/IEntitySystem.h>
  31.  
  32. // dummy struct needed to use the RMI macros without parameters
  33. struct TRMIInventory_Dummy
  34. {
  35.         TRMIInventory_Dummy() {}
  36.  
  37.         virtual ~TRMIInventory_Dummy(){}
  38.         virtual void SerializeWith(TSerialize ser)
  39.         {
  40.         }
  41. };
  42.  
  43. // for RMI that need an item class parameter
  44. struct TRMIInventory_Item
  45. {
  46.         string m_ItemClass;
  47.  
  48.         TRMIInventory_Item()
  49.         {}
  50.  
  51.         TRMIInventory_Item(const char* _pItemClass)
  52.                 : m_ItemClass(_pItemClass)
  53.         {}
  54.  
  55.         void SerializeWith(TSerialize ser)
  56.         {
  57.                 ser.Value("ItemClass", m_ItemClass);
  58.         }
  59. };
  60.  
  61. // for RMI that need ammo class + amount
  62. struct TRMIInventory_Ammo
  63. {
  64.         string m_AmmoClass;
  65.         int    m_iAmount;
  66.  
  67.         TRMIInventory_Ammo()
  68.                 : m_iAmount(0)
  69.         {}
  70.  
  71.         TRMIInventory_Ammo(const char* _pAmmoClass, int _iAmount)
  72.                 : m_AmmoClass(_pAmmoClass),
  73.                 m_iAmount(_iAmount)
  74.         {}
  75.  
  76.         void SerializeWith(TSerialize ser)
  77.         {
  78.                 ser.Value("AmmoClass", m_AmmoClass);
  79.                 ser.Value("Amount", m_iAmount);
  80.         }
  81. };
  82.  
  83. // for RMI that need an equipment pack name
  84. struct TRMIInventory_EquipmentPack
  85. {
  86.         string m_EquipmentPack;
  87.         bool   m_bAdd;
  88.         bool   m_bPrimary;
  89.  
  90.         TRMIInventory_EquipmentPack()
  91.                 : m_bAdd(false),
  92.                 m_bPrimary(false)
  93.         {}
  94.  
  95.         TRMIInventory_EquipmentPack(const char* _pEquipmentPack, bool _bAdd, bool _bPrimary)
  96.                 : m_EquipmentPack(_pEquipmentPack),
  97.                 m_bAdd(_bAdd),
  98.                 m_bPrimary(_bPrimary)
  99.         {}
  100.  
  101.         void SerializeWith(TSerialize ser)
  102.         {
  103.                 ser.Value("EquipmentPack", m_EquipmentPack);
  104.                 ser.Value("SetMode", m_bAdd);
  105.                 ser.Value("SelectPrimary", m_bPrimary);
  106.         }
  107. };
  108.  
  109. class CInventory :
  110.         public CGameObjectExtensionHelper<CInventory, IInventory>
  111. {
  112.         struct SAmmoInfo
  113.         {
  114.                 SAmmoInfo()
  115.                         : count(0)
  116.                         , users(0)
  117.                         , capacity(0)
  118.                 {
  119.  
  120.                 }
  121.  
  122.                 SAmmoInfo(int _count, int _capacity)
  123.                         : count(_count)
  124.                         , users(0)
  125.                         , capacity(_capacity)
  126.                 {
  127.  
  128.                 }
  129.  
  130.                 ILINE void SetCount(int _count)                    { count = _count; }
  131.                 ILINE int  GetCount() const                        { return count; }
  132.                 ILINE void SetCapacity(int _capacity)              { capacity = _capacity; }
  133.                 ILINE int  GetCapacity() const                     { return capacity; }
  134.                 ILINE void AddUser()                               { users++; }
  135.                 ILINE void RemoveUser()                            { CRY_ASSERT(users > 0); users = max(users - 1, 0); }
  136.                 ILINE int  GetUserCount() const                    { return users; }
  137.  
  138.                 ILINE void ResetCount()                            { count = 0; }
  139.                 ILINE void ResetUsers()                            { users = 0; }
  140.  
  141.                 void       GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  142.         private:
  143.                 int        count;
  144.                 int        users;
  145.                 int        capacity;
  146.         };
  147.  
  148.         typedef std::vector<EntityId>              TInventoryVector;
  149.         typedef TInventoryVector::const_iterator   TInventoryCIt;
  150.         typedef TInventoryVector::iterator         TInventoryIt;
  151.         typedef std::map<IEntityClass*, SAmmoInfo> TAmmoInfoMap;
  152.         typedef std::vector<IEntityClass*>         TInventoryVectorEx;
  153.         typedef std::vector<IInventoryListener*>   TListenerVec;
  154.  
  155. public:
  156.         CInventory();
  157.         virtual ~CInventory();
  158.  
  159.         //IGameObjectExtension
  160.         virtual bool                 Init(IGameObject* pGameObject);
  161.         virtual void                 InitClient(int channelId)          {};
  162.         virtual void                 PostInit(IGameObject* pGameObject) {};
  163.         virtual void                 PostInitClient(int channelId)      {};
  164.         virtual bool                 ReloadExtension(IGameObject* pGameObject, const SEntitySpawnParams& params);
  165.         virtual void                 PostReloadExtension(IGameObject* pGameObject, const SEntitySpawnParams& params);
  166.         virtual void                 Release()                                                                     { delete this; };
  167.         virtual void                 FullSerialize(TSerialize ser);
  168.         virtual bool                 NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags) { return true; }
  169.         virtual void                 PostSerialize();
  170.         virtual void                 SerializeSpawnInfo(TSerialize ser)                                            {}
  171.         virtual ISerializableInfoPtr GetSpawnInfo()                                                                { return 0; }
  172.         virtual void                 Update(SEntityUpdateContext& ctx, int)                                        {}
  173.         virtual void                 PostUpdate(float frameTime)                                                   {};
  174.         virtual void                 PostRemoteSpawn()                                                             {};
  175.         virtual void                 HandleEvent(const SGameObjectEvent&)                                          {};
  176.         virtual void                 ProcessEvent(SEntityEvent&);
  177.         virtual void                 SetChannelId(uint16 id)                                                       {};
  178.         virtual void                 SetAuthority(bool auth)                                                       {};
  179.         //~IGameObjectExtension
  180.  
  181.         //IInventory
  182.         virtual bool                AddItem(EntityId id);
  183.         virtual bool                RemoveItem(EntityId id);
  184.         virtual void                RemoveAllItems(bool forceClear = false);
  185.  
  186.         virtual void                RMIReqToServer_RemoveAllItems() const;
  187.         virtual void                RMIReqToServer_AddItem(const char* _pszItemClass) const;
  188.         virtual void                RMIReqToServer_RemoveItem(const char* _pszItemClass) const;
  189.         virtual void                RMIReqToServer_SetAmmoCount(const char* _pszAmmoClass, int _iAmount) const;
  190.         virtual void                RMIReqToServer_AddEquipmentPack(const char* _pszEquipmentPack, bool _bAdd, bool _bPrimary) const;
  191.  
  192.         virtual bool                AddAccessory(IEntityClass* itemClass);
  193.  
  194.         virtual void                Destroy();
  195.         virtual void                Clear(bool forceClear = false);
  196.  
  197.         virtual int                 GetCapacity() const;
  198.         virtual int                 GetCount() const;
  199.         virtual int                 GetCountOfClass(const char* className) const;
  200.         virtual int                 GetCountOfCategory(const char* categoryName) const;
  201.         virtual int                 GetCountOfUniqueId(uint8 uniqueId) const;
  202.  
  203.         virtual int                 GetSlotCount(int slotId) const;
  204.  
  205.         virtual EntityId            GetItem(int slotId) const;
  206.         virtual const char*         GetItemString(int slotId) const;
  207.         virtual EntityId            GetItemByClass(IEntityClass* pClass, IItem* pIgnoreItem = NULL) const;
  208.         virtual IItem*              GetItemByName(const char* name) const;
  209.  
  210.         virtual int                 GetAccessoryCount() const;
  211.         virtual const char*         GetAccessory(int slotId) const;
  212.         virtual const IEntityClass* GetAccessoryClass(int slotId) const;
  213.         virtual bool                HasAccessory(IEntityClass* pClass) const;
  214.  
  215.         virtual int                 FindItem(EntityId itemId) const;
  216.  
  217.         virtual int                 FindNext(IEntityClass* pClass, const char* category, int firstSlot, bool wrap) const;
  218.         virtual int                 FindPrev(IEntityClass* pClass, const char* category, int firstSlot, bool wrap) const;
  219.  
  220.         virtual EntityId            GetCurrentItem() const;
  221.         virtual EntityId            GetHolsteredItem() const;
  222.         virtual void                SetCurrentItem(EntityId itemId);
  223.         virtual void                SetHolsteredItem(EntityId itemId);
  224.  
  225.         virtual void                SetLastItem(EntityId itemId);
  226.         virtual EntityId            GetLastItem() const;
  227.         virtual EntityId            GetLastSelectedInSlot(IInventory::EInventorySlots slotId) const;
  228.         virtual void                RemoveItemFromCategorySlot(EntityId entityId);
  229.  
  230.         virtual void                HolsterItem(bool holster);
  231.  
  232.         virtual void                SerializeInventoryForLevelChange(TSerialize ser);
  233.         virtual bool                IsSerializingForLevelChange() const { return m_bSerializeLTL; }
  234.  
  235.         virtual int                 GetAmmoTypesCount() const;
  236.         virtual IEntityClass*       GetAmmoType(int idx) const;
  237.  
  238.         // these functions are not multiplayer safe..
  239.         // any changes made using these functions will not be synchronized...
  240.         virtual void         SetAmmoCount(IEntityClass* pAmmoType, int count);
  241.         virtual int          GetAmmoCount(IEntityClass* pAmmoType) const;
  242.         virtual void         SetAmmoCapacity(IEntityClass* pAmmoType, int max);
  243.         virtual int          GetAmmoCapacity(IEntityClass* pAmmoType) const;
  244.         virtual void         ResetAmmo();
  245.  
  246.         virtual void         AddAmmoUser(IEntityClass* pAmmoType);
  247.         virtual void         RemoveAmmoUser(IEntityClass* pAmmoType);
  248.         virtual int          GetNumberOfUsersForAmmo(IEntityClass* pAmmoType) const;
  249.  
  250.         inline void          AmmoIteratorFirst() { m_stats.ammoIterator = m_stats.ammoInfo.begin(); }
  251.         inline bool          AmmoIteratorEnd()   { return m_stats.ammoIterator == m_stats.ammoInfo.end(); }
  252.         inline int           GetAmmoPackCount()  { return m_stats.ammoInfo.size(); }
  253.  
  254.         inline IEntityClass* AmmoIteratorNext()
  255.         {
  256.                 IEntityClass* pClass = m_stats.ammoIterator->first;
  257.                 ++m_stats.ammoIterator;
  258.                 return pClass;
  259.         }
  260.  
  261.         inline const IEntityClass* AmmoIteratorGetClass()
  262.         {
  263.                 return m_stats.ammoIterator->first;
  264.         }
  265.  
  266.         inline int AmmoIteratorGetCount()
  267.         {
  268.                 return m_stats.ammoIterator->second.GetCount();
  269.         }
  270.  
  271.         virtual IActor*                     GetActor() { return m_pActor; };
  272.  
  273.         virtual void                        SetInventorySlotCapacity(IInventory::EInventorySlots slotId, unsigned int capacity);
  274.         virtual void                        AssociateItemCategoryToSlot(const char* itemCategory, IInventory::EInventorySlots slotId);
  275.         virtual bool                        IsAvailableSlotForItemClass(const char* itemClass) const;
  276.         virtual bool                        IsAvailableSlotForItemCategory(const char* itemCategory) const;
  277.         virtual bool                        AreItemsInSameSlot(const char* itemClass1, const char* itemClass2) const;
  278.         virtual IInventory::EInventorySlots GetSlotForItemCategory(const char* itemCategory) const;
  279.  
  280.         virtual void                        AddListener(IInventoryListener* pListener);
  281.         virtual void                        RemoveListener(IInventoryListener* pListener);
  282.  
  283.         virtual void                        IgnoreNextClear();
  284.  
  285.         //~IInventory
  286.  
  287.         int          GetAccessorySlotIndex(IEntityClass* accessoryClass) const;
  288.  
  289.         virtual void GetMemoryUsage(ICrySizer* s) const
  290.         {
  291.                 s->AddObject(this, sizeof(*this));
  292.                 s->AddObject(m_stats);
  293.                 s->AddObject(m_editorstats);
  294.         }
  295.  
  296. #if DEBUG_INVENTORY_ENABLED
  297.         void Dump() const;
  298. #endif
  299.  
  300.         // used for clients to request changes to the server.
  301.         DECLARE_SERVER_RMI_NOATTACH(SvReq_RemoveAllItems, TRMIInventory_Dummy, eNRT_ReliableOrdered);
  302.         DECLARE_SERVER_RMI_NOATTACH(SvReq_AddItem, TRMIInventory_Item, eNRT_ReliableOrdered);
  303.         DECLARE_SERVER_RMI_NOATTACH(SvReq_RemoveItem, TRMIInventory_Item, eNRT_ReliableOrdered);
  304.         DECLARE_SERVER_RMI_NOATTACH(SvReq_SetAmmoCount, TRMIInventory_Ammo, eNRT_ReliableOrdered);
  305.         DECLARE_SERVER_RMI_NOATTACH(SvReq_AddEquipmentPack, TRMIInventory_EquipmentPack, eNRT_ReliableOrdered);
  306.  
  307.         // used to set changes into the clients.
  308.         DECLARE_CLIENT_RMI_NOATTACH(Cl_SetAmmoCount, TRMIInventory_Ammo, eNRT_ReliableOrdered);
  309.         DECLARE_CLIENT_RMI_NOATTACH(Cl_RemoveAllAmmo, TRMIInventory_Dummy, eNRT_ReliableOrdered);
  310.         DECLARE_CLIENT_RMI_NOATTACH(Cl_SetAmmoCapacity, TRMIInventory_Ammo, eNRT_ReliableOrdered);
  311.  
  312. private:
  313.  
  314.         int      Validate();
  315.  
  316.         void     SetLastSelectedInSlot(EntityId entityId);
  317.         void     AddItemToCategorySlot(EntityId entityId);
  318.         void     ResetAmmoAndUsers();
  319.         EInventorySlots GetSlotFromEntityID(EntityId) const;
  320.         EntityId GetAnyEntityInSlot(int slot) const;
  321.  
  322.         struct compare_slots
  323.         {
  324.                 compare_slots()
  325.                 {
  326.                         m_pEntitySystem = gEnv->pEntitySystem;
  327.                         m_pItemSystem = CCryAction::GetCryAction()->GetIItemSystem();
  328.                 }
  329.                 bool operator()(const EntityId lhs, const EntityId rhs) const
  330.                 {
  331.                         const IEntity* pLeft = m_pEntitySystem->GetEntity(lhs);
  332.                         const IEntity* pRight = m_pEntitySystem->GetEntity(rhs);
  333.                         const uint32 lprio = pLeft ? m_pItemSystem->GetItemPriority(pLeft->GetClass()->GetName()) : 0;
  334.                         const uint32 rprio = pRight ? m_pItemSystem->GetItemPriority(pRight->GetClass()->GetName()) : 0;
  335.  
  336.                         if (lprio != rprio)
  337.                                 return lprio < rprio;
  338.                         else
  339.                                 return lhs < rhs;
  340.                 }
  341.  
  342.                 IEntitySystem* m_pEntitySystem;
  343.                 IItemSystem*   m_pItemSystem;
  344.         };
  345.  
  346.         struct compare_class_slots
  347.         {
  348.                 compare_class_slots()
  349.                 {
  350.                         m_pItemSystem = CCryAction::GetCryAction()->GetIItemSystem();
  351.                 }
  352.                 bool operator()(const IEntityClass* lhs, const IEntityClass* rhs) const
  353.                 {
  354.                         const uint32 lprio = m_pItemSystem->GetItemPriority(lhs->GetName());
  355.                         const uint32 rprio = m_pItemSystem->GetItemPriority(rhs->GetName());
  356.  
  357.                         return lprio < rprio;
  358.                 }
  359.                 IItemSystem* m_pItemSystem;
  360.         };
  361.  
  362.         struct SSlotInfo
  363.         {
  364.                 SSlotInfo()
  365.                         : maxCapacity(0)
  366.                         , count(0)
  367.                         , lastSelected(0)
  368.                 {
  369.  
  370.                 }
  371.  
  372.                 void Reset()
  373.                 {
  374.                         count = 0;
  375.                         lastSelected = 0;
  376.                 }
  377.  
  378.                 unsigned int count;
  379.                 unsigned int maxCapacity;
  380.                 EntityId     lastSelected;
  381.         };
  382.  
  383.         typedef std::map<string, IInventory::EInventorySlots> TCategoriesToSlot;
  384.  
  385.         struct SInventoryStats
  386.         {
  387.                 SInventoryStats()
  388.                         : currentItemId(0),
  389.                         holsteredItemId(0),
  390.                         lastItemId(0)
  391.                 {};
  392.  
  393.                 void GetMemoryUsage(ICrySizer* s) const
  394.                 {
  395.                         s->AddContainer(ammoInfo);
  396.                         s->AddContainer(slots);
  397.  
  398.                         for (TCategoriesToSlot::const_iterator it = categoriesToSlot.begin(); it != categoriesToSlot.end(); ++it)
  399.                         {
  400.                                 s->AddObject(it->first);
  401.                         }
  402.                 }
  403.  
  404.                 TInventoryVector       slots;
  405.                 TInventoryVectorEx     accessorySlots;    //Items in inventory, but the entity might not exit, or is in a shared pool
  406.                 TAmmoInfoMap           ammoInfo;
  407.                 SSlotInfo              slotsInfo[IInventory::eInventorySlot_Last];
  408.                 TCategoriesToSlot      categoriesToSlot;
  409.  
  410.                 TAmmoInfoMap::iterator ammoIterator;
  411.  
  412.                 EntityId               currentItemId;
  413.                 EntityId               holsteredItemId;
  414.                 EntityId               lastItemId;
  415.         };
  416.  
  417.         SInventoryStats m_stats;
  418.         SInventoryStats m_editorstats;
  419.         TListenerVec    m_listeners;
  420.  
  421.         IGameFramework* m_pGameFrameWork;
  422.         IActor*         m_pActor;
  423.         bool            m_bSerializeLTL;
  424.         bool            m_iteratingListeners;
  425.         bool            m_ignoreNextClear;
  426. };
  427.  
  428. #endif //__INVENTORY_H__
  429.  
downloadInventory.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