如何设计游戏中的道具功能（二）

freeeyes

下面来看看具体的实现代码吧。

1. #ifndef _OBJECT_H
2. #define _OBJECT_H
4. //所有物品的基类
5. //add by freeeyes
7. #include "ObjectDefine.h"
9. //此宏用于memcopy边界检查
10. #define CHECK_SCOPE(a,b) if(a < b){ return false; }
12. //所有对象的总类
13. class CBaseObject
14. {
15. public:
16.         CBaseObject()
17.         {
18.                 m_u8GUID        = 0;
19.                 m_emObjectType  = OBJECT_UNKNOW;
20.                 m_emObjectState = OBJECT_UNKNOW_STATE;
21.                 m_u2Count       = 1;
22.                 m_u2MaxCount    = 1;
24.         };
26.         CBaseObject(ENUM_OBJECT_TYPE emObjectType, ENUM_OBJECT_STATE emObjectState)
27.         {
28.                 m_emObjectType  = emObjectType;
29.                 m_emObjectState = emObjectState;
30.         }
32.         virtual ~CBaseObject() {};
34.         /*
35.         *    @Description: 设置对象的全局ID
36.         */
37.         void SetGUID(uint64 u8GUID) { m_u8GUID = u8GUID; };
39.         /*
40.         *    @Description: 获得对象的全局ID
41.         */
42.         uint64 GetGUID() { return m_u8GUID; };
44.         /*
45.         *    @Description: 设置对象类型
46.         */
47.         void SetObjectType(ENUM_OBJECT_TYPE emObjectType)
48.         {
49.                 m_emObjectType = emObjectType;
50.         }
52.         /*
53.         *    @Description: 得到对象类型
54.         */
55.         ENUM_OBJECT_TYPE GetObjectType()
56.         {
57.                 return m_emObjectType;
58.         }
60.         /*
61.         *    @Description: 设置对象状态
62.         */
63.         void SetObjectState(ENUM_OBJECT_STATE emObjectState)
64.         {
65.                 m_emObjectState = emObjectState;
66.         }
68.         /*
69.         *    @Description: 得到对象状态
70.         */
71.         ENUM_OBJECT_STATE GetObjectState()
72.         {
73.                 return m_emObjectState;
74.         }
76.         /*
77.         *    @Description: 设置对象叠加个数
78.         */
79.         void SetCount(uint16 u2Count)
80.         {
81.                 m_u2Count = u2Count;
82.         }
84.         /*
85.         *    @Description: 得到对象叠加个数
86.         */
87.         uint16 GetCount()
88.         {
89.                 return m_u2Count;
90.         }
92.         /*
93.         *    @Description: 设置最大个数
94.         */
95.         void SetMaxCount(uint16 u2MaxCount)
96.         {
97.                 m_u2MaxCount = u2MaxCount;
98.         }
100.         /*
101.         *    @Description: 获得最大个数
102.         */
103.         uint16 GetMaxCount()
104.         {
105.                 return m_u2MaxCount;
106.         }
108.         /*
109.         *    @Description: 将对象写入数据流
110.         */
111.         virtual bool WriteToBuffer(char* pBuffer, int& nSize)
112.         {
113.                 int nPos = 0;
115.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint64)));
116.                 uint64 u8NetGUID = 0;
117.                 HTON64(m_u8GUID, u8NetGUID);
118.                 MEMCOPY_SAFE((char* )&pBuffer[nPos], (char* )&u8NetGUID, sizeof(uint64));
119.                 nPos += sizeof(uint64);
121.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
122.                 uint16 u2NetObjectType = 0;
123.                 HTONS(m_emObjectType, u2NetObjectType);
124.                 MEMCOPY_SAFE((char* )&pBuffer[nPos], (char* )&u2NetObjectType, sizeof(uint16));
125.                 nPos += sizeof(uint16);
127.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint8)));
128.                 MEMCOPY_SAFE((char* )&pBuffer[nPos], (char* )&m_emObjectState, sizeof(uint8));
129.                 nPos += sizeof(uint8);
131.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
132.                 uint16 u2NetCount = 0;
133.                 HTONS(m_u2Count, u2NetCount);
134.                 MEMCOPY_SAFE((char* )&pBuffer[nPos], (char* )&u2NetCount, sizeof(uint16));
135.                 nPos += sizeof(uint16);
137.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
138.                 uint16 u2NetMaxCount = 0;
139.                 HTONS(m_u2MaxCount, u2NetMaxCount);
140.                 MEMCOPY_SAFE((char* )&pBuffer[nPos], (char* )&u2NetMaxCount, sizeof(uint16));
141.                 nPos += sizeof(uint16);
143.                 nSize = nPos;
144.                 return true;
145.         }
147.         /*
148.         *    @Description: 从数据流还原对象
149.         */
150.         virtual bool ReadFromBuffer(char* pBuffer, int& nSize)
151.         {
152.                 int nPos = 0;
154.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint64)));
155.                 MEMCOPY_SAFE((char* )&m_u8GUID, &pBuffer[nPos], sizeof(uint64));
156.                 NTOH64(m_u8GUID);
157.                 nPos += sizeof(uint64);
159.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
160.                 uint16 u2objectType = 0;
161.                 MEMCOPY_SAFE((char* )&u2objectType, &pBuffer[nPos], sizeof(uint16));
162.                 NTOHS(u2objectType);
163.                 m_emObjectType = (ENUM_OBJECT_TYPE)u2objectType;
164.                 nPos += sizeof(uint16);
166.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint8)));
167.                 MEMCOPY_SAFE((char* )&m_emObjectState, &pBuffer[nPos], sizeof(uint8));
168.                 nPos += sizeof(uint8);
170.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
171.                 MEMCOPY_SAFE((char* )&m_u2Count, &pBuffer[nPos], sizeof(uint16));
172.                 NTOHS(m_u2Count);
173.                 nPos += sizeof(uint16);
175.                 CHECK_SCOPE(nSize, (int)(nPos + sizeof(uint16)));
176.                 MEMCOPY_SAFE((char* )&m_u2MaxCount, &pBuffer[nPos], sizeof(uint16));
177.                 NTOHS(m_u2MaxCount);
178.                 nPos += sizeof(uint16);
180.                 nSize = nPos;
181.                 return true;
182.         }
184.         /*
185.         *    @Description: 重载等于运算符
186.         */
187.         CBaseObject& operator = (CBaseObject& ar)
188.         {
189.                 this->SetGUID(ar.GetGUID());
190.                 this->SetObjectType(ar.GetObjectType());
191.                 this->SetObjectState(ar.GetObjectState());
192.                 this->SetCount(ar.GetCount());
193.                 return *this;
194.         }
196. private:
197.         uint64            m_u8GUID;         //唯一编号
198.         ENUM_OBJECT_TYPE  m_emObjectType;   //对象类型
199.         ENUM_OBJECT_STATE m_emObjectState;  //对象状态
200.         uint16            m_u2Count;        //当前个数
201.         uint16            m_u2MaxCount;     //最大个数
202. };
204. #endif

复制代码

首先我构造了一个obj对象类，所有的物品都从此派生。
当然，你也可以选择从此派生出一些别的有意思的东东。
这个类我只提供4个参数，唯一编号，对象类型，对象状态，当前个数和最大个数。
唯一编号是当这个物品被创造到这个世界的时候必胜生成的唯一ID，这个算法有很多，64位长度，为了保持物品的唯一性并考虑合区的问题，建议在这个算法里面可以添加一个初始值。不同的服务器初始值不同，这样就可以方便的实现和服而不用在费力去合并那些重复的ID。
我在这个算法里面只提供了一个基本的计算方法。如果你愿意，你可以组织你的算法。

1. #ifndef _ITEM_H
2. #define _ITEM_H
4. //道具对象，继承自CBaseObject
5. //add by freeeyes
7. #include <stdio.h>
8. #include <string>
9. #include "Object.h"
11. #define ITEM_BUFFER_SIZE  10 * 1024
13. class CItem : public CBaseObject
14. {
15. public:
16.         CItem();
17.         CItem(uint32 u4Version);
18.         virtual ~CItem();
20. //以下物品设计相关方法
21. public:  
22.         /*
23.         *    @Description: 添加相关物品属性
24.         */
25.         void AddItemAttribute(ENUM_ITEM_ATTRIBUTE emAttrName, uint16 u2Value);
27.         /*
28.         *    @Description: 显示所有该物品属性
29.         */
30.         void DisPlay(char* pAttr, uint16& u2Size);
32.         /*
33.         *    @Description: 创建物品相关唯一ID，物品名称，物品描述
34.         */
35.         void Create(const char* pItemName, int nItemNameSize, const char* pItemDesc, int nItemDesc);
37.         /*
38.         *    @Description: 得到物品属性数组
39.         */
40.         uint32* GetItemAttributeList();
42.         /*
43.         *    @Description: 设置物品属性数组
44.         */
45.         void SetItemAttributeList(uint32* ayAttribute);
47. //物品使用相关方法
48. public:
49.         /*
50.         *    @Description: 得到指定的物品属性
51.         */
52.         uint32 GetItemAttribute(ENUM_ITEM_ATTRIBUTE emAttrName);
54.         /*
55.         *    @Description: 得到物品名称
56.         */
57.         const char* GetItemName();
59.         /*
60.         *    @Description: 得到物品描述
61.         */
62.         const char* GetItemDesc();
64.         /*
65.         *    @Description: 清除所有属性
66.         */
67.         void ClearAttribute();
69. //物品存取相关方法
70. public:
71.         /*
72.         *    @Description: 从数据流还原Item对象
73.         */
74.         bool ReadFromBuffer(char* pBuffer, int& nSize);
76.         /*
77.         *    @Description: 序列化入数据流
78.         */
79.         bool WriteToBuffer(char* pBuffer, int& nSize);
81.         /*
82.         *    @Description: 重载等于运算符
83.         */
84.         CItem& operator = (CItem& ar)
85.         {
86.                 //这里由于创建新道具的时候涉及拷贝操作，所以这里不负责拷贝GUID
87.                 //this->SetGUID(ar.GetGUID());
88.                 this->SetObjectType(ar.GetObjectType());
89.                 this->SetObjectState(ar.GetObjectState());
90.                 this->SetCount(ar.GetCount());
91.                 this->SetMaxCount(ar.GetMaxCount());
93.                 this->Create(ar.GetItemName(), (int)strlen(ar.GetItemName()), ar.GetItemDesc(), (int)strlen(ar.GetItemDesc()));
95.                 //复制属性
96.                 for(uint16 i = 0; i < MAX_ITEM_ATTRIBUTE; i++)
97.                 {
98.                         uint32 u4Value = ar.GetItemAttribute((ENUM_ITEM_ATTRIBUTE)i);
99.                         if(u4Value > 0)
100.                         {
101.                                 this->AddItemAttribute((ENUM_ITEM_ATTRIBUTE)i, u4Value);
102.                         }
103.                 }
104.                
105.                 return *this;
106.         }
108. private:
109.         uint32 m_ayAttribute[MAX_ITEM_ATTRIBUTE];
110.         char   m_szItemName[MAX_ITEM_NAME];
111.         char   m_szItemDesc[MAX_ITEM_DESC];
112. };
114. #endif

复制代码

这里是道具的具体结构了，继承了CBaseObject
这里首先我会根据上一章所说的宏，也就是MAX_ITEM_ATTRIBUTE创建一个数组，这个数组就是标识各个属性的。
这样做，有两种好处，因为在实际运行过程中，所有数据都已数组形式提供，快而且高效。不用遍历，根据数组下表定位具体属性的位置，方便查询。
在这里，实现了对指定对象的串行化操作。由于考虑到了不同的主机字序，所以写入文件的一律是网络字序，到本地打开文件流的时候是主机字序。
这里提供了一系列的方法，用于道具的功能。
考虑到了一些道具复制操作，于是在这里重载了=，如果你需要对这个类有添加，在这里也需要提供相应的代码。

道具的基础属性并没有什么问题，这些代码基本都是固定的。
那么，如果我的道具需要合并，分解，使用等等其他操作，应该怎么办呢？
这里首先提出一个概念，那就是，道具的合成，分解，使用，销毁或者其它功能，都离不开数据源。也就是说，我必须要有一个道具的容器。


这里，我们把这些道具的集合称为一种容器。
背包，仓库，银行。除了货币。只要出现的道具，都必须存在在一种容器中，哪怕是掉落了，也会在一个容器中。
如果有存在于没有所在容器指针的道具，说明程序出现了BUG，需要找出来。
这样做，可以最大程序的避免程序设计时以及使用时候的道具追踪。
好了，让我们看看道具容器（背包）是怎么实现的。

1. #ifndef _BAG_H
2. #define _BAG_H
4. //背包容器
5. //add by freeeyes
7. #include "Item.h"
8. #include "Contraner.h"
9. #include "ItemManager.h"
11. #define MAX_BAG_COUNT 100
12. #define BAG_FILE_NAME "Bag.pmf"
14. class CBag : public CContainer<CItem>
15. {
16. public:
17.         CBag(uint16 u2Count = MAX_BAG_COUNT);
18.     virtual ~CBag();
20.         /*
21.         *    @Description: 从数据流还原容器对象，需要从子类去实现
22.         */
23.         bool ReadFromBuffer(const char* pFileName);
25.         /*
26.         *    @Description: 从数据流还原容器对象，需要从子类去实现
27.         */
28.         bool WriteToBuffer(const char* pFileName);
30.         /*
31.         *    @Description: 设置对象管理器
32.         */
33.         void SetItemManager(CItemManager* pItemManager);
35.         /*
36.         *    @Description: 背包清空事件
37.         */
38.         void Close();
40.         /*
41.         *    @Description: 添加一个背包道具
42.         */
43.         uint16 AddObject(CItem* pItem);
45.         /*
46.         *    @Description: 添加一个背包道具
47.         */
48.         bool AddObject(uint16 u2Index, CItem* pItem);
50.         /*
51.         *    @Description: 删除指定类型的道具以及数量
52.         */
53.         bool DelObject(uint32 u4ItemBaseID, uint16 u2Count);
55.         /*
56.         *    @Description: 删除指定单元格的物品
57.         */
58.         bool DelObject(uint16 u2Index);
60.         /*
61.         *    @Description: 得到指定道具类型的总数
62.         */
63.         uint16 GetBagCurrCount(uint32 u4ItemBaseID);
65.         /*
66.         *    @Description: 得到指定位置的道具
67.         */
68.         CItem* GetContainObject(uint16 u2Index);
70.         /*
71.         *    @Description: 得到指定类型的道具，如果有多个返回第一个
72.         */
73.         CItem* GetContainObject(uint32 u4ItemBaseID);
75.         /*
76.         *    @Description: 从背包里移出一个物品
77.         */
78.         CItem* MoveOutItem(uint32 u2Index);
80.         /*
81.         *    @Description:分解一个叠加的道具格子
82.         */
83.         bool SplitItem(uint32 u2Index, uint16 u2ItemCount);
85. public:
86.         CItemManager* m_pItemManager;
87. };
89. #endif

复制代码

看这些函数的注释，你应该会大概理解其中的意思。
一般背包的基本功能都会实现。
实现了道具的容器，就要实现道具的各种使用花样了。
这里我单独独立出来了一个类，用于道具的使用，比如合成和分解。

1. #ifndef _ITEMSYNTHETIC_H
2. #define _ITEMSYNTHETIC_H
4. #include "Bag.h"
6. //合成专用类
7. //赫拉迪克方块
8. //add by freeeyes
10. //最大合成道具总数不能超过30个
11. #define MAX_NEWITEM_SYNTHETIC_COUNT 30
13. enum ENUM_SYNTHETIC_ERRROR:uint8
14. {
15.         SYNTHETIC_ERRROR_NONE = 0,   //无措
16.         SYNTHETIC_ERRROR_NOSYN,      //无法合成,公式错误
17.         SYNTHETIC_ERRROR_NOENOUGTH,  //不够
18.         SYNTHETIC_ERRROR_NOEXIST,    //不存在
19.         SYNTHETIC_ERRROR_DELETE,     //扣减道具失败
20.         SYNTHETIC_ERRROR_NOITEM,     //不是合成物品
21.         SYNTHETIC_ERRROR_NULLITEM,   //道具池已没有空余
22.         SYNTHETIC_ERRROR_ADDBAG,     //添加到背包错误
23.         SYNTHETIC_ERRROR_BAGFULL,    //背包已满
24.         SYNTHETIC_ERRROR_GUID,       //GUID已存在
25. };
28. class CItemSynTheTic
29. {
30. public:
31.         CItemSynTheTic();
32.         ~CItemSynTheTic();
34.         ENUM_SYNTHETIC_ERRROR SynTheTic(uint32 u4BaseID, CBag* pBag, CItemDictionary* pItemDictionary, CItemManager* pItemManager);
36. private:
37.         ENUM_SYNTHETIC_ERRROR Check_NewItem(CItem* pDrawItem, CItemDictionary* pItemDictionary);
38.         ENUM_SYNTHETIC_ERRROR Check_Item_Enougth(CItem* pDrawItem, CBag* pBag);
39.         ENUM_SYNTHETIC_ERRROR Check_Bag_Enougth(CItem* pDrawItem, CBag* pBag);
40.         ENUM_SYNTHETIC_ERRROR Check_Item_Pool_Enougth(CItem* pDrawItem, CItemManager* pItemManager);
41.         ENUM_SYNTHETIC_ERRROR Reduce_Bag_Item(CItem* pDrawItem, CBag* pBag, CItemManager* pItemManager);
42.         ENUM_SYNTHETIC_ERRROR Create_New_Bag_Item(CBag* pBag, CItemManager* pItemManager, CItemDictionary* pItemDictionary);
44.         void Get_New_Item_Count(CItem* pDrawItem);
46. private:
47.         uint32 m_u4ItemNewBaseID[MAX_NEWITEM_SYNTHETIC_COUNT];
48.         uint32 m_u4ItemClassCount;
49. };
52. #endif

复制代码

合成而言，方法就是SynTheTic，分解同理，用一个函数。
仔细想想，合成和分解无外乎，组合成一个或者多个新道具，分解岂不是一样？
这里需要几个参数。
BaseID：道具的基本类型，这个属性在道具设计的时候，就会被指定。
pBag: 背包的指针，我会根据BaseID去背包寻找是否存在这个物品，因为很可能存在的这个物品，是叠加的，或者是多个，我只需要找到其中一个去做这件事就行了。
CItemDictionary： 道具字典，我会根据这个字典去创建指定的物品。一个或者多个。
CItemManager： 这个就是整个世界的道具管理器，记录所有生成的道具，在这个类里面都有对应关系。
这里，其他的大家都容易理解，我要重点说一下CItemManager


CItemManager的类结构如下

1. #ifndef _ITEMMANAGER_H
2. #define _ITEMMANAGER_H
4. //道具管理器
5. //add by freeeyes
7. #include "ItemDictionary.h"
8. #include "ItemMonitor.h"
9. #include <time.h>
11. enum ENUM_ITEM_MANAGER_ERROR:uint8
12. {
13.         ITEM_MANAGER_NO_ERROR        = 0x00,     //无措
14.         ITEM_MANAGER_DICTIONARY_NULL = 0x01,     //字典为空
15.         ITEM_MANAGER_COUNT_FULL      = 0x02,     //已达到最大上限
16.         ITEM_MANAGER_BASEID_NULL     = 0x03,     //BaseID不存在
17.         ITEM_MANAGER_USED_NULL       = 0x04,     //该物品不存在
18.         ITEM_MANAGER_MAP_EXIST       = 0x05,     //关系已存在
19. };
21. //这个类需要单件来处理
22. class CItemManager
23. {
24. public:
25.         CItemManager();
26.         ~CItemManager();
28.         /*
29.         *    @Description: 创建一个GUID
30.         */
31.         uint64 CreateGUID();
33.         /*
34.         *    @Description: 初始化道具管理器
35.         */
36.         bool Init(CItemDictionary* pItemDic, uint32 u4ItemMaxCount);
38.         /*
39.         *    @Description: 清除道具管理器
40.         */
41.         void Close();
43.         /*
44.         *    @Description: 从道具管理器中获得一个空闲的CItem并返回
45.         */
46.         CItem* CreateItem();
48.         /*
49.         *    @Description: 从道具管理器中回收一个道具(这个道具还未生效)
50.         */
51.         ENUM_ITEM_MANAGER_ERROR DeleteItemUnRegedit(CItem*& pItem);
53.         /*
54.         *    @Description: 从道具管理器中回收一个道具
55.         */
56.         ENUM_ITEM_MANAGER_ERROR DeleteItem(CItem*& pItem);
58.         /*
59.         *    @Description: 从道具管理器中回收一个道具
60.         */
61.         ENUM_ITEM_MANAGER_ERROR DeleteItem(uint64 u6GUID);
63.         /*
64.         *    @Description: 建立物品和GUID之间的对应关系
65.         */
66.         ENUM_ITEM_MANAGER_ERROR RegeditItem(uint64 u8GUID, CItem* pItem);
68.         /*
69.         *    @Description: 得到空余的道具数量
70.         */
71.         uint32 GetFreeItemCount();
73.         /*
74.         *    @Description: 保存监控日志
75.         */
76.         void SaveMonitor();
78. private:
79.         typedef map<uint64, CItem*> mapItemUsed;
80.         typedef vector<CItem*> vecItemPool;
82.         mapItemUsed   m_mapItemUsed;        //记载和GUID的映射关系
83.         vecItemPool   m_vecItemUnUsed;      //空闲的道具
85.         CItemDictionary* m_pItemDic;   //物品字典，用于翻阅
86.         uint32           m_u4MaxCount; //最大生成物品个数（包含目前已经有的）
87.        
88.         //生成GUID相关参数
89.         uint32           m_u4TimeSeed;       //时间种子
90.         uint32           m_u4TimeSeedCount;  //当前种子个数
92.         //道具监控者
93.         CItemMonitor     m_objItemMonitor;   //监控道具的类
94. };
96. #endif

复制代码

我如何从这个类里面创建一个道具呢？

        //创建一个道具
        CItem* pItem = NULL;
        pItem = m_objItemManager.CreateItem();


首先，我去道具池里面获取一个空余的道具对象。
如果没有了，那么就会得到一个NULL，说明全世界的道具已经都被生成出来了，已经没有空余的道具可以被生成了。

                CItem* pItemDoc = m_ItemDictionary.GetItem(u4ItemBaseID);
                (*pItem) = (*pItemDoc);


从字典里面获取一个要生成的指定BaseID的道具信息，并赋值给这个空道具对象，让他具象化。

                m_objItemManager.RegeditItem(pItem->GetGUID(), pItem)
告诉CItemManager，我已经具象化完成了，并赋予了它一个GUID（唯一ID），建立道具和GUID的唯一关联关系。
如果这时候这个GUID已经存在，说明代码存在问题。生成的这个道具是不合法的。
于是回收之


                        //如果当前道具的GUID已被使用，则将物品销毁归还道具池
                        m_objItemManager.DeleteItemUnRegedit(pItem);

反之，放入容器。
完整整个操作，呵呵。
挺简单吧，其实，道具说复杂不复杂，但是要想做好可控的道具流，还是要费一些心思的。
下一章，我会讲讲邮件是怎么做的。下一章也是最后一章，在那时候我会贴出所有的代码。