程序博客网 > 网络词boom是什么意思

Lua与C++的逻辑舞步

来源：互联网 发布：网络词boom是什么意思 编辑：程序博客网 时间：2024/06/11 19:35

本文转自：http://www.acejoy.com/bbs/viewthread.php?tid=3136

 以前写过一篇Lua的基础文章，属于基础的技术普及贴，具体请参阅精华区。以下的文章，希望你能稍微了解一些Lua的基础知识，再来阅读更有益处。

在网上，很多人都在说Lua适合做游戏，但是怎么做？说的却知之甚少，更多的是长篇累牍的基础贴。脚本与C++的结合，如何能达到较高的效率？什么样的数据适合Lua去表现？什么样的数据适合C++去处理？怎么利用两者的关系？在这里我给出一种解决方法。
很多人说，你可以把C++的对象封装到Lua里面去。在Lua里面提供对C++类操作的各种方法。这样的手段见仁见智，但是我个人却并不赞同，原因是，Lua是一个面向过程的语言，它和python,js是完全不同的，就像C和C++，为什么要把面向过程和面向过程完全分开，是因为它们服务于不同的需求，看过一些朋友把C++的对象模式做了一个Lua的粘合层，很是感觉有些繁复。在我看来，面向过程就要体现出面向过程的精华，不要把过多对象的概念引入其中，这样，代码简洁，易于维护管理，同时也能发挥各自最高的价值。C++是面向对象的，就让它去处理它擅长的对象，Lua是面向过程的，那么我就让lua去处理它擅长的过程组织，两个互不干扰，这样，双方组合后的能量才能真正爆发出来。

还是那句话，在我看来，代码只是一种表现形式，更重要的是思想，如何思考问题的方法。如果你是Lua初学者，我希望更多的是去学会如何思考问题，并将问题化解到你的思维模式中，形成流。这样，你才不会过分的依赖语言本身，毕竟，基础的语法在谷歌上我们还是能大量获得的。但是好的想法，却需要日积月累的总结。
先来讲个故事，我以前做游戏，经常碰到这样的策划：
"你来帮我实现这么一个东东，玩家到一个NPC那里，NPC展现出一个列表，上面写着若干任务描述，玩家选择一个，然后找到另外一个NPC或者到野外打够任务需要的素材和条件，回来交给这个NPC，完成任务。"，"玩家找到一个NPC，直接展开一个副本，里面有很多怪物啊关卡啊等等，玩家进去就可以乒乒乓乓。做完任务就可以退出来，并获得奖励。"
这样的需求我在游戏开发中会经常遇到，有时候我很纠结，为什么这么说？因为更多的时候，策划是不会特别考虑细节的。而程序实现的时候，往往面对的是非常细节的东西。好不容易实现了策划的想法，保不齐哪天策划要变化，你难道再跟着策划改一遍吗？要知道，就算你写程序再牛，你也赶不上策划天马行空的速度。在"我觉得应该是这样..."这样的语句面前，你的任何技术积淀都可能瞬间化为浮云。东西做不出来，策划肯定认为是你的能力不行，而程序呢，认为策划太BT。最后双方变成了敌人，在很多游戏团队中都存在这样的问题。
那么能不能有一种模式，策划策划的过程，让他们自己去实现？而且可以满足他们自己去不断纠正，同时不影响我们的程序实现？方法是有的，就是让策划写一个剧本，这个剧本可以加载到程序里面去执行。不过，不要指望策划会用C++，这是不现实的。你可以把他们想象成一个厨师，你是一个配料师，按照厨师的要求，你给他准备好各种配料，至于做什么菜，那是厨师的事情了。对了，这就是脚本语言带给策划和程序开发模式的改变。也正是源于此，我们需要找到一种能够清晰的描述事件过程的语言，来配合我C++为厨师们准备灶台。炒菜的东西我给你准备好了，都是按照厨师要求的，如果厨师做不出来，那么是厨师自己的手艺问题了。如果配料你做不出来，那么就是你配料师水平不行。责任明确，问题容易找。
那么好了，我们先以lua来说，怎么做这样的架构？
首先，既然我们是配料师，那么一定要提供一系列的配料才行。我再强调一次，对于面向过程的语言，尽量不要扯入对象的概念。那么好，看看我们手里有什么材料？
玩家的数据资料，比如：血量，名称，身上背负的任务编号，身上的装备，材料，格子。。。。等等等等。


好了，说道理简单，让我们看看如何去做这样的架构吧，用代码来实现一个高弹性，可扩展的逻辑舞步，嘿嘿，很兴奋吧。
我先建立一个简单的CPlayer对象，姑且这就是最简单的玩家属性吧，当然，你可以扩展之，我只是展现这样的思维流程。这里包含了一个对所有CPlayer的数据管理对象。
  1. #include <string>
  2. #include <map>

  4. using namespace std;

  6. class CPlayer
  7. {
  8. public:
  9.         CPlayer(void) {};
  10.         ~CPlayer(void) {};

  12. //创建一个玩家信息
  13.         void CreatePlayer(int nPlayerID, string strPlayerName)
  14.         {
  15.                 m_nPlayerID      = nPlayerID;                   //玩家的ID
  16.                 m_nMessionID     = 0;                           //玩家的任务
  17.                 m_nItemID        = 0;                                //玩家所持有的物品ID
  18.                 m_strPlayerName  = strPlayerName;     //玩家的昵称
  19.                 m_strMessionDesc = "";                     //任务的描述
  20.         };

  22.         int GetPlayerID()
  23.         {
  24.                 return m_nPlayerID;
  25.         };

  27.         bool SetMessionID(int nMessionID)
  28.         {
  29.                 if(m_nMessionID != 0)
  30.                 {
  31.                         return false;
  32.                 }

  34.                 m_nMessionID = nMessionID;
  35.                 return true;
  36.         };

  38.         int GetMessionID()
  39.         {
  40.                 return m_nMessionID;
  41.         }

  43.         void FinishMessionID()
  44.         {
  45.                 m_nMessionID = 0;
  46.         };

  48.         void SetMessionDesc(const char* pDesc)
  49.         {
  50.                 m_strMessionDesc = pDesc;
  51.         };

  53.         void SetItemID(int nItemID)
  54.         {
  55.                 m_nItemID = nItemID;
  56.         };

  58.         int GetItemID()
  59.         {
  60.                 return m_nItemID;
  61.         }

  63. private:
  64.         int    m_nPlayerID;        //玩家ID
  65.         string m_strPlayerName;    //玩家姓名
  66.         int    m_nMessionID;       //玩家任务ID
  67.         string m_strMessionDesc;   //玩家任务描述
  68.         int    m_nItemID;          //玩家所持物品ID
  69. };


  72. class CPlayerManager
  73. {
  74. private:
  75.         CPlayerManager() {};

  77. public:
  78.         static CPlayerManager& Instance()
  79.         {
  80.                 if(m_pPlayerManager == NULL)
  81.                 {
  82.                         m_pPlayerManager = new CPlayerManager();
  83.                 }

  85.                 return *m_pPlayerManager;
  86.         };

  88.         ~CPlayerManager()
  89.         {
  90.                 Close();
  91.         };

  93.         bool AddPlayer(CPlayer* pPlayer)
  94.         {
  95.                 if(NULL == pPlayer)
  96.                 {
  97.                         return false;
  98.                 }

  100.                 mapPlayerManager::iterator f = m_mapPlayerManager.find(pPlayer->GetPlayerID());
  101.                 if(f != m_mapPlayerManager.end())
  102.                 {
  103.                         return false;
  104.                 }

  106.                 m_mapPlayerManager.insert(mapPlayerManager::value_type(pPlayer->GetPlayerID(), pPlayer));
  107.                 return true;
  108.         };

  110.         CPlayer* GetPlayer(int nPlayerID)
  111.         {
  112.                 mapPlayerManager::iterator f = m_mapPlayerManager.find(nPlayerID);
  113.                 if(f != m_mapPlayerManager.end())
  114.                 {
  115.                         return (CPlayer* )f->second;
  116.                 }
  117.                 else
  118.                 {
  119.                         return NULL;
  120.                 }
  121.         };

  123.         void Close()
  124.         {
  125.                 mapPlayerManager::iterator b = m_mapPlayerManager.begin();
  126.                 mapPlayerManager::iterator e = m_mapPlayerManager.end();

  128.                 for(b; b != e; b++)
  129.                 {
  130.                         CPlayer* pPlayer = (CPlayer* )b->second;
  131.                         if(NULL == pPlayer)
  132.                         {
  133.                                 delete pPlayer;
  134.                                 pPlayer = NULL;
  135.                         }
  136.                 }
  137.         };

  139. private:
  140.         typedef map<int, CPlayer*> mapPlayerManager;
  141.         mapPlayerManager m_mapPlayerManager;
  142.         static CPlayerManager* m_pPlayerManager;
  143. };
复制代码

呵呵，这个类很简单，里面包含了一些玩家的基本信息，并提供了一个CPlayerManager()的管理类，管理所有已经注册的CPlayer对象，这些CPlayer对象提供给我了修改玩家种种属性的方法。
好了，我还需要一个让Lua能够方便调用我的C++这些玩家的修改方法的类。来完成和lua的互联互通。这里，既然Lua是面向过程的语言，那么我就让我的方法全部是面向过程的。
  1. #ifndef LUAFNREGISTER_H
  2. #define LUAFNREGISTER_H

  4. //lua下的C++注册类，负责处理lua中用到的C++函数
  5. //add by freeeyes

  7. #include "LuaDefine.h"
  8. #include <vector>
  9. #include <string>
  10. using namespace std;

  12. typedef int (*FuncExecute)(lua_State* plua_State);

  14. struct _FuncInfo
  15. {
  16.         string      m_strFuncName;
  17.         FuncExecute m_FuncExecute;
  18. };

  20. //这个类负责管理所有注册的lua对C++函数类
  21. class CLuaFnRegister
  22. {
  23. public:
  24.         CLuaFnRegister() {};
  25.         ~CLuaFnRegister() {};

  27.         void Close()
  28.         {
  29.                 m_vecLuaFnRegCollection.clear();
  30.         };

  32.         bool AddFunc(const char* pFuncName, FuncExecute pFn)
  33.         {
  34.                 _FuncInfo objFuncInfo;
  35.                 objFuncInfo.m_strFuncName = pFuncName;
  36.                 objFuncInfo.m_FuncExecute = pFn;
  37.                 
  38.                 m_vecLuaFnRegCollection.push_back(objFuncInfo);
  39.                 return true;
  40.         };

  42.         int GetSize()
  43.         {
  44.                 return (int)m_vecLuaFnRegCollection.size();
  45.         };

  47.         _FuncInfo* GetFuncInfo(int nIndex)
  48.         {
  49.                 if(nIndex >= (int)m_vecLuaFnRegCollection.size())
  50.                 {
  51.                         return NULL;
  52.                 }
  53.                 else
  54.                 {
  55.                         return (_FuncInfo* )&m_vecLuaFnRegCollection[nIndex];
  56.                 }
  57.         };


  60. private:
  61.         typedef vector<_FuncInfo> vecLuaFnRegCollection;
  62.         vecLuaFnRegCollection m_vecLuaFnRegCollection;
  63. };

  65. #endif
复制代码

首先，我用一个类，来管理所有我的修改方法在lua中的注册。一个函数名外加一个函数指针，就完成了一个注册。这个类用于管理所有已知我需要让lua调用我的方法。
好了，再来看看，如果策划给我们一个任务的需求，我们需要给予策划什么样的接口呢？
  1. #ifndef _LUAFN_MESSION_H
  2. #define _LUAFN_MESSION_H

  4. #include "LuaDefine.h"
  5. #include "Player.h"

  7. //执行远程函数
  8. static int LuaExecute_Func(lua_State* pState, const char* pFuncName, int nPlayerID)
  9. {
  10.         lua_getglobal(pState, pFuncName);
  11.         lua_pushnumber(pState, nPlayerID);

  13.         int nRet = lua_pcall(pState, 1, 0, 0);
  14.         if (nRet != 0)
  15.         {
  16.                 printf("[LuaExecute_Func]call function(%s) error(%s).\n", pFuncName, lua_tostring(pState, -1));
  17.                 return false;
  18.         }

  20.         lua_settop(pState, -1);
  21.         return 0;
  22. }

  24. //输出文字
  25. static int LuaFn_Mession_Print(lua_State* pState)
  26. {
  27.         char* pGlobal = (char* )lua_tostring(pState, -1);
  28.         printf_s("[LuaFn_Mession_Print]Data=%s.\n", pGlobal);
  29.         return 0;
  30. }

  32. //输入描述信息
  33. static int Lua_Mession_Desc(lua_State* pState)
  34. {
  35.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  36.         char* pDesc    = (char* )lua_tostring(pState, -1);

  38.         //printf_s("[Lua_Mession_Desc]nPlayerID=%d, pDesc=%s.\n", nPlayerID, pDesc);
  39.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  40.         if(NULL == pPlayer)
  41.         {
  42.                 lua_pushboolean(pState, (int)false);
  43.         }
  44.         else
  45.         {
  46.                 pPlayer->SetMessionDesc(pDesc);
  47.                 lua_pushboolean(pState, (int)true);
  48.         }

  50.         return 1;
  51. }

  53. //输入描述信息
  54. static int Lua_Mession_Error(lua_State* pState)
  55. {
  56.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  57.         char* pDesc    = (char* )lua_tostring(pState, -1);

  59.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  60.         if(NULL == pPlayer)
  61.         {
  62.                 lua_pushboolean(pState, (int)false);
  63.         }
  64.         else
  65.         {
  66.                 pPlayer->SetMessionDesc(pDesc);
  67.                 lua_pushboolean(pState, (int)true);
  68.         }

  70.         return 1;
  71. }

  73. //当前用户是否存在任务，如果有则返回False
  74. static int Lua_Mession_IsHave(lua_State* pState)
  75. {
  76.         int nPlayerID  = (int)lua_tonumber(pState, -1);

  78.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  79.         if(NULL == pPlayer)
  80.         {
  81.                 lua_pushboolean(pState, (int)false);
  82.         }
  83.         else
  84.         {
  85.                 if(pPlayer->GetMessionID() != 0)
  86.                 {
  87.                         lua_pushboolean(pState, (int)true);
  88.                 }
  89.                 else
  90.                 {
  91.                         lua_pushboolean(pState, (int)false);
  92.                 }
  93.         }

  95.         return 1;
  96. }

  98. //得到用户任务ID
  99. static int Lua_Mession_GetID(lua_State* pState)
  100. {
  101.         int nPlayerID  = (int)lua_tonumber(pState, -1);

  103.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  104.         if(NULL == pPlayer)
  105.         {
  106.                 lua_pushnumber(pState, 0);
  107.         }
  108.         else
  109.         {
  110.                 int nMessionID = pPlayer->GetMessionID();
  111.                 lua_pushnumber(pState, nMessionID);
  112.         }

  114.         return 1;
  115. }

  117. //得到用户任务ID
  118. static int Lua_Mession_SetID(lua_State* pState)
  119. {
  120.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  121.         int nMessionID = (int)lua_tonumber(pState, -1);

  123.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  124.         if(NULL != pPlayer)
  125.         {
  126.                 pPlayer->SetMessionID(nMessionID);
  127.         }

  129.         return 0;
  130. }

  132. //给与玩家道具ID
  133. static int Lua_Mession_SetItemID(lua_State* pState)
  134. {
  135.         int nPlayerID  = (int)lua_tonumber(pState, -3);
  136.         int nMessionID = (int)lua_tonumber(pState, -2);
  137.         int nItemID    = (int)lua_tonumber(pState, -1);

  139.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  140.         if(NULL != pPlayer)
  141.         {
  142.                 pPlayer->SetItemID(nItemID);
  143.         }

  145.         return 0;
  146. }

  148. //得到玩家道具ID
  149. static int Lua_Mession_GetItemID(lua_State* pState)
  150. {
  151.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  152.         int nMessionID = (int)lua_tonumber(pState, -1);

  154.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  155.         if(NULL != pPlayer)
  156.         {
  157.                 int nItemID = pPlayer->GetItemID();
  158.                 lua_pushnumber(pState, nItemID);
  159.         }
  160.         else
  161.         {
  162.                 lua_pushnumber(pState, 0);
  163.         }

  165.         return 1;
  166. }

  168. //完成任务
  169. static int Lua_Mession_Done(lua_State* pState)
  170. {
  171.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  172.         int nMessionID = (int)lua_tonumber(pState, -1);

  174.         CPlayer* pPlayer = CPlayerManager::Instance().GetPlayer(nPlayerID);
  175.         if(NULL != pPlayer)
  176.         {
  177.                 pPlayer->FinishMessionID();
  178.         }

  180.         return 0;
  181. }

  183. //调用远程事件处理函数
  184. static int Lua_Mession_Events(lua_State* pState)
  185. {
  186.         int nPlayerID  = (int)lua_tonumber(pState, -2);
  187.         int nMessionID = (int)lua_tonumber(pState, -1);

  189.         //lua_pop(pState, -1);

  191.         //调用远程接口
  192.         char szFuncName[100] = {'\0'};
  193.         sprintf(szFuncName, "Event_%d_Request", nMessionID);

  195.         LuaExecute_Func(pState, szFuncName, nPlayerID);

  197.         return 0;
  198. }

  200. #endif
复制代码

好了，我提供了一批方法给策划，这就是作料，如果策划觉得不够，我可以随意添加。这里你可以看到，我所有传给lua的方法，都是以基础类型为参数的，避免了设计中的类传递，这也是我抵触把类给Lua的实现，因为在实现细节上，任何修改都应该可以转变成对基础类型的修改。所以，你没有必要把类给策划，让他自己去找繁复的接口。你给他们的，都是清晰可见的，而且是独立的。这样，减少了策划误用错用你的接口的可能性。
还记得我在Lua基础贴中的那个CLuaFn类吗？如果你读了我以前的Lua的文章，对它应该不陌生，好的，那么让我扩展一下它吧。让它支持我所需要的接口。
  1. bool CLuaFn::InitClass()
  2. {
  3.         if(NULL == m_pState)
  4.         {
  5.                 printf("[CLuaFn::InitClass]m_pState is NULL.\n");
  6.                 return false;
  7.         }

  9.         tolua_open(m_pState);
  10.         tolua_module(m_pState, NULL, 0);
  11.         tolua_beginmodule(m_pState, NULL);

  13.         m_LuaFnRegister.AddFunc("LuaFn_Mession_Print", LuaFn_Mession_Print);
  14.         m_LuaFnRegister.AddFunc("Lua_Mession_Error", Lua_Mession_Error);
  15.         m_LuaFnRegister.AddFunc("Lua_Mession_Desc", Lua_Mession_Desc);
  16.         m_LuaFnRegister.AddFunc("Lua_Mession_IsHave", Lua_Mession_IsHave);
  17.         m_LuaFnRegister.AddFunc("Lua_Mession_GetID", Lua_Mession_GetID);
  18.         m_LuaFnRegister.AddFunc("Lua_Mession_SetID", Lua_Mession_SetID);
  19.         m_LuaFnRegister.AddFunc("Lua_Mession_SetItemID", Lua_Mession_SetItemID);
  20.         m_LuaFnRegister.AddFunc("Lua_Mession_GetItemID", Lua_Mession_GetItemID);
  21.         m_LuaFnRegister.AddFunc("Lua_Mession_Done", Lua_Mession_Done);
  22.         m_LuaFnRegister.AddFunc("Lua_Mession_Events", Lua_Mession_Events);

  24.         for(int i = 0; i < m_LuaFnRegister.GetSize(); i++)
  25.         {
  26.                 _FuncInfo* pFuncInfo = m_LuaFnRegister.GetFuncInfo(i);
  27.                 if(NULL != pFuncInfo)
  28.                 {
  29.                         tolua_function(m_pState, pFuncInfo->m_strFuncName.c_str(), pFuncInfo->m_FuncExecute);
  30.                 }
  31.         }
  32.         tolua_endmodule(m_pState);


  35.         return true;
  36. }
复制代码

呵呵，看到了吧，一点也不复杂。
好了，让我们来看看策划要做什么。
策划需要实现两个lua。
第一个NPC_freeeyes.lua
  1. --NPC的ID，在程序里面对应NPC

  3. NPC_1001_NAME="自由之眼"

  5. function NPC_1001_OnDefault(nMapID, nPlayerID)
  6.     blMessionState = Lua_Mession_IsHave(nPlayerID)
  7.     if blMessionState == true then
  8.         --如果任务有，则判断是否需要完成
  9.         nMessionID = Lua_Mession_GetID(nMapID, nPlayerID)
  10.         NPC_1001_OnSubmit(nMapID, nPlayerID, nMessionID)
  11.     else
  12.         Lua_Mession_SetID(nPlayerID, 200001)
  13.         Lua_Mession_Desc(nPlayerID, "请选择你要接受的任务信息，1是要土豆，2是要黄铜。")
  14.     end
  15. end

  17. function NPC_1001_OnEvents(nMapID, nPlayerID)
  18.     nMessionID = Lua_Mession_GetID(nMapID, nPlayerID)
  19.     --print("[NPC_1001_OnEvents]nMessionID="..nMessionID)
  20.     if nMessionID ~= 0 then
  21.         Lua_Mession_Events(nPlayerID, nMessionID)
  22.     end
  23. end

  25. function NPC_1001_OnSubmit(nMapID, nPlayerID, nMessionID)
  26.                 nItemID = Lua_Mession_GetItemID(nPlayerID, nMessionID)
  27.                 if nMessionID == 200001 then
  28.                                 if nItemID == 300 then
  29.                                                 Lua_Mession_Done(nPlayerID, nMessionID)
  30.                         --LuaFn_Mession_Print("200001 完成了。")
  31.                                 end
  32.                 end
  33.                 if nMessionID == 200002 then
  34.                                 if nItemID == 301 then
  35.                                                 Lua_Mession_Done(nPlayerID, nMessionID)
  36.                         --LuaFn_Mession_Print("200002 完成了。")
  37.                                 end
  38.                 end
  39. end
复制代码

呵呵，看看，我把自己做成了一个NPC，当然，如果你愿意，你可以建立无数个这样的NPC在这个游戏中。这里面提供了两个最简单的方法，当玩家碰触这个NPC，我们调用NPC_1001_OnDefault()方法，这里会验证玩家身上有没有任务，有，则会调用是否完成的函数。我准备了两个任务，200001和200002
好了，那么，我们再看看第二个lua完成了什么？
  1. function Event_200001_Request(nPlayerID)    
  2.     --LuaFn_Mession_Print("200001 给你一个土豆。")
  3.     Lua_Mession_SetItemID(nPlayerID, 200001, 300)
  4. end

  6. function Event_200002_Request(nPlayerID)
  7.     --LuaFn_Mession_Print("200002 给你一个黄铜。")
  8.     Lua_Mession_SetItemID(nPlayerID, 200002, 301)
  9. end
复制代码



我们姑且命名为Mession_Event_200001.lua（其实这个名字并不是很合适，呵呵，例子嘛）
为什么这么设计，因为我需要策划也需要建立一个完整的思维体系。任务的创建和任务的接收，是在很多的lua文件中完成的，一个任务体系一个lua，这样很清晰。关于任务中条件的达成，都是各个Event的lua去做的。这样，你可以让策划写起来很舒服，而且从程序的角度来讲，也会很舒服。事件的触发过程，由策划在另一个lua里面完成。
比如，我创建一个获取黄铜的任务，我在Event被触发的时候，就给他一个黄铜。具体可以参考我的源代码。
这样，一个基于过程的逻辑实现体系就完成了，当然，这是一个很简单的。那么如何在游戏中和事件绑定呢？这又是另一个话题了，等我有时间好好的讲讲，如何在服务器上控制事件的触发，这些事件会根据条件，调用不同的lua形成结果。
最后，作为程序员的我，自然要对这个架构测试一下性能，看看能否满足我的要求，于是，我让一个玩家接受100万次任务，获得道具，交还任务。看看花费了多少时间。
结果如下： (windowsXP，CPUE5300，2G内存的的条件下)，运行时间是13.3秒。也就是每秒可以执行7.5万次任务交接，获得道具和任务完成的流程。呵呵，这个速度，我还是比较满意的。
以下代码在windowsXP和VS2005下测试通过。


如果你喜欢或者对你有帮助，我很高兴，当然，也欢迎你多多提问。
还有，代码永远是基础的，思想才是最有价值的东西。不要把自己的思路固定在代码实现的层面上

0 0
网络词boom是什么意思 网络词boom是什么意思
原创粉丝点击
热门IT博客
万网域名交易流程万网域名交易流程
海南网络机柜海南网络机柜
淘宝店手机端怎么弄
新疆广电网络
sql server 2016 sn
免费面料试衣软件
unity3d 5.0 布料
分布式系统一致性算法
java jit编译器
淘宝店铺违规怎么处罚
多益网络2018校园招聘
日式校服 男淘宝
知豆汽车
sms.dll源码
知父莫若子
sql 定义表变量
unity3d 动画制作
revit软件下载
软件测试笔试题库
清华珠三角研究院知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 家具活动策划方案 企业活动策划 品牌活动策划 活动策划搭建 策划是什么意思 广州活动策划 策划师是干什么的 策划人员主要做什么 策划是干什么的 学校活动策划 广告策划方案 活动策划案范本 聚会活动策划 大学活动策划 活动策划格式 活动策划方案范文 创业企划书格式及范文 活动策划书格式及范文文库 校园策划书 产品企划 创业计划书范文模板 义卖活动策划书 校园活动策划书范文 校园活动策划书模板 策划书格式及范文 大学生活动策划书模板 大学生活动策划书 活动计划范文 活动计划怎么写 活动计划书模板 大学生策划书模板 活动计划书范文 项目计划书模板 策划书范文大全 计划书模板 活动策划书格式 策划书格式 项目策划书模板 公司策划书 老照片讲故事策划 国庆晚会活动策划

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里