KBEngine簡單RPG-Demo源碼解析

一：環境搭建

1. 確定已經下載下傳過KBEngine服務端引擎，如果沒有下載下傳請先下載下傳    

      下載下傳服務端源碼(KBEngine)：        

       https://github.com/kbengine/kbengine/releases/latest    

     編譯(KBEngine)：      

       http://www.kbengine.org/docs/build.html    

      安裝(KBEngine)：        

       http://www.kbengine.org/docs/installation.html

2. 下載下傳unity3d demo源碼（kbengine_unity3d_demo）

      https://github.com/kbengine/kbengine_unity3d_demo/releases/latest

3. 下載下傳kbengine用戶端插件與服務端Demo資産庫:    

      * 使用git指令行，進入到kbengine_unity3d_demo目錄執行：        

                 git submodule update --init --remote                        

      * 或者使用 TortoiseGit(選擇菜單): TortoiseGit -> Submodule Update:

      * 也可以手動下載下傳kbengine用戶端插件與服務端Demo資産庫            

                用戶端插件下載下傳：                

                        https://github.com/kbengine/kben ... /archive/master.zip                 

                       下載下傳後請将其解壓縮，插件源碼請放置在: Assets/plugins/kbengine/kbengine_unity3d_plugins            

                服務端資産庫下載下傳：                

                        https://github.com/kbengine/kbengine_demos_assets/releases/latest                 

                       下載下傳後請将其解壓縮,并将目錄檔案放置于服務端引擎根目錄"kbengine/"之下，如下圖：

4. 拷貝服務端資産庫"kbengine_demos_assets"到服務端引擎根目錄"kbengine/"之下，如下圖：

二：配置Demo(可選):

改變登入IP位址與端口（注意：關于服務端端口部分參看 http://www.kbengine.org/cn/docs/installation.html ）:

                kbengine_unity3d_demo\Scripts\kbe_scripts\clientapp.cs -> ip    

                kbengine_unity3d_demo\Scripts\kbe_scripts\clientapp.cs -> port

三：啟動伺服器:

確定“kbengine_unity3d_demo\kbengine_demos_assets”已經拷貝到KBEngine根目錄：    

      參考上方章節：開始使用啟動腳本啟動服務端：   

Windows:        

      kbengine\kbengine_demos_assets\start_server.bat    

Linux:        

      kbengine\kbengine_demos_assets\start_server.sh

      檢查啟動狀态：        

               如果啟動成功将會在日志中找到"Components::process(): Found all the components!"。     

               任何其他情況請在日志中搜尋"ERROR"關鍵字，根據錯誤描述嘗試解決。        

               (更多參考:  http://www.kbengine.org/docs/startup_shutdown.html )

四：啟動用戶端:

直接在Unity3D編輯器啟動或者編譯後啟動

（編譯用戶端：Unity Editor -> File -> Build Settings -> PC, MAC & Linux Standalone.）

五：生成導航網格(可選):

服務端使用Recastnavigation在3D世界尋路，recastnavigation生成的導航網格（Navmeshs）放置于：    

      kbengine\demo\res\spaces\*

在Unity3D中使用插件生成導航網格（Navmeshs）:    

       https://github.com/kbengine/unity3d_nav_critterai

六：示範截圖:

七：服務端資産庫檔案夾結構

http://kbengine.org/cn/docs/concepts/directorys.html

看assets， 注意：demo使用的不是預設的assets資産目錄，而是上面章節下載下傳的kbengine_demos_assets，但檔案夾結構與意義是一緻的。

八：用戶端檔案夾結構

kbengine_unity3d_demo

             -> Assets                                                         // Unity3d資産庫

                      -> Plugins

                              -> kbengine                                   // KBEngine插件層（包含了網絡消息處理、用戶端實體維護、與服務端對接層）

                      -> Scripts

                              -> kbe_scripts                                // 用戶端邏輯腳本層（https://github.com/kbengine/kben ... e_scripts/README.md）

                                       -> Account.cs                       // 對應于服務端的賬号實體的用戶端部分實作

                                       -> Avatar.cs                          // 對應于服務端的角色實體的用戶端部分實作

                                       -> clientapp.cs                      // 按照服務端的概念cellapp、baseapp、etc，這裡我們抽象出一個clientapp

                                       -> Combat.cs                       // 對應于服務端的def interfaces/Combat的用戶端部分實作

                                       -> GameObject.cs                 // 對應于服務端的def interfaces/GameObject的用戶端部分實作

                                       -> Gate.cs                             // 對應于服務端的Gate實體的用戶端部分實作

                                       -> Monster.cs                       // 對應于服務端的Monster實體的用戶端部分實作

                                       -> NPC.cs                             // 對應于服務端的NPC實體的用戶端部分實作

                                       -> Skill.cs                              // 一個簡單的不能再簡單的技能執行類，服務端cell/skill下面也有，而用戶端主要是進行一些檢查

                                       -> SkillBox.cs                        // 玩家的技能清單，對應于服務端的def interfaces/Skillbox的用戶端部分實作

                                       -> SkillObject.cs                    // 技能對象（施法者、目标、受術者等），服務端cell/skill下面也有

                              -> u3d_scripts                               // 用戶端UI等表現層

                                       -> UI.cs                                // 處理UI部分

                                       -> World.cs                          // 處理場景世界部分

                                       -> GameEntity.cs                 // 所有服務端同步過來的實體在表現層都必須繼承該類，完成統一的表現(頭頂名稱、血條等)與控制（實體狀态、移動）

------------------------------------------

基本設計結構：

                                                                  -遊戲-

                                   |                                                                        |

                  表現層u3d_scripts(UI && 世界)                      KBE層kbe_scripts(插件 && 邏輯)

1:  表現層與KBE層可以配置為不同線程也能配置為同一個線程跑（單線程）

2:  表現層與KBE層使用事件互動， 向KBE層觸發的事件使用fireIn(...)，KBE層向外部觸發的事件使用fireOut(...)。 那麼表現層想要監聽KBE觸發的Out事件，需要注冊監聽Event.registerOut， KBE需要監聽外部觸發進來的事件則反之。

3: 使用unity3D插件與服務端配套則服務端中的scripts/client檔案夾可以忽略(https://github.com/kbengine/kben ... e_scripts/README.md)

九：遊戲配置

服務端demo所有的配置都存放于kbengine_demos_assets\scripts\data之下。

scripts\data\

               d_avatar_inittab.py    // 角色初始化表， 用于建立立的角色設定初始值， 由kbengine\kbe\tools\xlsx2py\rpgdemo\avatar_init.bat導出。

               d_dialogs.py               // NPC對話表， 其中'menu1'對于的是一個對話協定的ID，服務端根據不同的協定ID執行不同的對話功能， 由kbengine\kbe\tools\xlsx2py\rpgdemo\dialogs.bat導出。

               d_entities.py               // 實體類型表，描述某類型怪移動速度，攻擊力等，由kbengine\kbe\tools\xlsx2py\rpgdemo\NPC.bat導出。

               d_skills.py                   // 技能表，描述某類型技能判定條件，輸出等，由kbengine\kbe\tools\xlsx2py\rpgdemo\skils.bat導出。

               d_spaces.py               // 場景副本表，描述space是大地圖還是副本，以及地圖名稱等，由kbengine\kbe\tools\xlsx2py\rpgdemo\spaces.bat導出。

               d_spaces_spawns.py // NPC、Monster等出生點資訊，目前是手填的，也可以采用工具布點導出。

        spawnpoints\

                 xinshoucun_spawnpoints.xml   // 這個出生點資訊主要用于warring這個demo，(NPC、Monster等出生點資訊，采用Unity3d布點導出, 可以在unity打開warring這個demo，

                                                                 // 在unity3d(菜單上)->

ublish->Build Publish AssetBundles(打包所有需要動态加載資源)，然後在Assets->StreamingAssets目錄下會得到 "場景名稱_spawnpoints.xml"的出生點表)。

十：建立賬号

用戶端部分:

1: kbengine_unity3d_demo\Assets\Scripts\u3d_scripts\UI.cs

        1.1 點選登入按鈕導緻createAccount()被調用， createAccount中向KBE層觸發了一個建立賬号事件，參數是賬号名與密碼。

          注意：KBEngine插件kbengine_unity3d_demo\Assets\Plugins\kbengine \kbengine_unity3d_plugins\KBEngine.cs中已經注冊了這個“createAccount”事件，對應于 KBEngineApp.createAccount函數。

1.         public void createAccount()
2.         {
3.            KBEngine.Event.fireIn("createAccount", new object[]{stringAccount, stringPasswd});
4.         }

複制代碼

2. 事件在KBE插件中kbengine_unity3d_demo\Assets\Plugins\kbengine\kbengine_unity3d_plugins\KBEngine.cs, KBEngineApp.process()中被正式處理

1.                 public virtual void process()
2.                 {
3.                         // 處理網絡
4.                         _networkInterface.process();
5.                         // 處理外層抛入的事件
6.                         Event.processInEvents();
7.                         // 向服務端發送心跳以及同步角色資訊到服務端
8.                         sendTick();
9.                 }

複制代碼 3. 建立賬号函數被調用， createAccount_loginapp函數表示請求向服務端loginapp程序要求建立一個賬号，而此時可能還沒有連接配接伺服器，需要先連接配接，如果已經連接配接上了則向loginapp發送一個包“bundle.send”。

            可以看到向Bundle中寫入了相關需要的資料，而Bundle會将資料序列化成二進制流，服務端會采用相同的協定将其歸原并将調用服務端協定所綁定的方法（後面會講到服務端具體方法）。

1.                 public void createAccount(string username, string password)
2.                 {
3.                         KBEngineApp.app.username = username;
4.                         KBEngineApp.app.password = password;
5.                         KBEngineApp.app.createAccount_loginapp(true);
6.                 }
7.                 public void createAccount_loginapp(bool noconnect)
8.                 {
9.                         if(noconnect)
10.                         {
11.                                 reset();
12.                                 _networkInterface.connectTo(_args.ip, _args.port, onConnectTo_createAccount_callback, null);
13.                         }
14.                         else
15.                         {
16.                                 Bundle bundle = new Bundle();
17.                                 bundle.newMessage(Message.messages["Loginapp_reqCreateAccount"]);
18.                                 bundle.writeString(username);
19.                                 bundle.writeString(password);
20.                                 bundle.writeBlob(new byte[0]);
21.                                 bundle.send(_networkInterface);
22.                         }
23.                 }

複制代碼 建立傳回結果：

UI.cs -> onCreateAccountResult

服務端部分：

1. 通過上面可以得知用戶端向服務端發送了一條建立賬号的協定， 協定名稱為“Loginapp_reqCreateAccount”（注意，所有的協定名稱都能在服務端找到對應的方法， Loginapp_代表了協定的作用域僅為Loginapp， 方法名稱為reqCreateAccount）

1. void Loginapp::reqCreateAccount(Network::Channel* pChannel, MemoryStream& s)
2. {
3.         std::string accountName, password, datas;
4.         s >> accountName >> password;
5.         s.readBlob(datas);
6.         if(!_createAccount(pChannel, accountName, password, datas, ACCOUNT_TYPE(g_serverConfig.getLoginApp().account_type)))
7.                 return;
8. }

複制代碼 服務端解析出了賬号名與密碼，在_createAccount函數中會将這條請求最終送到dbmgr，dbmgr檢查之後決定是否建立資料庫賬号，并最終将結果傳回到loginapp，然後由loginapp将結果中轉至用戶端。

十一：登入賬号

1: kbengine_unity3d_demo\Assets\Scripts\u3d_scripts\UI.cs， 向KBE層觸發了登陸事件

1.         public void login()
2.         {
3.                 info("connect to server...(連接配接到服務端...)");
4.                 KBEngine.Event.fireIn("login", new object[]{stringAccount, stringPasswd});
5.         }

複制代碼 2： kbengine_unity3d_demo\Assets\Plugins\kbengine\kbengine_unity3d_plugins\KBEngine.cs, 插件觸發登陸函數，并最終向loginapp發送了一個登陸包“Loginapp_login”

1.         public void login(string username, string password)
2.         {
3.             KBEngineApp.app.username = username;
4.             KBEngineApp.app.password = password;
5.             KBEngineApp.app.login_loginapp(true);
6.         }
7.         public void login_loginapp(bool noconnect)
8.         {
9.             if(noconnect)
10.             {
11.                 reset();
12.                 _networkInterface.connectTo(_args.ip, _args.port, onConnectTo_loginapp_callback, null);
13.             }
14.             else
15.             {
16.                 Dbg.DEBUG_MSG("KBEngine::login_loginapp(): send login! username=" + username);
17.                 Bundle bundle = new Bundle();
18.                 bundle.newMessage(Message.messages["Loginapp_login"]);
19.                 bundle.writeInt8((sbyte)_args.clientType); // clientType
20.                 bundle.writeBlob(new byte[0]);
21.                 bundle.writeString(username);
22.                 bundle.writeString(password);
23.                 bundle.send(_networkInterface);
24.             }
25.         }

複制代碼

服務端部分：

1：服務端loginapp.cpp中“void Loginapp::login(Network::Channel* pChannel, MemoryStream& s)”被觸發， 這個函數進行了一系列的檢查，

确定合法後向dbmgr發送一個登陸請求包“(*pBundle).newMessage(DbmgrInterface:

nAccountLogin);”, dbmgr也會進行一系列的檢查并将登陸結果傳回到loginapp。

1. void Loginapp::login(Network::Channel* pChannel, MemoryStream& s)
2. {
3.         ...
4. ...
5.         if(loginName.size() > ACCOUNT_NAME_MAX_LENGTH)
6.         {
7.                 INFO_MSG(fmt::format("Loginapp::login: loginName is too long, size={}, limit={}.\n",
8.                         loginName.size(), ACCOUNT_NAME_MAX_LENGTH));
9.                 _loginFailed(pChannel, loginName, SERVER_ERR_NAME, datas, true);
10.                 s.done();
11.                 return;
12.         }
13.         if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
14.         {
15.                 INFO_MSG(fmt::format("Loginapp::login: password is too long, size={}, limit={}.\n",
16.                         password.size(), ACCOUNT_PASSWD_MAX_LENGTH));
17.                 ...
18. ...
19. ...
20.         // 向dbmgr查詢使用者合法性
21.         Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
22.         (*pBundle).newMessage(DbmgrInterface::onAccountLogin);
23.         (*pBundle) << loginName << password;
24.         (*pBundle).appendBlob(datas);
25.         dbmgrinfos->pChannel->send(pBundle);
26. }

複制代碼

1.1： loginapp得到dbmgr的登入合法結果後向baseappmgr發送了配置設定網關（baseapp）請求(registerPendingAccountToBaseapp)， 通常是負載較低的一個baseapp程序.

1. void Loginapp::onLoginAccountQueryResultFromDbmgr(Network::Channel* pChannel, MemoryStream& s)
2. {
3.         ...
4. ...
5. ...
6.         // 如果大于0則說明目前賬号仍然存活于某個baseapp上
7.         if(componentID > 0)
8.         {
9.                 Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
10.                 (*pBundle).newMessage(BaseappmgrInterface::registerPendingAccountToBaseappAddr);
11.                 (*pBundle) << componentID << loginName << accountName << password << entityID << dbid << flags << deadline << infos->ctype;
12.                 baseappmgrinfos->pChannel->send(pBundle);
13.                 return;
14.         }
15.         else
16.         {
17.                 // 注冊到baseapp并且擷取baseapp的位址
18.                 Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
19.                 (*pBundle).newMessage(BaseappmgrInterface::registerPendingAccountToBaseapp);
20.                 (*pBundle) << loginName;
21.                 (*pBundle) << accountName;
22.                 (*pBundle) << password;
23.                 (*pBundle) << dbid;
24.                 (*pBundle) << flags;
25.                 (*pBundle) << deadline;
26.                 (*pBundle) << infos->ctype;
27.                 baseappmgrinfos->pChannel->send(pBundle);
28.         }
29. }

複制代碼 1.2：baseappmgr最終傳回所配置設定的baseapp的ip位址等資訊，loginapp将其轉發給用戶端(登入成功協定onLoginSuccessfully，包含baseapp的ip和端口資訊）

1. void Loginapp::onLoginAccountQueryBaseappAddrFromBaseappmgr(Network::Channel* pChannel, std::string& loginName, 
2.                                                                                                                         std::string& accountName, std::string& addr, uint16 port)
3. {
4.         ...
5. ...
6. ...
7.         Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
8.         (*pBundle).newMessage(ClientInterface::onLoginSuccessfully);
9.         uint16 fport = ntohs(port);
10.         (*pBundle) << accountName;
11.         (*pBundle) << addr;
12.         (*pBundle) << fport;
13.         (*pBundle).appendBlob(infos->datas);
14.         pClientChannel->send(pBundle);
15.         SAFE_RELEASE(infos);
16. }

複制代碼 2: 用戶端插件得到傳回結果後調用KBEngineApp.cs->login_baseapp()函數開始正式登入到baseapp。

3：baseapp收到登入請求

1. void Baseapp::loginGateway(Network::Channel* pChannel, 
2.                                                    std::string& accountName, 
3.                                                    std::string& password)

複制代碼 進行了一系列的檢查，包括：賬号是否已經線上，是否可以在這裡登入等等。

當檢查合法後，向dbmgr發送了一個查詢賬号資訊的請求“DbmgrInterface::queryAccount”，dbmgr将查詢到的賬号資料(包括屬性等)傳回到baseapp， Baseapp:

nQueryAccountCBFromDbmgr

當函數結果為合法時，根據配置中定義的賬号實體腳本名稱 “g_serverConfig.getDBMgr().dbAccountEntityScriptType”建立了Account實體， 同時還建立了一個clientMailbox，賬号實體中調用clientMailbox->方法()即可與用戶端通訊了。

Account實體被建立後， 首先__init__被調用， 接着onEntitiesEnabled被調用， 此時實體正式可用了。

賬号登陸成功後， 用戶端Account.cs中會調用__init__() -> baseCall("reqAvatarList");來請求獲得角色清單，

UI.cs中onReqAvatarList得到結果。

十二：建立角色與選擇角色進入遊戲

1. 建立角色UI.cs -> void onSelAvatarUI()中

       account.reqCreateAvatar(1, stringAvatarName);

       UI.cs中onCreateAvatarResult得到結果。

2.選擇角色進入遊戲

UI.cs -> onSelAvatarUI()中

account.selectAvatarGame(selAvatarDBID);

這裡使用角色的資料庫ID作為辨別，服務端上Account實體有角色清單屬性，角色清單的資料結構大概為

AvatarList <Dict<AvatarDBID(UINT64), INFOS>>

十三：建立世界（大地圖與副本）

1. 建立世界管理器服務端啟動之後，baseapp與cellapp準備完畢、準備關閉等事件都會通知到kbengine_defs.xml配置中指定的個性 化腳本。kbe預設個性化腳本為kbengine.py,  baseapp程序準備好之後會調用kbengine.py的onBaseAppReady 回調函數， demo在這個函數中判定是否為第一個啟動的baseapp(假如啟動了很多baseapps)，

如果是第一個baseapp，腳本建立了一個世界管理實體“spaces”：

1. def onBaseAppReady(isBootstrap):
2.                               """
3.                               KBEngine method.
4.                               baseapp已經準備好了
5.                               @param isBootstrap: 是否為第一個啟動的baseapp
6.                               @type isBootstrap: BOOL
7.                               """
8.                               INFO_MSG('onBaseAppReady: isBootstrap=%s' % isBootstrap)
9.                               # 安裝螢幕
10.                               Watcher.setup()
11.                               if isBootstrap:
12.                                                             # 建立spacemanager
13.                                                             KBEngine.createBaseLocally( "Spaces", {} )

複制代碼

2. 世界管理器建立出所有的場景

在spaces.py中， spaces通過initAlloc函數根據配置中scripts/data/d_spaces.py建立出space實體，space實體描述的是一個抽象空間，一個空間可以被邏輯定義為大地圖、場景、房間、宇宙等等。

1.         def initAlloc(self):
2.                                       # 注冊一個定時器，在這個定時器中我們每個周期都建立出一些Space，直到建立完所有
3.                                       self._spaceAllocs = {}
4.                                       self.addTimer(3, 1, SCDefine.TIMER_TYPE_CREATE_SPACES)
5.               self._tmpDatas = list(d_spaces.datas.keys())
6.                                       for utype in self._tmpDatas:
7.                                                  spaceData = d_spaces.datas.get(utype)
8.                                               if spaceData["entityType"] == "SpaceDuplicate":
9.                                                          self._spaceAllocs[utype] = SpaceAllocDuplicate(utype)
10.                                               else:
11.                                                          self._spaceAllocs[utype] = SpaceAlloc(utype)

複制代碼

SpaceAlloc： 普通地圖，可以了解為大地圖，但整個世界中隻能有一個這樣類型的地圖。

SpaceAllocDuplicate：副本地圖，可以複制出很多個

上面函數注冊了一個定時器， 這裡是定時器的回調， 每一秒回調一次。

self._spaceAllocs[spaceUType].init()， 這裡真正開始建立這些space實體， 裡面調用的createBaseAnywhere函數來建立實體， 如果啟動了多個baseapp這個函數根據負載情況将實體選擇到合适的程序中建立。

1.     def createSpaceOnTimer(self, tid, tno):
2.            """
3.            建立space
4.            """
5.            if len(self._tmpDatas) > 0:
6.                      spaceUType = self._tmpDatas.pop(0)
7.                   self._spaceAllocs[spaceUType].init()
8.              if len(self._tmpDatas) <= 0:
9.                      del self._tmpDatas
10.                      self.delTimer(tid)

複制代碼

Space實體建立出來之後，此時還沒有真正建立出空間， 這個實體僅僅是将要與某個真正空間關聯的實體， 可以通過它來操控那個空間。

但空間隻能在cellapp上存在， 是以我們需要調用API讓實體在cell上建立出一個空間，并在cell上建立出一個實體與空間關聯， 這個實體就像一個空間的句柄。

1. class Space(KBEngine.Base, GameObject):
2.               def __init__(self):
3.                             self.createInNewSpace(None)

複制代碼 此功能由createInNewSpace完成, __init__可以了解為Space的構造函數。

3. 為這個抽象的空間增加幾何資料

有指定幾何資料的空間可以被看做是一個特定的場景， 這些幾何資料與用戶端對應的場景表現相關聯， 例如：導航網格（navmesh）， 服務端通過這些資料讓NPC進行正确的移動，碰撞等。

上面Space建立cell部分之後， cell上的Space._init__也會被調用， 其中addSpaceGeometryMapping API接口完成幾何資料加載工作

（注意：為了加載大量資料不讓程序卡頓，這個資料加載是多線程的，它會通過一些回調來告訴開發者加載狀态，具體參考API手冊）。

1. class Space(KBEngine.Entity, GameObject):
2.               def __init__(self):
3.              KBEngine.addSpaceGeometryMapping(self.spaceID, None, resPath)

十四：在世界中投放NPC/Monster

Space的cell建立完畢之後， 引擎會調用base上的Space實體， 告知已經獲得了cell（onGetCell），那麼我們确認cell部分建立好了之後就可以開始投放NPC出生點了 。

(注意：這裡并不是直接将NPC/Monster建立出來，而是先在對應的位置建立了一個出生點， 出生點的好處是可以根據一定規則， 當NPC/Monster在某區域減少的時候

可以在合适的時候将其建立出來，例如：一群怪被玩家清理掉了，半小時後怪刷出。 )

onGetCell添加了一個刷出生點的定時器， 我們不能一次性建立出所有的出生點，因為數量可能很多, 使用定時器分批建立 。

1. scripts/base/space.py:
2. def onGetCell(self):
3.                       """
4.                       KBEngine method.
5.                       entity的cell部分實體被建立成功
6.                       """
7.                       self.addTimer(0.1, 0.1, SCDefine.TIMER_TYPE_SPACE_SPAWN_TICK)

複制代碼

出生點的資料（實體類型、坐标、朝向等）是通過配置檔案給出的，script/data/d_spaces_spawns.py與script/data /spawnpoints/xinshoucun_spawnpoints.xml 關于這2個配置的由來可以參考配置章節

1. kbengine_demos_assets\scripts/base/space.py:
2. def spawnOnTimer(self, tid, tno):
3.           """
4.           出生怪物
5.           """
6.           if len(self.tmpCreateEntityDatas) <= 0:
7.                    self.delTimer(tid)
8.                    return
9.           datas = self.tmpCreateEntityDatas.pop(0)
10.           if datas is None:
11.                     ERROR_MSG("Space::onTimer: spawn %i is error!" % datas[0])
12.                    KBEngine.createBaseAnywhere("SpawnPoint",
13.                                     {"spawnEntityNO" : datas[0], \
14.                                     "position" : datas[1], \
15.                                     "direction" : datas[2], \
16.                 "modelScale" : datas[3], \
17.                                     "createToCell" : self.cell})

複制代碼

SpawnPoint實體被建立出來之後，其構造函數中會調用API接口建立實體的cell部分

1. kbengine_demos_assets\scripts/base/spawnpoint.py:
2. class SpawnPoint(KBEngine.Base, GameObject):
3.           def __init__(self):
4.                      self.createCellEntity(self.createToCell)

複制代碼

SpawnPoint的cell部分會在目前位置根據自身被建立時所給予的參數資訊來建立出真正的NPC/Monster

1. kbengine_demos_assets\scripts/base/spawnpoint.py:
2.     def spawnTimer(self, tid, tno):
3.         datas = d_entities.datas.get(self.spawnEntityNO)
4.         if datas is None:
5.             ERROR_MSG("SpawnPoint::spawn:%i not found." % self.spawnEntityNO)
6.             return
7.         params = {
8.             "spawnID"    : self.id,
9.             "spawnPos" : tuple(self.position),
10.             "uid" : datas["id"],
11.             "utype" : datas["etype"],
12.             "modelID" : datas["modelID"],
13.             "modelScale" : self.modelScale,
14.             "dialogID" : datas["dialogID"],
15.             "name" : datas["name"],
16.             "descr" : datas.get("descr", ''),
17.         }
18.         e = KBEngine.createEntity(datas["entityType"], self.spaceID, tuple(self.position), tuple(self.direction), params)

十五：Monster的AI（移動、攻擊、思考）

Monster繼承了一系列的接口， 每種接口對應于不同的功能。

（注意：這裡使用的繼承而沒有用元件的原因是目前的設計def定義的遠端方法隻能與entity是同一個層的，可以了解為entity.xxx一級的屬性，如果是元件形式則entity.component.xxx方法是無法被遠端調用到的。

一定要使用元件形式也可以， 繼承這些接口之後，在接口子產品中實作元件， 如果有需要遠端調用的接口則通過接口層向元件中轉發）

1. class Monster(KBEngine.Entity,    // 每個實體都必須從引擎基本實體類型繼承出來，這樣引擎才可以維護，并擁有一些API特性
2.                         NPCObject, 
3.                         Flags,                                          // 一個管理标記資訊的子產品，标記如： 正在交易中、正在xx。
4.                         State,                                         // 狀态子產品， 主狀态例如：死亡、活着。子狀态例如：閑置狀态、戰鬥狀态
5.                         Motion,                                       // 關于移動的封裝
6.                         Combat,                                    // 關于戰鬥公式、戰鬥屬性等等的封裝
7.                         Spell,                                          // 技能釋放、buff/debuff維護等
8.                         AI):                                            // 智能思考子產品

複制代碼

移動實體：

    scripts/cell/Motion.py                randomWalk : 随機走動， 通常用于怪物閑置狀态時的走動

              backSpawnPos: 傳回出生點，如果怪物被引誘至較遠距離，則傳回到出生時的點，避免被玩家帶到别處。

              gotoEntity： 移動到目标實體的位置。

              gotoPosition：移動到目标坐标點     實體繼承與這個功能子產品之後，實體就可以調用相關方法來移動了， 例如：monster.randomWalk() 。  這些移動函數都是二次封裝的，裡面調用了引擎所提供的底層API函數來實作。

思考與攻擊：

這裡思考子產品做的比較簡單，隻是添加了一個定時器以一定頻率執行一些流程， 這些流程根據狀态區分， 例如：怪物主狀态為活着， 子狀态為戰鬥時， 流程中（onThinkFight）會不斷檢查自己敵人清單的敵人，

根據敵人的情況決定是否攻擊或者追擊。 當距離敵人較遠時使用“self.gotoPosition(entity.position, attackMaxDist - 0.2)”移動到離敵人較勁的可攻擊距離， 當可攻擊距離時對目标釋放一個技能“self.spellTarget(skillID, entity.id)”

需要注意的是,  服務端上怪物成千上萬， 而AI是比較耗的，如果隻有一個玩家線上， 顯然大量的怪物是不需要開啟AI思考來白白耗掉CPU的， 這裡有一個優化方法。

隻有在玩家視野範圍内的怪物才激活AI思考：

1.         def onWitnessed(self, isWitnessed):
2.                 """
3.                 KBEngine method.
4.                 此實體是否被觀察者(player)觀察到, 此接口主要是提供給伺服器做一些性能方面的優化工作，
5.                 在通常情況下，一些entity不被任何用戶端所觀察到的時候， 他們不需要做任何工作， 利用此接口
6.                 可以在适當的時候激活或者停止這個entity的任意行為。
7.                 @param isWitnessed        : 為false時， entity脫離了任何觀察者的觀察
8.                 """
9.                 INFO_MSG("%s::onWitnessed: %i isWitnessed=%i." % (self.getScriptName(), self.id, isWitnessed))
10.                 if isWitnessed:
11.                         self.enable()

十六：場景傳送

首先看看API接口的要求

1. def teleport( self, nearbyMBRef, position, direction ): 
2. 功能說明：
3. 瞬間移動一個Entity到一個指定的空間。這個函數允許指定實體移動後的位置與朝向。
4. 如果需要在不同空間跳轉（ 通常用于不同場景或者房間跳轉 ），可以傳一個CellMailbox給這個函數（ 這個mailbox所對應的實體必須在目的空間中 ）。 
5. 這個函數隻能在real的實體上被調用。 
6. 參數： nearbyMBRef 一個決定Entity跳往哪個Space的CellMailbox（ 這個mailbox所對應的實體必須在目的Space中 ），它被認為是傳送目的地。這個可以設為None，在這種情形下它會在目前的cell完成瞬移。  
7. position Entity瞬移後的坐标，是一個有3個float(x, y, z)組成的序列。  
8. direction Entity瞬移後的朝向，是一個由3個float組成的序列(roll,pitch, yaw)。  

複制代碼

demo中可以看見2個傳送門實體， 對應服務端的腳本為Gate.py

1. class Gate(KBEngine.Entity, GameObject):
2.         def __init__(self):
3.                 KBEngine.Entity.__init__(self)
4.                 GameObject.__init__(self) 
5.                 self.addTimer(1, 0, SCDefine.TIMER_TYPE_HEARDBEAT)                                # 心跳timer, 每1秒一次
6.         # ----------------------------------------------------------------
7.         # callback
8.         # ----------------------------------------------------------------
9.         def onHeardTimer(self, tid, tno):
10.                 """
11.                 entity的心跳
12.                 """
13.                 self.addProximity(5.0, 0, 0)
14.         def onEnterTrap(self, entityEntering, range_xz, range_y, controllerID, userarg):
15.                 """
16.                 KBEngine method.
17.                 有entity進入trap
18.                 """
19.                 if entityEntering.isDestroyed or entityEntering.getScriptName() != "Avatar":
20.                         return
21.                 DEBUG_MSG("%s::onEnterTrap: %i entityEntering=(%s)%i, range_xz=%s, range_y=%s, controllerID=%i, userarg=%i" % \
22.                                                (self.getScriptName(), 
23. self.id, entityEntering.getScriptName(), entityEntering.id, \
24.                                                 range_xz, range_y, controllerID, userarg))
25.                 if self.uid == 40001003: # currspace - teleport
26.                         spaceData = d_spaces.datas.get(entityEntering.spaceUType)
27.                         entityEntering.teleport(None, spaceData["spawnPos"], tuple(self.direction))                
28.                 else:                                         # teleport to xxspace
29.                         if entityEntering.spaceUType == 3:
30.                                 gotoSpaceUType = 4
31.                         else:
32.                                 gotoSpaceUType = 3
33.                         spaceData = d_spaces.datas.get(gotoSpaceUType)
34.                         entityEntering.teleportSpace(gotoSpaceUType, spaceData["spawnPos"], tuple(self.direction), {})
35.         def onLeaveTrap(self, entityLeaving, range_xz, range_y, controllerID, userarg):
36.                 """
37.                 KBEngine method.
38.                 有entity離開trap
39.                 """
40.                 if entityLeaving.isDestroyed or entityLeaving.getScriptName() != "Avatar":
41.                         return
42.                 INFO_MSG("%s::onLeaveTrap: %i entityLeaving=(%s)%i." % (self.getScriptName(), self.id, \
43.                                 entityLeaving.getScriptName(), entityLeaving.id))

複制代碼

在onHeardTimer中添加了一個範圍觸發器，當某個實體進入目前實體一定範圍内觸發器觸發回調onEnterTrap， 當在範圍内的實體離開了範圍則觸發回調onLeaveTrap。

其中進入範圍回調中調用了場景傳送接口， “entityEntering.teleportSpace(gotoSpaceUType, spaceData["spawnPos"], tuple(self.direction), {})”， 這個接口首先會從KBEngine.globalData中獲得

世界管理器的baseMailbox， 然後調用他的base方法teleportSpace， scripts/base/Spaces.py中teleportSpace方法找到對應的space， 然後将自己的cellMailbox回調給cell上的玩家實體(Avatar），

1.         <b><b><b><b>scripts/base/Space.py</b></b></b></b>
2. def teleportSpace(self, entityMailbox, position, direction, context):
3.                 """
4.                 defined method.
5.                 請求進入某個space中
6.                 """
7.                 entityMailbox.cell.onTeleportSpaceCB(self.cell, self.spaceUTypeB, position, direction)

複制代碼

玩家獲得space的cell之後就可以調用API正式跳轉到指定空間中

1.         def onTeleportSpaceCB(self, spaceCellMailbox, spaceUType, position, direction):
2.                 """
3.                 defined.
4.                 baseapp傳回teleportSpace的回調
5.                 """
6.                 self.teleport(spaceCellMailbox, position, direction)

轉自：http://bbs.kbengine.org/forum.php?mod=viewthread&tid=166&extra=page%3D1