开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KProtocolProcess.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：120k
源码类别：

模拟服务器

开发平台：

C/C++

KProtocolProcess.cpp：源码内容
  1. #include "KEngine.h"
  2. #include "KCore.h"
  3. #ifndef _SERVER
  4. #include "../../Headers/IClient.h"
  5. #include "CoreShell.h"
  6. #include "KViewItem.h"
  7. #endif
  8. #include "KObjSet.h"
  9. #include "KNpcSet.h"
  10. #include "KPlayer.h"
  11. #include "KPlayerSet.h"
  12. #include "KPlayerTeam.h"
  13. #include "KPlayerFaction.h"
  14. #include "KNpc.h"
  15. #include "KSubWorld.h"
  16. #include "LuaFuns.h"
  17. #include "KProtocolProcess.h"
  18. #include "KSkills.h"
  19. #include "KItemSet.h"
  20. #include "KBuySell.h"
  21. #include "KSubWorldSet.h"
  22. //#include "MyAssert.h"
  23. #include "Scene/ObstacleDef.h"
  24. #include "KMath.h"
  25. #ifndef _SERVER
  26. #include "SceneKScenePlaceC.h"
  27. #endif
  28. #include "KTongProtocol.h"
  29. #include "KLadder.h"
  31. //#define WAIGUA_ZROC
  33. KProtocolProcess g_ProtocolProcess;
  34. KProtocolProcess::KProtocolProcess()
  35. {
  36. ZeroMemory(ProcessFunc, sizeof(ProcessFunc));
  37. #ifndef _SERVER
  38. ProcessFunc[s2c_login] = NULL;
  39. ProcessFunc[s2c_logout] = NULL;
  40. ProcessFunc[s2c_syncend] = SyncEnd;
  41. ProcessFunc[s2c_synccurplayer] = SyncCurPlayer;
  42. ProcessFunc[s2c_synccurplayerskill] = s2cSyncAllSkill;
  43. ProcessFunc[s2c_synccurplayernormal] = SyncCurNormalData;
  44. ProcessFunc[s2c_newplayer] = NULL;
  45. ProcessFunc[s2c_removeplayer] = NULL;
  46. ProcessFunc[s2c_syncworld] = SyncWorld;
  47. ProcessFunc[s2c_syncplayer] = SyncPlayer;
  48. ProcessFunc[s2c_syncplayermin] = SyncPlayerMin;
  49. ProcessFunc[s2c_syncnpc] = SyncNpc;
  50. ProcessFunc[s2c_syncnpcmin] = SyncNpcMin;
  51. ProcessFunc[s2c_syncnpcminplayer] = SyncNpcMinPlayer;
  52. ProcessFunc[s2c_objadd] = SyncObjectAdd;
  53. ProcessFunc[s2c_syncobjstate] = SyncObjectState;
  54. ProcessFunc[s2c_syncobjdir] = SyncObjectDir;
  55. ProcessFunc[s2c_objremove] = SyncObjectRemove;
  56. ProcessFunc[s2c_objTrapAct] = SyncObjectTrap;
  57. ProcessFunc[s2c_npcremove] = NetCommandRemoveNpc;
  58. ProcessFunc[s2c_npcwalk] = NetCommandWalk;
  59. ProcessFunc[s2c_npcrun] = NetCommandRun;
  60. ProcessFunc[s2c_npcattack] = NULL;
  61. ProcessFunc[s2c_npcmagic] = NULL;
  62. ProcessFunc[s2c_npcjump] = NetCommandJump;
  63. ProcessFunc[s2c_npctalk] = NULL;
  64. ProcessFunc[s2c_npchurt] = NetCommandHurt;
  65. ProcessFunc[s2c_npcdeath] = NetCommandDeath;
  66. ProcessFunc[s2c_npcchgcurcamp] = NetCommandChgCurCamp;
  67. ProcessFunc[s2c_npcchgcamp] = NetCommandChgCamp;
  68. ProcessFunc[s2c_skillcast] = NetCommandSkill;
  69. ProcessFunc[s2c_playertalk] = NULL;
  70. ProcessFunc[s2c_playerexp] = s2cPlayerExp;
  71. ProcessFunc[s2c_teaminfo] = s2cShowTeamInfo;
  72. ProcessFunc[s2c_teamselfinfo] = s2cUpdataSelfTeamInfo;
  73. ProcessFunc[s2c_teamapplyinfofalse] = s2cApplyTeamInfoFalse;
  74. ProcessFunc[s2c_teamcreatesuccess] = s2cCreateTeam;
  75. ProcessFunc[s2c_teamcreatefalse] = s2cApplyCreateTeamFalse;
  76. ProcessFunc[s2c_teamopenclose] = s2cSetTeamState;
  77. ProcessFunc[s2c_teamgetapply] = s2cApplyAddTeam;
  78. ProcessFunc[s2c_teamaddmember] = s2cTeamAddMember;
  79. ProcessFunc[s2c_teamleave] = s2cLeaveTeam;
  80. ProcessFunc[s2c_teamchangecaptain] = s2cTeamChangeCaptain;
  81. ProcessFunc[s2c_playerfactiondata] = s2cSetFactionData;
  82. ProcessFunc[s2c_playerleavefaction] = s2cLeaveFaction;
  83. ProcessFunc[s2c_playerfactionskilllevel] = s2cFactionSkillOpen;
  84. ProcessFunc[s2c_playersendchat] = s2cGetChat;
  85. ProcessFunc[s2c_playersyncleadexp] = s2cGetLeadExp;
  86. ProcessFunc[s2c_playerlevelup] = s2cLevelUp;
  87. ProcessFunc[s2c_teammatelevel] = s2cGetTeammateLevel;
  88. ProcessFunc[s2c_playersyncattribute] = s2cGetCurAttribute;
  89. ProcessFunc[s2c_playerskilllevel] = s2cGetSkillLevel;
  90. ProcessFunc[s2c_syncitem] = s2cSyncItem;
  91. ProcessFunc[s2c_removeitem] = s2cRemoveItem;
  92. ProcessFunc[s2c_syncmoney] = s2cSyncMoney;
  93. ProcessFunc[s2c_playermoveitem] = s2cMoveItem;
  94. ProcessFunc[s2c_scriptaction] = SyncScriptAction;
  95. ProcessFunc[s2c_chatapplyaddfriend] = s2cChatGetApplyAddFriend;
  96. ProcessFunc[s2c_chataddfriend] = s2cChatAddFriend;
  97. ProcessFunc[s2c_chatrefusefriend] = s2cChatBeRefusedAddFriend;
  98. ProcessFunc[s2c_chataddfriendfail] = s2cChatAddFriendFail;
  99. ProcessFunc[s2c_chatloginfriendnoname] = s2cChatLoginFriendNoName;
  100. ProcessFunc[s2c_chatloginfriendname] = s2cChatLoginFriendName;
  101. ProcessFunc[s2c_chatonefrienddata] = s2cChatAddOneFriend;
  102. ProcessFunc[s2c_chatfriendonline] = s2cChatFriendOnline;
  103. ProcessFunc[s2c_chatdeletefriend] = s2cChatDeleteFriend;
  104. ProcessFunc[s2c_chatfriendoffline] = s2cChatFriendOffLine;
  105. ProcessFunc[s2c_syncrolelist] = s2cSyncRoleList;
  106. ProcessFunc[s2c_tradechangestate] = s2cTradeChangeState;
  107. ProcessFunc[s2c_npcsetmenustate] = s2cNpcSetMenuState;
  108. ProcessFunc[s2c_trademoneysync] = s2cTradeMoneySync;
  109. ProcessFunc[s2c_tradedecision] = s2cTradeDecision;
  110. ProcessFunc[s2c_chatscreensingleerror] = s2cChatScreenSingleError;
  111. ProcessFunc[s2c_syncnpcstate] = s2cUpdateNpcState;
  112. ProcessFunc[s2c_teaminviteadd] = s2cTeamInviteAdd;
  113. ProcessFunc[s2c_tradepressoksync] = s2cTradePressOkSync;
  114. ProcessFunc[s2c_ping] = s2cPing;
  115. ProcessFunc[s2c_npcsit] = NetCommandSit;
  116. ProcessFunc[s2c_opensalebox] = OpenSaleBox;
  117. ProcessFunc[s2c_castskilldirectly] = s2cDirectlyCastSkill;
  118. ProcessFunc[s2c_msgshow] = s2cShowMsg;
  119. ProcessFunc[s2c_syncstateeffect] = SyncStateEffect;
  120. ProcessFunc[s2c_openstorebox] = OpenStoreBox;
  121. ProcessFunc[s2c_playerrevive] = PlayerRevive;
  122. ProcessFunc[s2c_requestnpcfail] = RequestNpcFail;
  123. ProcessFunc[s2c_tradeapplystart] = s2cTradeApplyStart;
  124. ProcessFunc[s2c_rolenewdelresponse] = NULL;
  125. ProcessFunc[s2c_ItemAutoMove] = s2cItemAutoMove;
  126. ProcessFunc[s2c_itemexchangefinish] = FinishedItemExchange;
  127. ProcessFunc[s2c_changeweather] = s2cChangeWeather;
  128. ProcessFunc[s2c_pksyncnormalflag] = s2cPKSyncNormalFlag;
  129. ProcessFunc[s2c_pksyncenmitystate] = s2cPKSyncEnmityState;
  130. ProcessFunc[s2c_pksyncexercisestate] = s2cPKSyncExerciseState;
  131. ProcessFunc[s2c_pksyncpkvalue] = s2cPKValueSync;
  132. ProcessFunc[s2c_npcsleepmode] = NpcSleepSync;
  133. ProcessFunc[s2c_viewequip] = s2cViewEquip;
  134. ProcessFunc[s2c_ladderresult] = LadderResult;
  135. ProcessFunc[s2c_ladderlist] = LadderList;
  136. ProcessFunc[s2c_tongcreate] = s2cTongCreate;
  137. ProcessFunc[s2c_replyclientping] = ServerReplyClientPing;
  138. ProcessFunc[s2c_npcgoldchange] = s2cNpcGoldChange;
  139. ProcessFunc[s2c_itemdurabilitychange] = ItemChangeDurability;
  141. ProcessFunc[s2c_extend] = s2cExtend;
  142. ProcessFunc[s2c_extendchat] = s2cExtendChat;
  143. ProcessFunc[s2c_extendfriend] = s2cExtendFriend;
  144. ProcessFunc[s2c_extendtong] = s2cExtendTong;
  147. #else
  148. ProcessFunc[c2s_login] = NULL;
  149. ProcessFunc[c2s_logiclogin] = NULL;
  150. ProcessFunc[c2s_syncend] = NULL;
  151. ProcessFunc[c2s_loadplayer] = NULL;
  152. ProcessFunc[c2s_newplayer] = NULL;
  153. ProcessFunc[c2s_removeplayer] = &KProtocolProcess::RemoveRole;
  154. ProcessFunc[c2s_requestworld] = NULL;
  155. ProcessFunc[c2s_requestplayer] = NULL;
  156. ProcessFunc[c2s_requestnpc] = &KProtocolProcess::NpcRequestCommand;
  157. ProcessFunc[c2s_requestobj] = &KProtocolProcess::ObjRequestCommand;
  158. ProcessFunc[c2s_npcwalk] = &KProtocolProcess::NpcWalkCommand;
  159. ProcessFunc[c2s_npcrun] = &KProtocolProcess::NpcRunCommand;
  160. ProcessFunc[c2s_npcskill] = &KProtocolProcess::NpcSkillCommand;
  161. ProcessFunc[c2s_npcjump] = &KProtocolProcess::NpcJumpCommand;
  162. ProcessFunc[c2s_npctalk] = &KProtocolProcess::NpcTalkCommand;
  163. ProcessFunc[c2s_npchurt] = NULL;
  164. ProcessFunc[c2s_npcdeath] = NULL;
  165. ProcessFunc[c2s_playertalk] = &KProtocolProcess::PlayerTalkCommand;
  166. ProcessFunc[c2s_teamapplyinfo] = &KProtocolProcess::PlayerApplyTeamInfo;
  167. ProcessFunc[c2s_teamapplycreate] = &KProtocolProcess::PlayerApplyCreateTeam;
  168. ProcessFunc[c2s_teamapplyopenclose] = &KProtocolProcess::PlayerApplyTeamOpenClose;
  169. ProcessFunc[c2s_teamapplyadd] = &KProtocolProcess::PlayerApplyAddTeam;
  170. ProcessFunc[c2s_teamacceptmember] = &KProtocolProcess::PlayerAcceptTeamMember;
  171. ProcessFunc[c2s_teamapplyleave] = &KProtocolProcess::PlayerApplyLeaveTeam;
  172. ProcessFunc[c2s_teamapplykickmember] = &KProtocolProcess::PlayerApplyTeamKickMember;
  173. ProcessFunc[c2s_teamapplychangecaptain] = &KProtocolProcess::PlayerApplyTeamChangeCaptain;
  174. ProcessFunc[c2s_teamapplydismiss] = &KProtocolProcess::PlayerApplyTeamDismiss;
  175. ProcessFunc[c2s_playerapplysetpk] = &KProtocolProcess::PlayerApplySetPK;
  176. ProcessFunc[c2s_playerapplyfactiondata] = &KProtocolProcess::PlayerApplyFactionData;
  177. ProcessFunc[c2s_playersendchat] = &KProtocolProcess::PlayerSendChat;
  178. ProcessFunc[c2s_playeraddbaseattribute] = &KProtocolProcess::PlayerAddBaseAttribute;
  179. ProcessFunc[c2s_playerapplyaddskillpoint] = &KProtocolProcess::PlayerApplyAddSkillPoint;
  180. ProcessFunc[c2s_playereatitem] = &KProtocolProcess::PlayerEatItem;
  181. ProcessFunc[c2s_playerpickupitem] = &KProtocolProcess::PlayerPickUpItem;
  182. ProcessFunc[c2s_playermoveitem] = &KProtocolProcess::PlayerMoveItem;
  183. ProcessFunc[c2s_playersellitem] = &KProtocolProcess::PlayerSellItem;
  184. ProcessFunc[c2s_playerbuyitem] = &KProtocolProcess::PlayerBuyItem;
  185. ProcessFunc[c2s_playerthrowawayitem] = &KProtocolProcess::PlayerDropItem;
  186. ProcessFunc[c2s_playerselui] = &KProtocolProcess::PlayerSelUI;
  187. ProcessFunc[c2s_chatsetchannel] = &KProtocolProcess::ChatSetChannel;
  188. ProcessFunc[c2s_chatapplyaddfriend] = &KProtocolProcess::ChatApplyAddFriend;
  189. ProcessFunc[c2s_chataddfriend] = &KProtocolProcess::ChatAddFriend;
  190. ProcessFunc[c2s_chatrefusefriend] = &KProtocolProcess::ChatRefuseFriend;
  191. ProcessFunc[c2s_dbplayerselect] = NULL;
  192. ProcessFunc[c2s_chatapplyresendallfriendname] = &KProtocolProcess::ChatApplyReSendAllFriendName;
  193. ProcessFunc[c2s_chatapplysendonefriendname] = &KProtocolProcess::ChatApplySendOneFriendName;
  194. ProcessFunc[c2s_chatdeletefriend] = &KProtocolProcess::ChatDeleteFriend;
  195. ProcessFunc[c2s_chatredeletefriend] = &KProtocolProcess::ChatReDeleteFriend;
  196. ProcessFunc[c2s_tradeapplystateopen] = &KProtocolProcess::TradeApplyOpen;
  197. ProcessFunc[c2s_tradeapplystateclose] = &KProtocolProcess::TradeApplyClose;
  198. ProcessFunc[c2s_tradeapplystart] = &KProtocolProcess::TradeApplyStart;
  199. ProcessFunc[c2s_trademovemoney] = &KProtocolProcess::TradeMoveMoney;
  200. ProcessFunc[c2s_tradedecision] = &KProtocolProcess::TradeDecision;
  201. ProcessFunc[c2s_dialognpc] = &KProtocolProcess::DialogNpc;
  202. ProcessFunc[c2s_teaminviteadd] = &KProtocolProcess::TeamInviteAdd;
  203. ProcessFunc[c2s_changeauraskill] = &KProtocolProcess::ChangeAuraSkill;
  204. ProcessFunc[c2s_teamreplyinvite] = &KProtocolProcess::TeamReplyInvite;
  205. ProcessFunc[c2s_ping] = NULL;//ReplyPing;
  206. ProcessFunc[c2s_npcsit] = &KProtocolProcess::NpcSitCommand;
  207. ProcessFunc[c2s_objmouseclick] = &KProtocolProcess::ObjMouseClick;
  208. ProcessFunc[c2s_storemoney] = &KProtocolProcess::StoreMoneyCommand;
  209. ProcessFunc[c2s_playerrevive] = &KProtocolProcess::NpcReviveCommand;
  210. ProcessFunc[c2s_tradereplystart] = &KProtocolProcess::c2sTradeReplyStart;
  211. ProcessFunc[c2s_pkapplychangenormalflag] = &KProtocolProcess::c2sPKApplyChangeNormalFlag;
  212. ProcessFunc[c2s_pkapplyenmity] = &KProtocolProcess::c2sPKApplyEnmity;
  213. ProcessFunc[c2s_viewequip] = &KProtocolProcess::c2sViewEquip;
  214. ProcessFunc[c2s_ladderquery] = &KProtocolProcess::LadderQuery;
  215. ProcessFunc[c2s_repairitem] = &KProtocolProcess::ItemRepair;
  216. #endif
  217. }
  219. KProtocolProcess::~KProtocolProcess()
  220. {
  221. }
  223. #ifndef _SERVER
  224. void KProtocolProcess::ProcessNetMsg(BYTE* pMsg)
  225. {
  226. if (!pMsg || pMsg[0] <= s2c_clientbegin || pMsg[0] >= s2c_end || ProcessFunc[pMsg[0]] == NULL)
  227. {
  228. g_DebugLog("[error]Net Msg Error");
  229. return;
  230. }
  231. g_DebugLog("[net]Msg:%c", pMsg[0]);
  232. if (ProcessFunc[pMsg[0]])
  233. (this->*ProcessFunc[pMsg[0]])(pMsg);
  234. }
  235. #else
  236. void KProtocolProcess::ProcessNetMsg(int nIndex, BYTE* pMsg)
  237. {
  238. _ASSERT(pMsg && pMsg[0] > c2s_gameserverbegin && pMsg[0] < c2s_end);
  240. BYTE byProtocol = pMsg[0];
  241. _ASSERT(nIndex > 0 && nIndex < MAX_PLAYER);
  242. if (ProcessFunc[byProtocol])
  243. {
  244. (this->*ProcessFunc[byProtocol])(nIndex, pMsg);
  245. Player[nIndex].SetLastNetOperationTime(g_SubWorldSet.GetGameTime());
  246. }
  247. }
  248. #endif
  250. #ifndef _SERVER
  251. void KProtocolProcess::NpcSleepSync(BYTE* pMsg)
  252. {
  253. NPC_SLEEP_SYNC* pSync = (NPC_SLEEP_SYNC *)pMsg;
  254. DWORD dwNpcId = pSync->NpcID;
  256. int nIdx = NpcSet.SearchID(dwNpcId);
  258. if (nIdx > 0)
  259. {
  260. Npc[nIdx].SetSleepMode((BOOL)pSync->bSleep);
  261. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  262. }
  263. }
  265. void KProtocolProcess::s2cPing(BYTE* pMsg)
  266. {
  267. // DWORD dwTimer = GetTickCount();
  268. // PING_COMMAND* PingCmd = (PING_COMMAND *)pMsg;
  269. //
  270. // dwTimer -= PingCmd->m_dwTime;
  271. // dwTimer >>= 1;
  272. // g_SubWorldSet.SetPing(dwTimer);
  273. // g_bPingReply = TRUE;
  275. DWORD dwTimer = GetTickCount();
  276. PING_COMMAND* PingCmd = (PING_COMMAND *)pMsg;
  277. PING_CLIENTREPLY_COMMAND pcc;
  278. pcc.ProtocolType = c2s_ping;
  279. pcc.m_dwReplyServerTime = PingCmd->m_dwTime;
  280. pcc.m_dwClientTime = dwTimer;
  281. g_pClient->SendPackToServer(&pcc, sizeof(PING_CLIENTREPLY_COMMAND));
  282. //g_SubWorldSet.SetPing(PingCmd->m_dwTime);
  283. }
  285. void KProtocolProcess::ServerReplyClientPing(BYTE* pMsg)
  286. {
  287. DWORD dwTimer = GetTickCount();
  288. PING_COMMAND* pPc = (PING_COMMAND *)pMsg;
  290. dwTimer -= pPc->m_dwTime;
  291. dwTimer >>= 1;
  292. g_SubWorldSet.SetPing(dwTimer);
  293. }
  295. void KProtocolProcess::s2cPlayerExp(BYTE* pMsg)
  296. {
  297. PLAYER_EXP_SYNC *pExp = (PLAYER_EXP_SYNC*)pMsg;
  298. Player[CLIENT_PLAYER_INDEX].s2cSetExp(pExp->m_nExp);
  299. }
  301. void KProtocolProcess::s2cChatScreenSingleError(BYTE* pMsg)
  302. {
  303. CHAT_SCREENSINGLE_ERROR_SYNC *pError = (CHAT_SCREENSINGLE_ERROR_SYNC*)pMsg;
  305. // 通知界面屏幕单聊不成功
  306. char szName[32];
  307. memset(szName, 0, sizeof(szName));
  308. memcpy(szName, pError->m_szName, pError->m_wLength + 1 + sizeof(pError->m_szName) - sizeof(CHAT_SCREENSINGLE_ERROR_SYNC));
  310. KSystemMessage sMsg;
  311. sprintf(sMsg.szMessage, MSG_CHAT_TAR_REFUSE_SINGLE_TALK, szName);
  312. sMsg.eType = SMT_NORMAL;
  313. sMsg.byConfirmType = SMCT_NONE;
  314. sMsg.byPriority = 0;
  315. sMsg.byParamSize = 0;
  316. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  317. }
  319. void KProtocolProcess::NetCommandChgCamp(BYTE* pMsg)
  320. {
  321. DWORD dwNpcId;
  323. dwNpcId = *(DWORD *)&pMsg[1];
  324. int nIdx = NpcSet.SearchID(dwNpcId);
  326. if (nIdx > 0)
  327. {
  328. Npc[nIdx].m_Camp = (int)pMsg[5];
  329. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  330. }
  331. }
  333. void KProtocolProcess::NetCommandChgCurCamp(BYTE* pMsg)
  334. {
  335. DWORD dwNpcId;
  337. dwNpcId = *(DWORD *)&pMsg[1];
  338. int nIdx = NpcSet.SearchID(dwNpcId);
  340. if (nIdx > 0)
  341. {
  342. Npc[nIdx].m_CurrentCamp = (int)pMsg[5];
  343. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  344. }
  345. }
  347. void KProtocolProcess::NetCommandDeath(BYTE* pMsg)
  348. {
  349. DWORD dwNpcID;
  351. dwNpcID = *(DWORD *)&pMsg[1];
  352. int nIdx = NpcSet.SearchID(dwNpcID);
  354. if (nIdx > 0)
  355. {
  356. //Npc[nIdx].SendCommand(do_death);
  357. Npc[nIdx].ProcNetCommand(do_death);
  358. Npc[nIdx].m_CurrentLife = 0;
  359. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  360. g_DebugLog("[Death]Net command comes");
  361. }
  362. }
  364. void KProtocolProcess::NetCommandJump(BYTE* pMsg)
  365. {
  366. NPC_JUMP_SYNC* pNetCommandJump = (NPC_JUMP_SYNC *)pMsg;
  367. DWORD dwNpcId = pNetCommandJump->ID;
  368. int nIdx = NpcSet.SearchID(dwNpcId);
  370. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  371. {
  372. Npc[nIdx].SendCommand(do_jump, pNetCommandJump->nMpsX, pNetCommandJump->nMpsY);
  373. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  374. }
  375. }
  377. void KProtocolProcess::NetCommandHurt(BYTE* pMsg)
  378. {
  379. NPC_HURT_SYNC* pSync = (NPC_HURT_SYNC *)pMsg;
  381. int nIdx = NpcSet.SearchID(pSync->ID);
  382. if (nIdx > 0)
  383. {
  384. //Npc[nIdx].SendCommand(do_hurt, pSync->nFrames, pSync->nX, pSync->nY);
  385. Npc[nIdx].ProcNetCommand(do_hurt, pSync->nFrames, pSync->nX, pSync->nY);
  386. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  387. }
  388. }
  390. void KProtocolProcess::NetCommandRemoveNpc(BYTE* pMsg)
  391. {
  392. DWORD dwNpcID;
  393. dwNpcID = *(DWORD *)&pMsg[1];
  394. int nIdx = NpcSet.SearchID(dwNpcID);
  396. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  397. {
  398. if (Npc[nIdx].m_RegionIndex >= 0)
  399. {
  400. // zroc change
  401. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].RemoveNpc(nIdx);
  402. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].DecRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  403. // SubWorld[Npc[nIdx].m_SubWorldIndex].m_Region[Npc[nIdx].m_RegionIndex].RemoveNpc(nIdx);
  404. }
  405. NpcSet.Remove(nIdx);
  406. }
  407. }
  409. void KProtocolProcess::NetCommandRun(BYTE* pMsg)
  410. {
  411. DWORD dwNpcID;
  412. DWORD MapX, MapY;
  414. dwNpcID = *(DWORD *)&pMsg[1];
  415. MapX = *(int *)&pMsg[5];
  416. MapY = *(int *)&pMsg[9];
  417. int nIdx = NpcSet.SearchID(dwNpcID);
  418. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  419. {
  420. Npc[nIdx].SendCommand(do_run, MapX, MapY);
  421. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  422. }
  423. }
  425. void KProtocolProcess::NetCommandSit(BYTE* pMsg)
  426. {
  427. NPC_SIT_SYNC* pSitSync;
  429. pSitSync = (NPC_SIT_SYNC *)pMsg;
  431. int nIdx = NpcSet.SearchID(pSitSync->ID);
  433. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  434. {
  435. Npc[nIdx].SendCommand(do_sit);
  436. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  437. }
  438. }
  440. void KProtocolProcess::OpenSaleBox(BYTE* pMsg)
  441. {
  442. SALE_BOX_SYNC* pSale = (SALE_BOX_SYNC *)pMsg;
  444. BuySell.OpenSale(pSale->nShopIndex);
  445. }
  447. void KProtocolProcess::OpenStoreBox(BYTE* pMsg)
  448. {
  449. CoreDataChanged(GDCNI_OPEN_STORE_BOX, NULL, NULL);
  450. }
  452. void KProtocolProcess::PlayerRevive(BYTE* pMsg)
  453. {
  454. NPC_REVIVE_SYNC* pSync = (NPC_REVIVE_SYNC*)pMsg;
  456. int nIdx = NpcSet.SearchID(pSync->ID);
  457. if (nIdx > 0)
  458. {
  459. if (!Npc[nIdx].IsPlayer() && pSync->Type == REMOTE_REVIVE_TYPE)
  460. {
  461. SubWorld[0].m_WorldMessage.Send(GWM_NPC_DEL, nIdx);
  462. return;
  463. }
  464. else
  465. {
  466. Npc[nIdx].ProcNetCommand(do_revive);
  467. }
  468. }
  469. }
  471. void KProtocolProcess::RequestNpcFail(BYTE* pMsg)
  472. {
  473. NPC_REQUEST_FAIL* pNpcSync = (NPC_REQUEST_FAIL *)pMsg;
  475. if (NpcSet.IsNpcRequestExist(pNpcSync->ID))
  476. NpcSet.RemoveNpcRequest(pNpcSync->ID);
  477. }
  479. void KProtocolProcess::NetCommandSkill(BYTE* pMsg)
  480. {
  481. DWORD dwNpcID;
  482. int nSkillID, nSkillLevel;
  483. int MapX, MapY;
  485. dwNpcID = *(DWORD *)&pMsg[1];
  486. nSkillID = *(int *)&pMsg[5];
  487. nSkillLevel = *(int *)&pMsg[9];
  488. MapX = *(int *)&pMsg[13];
  489. MapY = *(int *)&pMsg[17];
  491. if (MapY < 0)
  492. return ;
  494. //当指定某个目标时(MapX == -1),MapY为目标的NpcdwID，需要转换成本地的NpcIndex才行
  495. if (MapX < 0)
  496. {
  497. if (MapX != -1)
  498. return;
  500. MapY = NpcSet.SearchID(MapY);
  501. if (MapY == 0)
  502. return;
  504. if (Npc[MapY].m_RegionIndex < 0)
  505. return;
  507. }
  509. int nIdx = NpcSet.SearchID(dwNpcID);
  511. if (nIdx <= 0) 
  512. return;
  514. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  515. {
  516. Npc[nIdx].m_SkillList.SetSkillLevel(nSkillID, nSkillLevel);
  517. Npc[nIdx].SendCommand(do_skill, nSkillID, MapX, MapY);
  518. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  519. }
  520. }
  522. void KProtocolProcess::NetCommandWalk(BYTE* pMsg)
  523. {
  524. DWORD dwNpcID;
  525. DWORD MapX, MapY;
  527. dwNpcID = *(DWORD *)&pMsg[1];
  528. MapX = *(int *)&pMsg[5];
  529. MapY = *(int *)&pMsg[9];
  530. int nIdx = NpcSet.SearchID(dwNpcID);
  531. if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  532. {
  533. Npc[nIdx].SendCommand(do_walk, MapX, MapY);
  534. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  535. }
  536. }
  538. //-------------------------------------------------------------------------
  539. // 功能：收到服务器通知队伍创建失败
  540. //-------------------------------------------------------------------------
  541. void KProtocolProcess::s2cApplyCreateTeamFalse(BYTE* pMsg)
  542. {
  543. PLAYER_SEND_CREATE_TEAM_FALSE *pCreateFalse = (PLAYER_SEND_CREATE_TEAM_FALSE*)pMsg;
  544. KSystemMessage sMsg;
  546. switch (pCreateFalse->m_btErrorID)
  547. {
  548. // 已经在队伍中，说明客户端队伍数据有错误，申请重新获得队伍数据
  549. case Team_Create_Error_InTeam:
  550. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  551. break;
  553. // 当前处于不能组队状态
  554. case Team_Create_Error_CannotCreate:
  555. sprintf(sMsg.szMessage, MSG_TEAM_CANNOT_CREATE);
  556. sMsg.eType = SMT_NORMAL;
  557. sMsg.byConfirmType = SMCT_NONE;
  558. sMsg.byPriority = 0;
  559. sMsg.byParamSize = 0;
  560. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  561. break;
  564. default:
  565. sprintf(sMsg.szMessage, MSG_TEAM_CREATE_FAIL);
  566. sMsg.eType = SMT_NORMAL;
  567. sMsg.byConfirmType = SMCT_NONE;
  568. sMsg.byPriority = 0;
  569. sMsg.byParamSize = 0;
  570. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  571. break;
  572. }
  573. }
  575. //-------------------------------------------------------------------------
  576. // 功能：收到服务器通知查询某个队伍组队情况失败
  577. //-------------------------------------------------------------------------
  578. void KProtocolProcess::s2cApplyTeamInfoFalse(BYTE* pMsg)
  579. {
  580. // 界面显示队伍查询失败(not end)
  581. }
  583. //-------------------------------------------------------------------------
  584. // 功能：添加一个好友
  585. //-------------------------------------------------------------------------
  586. void KProtocolProcess::s2cChatAddFriend(BYTE* pMsg)
  587. {
  588. CHAT_ADD_FRIEND_SYNC *pFriend = (CHAT_ADD_FRIEND_SYNC*)pMsg;
  590. Player[CLIENT_PLAYER_INDEX].m_cChat.AddOne(pFriend->m_dwID, pFriend->m_nIdx, pFriend->m_szName, 0);
  591. Player[CLIENT_PLAYER_INDEX].m_cChat.SaveTeamInfo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  593. KSystemMessage sMsg;
  594. KUiPlayerItem sPlayer;
  596. memset(&sPlayer, 0, sizeof(KUiPlayerItem));
  597. strcpy(sPlayer.Name, pFriend->m_szName);
  598. sPlayer.uId = pFriend->m_dwID;
  599. sPlayer.nIndex = pFriend->m_nIdx;
  601. sprintf(sMsg.szMessage, MSG_CHAT_ADD_FRIEND_SUCCESS, pFriend->m_szName);
  602. sMsg.eType = SMT_FRIEND;
  603. sMsg.byConfirmType = SMCT_UI_INTERVIEW;
  604. sMsg.byPriority = 2;
  605. sMsg.byParamSize = sizeof(KUiPlayerItem);
  606. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, (int)&sPlayer);
  607. }
  609. //-------------------------------------------------------------------------
  610. // 功能：添加好友失败
  611. //-------------------------------------------------------------------------
  612. void KProtocolProcess::s2cChatAddFriendFail(BYTE* pMsg)
  613. {
  614. CHAT_ADD_FRIEND_FAIL_SYNC *pFail = (CHAT_ADD_FRIEND_FAIL_SYNC*)pMsg;
  616. char szName[32];
  617. CChatApplyListNode *pList;
  618. pList = (CChatApplyListNode*)Player[CLIENT_PLAYER_INDEX].m_cChat.m_cApplyAddList.GetHead();
  619. while (pList)
  620. {
  621. if (pList->m_nPlayerIdx == pFail->m_nTargetPlayerIdx)
  622. {
  623. g_StrCpy(szName, pList->m_szName);
  625. // 通知界面添加某人为好友操作失败
  626. KSystemMessage sMsg;
  627. sprintf(sMsg.szMessage, MSG_CHAT_ADD_FRIEND_FAIL, szName);
  628. sMsg.eType = SMT_NORMAL;
  629. sMsg.byConfirmType = SMCT_NONE;
  630. sMsg.byPriority = 0;
  631. sMsg.byParamSize = 0;
  632. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  634. return;
  635. }
  636. pList = (CChatApplyListNode*)pList->GetNext();
  637. }
  638. }
  640. //-------------------------------------------------------------------------
  641. // 功能：收到服务器过来的玩家某个聊天好友的数据（带名字）
  642. //-------------------------------------------------------------------------
  643. void KProtocolProcess::s2cChatAddOneFriend(BYTE* pMsg)
  644. {
  645. CHAT_ONE_FRIEND_DATA_SYNC *pData = (CHAT_ONE_FRIEND_DATA_SYNC*)pMsg;
  646. int nTeamNo;
  648. nTeamNo = Player[CLIENT_PLAYER_INDEX].m_cChat.CheckTeamNo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, pData->m_szName);
  649. if (nTeamNo < 0)
  650. nTeamNo = 0;
  651. Player[CLIENT_PLAYER_INDEX].m_cChat.AddOne(pData->m_dwID, pData->m_nPlayerIdx, pData->m_szName, nTeamNo);
  652. Player[CLIENT_PLAYER_INDEX].m_cChat.SaveTeamInfo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  654. // 通知界面得到新成员 not end
  655. }
  657. //-------------------------------------------------------------------------
  658. // 功能：被别的玩家拒绝交友
  659. //-------------------------------------------------------------------------
  660. void KProtocolProcess::s2cChatBeRefusedAddFriend(BYTE* pMsg)
  661. {
  662. CHAT_REFUSE_FRIEND_SYNC *pRefuse = (CHAT_REFUSE_FRIEND_SYNC*)pMsg;
  663. char szName[64];
  665. memset(szName, 0, sizeof(szName));
  666. memcpy(szName, pRefuse->m_szName, pRefuse->m_wLength + 1 + sizeof(pRefuse->m_szName) - sizeof(CHAT_REFUSE_FRIEND_SYNC));
  668. // 通知界面pRefuse->m_szName拒绝了他的交友申请
  669. KSystemMessage sMsg;
  671. sprintf(sMsg.szMessage, MSG_CHAT_REFUSE_FRIEND, szName);
  672. sMsg.eType = SMT_FRIEND;
  673. sMsg.byConfirmType = SMCT_CLICK;
  674. sMsg.byPriority = 1;
  675. sMsg.byParamSize = 0;
  676. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  677. }
  679. //-------------------------------------------------------------------------
  680. // 功能：得到通知好友上线
  681. //-------------------------------------------------------------------------
  682. void KProtocolProcess::s2cChatFriendOnline(BYTE* pMsg)
  683. {
  684. CHAT_FRIEND_ONLINE_SYNC *pFriend = (CHAT_FRIEND_ONLINE_SYNC*)pMsg;
  686. Player[CLIENT_PLAYER_INDEX].ChatFriendOnLine(pFriend->m_dwID, pFriend->m_nPlayerIdx);
  687. }
  689. //-------------------------------------------------------------------------
  690. // 收到服务器转发的别人添加聊天好友的申请
  691. //-------------------------------------------------------------------------
  692. void KProtocolProcess::s2cChatGetApplyAddFriend(BYTE* pMsg)
  693. {
  694. CHAT_APPLY_ADD_FRIEND_SYNC *pApply = (CHAT_APPLY_ADD_FRIEND_SYNC*)pMsg;
  696. if ( Player[CLIENT_PLAYER_INDEX].m_cChat.CheckIsFriend(pApply->m_nSrcPlayerIdx) )
  697. return;
  699. CChatApplyListNode *pNode = NULL;
  700. pNode = new CChatApplyListNode;
  701. if (pNode == NULL)
  702. return;
  703. pNode->m_nPlayerIdx = pApply->m_nSrcPlayerIdx;
  704. strcpy(pNode->m_szName, pApply->m_szSourceName);
  705. strcpy(pNode->m_szInfo, pApply->m_szInfo);
  707. Player[CLIENT_PLAYER_INDEX].m_cChat.m_cApplyAddList.AddTail(pNode);
  709. // 通知界面有人申请添加聊天好友
  710. KSystemMessage sMsg;
  711. KUiPlayerItem sPlayer;
  713. strcpy(sPlayer.Name, pApply->m_szSourceName);
  714. sPlayer.nIndex = pApply->m_nSrcPlayerIdx;
  715. sPlayer.uId = 0;
  716. sPlayer.nData = 0;
  718. sprintf(sMsg.szMessage, MSG_CHAT_GET_FRIEND_APPLY, pNode->m_szName);
  719. sMsg.eType = SMT_FRIEND;
  720. sMsg.byConfirmType = SMCT_UI_FRIEND_INVITE;
  721. sMsg.byPriority = 3;
  722. sMsg.byParamSize = sizeof(KUiPlayerItem);
  723. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, (int)&sPlayer);
  724. }
  726. //-------------------------------------------------------------------------
  727. // 功能：收到服务器过来的玩家登录时获得聊天好友数据（带名字）
  728. //-------------------------------------------------------------------------
  729. void KProtocolProcess::s2cChatLoginFriendName(BYTE* pMsg)
  730. {
  731. CHAT_LOGIN_FRIEND_NAME_SYNC *pFriend = (CHAT_LOGIN_FRIEND_NAME_SYNC*)pMsg;
  732. int nTeamNo;
  733. char szName[64];
  735. memset(szName, 0, sizeof(szName));
  736. memcpy(szName, pFriend->m_szName, pFriend->m_wLength + 1 + sizeof(pFriend->m_szName) - sizeof(CHAT_LOGIN_FRIEND_NAME_SYNC));
  737. nTeamNo = Player[CLIENT_PLAYER_INDEX].m_cChat.CheckTeamNo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, szName);
  738. if (nTeamNo < 0)
  739. nTeamNo = 0;
  740. Player[CLIENT_PLAYER_INDEX].m_cChat.AddOne(pFriend->m_dwID, pFriend->m_nPlayerIdx, szName, nTeamNo);
  741. }
  743. //-------------------------------------------------------------------------
  744. // 功能：收到服务器过来的玩家登录时获得聊天好友数据（不带名字）
  745. //-------------------------------------------------------------------------
  746. void KProtocolProcess::s2cChatLoginFriendNoName(BYTE* pMsg)
  747. {
  748. CHAT_LOGIN_FRIEND_NONAME_SYNC *pFriend = (CHAT_LOGIN_FRIEND_NONAME_SYNC*)pMsg;
  749. char szName[32];
  750. int nTeamNo;
  752. szName[0] = 0;
  753. nTeamNo = Player[CLIENT_PLAYER_INDEX].m_cChat.CheckTeamNo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, NULL);
  754. if (nTeamNo < 0)
  755. {
  756. if (Player[CLIENT_PLAYER_INDEX].m_cChat.m_nLoginGetFirstOneFriendFlag == 0) // 申请重新发送所有好友数据，带名字
  757. {
  758. Player[CLIENT_PLAYER_INDEX].m_cChat.m_nLoginGetFirstOneFriendFlag = 1;
  760. CHAT_APPLY_RESEND_ALL_FRIEND_NAME_COMMAND sApply;
  761. sApply.ProtocolType = c2s_chatapplyresendallfriendname;
  763. if (g_pClient)
  764. g_pClient->SendPackToServer((BYTE*)&sApply, sizeof(CHAT_APPLY_RESEND_ALL_FRIEND_NAME_COMMAND));
  765. }
  766. else // 申请重新发送这个好友数据，带名字
  767. {
  768. CHAT_APPLY_SEND_ONE_FRIEND_NAME_COMMAND sApply;
  769. sApply.ProtocolType = c2s_chatapplysendonefriendname;
  770. sApply.m_dwID = pFriend->m_dwID;
  772. if (g_pClient)
  773. g_pClient->SendPackToServer((BYTE*)&sApply, sizeof(CHAT_APPLY_SEND_ONE_FRIEND_NAME_COMMAND));
  774. }
  775. return;
  776. }
  777. Player[CLIENT_PLAYER_INDEX].m_cChat.AddOne(pFriend->m_dwID, pFriend->m_nPlayerIdx, szName, nTeamNo);
  778. Player[CLIENT_PLAYER_INDEX].m_cChat.SaveTeamInfo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  779. Player[CLIENT_PLAYER_INDEX].m_cChat.m_nLoginGetFirstOneFriendFlag = 1;
  781. }
  783. //-------------------------------------------------------------------------
  784. // 功能：收到服务器通知创建一支队伍
  785. //-------------------------------------------------------------------------
  786. void KProtocolProcess::s2cCreateTeam(BYTE* pMsg)
  787. {
  788. PLAYER_SEND_CREATE_TEAM_SUCCESS *pCreateSuccess = (PLAYER_SEND_CREATE_TEAM_SUCCESS*)pMsg;
  790. g_Team[0].CreateTeam(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_Level, pCreateSuccess->nTeamServerID);
  791. Player[CLIENT_PLAYER_INDEX].m_cTeam.Release();
  792. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 1;
  793. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_CAPTAIN;
  794. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nApplyCaptainID = 0;
  795. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].RestoreCurrentCamp();
  797. KSystemMessage sMsg;
  798. sprintf(sMsg.szMessage, MSG_TEAM_CREATE);
  799. sMsg.eType = SMT_NORMAL;
  800. sMsg.byConfirmType = SMCT_NONE;
  801. sMsg.byPriority = 0;
  802. sMsg.byParamSize = 0;
  803. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  805. sprintf(sMsg.szMessage, MSG_TEAM_CREATE);
  806. sMsg.eType = SMT_TEAM;
  807. sMsg.byConfirmType = SMCT_CLICK;
  808. sMsg.byPriority = 1;
  809. sMsg.byParamSize = 0;
  810. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  812. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetInstantSpr(enumINSTANT_STATE_CREATE_TEAM);
  813. }
  815. //-------------------------------------------------------------------------
  816. // 功能：收到服务器通知开放当前门派技能某等级
  817. //-------------------------------------------------------------------------
  818. void KProtocolProcess::s2cFactionSkillOpen(BYTE* pMsg)
  819. {
  820. PLAYER_FACTION_SKILL_LEVEL *pSkill = (PLAYER_FACTION_SKILL_LEVEL*)pMsg;
  822. if (Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nCurFaction < 0 || Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nCurFaction != pSkill->m_btCurFactionID)
  823. {
  824. // 申请更新门派信息
  825. Player[CLIENT_PLAYER_INDEX].ApplyFactionData();
  826. return;
  827. }
  829. // for (int i = 0; i < FACTIONS_PRR_SERIES; i++)
  830. // {
  831. // if (Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[i].m_nID == Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nCurFaction)
  832. // {
  833. // Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[i].m_nOpenLevel = pSkill->m_btLevel;
  834. // Player[CLIENT_PLAYER_INDEX].m_cFaction.OpenCurSkillLevel(Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[i].m_nOpenLevel, &Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList);
  835. // break;
  836. // }
  837. // }
  838. }
  840. //-------------------------------------------------------------------------
  841. // 功能：收到服务器发来的聊天信息
  842. //-------------------------------------------------------------------------
  843. void KProtocolProcess::s2cGetChat(BYTE* pMsg)
  844. {
  845. PLAYER_SEND_CHAT_SYNC *pChat = (PLAYER_SEND_CHAT_SYNC*)pMsg;
  847. Player[CLIENT_PLAYER_INDEX].m_cChat.GetChat(pChat);
  848. }
  850. //-------------------------------------------------------------------------
  851. // 功能：收到服务器发过来的当前某属性的点数
  852. //-------------------------------------------------------------------------
  853. void KProtocolProcess::s2cGetCurAttribute(BYTE* pMsg)
  854. {
  855. Player[CLIENT_PLAYER_INDEX].s2cGetCurAttribute(pMsg);
  856. }
  858. //-------------------------------------------------------------------------
  859. // 功能：收到服务器发来的统率力经验值
  860. //-------------------------------------------------------------------------
  861. void KProtocolProcess::s2cGetLeadExp(BYTE* pMsg)
  862. {
  863. DWORD dwLevel = Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel;
  865. PLAYER_LEAD_EXP_SYNC *pLeadExp = (PLAYER_LEAD_EXP_SYNC*)pMsg;
  866. Player[CLIENT_PLAYER_INDEX].m_dwLeadExp = pLeadExp->m_dwLeadExp;
  867. Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel = PlayerSet.m_cLeadExp.GetLevel(Player[CLIENT_PLAYER_INDEX].m_dwLeadExp, Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel);
  868. Player[CLIENT_PLAYER_INDEX].m_dwNextLevelLeadExp = PlayerSet.m_cLeadExp.GetLevelExp(Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel);
  870. if (dwLevel < Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel)
  871. {
  872. KSystemMessage sMsg;
  873. sprintf(sMsg.szMessage, MSG_LEADER_LEVEL_UP, Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel);
  874. sMsg.eType = SMT_PLAYER;
  875. sMsg.byConfirmType = SMCT_CLICK;
  876. sMsg.byPriority = 1;
  877. sMsg.byParamSize = 0;
  878. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  879. }
  880. }
  882. //-------------------------------------------------------------------------
  883. // 功能：收到服务器发过来的某技能点数
  884. //-------------------------------------------------------------------------
  885. void KProtocolProcess::s2cGetSkillLevel(BYTE* pMsg)
  886. {
  887. int nSkillIndex;
  888. PLAYER_SKILL_LEVEL_SYNC *pSkill = (PLAYER_SKILL_LEVEL_SYNC*)pMsg;
  889. if (pSkill->m_nSkillLevel > MAX_SKILLLEVEL)
  890. return;
  891. nSkillIndex = Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList.FindSame(pSkill->m_nSkillID);
  892. Player[CLIENT_PLAYER_INDEX].m_nSkillPoint = pSkill->m_nLeavePoint;
  893. if ( !nSkillIndex )
  894. {
  895. //如果该技能的等级为零，表示新学，直接向客户端填加
  896. if (pSkill->m_nSkillLevel == 0)
  897. {
  898. if ( Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList.Add(pSkill->m_nSkillID, 0) == 0 )
  899. return;
  900. }
  901. else
  902. {
  903. if ( Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList.Add(pSkill->m_nSkillID, pSkill->m_nSkillLevel) == 0 )
  904. return;
  905. }
  906. }
  907. else
  908. {
  909. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList.SetLevel(nSkillIndex, pSkill->m_nSkillLevel);
  910. }
  912. // 通知界面更新技能数据
  913. CoreDataChanged(GDCNI_FIGHT_SKILL_POINT, 0, Player[CLIENT_PLAYER_INDEX].m_nSkillPoint);
  914. KUiSkillData SkillData;
  915. SkillData.uGenre = CGOG_SKILL_FIGHT;
  916. SkillData.uId = pSkill->m_nSkillID;
  917. SkillData.nLevel = pSkill->m_nSkillLevel;
  918. int nSkillPosition = Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList.GetSkillPosition(pSkill->m_nSkillID);
  919. if(nSkillPosition < 0) return;
  920. CoreDataChanged(GDCNI_SKILL_CHANGE, (unsigned int)&SkillData, nSkillPosition);
  921. }
  923. //-------------------------------------------------------------------------
  924. // 功能：收到服务器发来的队友等级变化通知
  925. //-------------------------------------------------------------------------
  926. void KProtocolProcess::s2cGetTeammateLevel(BYTE* pMsg)
  927. {
  928. PLAYER_TEAMMATE_LEVEL_SYNC *pLevel = (PLAYER_TEAMMATE_LEVEL_SYNC*)pMsg;
  929. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag)
  930. {
  931. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  932. return;
  933. }
  935. if ((DWORD)g_Team[0].m_nCaptain == pLevel->m_dwTeammateID)
  936. {
  937. g_Team[0].m_nMemLevel[0] = (DWORD)pLevel->m_btLevel;
  938. return;
  939. }
  941. for (int i = 0; i < MAX_TEAM_MEMBER; i++)
  942. {
  943. if ((DWORD)g_Team[0].m_nMember[i] == pLevel->m_dwTeammateID)
  944. {
  945. g_Team[0].m_nMemLevel[i + 1] = (DWORD)pLevel->m_btLevel;
  946. break;
  947. }
  948. }
  949. }
  951. //-------------------------------------------------------------------------
  952. // 功能：收到服务器通知离开门派
  953. //-------------------------------------------------------------------------
  954. void KProtocolProcess::s2cLeaveFaction(BYTE* pMsg)
  955. {
  956. Player[CLIENT_PLAYER_INDEX].m_cFaction.LeaveFaction();
  958. // 改变阵营
  959. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetCamp(camp_free);
  961. CoreDataChanged(GDCNI_PLAYER_BASE_INFO, 0, 0);
  962. }
  964. //-------------------------------------------------------------------------
  965. // 功能：收到服务器通知有成员离开(包括自己离开)
  966. //-------------------------------------------------------------------------
  967. void KProtocolProcess::s2cLeaveTeam(BYTE* pMsg)
  968. {
  969. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag)
  970. {
  971. Player[CLIENT_PLAYER_INDEX].m_cTeam.UpdateInterface();
  972. return;
  973. }
  975. PLAYER_LEAVE_TEAM *pLeaveTeam = (PLAYER_LEAVE_TEAM*)pMsg;
  977. // 自己离开
  978. if (pLeaveTeam->m_dwNpcID == Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  979. {
  980. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 0;
  981. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nApplyCaptainID = 0;
  982. g_Team[0].Release();
  983. if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].GetMenuState() == PLAYER_MENU_STATE_TEAMOPEN)
  984. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetMenuState(PLAYER_MENU_STATE_NORMAL);
  985. }
  986. // 别人离开
  987. else
  988. {
  989. g_Team[0].DeleteMember(pLeaveTeam->m_dwNpcID);
  990. }
  992. Player[CLIENT_PLAYER_INDEX].m_cTeam.UpdateInterface();
  993. return;
  994. }
  996. //-------------------------------------------------------------------------
  997. // 功能：收到服务器通知升级
  998. //-------------------------------------------------------------------------
  999. void KProtocolProcess::s2cLevelUp(BYTE* pMsg)
  1000. {
  1001. Player[CLIENT_PLAYER_INDEX].s2cLevelUp(pMsg);
  1002. }
  1004. void KProtocolProcess::s2cMoveItem(BYTE* pMsg)
  1005. {
  1006. PLAYER_MOVE_ITEM_SYNC *pMove = (PLAYER_MOVE_ITEM_SYNC*)pMsg;
  1008. ItemPos DownPos, UpPos;
  1009. DownPos.nPlace = pMove->m_btDownPos;
  1010. DownPos.nX = pMove->m_btDownX;
  1011. DownPos.nY = pMove->m_btDownY;
  1012. UpPos.nPlace = pMove->m_btUpPos;
  1013. UpPos.nX = pMove->m_btUpX;
  1014. UpPos.nY = pMove->m_btUpY;
  1016. Player[CLIENT_PLAYER_INDEX].m_ItemList.ExchangeItem(&DownPos, &UpPos);
  1017. }
  1019. void KProtocolProcess::s2cRemoveItem(BYTE* pMsg)
  1020. {
  1021. ITEM_REMOVE_SYNC *pRemove = (ITEM_REMOVE_SYNC*)pMsg;
  1023. int nIdx;
  1024. nIdx = Player[CLIENT_PLAYER_INDEX].m_ItemList.SearchID(pRemove->m_ID);
  1025. if (nIdx > 0)
  1026. {
  1027. Player[CLIENT_PLAYER_INDEX].m_ItemList.Remove(nIdx);
  1028. Player[CLIENT_PLAYER_INDEX].m_ItemList.UnlockOperation();
  1029. }
  1032. }
  1034. //-------------------------------------------------------------------------
  1035. // 功能：收到服务器发来的门派信息
  1036. //-------------------------------------------------------------------------
  1037. void KProtocolProcess::s2cSetFactionData(BYTE* pMsg)
  1038. {
  1039. PLAYER_FACTION_DATA *pData = (PLAYER_FACTION_DATA*)pMsg;
  1041. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetCamp(pData->m_btCamp);
  1042. Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nCurFaction = (char)pData->m_btCurFaction;
  1043. Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nFirstAddFaction = (char)pData->m_btFirstFaction;
  1044. Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nAddTimes = pData->m_nAddTimes;
  1046. CoreDataChanged(GDCNI_PLAYER_BASE_INFO, 0, 0);
  1048. // Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[0].m_nOpenLevel = pData->m_btNo1SkillOpenLevel;
  1049. // Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[1].m_nOpenLevel = pData->m_btNo2SkillOpenLevel;
  1050. // if (Player[CLIENT_PLAYER_INDEX].m_cFaction.m_nCurFaction == Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[0].m_nID)
  1051. // Player[CLIENT_PLAYER_INDEX].m_cFaction.OpenCurSkillLevel(Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[0].m_nOpenLevel, &Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList);
  1052. // else
  1053. // Player[CLIENT_PLAYER_INDEX].m_cFaction.OpenCurSkillLevel(Player[CLIENT_PLAYER_INDEX].m_cFaction.m_sSkillOpen[1].m_nOpenLevel, &Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SkillList);
  1054. }
  1056. //-------------------------------------------------------------------------
  1057. // 功能：收到服务器通知队伍状态(队长申请开放、关闭队伍状态时才会收到此信息)
  1058. //-------------------------------------------------------------------------
  1059. void KProtocolProcess::s2cSetTeamState(BYTE* pMsg)
  1060. {
  1061. // 客户端数据有误，申请更新数据
  1062. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag || Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure != TEAM_CAPTAIN)
  1063. {
  1064. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1065. return;
  1066. }
  1068. PLAYER_TEAM_OPEN_CLOSE *pTeamState = (PLAYER_TEAM_OPEN_CLOSE*)pMsg;
  1069. Player[CLIENT_PLAYER_INDEX].m_cTeam.ReleaseList();
  1070. if (pTeamState->m_btOpenClose)
  1071. {
  1072. g_Team[0].SetTeamOpen();
  1074. KSystemMessage sMsg;
  1075. sprintf(sMsg.szMessage, MSG_TEAM_OPEN);
  1076. sMsg.eType = SMT_NORMAL;
  1077. sMsg.byConfirmType = SMCT_NONE;
  1078. sMsg.byPriority = 0;
  1079. sMsg.byParamSize = 0;
  1080. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1081. }
  1082. else
  1083. {
  1084. g_Team[0].SetTeamClose();
  1086. KSystemMessage sMsg;
  1087. sprintf(sMsg.szMessage, MSG_TEAM_CLOSE);
  1088. sMsg.eType = SMT_NORMAL;
  1089. sMsg.byConfirmType = SMCT_NONE;
  1090. sMsg.byPriority = 0;
  1091. sMsg.byParamSize = 0;
  1092. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1093. }
  1094. }
  1096. //-------------------------------------------------------------------------
  1097. // 功能：收到服务器通知队伍状态(队长申请开放、关闭队伍状态时才会收到此信息)
  1098. //-------------------------------------------------------------------------
  1099. void KProtocolProcess::s2cApplyAddTeam(BYTE* pMsg)
  1100. {
  1101. Player[CLIENT_PLAYER_INDEX].s2cApplyAddTeam(pMsg);
  1102. }
  1104. //-------------------------------------------------------------------------
  1105. // 功能：收到服务器发来的某个队伍的组队情况，显示之
  1106. //-------------------------------------------------------------------------
  1107. void KProtocolProcess::s2cShowTeamInfo(BYTE* pMsg)
  1108. {
  1109. }
  1111. void KProtocolProcess::s2cSyncItem(BYTE* pMsg)
  1112. {
  1113. ITEM_SYNC *pItemSync = (ITEM_SYNC*)pMsg;
  1114. int pnMagicParam[6];
  1115. for (int i = 0; i < 6; i++)
  1116. {
  1117. pnMagicParam[i] = pItemSync->m_MagicLevel[i];
  1118. }
  1119. int nIndex = ItemSet.Add(
  1120. pItemSync->m_Genre,
  1121. pItemSync->m_Series,
  1122. pItemSync->m_Level,
  1123. pItemSync->m_Luck,
  1124. pItemSync->m_Detail,
  1125. pItemSync->m_Particur,
  1126. pnMagicParam,
  1127. pItemSync->m_Version,
  1128. pItemSync->m_RandomSeed);
  1129. if (nIndex > 0)
  1130. {
  1131. Item[nIndex].SetID(pItemSync->m_ID);
  1132. Item[nIndex].SetDurability((short)pItemSync->m_Durability);
  1133. Player[CLIENT_PLAYER_INDEX].m_ItemList.Add(nIndex, pItemSync->m_btPlace, pItemSync->m_btX, pItemSync->m_btY);
  1134. }
  1135. Player[CLIENT_PLAYER_INDEX].m_ItemList.UnlockOperation();
  1136. }
  1138. //-------------------------------------------------------------------------
  1139. // 功能：收到服务器发过来的同步money的消息
  1140. //-------------------------------------------------------------------------
  1141. void KProtocolProcess::s2cSyncMoney(BYTE* pMsg)
  1142. {
  1143. Player[CLIENT_PLAYER_INDEX].s2cSyncMoney(pMsg);
  1144. }
  1146. void KProtocolProcess::s2cSyncRoleList(BYTE* pMsg)
  1147. {
  1148. ROLE_LIST_SYNC *pSync = (ROLE_LIST_SYNC *)pMsg;
  1149. // TODO: 通过CORESHELL交给界面？
  1150. }
  1152. //-------------------------------------------------------------------------
  1153. // 功能：收到服务器通知有新人加入队伍
  1154. //-------------------------------------------------------------------------
  1155. void KProtocolProcess::s2cTeamAddMember(BYTE* pMsg)
  1156. {
  1157. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag )
  1158. {
  1159. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1160. return;
  1161. }
  1163. PLAYER_TEAM_ADD_MEMBER *pAddMem = (PLAYER_TEAM_ADD_MEMBER*)pMsg;
  1164. int nMemNum;
  1166. nMemNum = g_Team[0].FindFree();
  1167. if (nMemNum < 0)
  1168. return;
  1169. g_Team[0].m_nMember[nMemNum] = pAddMem->m_dwNpcID;
  1170. g_Team[0].m_nMemLevel[nMemNum + 1] = (DWORD)pAddMem->m_btLevel;
  1171. strcpy(g_Team[0].m_szMemName[nMemNum + 1], pAddMem->m_szName);
  1172. g_Team[0].m_nMemNum++;
  1173. Player[CLIENT_PLAYER_INDEX].m_cTeam.DeleteOneFromApplyList(pAddMem->m_dwNpcID);
  1174. Player[CLIENT_PLAYER_INDEX].m_cTeam.UpdateInterface();
  1176. KSystemMessage sMsg;
  1177. sprintf(sMsg.szMessage, MSG_TEAM_ADD_MEMBER, pAddMem->m_szName);
  1178. sMsg.eType = SMT_NORMAL;
  1179. sMsg.byConfirmType = SMCT_NONE;
  1180. sMsg.byPriority = 0;
  1181. sMsg.byParamSize = 0;
  1182. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1183. }
  1185. //-------------------------------------------------------------------------
  1186. // 功能：收到服务器通知更换队长
  1187. //-------------------------------------------------------------------------
  1188. void KProtocolProcess::s2cTeamChangeCaptain(BYTE* pMsg)
  1189. {
  1190. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag)
  1191. {
  1192. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1193. return;
  1194. }
  1196. int nLevel, nMemNo;
  1197. char szName[32];
  1198. PLAYER_TEAM_CHANGE_CAPTAIN *pChange = (PLAYER_TEAM_CHANGE_CAPTAIN*)pMsg;
  1200. nMemNo = g_Team[0].FindMemberID(pChange->m_dwCaptainID);
  1201. // 当前队伍数据有误
  1202. if ((DWORD)g_Team[0].m_nCaptain != pChange->m_dwMemberID || nMemNo < 0)
  1203. {
  1204. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1205. return;
  1206. }
  1208. // 自己被任命为队长
  1209. if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID == pChange->m_dwCaptainID)
  1210. {
  1211. KSystemMessage sMsg;
  1212. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN_SELF, g_Team[0].m_szMemName[0]);
  1213. sMsg.eType = SMT_TEAM;
  1214. sMsg.byConfirmType = SMCT_UI_TEAM;
  1215. sMsg.byPriority = 3;
  1216. sMsg.byParamSize = 0;
  1217. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1218. }
  1219. else // 别人被任命为队长
  1220. {
  1221. KSystemMessage sMsg;
  1222. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN, g_Team[0].m_szMemName[nMemNo + 1]);
  1223. sMsg.eType = SMT_TEAM;
  1224. sMsg.byConfirmType = SMCT_UI_TEAM;
  1225. sMsg.byPriority = 3;
  1226. sMsg.byParamSize = 0;
  1227. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1228. }
  1230. // 更换人员
  1231. nLevel = g_Team[0].m_nMemLevel[0];
  1232. strcpy(szName, g_Team[0].m_szMemName[0]);
  1233. g_Team[0].m_nCaptain = pChange->m_dwCaptainID;
  1234. g_Team[0].m_nMemLevel[0] = g_Team[0].m_nMemLevel[nMemNo + 1];
  1235. strcpy(g_Team[0].m_szMemName[0], g_Team[0].m_szMemName[nMemNo + 1]);
  1236. g_Team[0].m_nMember[nMemNo] = pChange->m_dwMemberID;
  1237. g_Team[0].m_nMemLevel[nMemNo + 1] = nLevel;
  1238. strcpy(g_Team[0].m_szMemName[nMemNo + 1], szName);
  1240. if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID == pChange->m_dwCaptainID)
  1241. {
  1242. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_CAPTAIN;
  1243. Player[CLIENT_PLAYER_INDEX].m_cTeam.ReleaseList();
  1244. }
  1245. else if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID == pChange->m_dwMemberID)
  1246. {
  1247. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_MEMBER;
  1248. Player[CLIENT_PLAYER_INDEX].m_cTeam.ReleaseList();
  1249. }
  1251. Player[CLIENT_PLAYER_INDEX].m_cTeam.UpdateInterface();
  1252. }
  1254. //-------------------------------------------------------------------------
  1255. // 功能：收到服务器发来的自己队伍的组队情况，更新相应信息
  1256. //-------------------------------------------------------------------------
  1257. void KProtocolProcess::s2cUpdataSelfTeamInfo(BYTE* pMsg)
  1258. {
  1259. int i;
  1260. PLAYER_SEND_SELF_TEAM_INFO *pSelfInfo = (PLAYER_SEND_SELF_TEAM_INFO*)pMsg;
  1262. // 数据包出错
  1263. if (pSelfInfo->m_dwNpcID[0] == 0)
  1264. return;
  1266. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 1;
  1267. Player[CLIENT_PLAYER_INDEX].m_dwLeadExp = pSelfInfo->m_dwLeadExp;
  1268. Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel = PlayerSet.m_cLeadExp.GetLevel(Player[CLIENT_PLAYER_INDEX].m_dwLeadExp);
  1269. Player[CLIENT_PLAYER_INDEX].m_dwNextLevelLeadExp = PlayerSet.m_cLeadExp.GetLevelExp(Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel);
  1270. if (Player[CLIENT_PLAYER_INDEX].m_dwNextLevelLeadExp == 0)
  1271. Player[CLIENT_PLAYER_INDEX].m_dwNextLevelLeadExp = Player[CLIENT_PLAYER_INDEX].m_dwLeadLevel;
  1273. if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID == pSelfInfo->m_dwNpcID[0]) // 队长
  1274. {
  1275. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_CAPTAIN;
  1276. }
  1277. else // 队员
  1278. {
  1279. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_MEMBER;
  1280. for (i = 0; i < MAX_TEAM_APPLY_LIST; i++)
  1281. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_sApplyList[i].Release();
  1282. }
  1283. g_Team[0].m_nCaptain = pSelfInfo->m_dwNpcID[0];
  1284. if (pSelfInfo->m_btState == 0)
  1285. g_Team[0].SetTeamClose();
  1286. else
  1287. g_Team[0].SetTeamOpen();
  1288. g_Team[0].m_nTeamServerID = pSelfInfo->nTeamServerID;
  1289. g_Team[0].m_nMemLevel[0] = (DWORD)pSelfInfo->m_btLevel[0];
  1290. strcpy(g_Team[0].m_szMemName[0], pSelfInfo->m_szNpcName[0]);
  1291. g_Team[0].m_nMemNum = 0;
  1292. for (i = 0; i < MAX_TEAM_MEMBER; i++)
  1293. {
  1294. if (pSelfInfo->m_dwNpcID[i + 1] > 0)
  1295. {
  1296. g_Team[0].m_nMember[i] = pSelfInfo->m_dwNpcID[i + 1];
  1297. g_Team[0].m_nMemLevel[i + 1] = (DWORD)pSelfInfo->m_btLevel[i + 1];
  1298. strcpy(g_Team[0].m_szMemName[i + 1], pSelfInfo->m_szNpcName[i + 1]);
  1299. g_Team[0].m_nMemNum++;
  1300. }
  1301. else
  1302. {
  1303. g_Team[0].m_nMember[i] = -1;
  1304. g_Team[0].m_nMemLevel[i + 1] = 0;
  1305. g_Team[0].m_szMemName[i + 1][0] = 0;
  1306. }
  1307. }
  1308. Player[CLIENT_PLAYER_INDEX].m_cTeam.UpdateInterface();
  1309. }
  1311. void KProtocolProcess::SyncCurNormalData(BYTE* pMsg)
  1312. {
  1313. CURPLAYER_NORMAL_SYNC *pSync = (CURPLAYER_NORMAL_SYNC*)pMsg;
  1314. if (pSync->m_shLife > 0)
  1315. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentLife = pSync->m_shLife;
  1316. else
  1317. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentLife = 0;
  1318. if (pSync->m_shStamina > 0)
  1319. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentStamina = pSync->m_shStamina;
  1320. else
  1321. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentStamina = 0;
  1323. if (pSync->m_shMana > 0)
  1324. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentMana = pSync->m_shMana;
  1325. else
  1326. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentMana = 0;
  1328. // if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_Doing == do_sit)
  1329. // {
  1330. // if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentLife >= Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentLifeMax &&
  1331. // Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentMana >= Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_CurrentManaMax)
  1332. // {
  1333. // Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SendCommand(do_stand);
  1334. // }
  1335. // }
  1337. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  1338. switch (pSync->m_btTeamData)
  1339. {
  1340. case 0x00:
  1341. if ( Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag )
  1342. {
  1343. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 0;
  1344. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1345. }
  1346. break;
  1347. case 0x03:
  1348. if ( !Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag || Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure != TEAM_CAPTAIN)
  1349. {
  1350. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 1;
  1351. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_CAPTAIN;
  1352. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1353. }
  1354. break;
  1355. case 0x01:
  1356. if ( !Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag || Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure != TEAM_MEMBER)
  1357. {
  1358. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag = 1;
  1359. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure = TEAM_MEMBER;
  1360. Player[CLIENT_PLAYER_INDEX].ApplySelfTeamInfo();
  1361. }
  1362. break;
  1363. }
  1364. }
  1366. void KProtocolProcess::SyncCurPlayer(BYTE* pMsg)
  1367. {
  1368. Player[CLIENT_PLAYER_INDEX].SyncCurPlayer(pMsg);
  1369. }
  1371. void KProtocolProcess::SyncNpc(BYTE* pMsg)
  1372. {
  1373. NPC_SYNC* NpcSync = (NPC_SYNC *)pMsg;
  1375. /*
  1376. int nRegion = SubWorld[0].FindRegion(NpcSync->RegionID);
  1377. // 如果Region不存在，说明这个包可能有问题，不处理了。
  1378. if (nRegion == -1)
  1379. return;
  1380. */
  1381. int nRegion, nMapX, nMapY, nOffX, nOffY;
  1382. SubWorld[0].Mps2Map(NpcSync->MapX, NpcSync->MapY, &nRegion, &nMapX, &nMapY, &nOffX, &nOffY);
  1384. if (nRegion == -1)
  1385. return;
  1387. int nIdx = NpcSet.SearchID(NpcSync->ID);
  1388. if (!nIdx)
  1389. {
  1390. nIdx = NpcSet.Add(NpcSync->NpcSettingIdx, 0, NpcSync->MapX, NpcSync->MapY);
  1391. Npc[nIdx].m_dwID = NpcSync->ID;
  1392. Npc[nIdx].m_Kind = NpcSync->m_btKind;
  1393. Npc[nIdx].m_Height = 0;
  1395. if (NpcSet.IsNpcRequestExist(NpcSync->ID))
  1396. NpcSet.RemoveNpcRequest(NpcSync->ID);
  1397. }
  1398. else
  1399. {
  1400. if (Npc[nIdx].m_RegionIndex >= 0)
  1401. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].DecRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1403. Npc[nIdx].m_MapX = nMapX;
  1404. Npc[nIdx].m_MapY = nMapY;
  1405. Npc[nIdx].m_OffX = nOffX;
  1406. Npc[nIdx].m_OffY = nOffY;
  1408. Npc[nIdx].m_NpcSettingIdx = (short)HIWORD(NpcSync->NpcSettingIdx);
  1409. Npc[nIdx].m_Level = LOWORD(NpcSync->NpcSettingIdx);
  1411. if (Npc[nIdx].m_RegionIndex >= 0)
  1412. {
  1413. if (Npc[nIdx].m_RegionIndex != nRegion)
  1414. {
  1415. // zroc change
  1416. SubWorld[0].NpcChangeRegion(SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].m_RegionID, SubWorld[0].m_Region[nRegion].m_RegionID, nIdx);
  1417. Npc[nIdx].m_RegionIndex = nRegion;
  1418. }
  1419. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].AddRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1420. }
  1421. else
  1422. {
  1423. SubWorld[0].m_Region[nRegion].AddNpc(nIdx);
  1424. Npc[nIdx].m_RegionIndex = nRegion;
  1425. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].AddRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1426. }
  1428. }
  1429. Npc[nIdx].m_Camp = (NPCCAMP)NpcSync->Camp;
  1430. Npc[nIdx].m_CurrentCamp = (NPCCAMP)NpcSync->CurrentCamp;
  1431. Npc[nIdx].m_Series = NpcSync->m_bySeries;
  1432. // Npc[nIdx].m_NpcEnchant = NpcSync->NpcEnchant;
  1433. Npc[nIdx].m_cGold.SetGoldCurrentType(NpcSync->NpcEnchant);
  1435. if (NpcSync->LifePerCent <= 128)
  1436. Npc[nIdx].m_CurrentLife = (Npc[nIdx].m_CurrentLifeMax * NpcSync->LifePerCent) >> 7 ;
  1437. else
  1438. Npc[nIdx].m_CurrentLife = 0;
  1440. if (Npc[nIdx].m_Doing != do_death || Npc[nIdx].m_Doing != do_revive) // need check later -- spe 03/05/27
  1441. Npc[nIdx].SendCommand((NPCCMD)NpcSync->m_Doing, NpcSync->MapX, NpcSync->MapY);
  1443. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  1444. Npc[nIdx].SetMenuState(NpcSync->m_btMenuState);
  1445. memset(Npc[nIdx].Name, 0, sizeof(Npc[nIdx].Name));
  1446. memcpy(Npc[nIdx].Name, NpcSync->m_szName, NpcSync->m_wLength - (sizeof(NPC_SYNC) - 1 - sizeof(NpcSync->m_szName)));
  1447. }
  1449. void KProtocolProcess::SyncNpcMin(BYTE* pMsg)
  1450. {
  1451. NPC_NORMAL_SYNC* NpcSync = (NPC_NORMAL_SYNC *)pMsg;
  1453. // if (NpcSync->ID == Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  1454. // return;
  1456. if (NpcSync->Doing == do_revive || NpcSync->Doing == do_death)
  1457. return;
  1459. int nIdx = NpcSet.SearchID(NpcSync->ID);
  1460. if (!nIdx)
  1461. {
  1462. // 向服务器请求同步这个NPC的全部数据
  1463. if (!NpcSet.IsNpcRequestExist(NpcSync->ID))
  1464. {
  1465. SendClientCmdRequestNpc(NpcSync->ID);
  1466. NpcSet.InsertNpcRequest(NpcSync->ID);
  1467. }
  1468. }
  1469. else
  1470. {
  1471. // int nRegion = SubWorld[0].FindRegion(NpcSync->RegionID);
  1472. int nRegion, nMapX, nMapY, nOffX, nOffY;
  1473. SubWorld[0].Mps2Map(NpcSync->MapX, NpcSync->MapY, &nRegion, &nMapX, &nMapY, &nOffX, &nOffY);
  1475. if (Npc[nIdx].m_RegionIndex == -1 && nIdx != Player[CLIENT_PLAYER_INDEX].m_nIndex)
  1476. {
  1477. if (nRegion == -1)
  1478. {
  1479. return;
  1480. }
  1481. else
  1482. {
  1483. Npc[nIdx].m_MapX = nMapX;
  1484. Npc[nIdx].m_MapY = nMapY;
  1485. Npc[nIdx].m_OffX = nOffX;
  1486. Npc[nIdx].m_OffY = nOffY;
  1487. Npc[nIdx].m_RegionIndex = nRegion;
  1488. Npc[nIdx].m_dwRegionID = SubWorld[0].m_Region[nRegion].m_RegionID;
  1489. SubWorld[0].m_Region[nRegion].AddNpc(nIdx);
  1490. SubWorld[0].m_Region[nRegion].AddRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1491. }
  1493. if (NpcSync->Doing == do_stand)
  1494. Npc[nIdx].ProcNetCommand(do_stand);
  1495. }
  1496. else
  1497. {
  1498. if (Npc[nIdx].m_RegionIndex != nRegion && nIdx != Player[CLIENT_PLAYER_INDEX].m_nIndex)
  1499. {
  1500. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].RemoveNpc(nIdx);
  1501. SubWorld[0].m_Region[Npc[nIdx].m_RegionIndex].DecRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1502. Npc[nIdx].m_MapX = nMapX;
  1503. Npc[nIdx].m_MapY = nMapY;
  1504. Npc[nIdx].m_OffX = nOffX;
  1505. Npc[nIdx].m_OffY = nOffY;
  1506. Npc[nIdx].m_RegionIndex = nRegion;
  1507. if (nRegion >= 0)
  1508. {
  1509. SubWorld[0].m_Region[nRegion].AddNpc(nIdx);
  1510. Npc[nIdx].m_dwRegionID = SubWorld[0].m_Region[nRegion].m_RegionID;
  1511. SubWorld[0].m_Region[nRegion].AddRef(Npc[nIdx].m_MapX, Npc[nIdx].m_MapY, obj_npc);
  1512. }
  1513. }
  1514. }
  1516. if (nIdx != Player[CLIENT_PLAYER_INDEX].m_nIndex) // 非玩家
  1517. {
  1518. int nOldLife = Npc[nIdx].m_CurrentLife;
  1519. if (NpcSync->LifePerCent <= 128)
  1520. {
  1521. Npc[nIdx].m_CurrentLife = (Npc[nIdx].m_CurrentLifeMax * NpcSync->LifePerCent) >> 7;
  1522. }
  1523. else
  1524. {
  1525. Npc[nIdx].m_CurrentLife = 0;
  1526. }
  1527. // 冒血处理
  1528. if (Npc[nIdx].m_Kind == kind_normal)
  1529. {
  1530. Npc[nIdx].SetBlood(nOldLife - Npc[nIdx].m_CurrentLife);
  1531. }
  1532. Npc[nIdx].m_CurrentCamp = NpcSync->Camp;
  1533. }
  1534. Npc[nIdx].m_FreezeState.nTime = NpcSync->State & STATE_FREEZE;
  1535. Npc[nIdx].m_PoisonState.nTime = NpcSync->State & STATE_POISON;
  1536. Npc[nIdx].m_ConfuseState.nTime =NpcSync->State & STATE_CONFUSE;
  1537. Npc[nIdx].m_StunState.nTime = NpcSync->State & STATE_STUN;
  1538. Npc[nIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  1539. }
  1540. }
  1542. //-------------------------------------------------------------------------
  1543. // 功能：收到服务器消息同步本玩家npc数据
  1544. //-------------------------------------------------------------------------
  1545. void KProtocolProcess::SyncNpcMinPlayer(BYTE* pMsg)
  1546. {
  1547. NPC_PLAYER_TYPE_NORMAL_SYNC *pSync = (NPC_PLAYER_TYPE_NORMAL_SYNC*)pMsg;
  1549. _ASSERT(pSync->m_dwNpcID == Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID);
  1550. if (pSync->m_dwNpcID != Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  1551. return;
  1553. int nRegion, nMapX, nMapY, nOffX, nOffY, nNpcIdx;
  1554. SubWorld[0].Mps2Map(pSync->m_dwMapX, pSync->m_dwMapY, &nRegion, &nMapX, &nMapY, &nOffX, &nOffY);
  1556. nNpcIdx = Player[CLIENT_PLAYER_INDEX].m_nIndex;
  1558. // 切换地图了，主角的RegionIndex为-1
  1559. if (Npc[nNpcIdx].m_RegionIndex == -1)
  1560. {
  1561. //nRegionIdx = SubWorld[0].FindRegion(pSync->m_nRegionID);
  1562. if (nRegion < 0)
  1563. {
  1564. // 刚刚换的地图，这个时候应该能找得到region，如果找不到，说明数据包可能出错了
  1565. // _ASSERT(0);
  1566. return;
  1567. }
  1568. Npc[nNpcIdx].m_RegionIndex = nRegion;
  1569. Npc[nNpcIdx].m_dwRegionID = SubWorld[0].m_Region[nRegion].m_RegionID;
  1570. //pSync->m_nRegionID;
  1571. SubWorld[0].NpcChangeRegion(-1, SubWorld[0].m_Region[nRegion].m_RegionID, nNpcIdx);
  1572. SubWorld[0].m_Region[nRegion].AddRef(nMapX, nMapY, obj_npc);
  1574. Npc[nNpcIdx].m_MapX = nMapX;
  1575. Npc[nNpcIdx].m_MapY = nMapY;
  1576. Npc[nNpcIdx].m_OffX = pSync->m_wOffX;
  1577. Npc[nNpcIdx].m_OffY = pSync->m_wOffY;
  1578. memset(&Npc[nNpcIdx].m_sSyncPos, 0, sizeof(Npc[nNpcIdx].m_sSyncPos));
  1579. Npc[nNpcIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  1580. return;
  1581. }
  1583. // 跳太远，超出9屏范围
  1584. //nRegionIdx = SubWorld[0].FindRegion(pSync->m_nRegionID);
  1585. if (nRegion == -1)
  1586. {
  1587. SubWorld[0].m_Region[Npc[nNpcIdx].m_RegionIndex].DecRef(Npc[nNpcIdx].m_MapX, Npc[nNpcIdx].m_MapY, obj_npc);
  1589. int nRegionX = pSync->m_dwMapX / (SubWorld[0].m_nCellWidth * SubWorld[0].m_nRegionWidth);
  1590. int nRegionY = pSync->m_dwMapY / (SubWorld[0].m_nCellHeight * SubWorld[0].m_nRegionHeight);
  1592. DWORD dwRegionID = MAKELONG(nRegionX, nRegionY);
  1593. SubWorld[0].LoadMap(SubWorld[0].m_SubWorldID, dwRegionID);
  1595. // SubWorld[0].LoadMap(SubWorld[0].m_SubWorldID, pSync->m_nRegionID);
  1596. nRegion = SubWorld[0].FindRegion(dwRegionID);
  1597. _ASSERT(nRegion >= 0);
  1598. Npc[nNpcIdx].m_RegionIndex = nRegion;
  1599. Npc[nNpcIdx].m_dwRegionID = dwRegionID;//pSync->m_nRegionID;
  1600. SubWorld[0].NpcChangeRegion(-1, SubWorld[0].m_Region[nRegion].m_RegionID, nNpcIdx);
  1602. SubWorld[0].Mps2Map(pSync->m_dwMapX, pSync->m_dwMapY, &nRegion, &nMapX, &nMapY, &nOffX, &nOffY);
  1603. Npc[nNpcIdx].m_MapX = nMapX;
  1604. Npc[nNpcIdx].m_MapY = nMapY;
  1605. Npc[nNpcIdx].m_OffX = pSync->m_wOffX;
  1606. Npc[nNpcIdx].m_OffY = pSync->m_wOffY;
  1608. SubWorld[0].m_Region[Npc[nNpcIdx].m_RegionIndex].AddRef(Npc[nNpcIdx].m_MapX, Npc[nNpcIdx].m_MapY, obj_npc);
  1609. memset(&Npc[nNpcIdx].m_sSyncPos, 0, sizeof(Npc[nNpcIdx].m_sSyncPos));
  1610. Npc[nNpcIdx].m_SyncSignal = SubWorld[0].m_dwCurrentTime;
  1612. return;
  1613. }
  1615. BYTE byBarrier = SubWorld[0].m_Region[Npc[nNpcIdx].m_RegionIndex].GetBarrier(Npc[nNpcIdx].m_MapX, Npc[nNpcIdx].m_MapY, Npc[nNpcIdx].m_OffX, Npc[nNpcIdx].m_OffY);
  1616. if (0 != byBarrier && Obstacle_JumpFly != byBarrier)
  1617. {
  1618. g_DebugLog("[Barrier]Player in Barrier");
  1619. }
  1620. }
  1622. //-------------------------------------------------------------------------
  1623. // 功能：收到服务器消息添加一个obj
  1624. //-------------------------------------------------------------------------
  1625. void KProtocolProcess::SyncObjectAdd(BYTE* pMsg)
  1626. {
  1627. OBJ_ADD_SYNC *pObjSyncAdd = (OBJ_ADD_SYNC*)pMsg;
  1628. int nObjIndex;
  1629. KObjItemInfo sInfo;
  1631. nObjIndex = ObjSet.FindID(pObjSyncAdd->m_nID);
  1632. if (nObjIndex > 0)
  1633. return;
  1635. sInfo.m_nItemID = pObjSyncAdd->m_nItemID;
  1636. sInfo.m_nItemWidth = pObjSyncAdd->m_btItemWidth;
  1637. sInfo.m_nItemHeight = pObjSyncAdd->m_btItemHeight;
  1638. sInfo.m_nMoneyNum = pObjSyncAdd->m_nMoneyNum;
  1639. sInfo.m_nColorID = pObjSyncAdd->m_btColorID;
  1640. sInfo.m_nMovieFlag = ((pObjSyncAdd->m_btFlag & 0x02) > 0 ? 1 : 0);
  1641. sInfo.m_nSoundFlag = ((pObjSyncAdd->m_btFlag & 0x01) > 0 ? 1 : 0);
  1642. memset(sInfo.m_szName, 0, sizeof(sInfo.m_szName));
  1643. memcpy(sInfo.m_szName, pObjSyncAdd->m_szName, pObjSyncAdd->m_wLength + 1 + sizeof(pObjSyncAdd->m_szName) - sizeof(OBJ_ADD_SYNC));
  1645. nObjIndex = ObjSet.ClientAdd(
  1646. pObjSyncAdd->m_nID,
  1647. pObjSyncAdd->m_nDataID,
  1648. pObjSyncAdd->m_btState,
  1649. pObjSyncAdd->m_btDir,
  1650. pObjSyncAdd->m_wCurFrame,
  1651. pObjSyncAdd->m_nXpos,
  1652. pObjSyncAdd->m_nYpos,
  1653. sInfo);
  1654. #ifdef WAIGUA_ZROC
  1655. if (nObjIndex <= 0)
  1656. return;
  1657. PLAYER_PICKUP_ITEM_COMMAND sPickUp;
  1658. if (Object[nObjIndex].m_nKind == Obj_Kind_Money)
  1659. {
  1660. // sPickUp.ProtocolType = c2s_playerpickupitem;
  1661. // sPickUp.m_nObjID = Object[nObjIndex].m_nID;
  1662. // sPickUp.m_btPosType = 0;
  1663. // sPickUp.m_btPosX = 0;
  1664. // sPickUp.m_btPosY = 0;
  1665. // if (g_pClient)
  1666. // g_pClient->SendPackToServer(&sPickUp, sizeof(PLAYER_PICKUP_ITEM_COMMAND));
  1667. }
  1668. else if (Object[nObjIndex].m_nKind == Obj_Kind_Item)
  1669. {
  1670. ItemPos sItemPos;
  1671. if ( FALSE == Player[CLIENT_PLAYER_INDEX].m_ItemList.SearchPosition(Object[nObjIndex].m_nItemWidth, Object[nObjIndex].m_nItemHeight, &sItemPos) )
  1672. return;
  1673. sPickUp.ProtocolType = c2s_playerpickupitem;
  1674. sPickUp.m_nObjID = Object[nObjIndex].m_nID;
  1675. sPickUp.m_btPosType = sItemPos.nPlace;
  1676. sPickUp.m_btPosX = sItemPos.nX;
  1677. sPickUp.m_btPosY = sItemPos.nY;
  1678. if (g_pClient)
  1679. g_pClient->SendPackToServer(&sPickUp, sizeof(PLAYER_PICKUP_ITEM_COMMAND));
  1680. }
  1681. #endif
  1682. }
  1684. //-------------------------------------------------------------------------
  1685. // 功能：收到服务器消息更新某个obj方向
  1686. //-------------------------------------------------------------------------
  1687. void KProtocolProcess::SyncObjectDir(BYTE* pMsg)
  1688. {
  1689. OBJ_SYNC_DIR *pObjSyncDir = (OBJ_SYNC_DIR*)pMsg;
  1690. int nObjIndex;
  1691. nObjIndex = ObjSet.FindID(pObjSyncDir->m_nID);
  1692. if (nObjIndex <= 0)
  1693. {
  1694. // 向服务器发添加请求
  1695. OBJ_CLIENT_SYNC_ADD sObjClientSyncAdd;
  1696. sObjClientSyncAdd.ProtocolType = c2s_requestobj;
  1697. sObjClientSyncAdd.m_nID = pObjSyncDir->m_nID;
  1698. if (g_pClient)
  1699. g_pClient->SendPackToServer(&sObjClientSyncAdd, sizeof(sObjClientSyncAdd));
  1700. }
  1701. else
  1702. { // 同步方向
  1703. Object[nObjIndex].SetDir(pObjSyncDir->m_btDir);
  1704. }
  1705. }
  1707. //-------------------------------------------------------------------------
  1708. // 功能：收到服务器消息删除某个obj
  1709. //-------------------------------------------------------------------------
  1710. void KProtocolProcess::SyncObjectRemove(BYTE* pMsg)
  1711. {
  1712. OBJ_SYNC_REMOVE *pObjSyncRemove = (OBJ_SYNC_REMOVE*)pMsg;
  1713. int nObjIndex;
  1714. nObjIndex = ObjSet.FindID(pObjSyncRemove->m_nID);
  1715. if (nObjIndex > 0)
  1716. { // 删除
  1717. Object[nObjIndex].Remove(pObjSyncRemove->m_btSoundFlag);
  1718. }
  1719. }
  1721. //-------------------------------------------------------------------------
  1722. // 功能：收到服务器消息更新某个obj状态
  1723. //-------------------------------------------------------------------------
  1724. void KProtocolProcess::SyncObjectState(BYTE* pMsg)
  1725. {
  1726. OBJ_SYNC_STATE *pObjSyncState = (OBJ_SYNC_STATE*)pMsg;
  1727. int nObjIndex;
  1728. nObjIndex = ObjSet.FindID(pObjSyncState->m_nID);
  1729. if (nObjIndex <= 0)
  1730. {
  1731. // 向服务器发添加请求
  1732. OBJ_CLIENT_SYNC_ADD sObjClientSyncAdd;
  1733. sObjClientSyncAdd.ProtocolType = c2s_requestobj;
  1734. sObjClientSyncAdd.m_nID = pObjSyncState->m_nID;
  1735. if (g_pClient)
  1736. g_pClient->SendPackToServer(&sObjClientSyncAdd, sizeof(sObjClientSyncAdd));
  1737. }
  1738. else
  1739. { // 同步状态
  1740. if (Object[nObjIndex].m_nRegionIdx == -1)
  1741. {
  1742. int nRegion;
  1743. nRegion = SubWorld[0].FindRegion(Object[nObjIndex].m_nBelongRegion);
  1744. if (nRegion >= 0)
  1745. {
  1746. Object[nObjIndex].m_nRegionIdx = nRegion;
  1747. SubWorld[0].m_Region[nRegion].AddObj(nObjIndex);
  1748. }
  1749. }
  1750. Object[nObjIndex].SetState(pObjSyncState->m_btState);
  1751. }
  1752. }
  1754. //-------------------------------------------------------------------------
  1755. // 功能：收到服务器消息同步某个 trap 类 obj 的数据
  1756. //-------------------------------------------------------------------------
  1757. void KProtocolProcess::SyncObjectTrap(BYTE* pMsg)
  1758. {
  1759. OBJ_SYNC_TRAP_ACT *pObjTrapSync = (OBJ_SYNC_TRAP_ACT*)pMsg;
  1760. int nObjIndex;
  1761. nObjIndex = ObjSet.FindID(pObjTrapSync->m_nID);
  1762. if (nObjIndex <= 0)
  1763. {
  1764. // 向服务器发添加请求
  1765. OBJ_CLIENT_SYNC_ADD sObjClientSyncAdd;
  1766. sObjClientSyncAdd.ProtocolType = c2s_requestobj;
  1767. sObjClientSyncAdd.m_nID = pObjTrapSync->m_nID;
  1768. if (g_pClient)
  1769. g_pClient->SendPackToServer(&sObjClientSyncAdd, sizeof(sObjClientSyncAdd));
  1770. }
  1771. else
  1772. {
  1773. Object[nObjIndex].m_nState = OBJ_TRAP_STATE_ACTING;
  1774. Object[nObjIndex].m_cImage.SetDirStart();
  1775. Object[nObjIndex].m_cSkill.m_nTarX = pObjTrapSync->m_nTarX;
  1776. Object[nObjIndex].m_cSkill.m_nTarY = pObjTrapSync->m_nTarY;
  1777. }
  1778. }
  1780. void KProtocolProcess::SyncPlayer(BYTE* pMsg)
  1781. {
  1782. PLAYER_SYNC* pPlaySync = (PLAYER_SYNC *)pMsg;
  1784. int nIdx = NpcSet.SearchID(pPlaySync->ID);
  1786. Npc[nIdx].m_ArmorType = pPlaySync->ArmorType;
  1787. Npc[nIdx].m_AttackSpeed = pPlaySync->AttackSpeed;
  1788. Npc[nIdx].m_CastSpeed = pPlaySync->CastSpeed;
  1789. Npc[nIdx].m_HelmType = pPlaySync->HelmType;
  1790. Npc[nIdx].m_HorseType = (char)pPlaySync->HorseType;
  1791. Npc[nIdx].m_CurrentRunSpeed = pPlaySync->RunSpeed;
  1792. Npc[nIdx].m_CurrentWalkSpeed = pPlaySync->WalkSpeed;
  1793. Npc[nIdx].m_WeaponType = pPlaySync->WeaponType;
  1794. Npc[nIdx].m_Kind = kind_player;
  1795. Npc[nIdx].m_btRankId = pPlaySync->RankID;
  1796. if (Npc[nIdx].m_HorseType == -1)
  1797. Npc[nIdx].m_bRideHorse = FALSE;
  1798. else
  1799. Npc[nIdx].m_bRideHorse = TRUE;
  1800. if (pPlaySync->m_btSomeFlag & 0x01)
  1801. Npc[nIdx].m_nPKFlag = 1;
  1802. else
  1803. Npc[nIdx].m_nPKFlag = 0;
  1804. if (pPlaySync->m_btSomeFlag & 0x02)
  1805. Npc[nIdx].m_FightMode = 1;
  1806. else
  1807. Npc[nIdx].m_FightMode = 0;
  1808. if (pPlaySync->m_btSomeFlag & 0x04)
  1809. Npc[nIdx].SetSleepMode(1);
  1810. else
  1811. Npc[nIdx].SetSleepMode(0);
  1813. }
  1815. void KProtocolProcess::SyncPlayerMin(BYTE* pMsg)
  1816. {
  1817. PLAYER_NORMAL_SYNC* pPlaySync = (PLAYER_NORMAL_SYNC *)pMsg;
  1819. int nIdx = NpcSet.SearchID(pPlaySync->ID);
  1821. Npc[nIdx].m_AttackSpeed = pPlaySync->AttackSpeed;
  1822. Npc[nIdx].m_CastSpeed = pPlaySync->CastSpeed;
  1823. Npc[nIdx].m_CurrentRunSpeed = pPlaySync->RunSpeed;
  1824. Npc[nIdx].m_CurrentWalkSpeed = pPlaySync->WalkSpeed;
  1825. Npc[nIdx].m_HelmType = pPlaySync->HelmType;
  1826. Npc[nIdx].m_ArmorType = pPlaySync->ArmorType;
  1827. Npc[nIdx].m_HorseType = (char)pPlaySync->HorseType;
  1828. Npc[nIdx].m_WeaponType = pPlaySync->WeaponType;
  1829. Npc[nIdx].m_Kind = kind_player;
  1830. Npc[nIdx].m_btRankId = pPlaySync->RankID;
  1831. if (Npc[nIdx].m_HorseType == -1)
  1832. Npc[nIdx].m_bRideHorse = FALSE;
  1833. else
  1834. Npc[nIdx].m_bRideHorse = TRUE;
  1836. if (pPlaySync->m_btSomeFlag & 0x01)
  1837. Npc[nIdx].m_nPKFlag = 1;
  1838. else
  1839. Npc[nIdx].m_nPKFlag = 0;
  1840. if (pPlaySync->m_btSomeFlag & 0x02)
  1841. Npc[nIdx].m_FightMode = 1;
  1842. else
  1843. Npc[nIdx].m_FightMode = 0;
  1844. if (pPlaySync->m_btSomeFlag & 0x04)
  1845. Npc[nIdx].SetSleepMode(1);
  1846. else
  1847. Npc[nIdx].SetSleepMode(0);
  1848. if (pPlaySync->m_btSomeFlag & 0x08)
  1849. Npc[nIdx].m_nTongFlag = 1;
  1850. else
  1851. Npc[nIdx].m_nTongFlag = 0;
  1852. }
  1854. void KProtocolProcess::SyncScriptAction(BYTE* pMsg)
  1855. {
  1856. Player[CLIENT_PLAYER_INDEX].OnScriptAction((PLAYER_SCRIPTACTION_SYNC *)pMsg);
  1857. }
  1859. void KProtocolProcess::SyncWorld(BYTE* pMsg)
  1860. {
  1861. WORLD_SYNC *WorldSync = (WORLD_SYNC *)pMsg;
  1863. if (Player[CLIENT_PLAYER_INDEX].m_nIndex > 0)
  1864. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SendCommand(do_stand);
  1865. if (SubWorld[0].m_SubWorldID != WorldSync->SubWorld)
  1866. {
  1867. SubWorld[0].LoadMap(WorldSync->SubWorld, WorldSync->Region);
  1868. /* SubWorld[0].m_Region[0].Load(WorldSync->SubWorld, WorldSync->Region);
  1869. SubWorld[0].m_Region[0].Init(SubWorld[0].m_nRegionWidth, SubWorld[0].m_nRegionHeight);
  1870. for (int i = 0; i < 8; i++)
  1871. {
  1872. if (SubWorld[0].m_Region[0].m_nConRegionID[i] == -1)
  1873. continue;
  1874. SubWorld[0].m_Region[i+1].Load(WorldSync->SubWorld, SubWorld[0].m_Region[0].m_nConRegionID[i]);
  1875. SubWorld[0].m_Region[i+1].Init(SubWorld[0].m_nRegionWidth, SubWorld[0].m_nRegionHeight);
  1876. }*/
  1877. }
  1879. if (SubWorld[0].m_dwCurrentTime > WorldSync->Frame)
  1880. {
  1881. // 客户端快了，减速处理，或者是Lag引起的旧消息，需要处理
  1882. }
  1883. else if (SubWorld[0].m_dwCurrentTime < WorldSync->Frame)
  1884. {
  1885. // 客户端慢了，加速处理
  1886. }
  1888. SubWorld[0].m_dwCurrentTime = WorldSync->Frame;
  1891. // 同步天气
  1892. SubWorld[0].m_nWeather = WorldSync->Weather;
  1893. g_ScenePlace.ChangeWeather(WorldSync->Weather);
  1894. }
  1896. //-------------------------------------------------------------------------
  1897. // 功能：收到服务器消息某玩家终止了与本客户端的好友关系
  1898. //-------------------------------------------------------------------------
  1899. void KProtocolProcess::s2cChatDeleteFriend(BYTE* pMsg)
  1900. {
  1901. CHAT_DELETE_FRIEND_SYNC *pDelete = (CHAT_DELETE_FRIEND_SYNC*)pMsg;
  1903. CChatFriend *pFriend;
  1904. for (int i = 0; i < MAX_FRIEND_TEAM; i++)
  1905. {
  1906. pFriend = (CChatFriend*)Player[CLIENT_PLAYER_INDEX].m_cChat.m_cFriendTeam[i].m_cEveryOne.GetHead();
  1907. while (pFriend)
  1908. {
  1909. if (pFriend->m_dwID == pDelete->m_dwID)
  1910. {
  1911. pFriend->Remove();
  1912. Player[CLIENT_PLAYER_INDEX].m_cChat.m_cFriendTeam[i].m_nFriendNo--;
  1914. // 通知界面 某玩家终止了与本客户端的好友关系
  1915. // CoreDataChanged(GDCNI_CHAT_GROUP, 0, 0);
  1916. CoreDataChanged(GDCNI_CHAT_FRIEND, 0, i);
  1918. KSystemMessage sMsg;
  1919. sprintf(sMsg.szMessage, MSG_CHAT_DELETED_FRIEND, pFriend->m_szName);
  1920. sMsg.eType = SMT_NORMAL;
  1921. sMsg.byConfirmType = SMCT_NONE;
  1922. sMsg.byPriority = 0;
  1923. sMsg.byParamSize = 0;
  1924. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  1926. delete pFriend;
  1927. return;
  1928. }
  1929. pFriend = (CChatFriend*)pFriend->GetNext();
  1930. }
  1931. }
  1932. }
  1934. //-------------------------------------------------------------------------
  1935. // 功能：收到服务器通知某聊天好友下线
  1936. //-------------------------------------------------------------------------
  1937. void KProtocolProcess::s2cChatFriendOffLine(BYTE* pMsg)
  1938. {
  1939. CHAT_FRIEND_OFFLINE_SYNC *pSync = (CHAT_FRIEND_OFFLINE_SYNC*)pMsg;
  1940. Player[CLIENT_PLAYER_INDEX].m_cChat.GetMsgOffLine(pSync->m_dwID);
  1941. }
  1943. void KProtocolProcess::s2cSyncAllSkill(BYTE * pMsg)
  1944. {
  1945. SKILL_SEND_ALL_SYNC * pSync = (SKILL_SEND_ALL_SYNC*) pMsg;
  1946. int nSkillCount = (pSync->m_wProtocolLong - 2) / sizeof(SKILL_SEND_ALL_SYNC_DATA);
  1947. int nNpcIndex = Player[CLIENT_PLAYER_INDEX].m_nIndex;
  1948. KSkill * pOrdinSkill = NULL;
  1949. Npc[nNpcIndex].m_SkillList.Clear();
  1950. for (int i = 0; i < nSkillCount; i ++)
  1951. {
  1952. if (pSync->m_sAllSkill[i].SkillId)
  1953. {
  1955. // pOrdinSkill = (KSkill *) g_SkillManager.GetSkill(pSync->m_sAllSkill[i].SkillId, pSync->m_sAllSkill[i].SkillLevel);
  1956. // if (!pOrdinSkill) 
  1957. //              continue;
  1959. Npc[nNpcIndex].m_SkillList.Add(
  1960. pSync->m_sAllSkill[i].SkillId,
  1961. pSync->m_sAllSkill[i].SkillLevel,
  1962. 0
  1963.             );
  1964. }
  1965. }
  1967. }
  1969. void KProtocolProcess::SyncEnd(BYTE* pMsg)
  1970. {
  1971. BYTE SyncEnd = (BYTE)c2s_syncend;
  1972. if (g_pClient)
  1973. g_pClient->SendPackToServer(&SyncEnd, sizeof(BYTE));
  1974. Player[CLIENT_PLAYER_INDEX].SetDefaultImmedSkill();
  1975. g_DebugLog("[TRACE]SyncEnd to Server");
  1976. CoreDataChanged(GDCNI_GAME_START, 0, 0);
  1977. // g_bPingReply = TRUE;
  1978. // 设定聊天订阅频道
  1979. // Player[CLIENT_PLAYER_INDEX].m_cChat.LoadTeamName(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  1980. // Player[CLIENT_PLAYER_INDEX].m_cChat.SaveTeamInfo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  1981. // Player[CLIENT_PLAYER_INDEX].m_cChat.LoadTakeChannelInfo(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  1983. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetInstantSpr(enumINSTANT_STATE_LOGIN);
  1985. // 开始播音乐
  1986. g_SubWorldSet.m_cMusic.Start(SubWorld[0].m_SubWorldID, SubWorld[0].m_dwCurrentTime, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_FightMode);
  1988. // PK初始化
  1989. Player[CLIENT_PLAYER_INDEX].m_cPK.Init();
  1992. }
  1994. void KProtocolProcess::s2cTradeChangeState(BYTE* pMsg)
  1995. {
  1996. Player[CLIENT_PLAYER_INDEX].s2cTradeChangeState(pMsg);
  1997. }
  1999. void KProtocolProcess::s2cNpcSetMenuState(BYTE* pMsg)
  2000. {
  2001. NPC_SET_MENU_STATE_SYNC *pState = (NPC_SET_MENU_STATE_SYNC*)pMsg;
  2002. int nNpc;
  2003. if (pState->m_dwID == Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  2004. {
  2005. nNpc = Player[CLIENT_PLAYER_INDEX].m_nIndex;
  2006. if (pState->m_btState == PLAYER_MENU_STATE_TRADEOPEN)
  2007. {
  2008. KSystemMessage sMsg;
  2009. sprintf(sMsg.szMessage, MSG_TRADE_STATE_OPEN);
  2010. sMsg.eType = SMT_NORMAL;
  2011. sMsg.byConfirmType = SMCT_NONE;
  2012. sMsg.byPriority = 0;
  2013. sMsg.byParamSize = 0;
  2014. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2015. }
  2016. else if (pState->m_btState == PLAYER_MENU_STATE_NORMAL)
  2017. {
  2018. if (Npc[nNpc].GetMenuState() == PLAYER_MENU_STATE_TRADEOPEN)
  2019. {
  2020. KSystemMessage sMsg;
  2021. sprintf(sMsg.szMessage, MSG_TRADE_STATE_CLOSE);
  2022. sMsg.eType = SMT_NORMAL;
  2023. sMsg.byConfirmType = SMCT_NONE;
  2024. sMsg.byPriority = 0;
  2025. sMsg.byParamSize = 0;
  2026. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2027. }
  2028. }
  2029. }
  2030. else
  2031. {
  2032. nNpc = NpcSet.SearchID(pState->m_dwID);
  2033. if (nNpc == 0)
  2034. return;
  2035. }
  2036. if (pState->m_wLength > sizeof(NPC_SET_MENU_STATE_SYNC) - 1 - sizeof(pState->m_szSentence))
  2037. Npc[nNpc].SetMenuState(pState->m_btState, pState->m_szSentence, pState->m_wLength - (sizeof(NPC_SET_MENU_STATE_SYNC) - 1 - sizeof(pState->m_szSentence)));
  2038. else
  2039. Npc[nNpc].SetMenuState(pState->m_btState);
  2040. }
  2042. void KProtocolProcess::s2cTradeMoneySync(BYTE* pMsg)
  2043. {
  2044. Player[CLIENT_PLAYER_INDEX].s2cTradeMoneySync(pMsg);
  2045. }
  2047. void KProtocolProcess::s2cTradeDecision(BYTE* pMsg)
  2048. {
  2049. Player[CLIENT_PLAYER_INDEX].s2cTradeDecision(pMsg);
  2050. Player[CLIENT_PLAYER_INDEX].m_ItemList.UnlockOperation();
  2051. }
  2053. void KProtocolProcess::s2cUpdateNpcState(BYTE * pMsg)
  2054. {
  2055. NPC_SYNC_STATEINFO * pInfo = (NPC_SYNC_STATEINFO*) pMsg;
  2056. int nIndex = NpcSet.SearchID(pInfo->m_ID);
  2058. if (nIndex > 0 && !Npc[nIndex].IsPlayer() && Npc[nIndex].m_RegionIndex >= 0)
  2059. {
  2060. Npc[nIndex].SetNpcState(pInfo->m_btStateInfo);
  2061. }
  2062. }
  2064. void KProtocolProcess::s2cTeamInviteAdd(BYTE * pMsg)
  2065. {
  2066. Player[CLIENT_PLAYER_INDEX].m_cTeam.ReceiveInvite((TEAM_INVITE_ADD_SYNC*)pMsg);
  2067. }
  2069. void KProtocolProcess::s2cTradePressOkSync(BYTE * pMsg)
  2070. {
  2071. TRADE_STATE_SYNC *pPress = (TRADE_STATE_SYNC*)pMsg;
  2072. Player[CLIENT_PLAYER_INDEX].m_cTrade.SetTradeState(pPress->m_btSelfLock, pPress->m_btDestLock, pPress->m_btSelfOk, pPress->m_btDestOk);
  2073. }
  2075. void KProtocolProcess::s2cDirectlyCastSkill(BYTE * pMsg)
  2076. {
  2077. DWORD dwNpcID;
  2078. int nSkillID, nSkillLevel;
  2079. DWORD MapX, MapY;
  2081. dwNpcID = *(DWORD *)&pMsg[1];
  2082. nSkillID = *(int *)&pMsg[5];
  2083. nSkillLevel = *(int *)&pMsg[9];
  2084. MapX = *(int *)&pMsg[13];
  2085. MapY = *(int *)&pMsg[17];
  2087. //当指定某个目标时(MapX == -1),MapY为目标的NpcdwID，需要转换成本地的NpcIndex才行
  2088. if (MapX == -1)
  2089. {
  2090. if (MapY < 0 ) return;
  2091. MapY = NpcSet.SearchID(MapY);
  2092. if (MapY == 0) return;
  2093. if (Npc[MapY].m_RegionIndex < 0)
  2094. return;
  2095. int nX, nY;
  2096. nX = Npc[MapY].m_MapX;
  2097. nY = Npc[MapY].m_MapY;
  2098. SubWorld[0].Map2Mps(Npc[MapY].m_RegionIndex, nX, nY, 0, 0, (int *)&MapX, (int *)&MapY);
  2099. }
  2101. int nIdx = NpcSet.SearchID(dwNpcID);
  2103. /// if (Player[CLIENT_PLAYER_INDEX].ConformIdx(nIdx))
  2104. {
  2105. _ASSERT (nSkillID > 0 && nSkillLevel > 0);
  2106. KSkill * pOrdinSkill = (KSkill *) g_SkillManager.GetSkill(nSkillID, nSkillLevel);
  2107. if (!pOrdinSkill) 
  2108.             return ;
  2110.         pOrdinSkill->Cast(nIdx, MapX, MapY);
  2111. }
  2113. }
  2115. void KProtocolProcess::s2cShowMsg(BYTE *pMsg)
  2116. {
  2117. if (!pMsg)
  2118. return;
  2119. SHOW_MSG_SYNC *pShowMsg = (SHOW_MSG_SYNC*)pMsg;
  2121. switch (pShowMsg->m_wMsgID)
  2122. {
  2123. case enumMSG_ID_TEAM_KICK_One:
  2124. {
  2125. char szName[32];
  2126. KSystemMessage sMsg;
  2128. memset(szName, 0, sizeof(szName));
  2129. memcpy(szName, pMsg + sizeof(SHOW_MSG_SYNC) - sizeof(LPVOID), pShowMsg->m_wLength + 1 + sizeof(LPVOID) - sizeof(SHOW_MSG_SYNC));
  2130. if (strcmp(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, szName) == 0)
  2131. {
  2132. sprintf(sMsg.szMessage, MSG_TEAM_BE_KICKEN);
  2133. sMsg.eType = SMT_TEAM;
  2134. sMsg.byConfirmType = SMCT_CLICK;
  2135. sMsg.byPriority = 1;
  2136. }
  2137. else
  2138. {
  2139. sprintf(sMsg.szMessage, MSG_TEAM_KICK_ONE, szName);
  2140. sMsg.eType = SMT_NORMAL;
  2141. sMsg.byConfirmType = SMCT_NONE;
  2142. sMsg.byPriority = 0;
  2143. }
  2144. sMsg.byParamSize = 0;
  2145. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2146. }
  2147. break;
  2148. case enumMSG_ID_TEAM_DISMISS:
  2149. {
  2150. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag)
  2151. break;
  2152. KSystemMessage sMsg;
  2153. if (Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFigure == TEAM_CAPTAIN)
  2154. {
  2155. sprintf(sMsg.szMessage, MSG_TEAM_DISMISS_CAPTAIN);
  2156. }
  2157. else
  2158. {
  2159. sprintf(sMsg.szMessage, MSG_TEAM_DISMISS_MEMBER, g_Team[0].m_szMemName[0]);
  2160. }
  2161. sMsg.eType = SMT_TEAM;
  2162. sMsg.byConfirmType = SMCT_CLICK;
  2163. sMsg.byPriority = 1;
  2164. sMsg.byParamSize = 0;
  2165. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2166. }
  2167. break;
  2168. case enumMSG_ID_TEAM_LEAVE:
  2169. {
  2170. if (!Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag)
  2171. break;
  2172. KSystemMessage sMsg;
  2173. DWORD dwID = *(DWORD*)(&pShowMsg->m_lpBuf);
  2174. if (Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID == dwID)
  2175. {
  2176. sprintf(sMsg.szMessage, MSG_TEAM_LEAVE_SELF_MSG, g_Team[0].m_szMemName[0]);
  2177. }
  2178. else
  2179. {
  2180. sprintf(sMsg.szMessage, MSG_TEAM_LEAVE, "有人");
  2181. for (int i = 0; i < MAX_TEAM_MEMBER; i++)
  2182. {
  2183. if ((DWORD)g_Team[0].m_nMember[i] == dwID)
  2184. {
  2185. sprintf(sMsg.szMessage, MSG_TEAM_LEAVE, g_Team[0].m_szMemName[i + 1]);
  2186. break;
  2187. }
  2188. }
  2189. }
  2190. sMsg.eType = SMT_NORMAL;
  2191. sMsg.byConfirmType = SMCT_NONE;
  2192. sMsg.byPriority = 0;
  2193. sMsg.byParamSize = 0;
  2194. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2195. }
  2196. break;
  2197. case enumMSG_ID_TEAM_REFUSE_INVITE:
  2198. {
  2199. char szName[32];
  2200. memset(szName, 0, sizeof(szName));
  2201. memcpy(szName, &pShowMsg->m_lpBuf, pShowMsg->m_wLength + 1 + sizeof(LPVOID) - sizeof(SHOW_MSG_SYNC));
  2203. KSystemMessage sMsg;
  2204. sprintf(sMsg.szMessage, MSG_TEAM_REFUSE_INVITE, szName);
  2205. sMsg.eType = SMT_NORMAL;
  2206. sMsg.byConfirmType = SMCT_NONE;
  2207. sMsg.byPriority = 0;
  2208. sMsg.byParamSize = 0;
  2209. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2210. }
  2211. break;
  2212. case enumMSG_ID_TEAM_SELF_ADD:
  2213. {
  2214. KSystemMessage sMsg;
  2215. sprintf(sMsg.szMessage, MSG_TEAM_SELF_ADD, g_Team[0].m_szMemName[0]);
  2216. sMsg.eType = SMT_TEAM;
  2217. sMsg.byConfirmType = SMCT_UI_TEAM;
  2218. sMsg.byPriority = 3;
  2219. sMsg.byParamSize = 0;
  2220. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2221. }
  2222. break;
  2223. case enumMSG_ID_TEAM_CHANGE_CAPTAIN_FAIL:
  2224. {
  2225. int nMember;
  2226. DWORD dwID = *(DWORD*)(&pShowMsg->m_lpBuf);
  2227. nMember = g_Team[0].FindMemberID(dwID);
  2228. if (nMember < 0)
  2229. break;
  2230. KSystemMessage sMsg;
  2231. sMsg.eType = SMT_NORMAL;
  2232. sMsg.byConfirmType = SMCT_NONE;
  2233. sMsg.byPriority = 0;
  2234. sMsg.byParamSize = 0;
  2236. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN_FAIL1);
  2237. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2238. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN_FAIL2, g_Team[0].m_szMemName[nMember + 1]);
  2239. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2240. }
  2241. break;
  2242. case enumMSG_ID_TEAM_CHANGE_CAPTAIN_FAIL2:
  2243. {
  2244. int nMember;
  2245. DWORD dwID = *(DWORD*)(&pShowMsg->m_lpBuf);
  2246. nMember = g_Team[0].FindMemberID(dwID);
  2247. if (nMember < 0)
  2248. break;
  2249. KSystemMessage sMsg;
  2250. sMsg.eType = SMT_NORMAL;
  2251. sMsg.byConfirmType = SMCT_NONE;
  2252. sMsg.byPriority = 0;
  2253. sMsg.byParamSize = 0;
  2255. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN_FAIL1);
  2256. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2257. sprintf(sMsg.szMessage, MSG_TEAM_CHANGE_CAPTAIN_FAIL3);
  2258. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2259. }
  2260. break;
  2261. case enumMSG_ID_OBJ_CANNOT_PICKUP:
  2262. {
  2263. KSystemMessage sMsg;
  2264. sMsg.eType = SMT_NORMAL;
  2265. sMsg.byConfirmType = SMCT_NONE;
  2266. sMsg.byPriority = 0;
  2267. sMsg.byParamSize = 0;
  2269. strcpy(sMsg.szMessage, MSG_OBJ_CANNOT_PICKUP);
  2270. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2271. }
  2272. break;
  2273. case enumMSG_ID_OBJ_TOO_FAR:
  2274. {
  2275. KSystemMessage sMsg;
  2276. sMsg.eType = SMT_NORMAL;
  2277. sMsg.byConfirmType = SMCT_NONE;
  2278. sMsg.byPriority = 0;
  2279. sMsg.byParamSize = 0;
  2280. strcpy(sMsg.szMessage, MSG_OBJ_TOO_FAR);
  2281. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2282. }
  2283. break;
  2284. case enumMSG_ID_DEC_MONEY:
  2285. {
  2286. KSystemMessage sMsg;
  2287. sMsg.eType = SMT_NORMAL;
  2288. sMsg.byConfirmType = SMCT_NONE;
  2289. sMsg.byPriority = 0;
  2290. sMsg.byParamSize = 0;
  2291. sprintf(sMsg.szMessage, MSG_DEC_MONEY, (int)pShowMsg->m_lpBuf);
  2292. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2293. }
  2294. break;
  2295. case enumMSG_ID_TRADE_SELF_ROOM_FULL:
  2296. {
  2297. KSystemMessage sMsg;
  2298. sprintf(sMsg.szMessage, MSG_TRADE_SELF_ROOM_FULL);
  2299. sMsg.eType = SMT_SYSTEM;
  2300. sMsg.byConfirmType = SMCT_CLICK;
  2301. sMsg.byPriority = 1;
  2302. sMsg.byParamSize = 0;
  2303. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2304. }
  2305. break;
  2306. case enumMSG_ID_TRADE_DEST_ROOM_FULL:
  2307. {
  2308. KSystemMessage sMsg;
  2309. sprintf(sMsg.szMessage, MSG_TRADE_DEST_ROOM_FULL, Player[CLIENT_PLAYER_INDEX].m_cTrade.m_szDestName);
  2310. sMsg.eType = SMT_NORMAL;
  2311. sMsg.byConfirmType = SMCT_NONE;
  2312. sMsg.byPriority = 0;
  2313. sMsg.byParamSize = 0;
  2314. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2315. }
  2316. break;
  2317. case enumMSG_ID_TRADE_REFUSE_APPLY:
  2318. {
  2319. int nIdx = NpcSet.SearchID(*((DWORD*)&pShowMsg->m_lpBuf));
  2320. if (nIdx <= 0)
  2321. return;
  2322. KSystemMessage sMsg;
  2323. sprintf(sMsg.szMessage, MSG_TRADE_REFUSE_APPLY, Npc[nIdx].Name);
  2324. sMsg.eType = SMT_NORMAL;
  2325. sMsg.byConfirmType = SMCT_NONE;
  2326. sMsg.byPriority = 0;
  2327. sMsg.byParamSize = 0;
  2328. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2329. }
  2330. break;
  2331. case enumMSG_ID_TRADE_TASK_ITEM:
  2332. {
  2333. KSystemMessage sMsg;
  2334. sprintf(sMsg.szMessage, MSG_TRADE_TASK_ITEM);
  2335. sMsg.eType = SMT_NORMAL;
  2336. sMsg.byConfirmType = SMCT_NONE;
  2337. sMsg.byPriority = 0;
  2338. sMsg.byParamSize = 0;
  2339. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2340. }
  2341. break;
  2342. case enumMSG_ID_ITEM_DAMAGED:
  2343. {
  2344. int nItemID = (int)pShowMsg->m_lpBuf;
  2345. int nIdx = ItemSet.SearchID(nItemID);
  2346. if (!nIdx)
  2347. break;
  2349. KSystemMessage sMsg;
  2350. sMsg.eType = SMT_NORMAL;
  2351. sMsg.byConfirmType = SMCT_NONE;
  2352. sMsg.byPriority = 1;
  2353. sMsg.byParamSize = 0;
  2354. sprintf(sMsg.szMessage, MSG_ITEM_DAMAGED, Item[nIdx].GetName());
  2355. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2356. }
  2357. break;
  2358. case enumMSG_ID_GET_ITEM:
  2359. {
  2360. DWORD dwID = *(DWORD*)(&pShowMsg->m_lpBuf);
  2362. int nItemIdx = ItemSet.SearchID(dwID);
  2363. if (nItemIdx <= 0 || nItemIdx >= MAX_ITEM)
  2364. break;
  2366. char szName[128];
  2367. KSystemMessage sMsg;
  2369. strcpy(szName, Item[nItemIdx].GetName());
  2371. if (strlen(szName) >= sizeof(sMsg.szMessage) - strlen(MSG_ADD_ITEM))
  2372. break;
  2374. sMsg.eType = SMT_NORMAL;
  2375. sMsg.byConfirmType = SMCT_NONE;
  2376. sMsg.byPriority = 0;
  2377. sMsg.byParamSize = 0;
  2378. sprintf(sMsg.szMessage, MSG_ADD_ITEM, szName);
  2379. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2380. }
  2381. break;
  2382. case enumMSG_ID_MONEY_CANNOT_PICKUP:
  2383. {
  2384. KSystemMessage sMsg;
  2385. sMsg.eType = SMT_NORMAL;
  2386. sMsg.byConfirmType = SMCT_NONE;
  2387. sMsg.byPriority = 0;
  2388. sMsg.byParamSize = 0;
  2390. strcpy(sMsg.szMessage, MSG_MONEY_CANNOT_PICKUP);
  2391. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2392. }
  2393. break;
  2394. case enumMSG_ID_CANNOT_ADD_TEAM:
  2395. {
  2396. KSystemMessage sMsg;
  2397. sMsg.eType = SMT_NORMAL;
  2398. sMsg.byConfirmType = SMCT_NONE;
  2399. sMsg.byPriority = 0;
  2400. sMsg.byParamSize = 0;
  2401. sprintf(sMsg.szMessage, MSG_TEAM_CANNOT_CREATE);
  2402. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2403. }
  2404. break;
  2405. case enumMSG_ID_TARGET_CANNOT_ADD_TEAM:
  2406. {
  2407. KSystemMessage sMsg;
  2408. sMsg.eType = SMT_NORMAL;
  2409. sMsg.byConfirmType = SMCT_NONE;
  2410. sMsg.byPriority = 0;
  2411. sMsg.byParamSize = 0;
  2412. sprintf(sMsg.szMessage, MSG_TEAM_TARGET_CANNOT_ADD_TEAM);
  2413. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2414. }
  2415. break;
  2416. case enumMSG_ID_PK_ERROR_1:
  2417. {
  2418. KSystemMessage sMsg;
  2419. sMsg.eType = SMT_NORMAL;
  2420. sMsg.byConfirmType = SMCT_NONE;
  2421. sMsg.byPriority = 0;
  2422. sMsg.byParamSize = 0;
  2423. sprintf(sMsg.szMessage, MSG_PK_ERROR_1);
  2424. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2425. }
  2426. break;
  2427. case enumMSG_ID_PK_ERROR_2:
  2428. {
  2429. KSystemMessage sMsg;
  2430. sMsg.eType = SMT_NORMAL;
  2431. sMsg.byConfirmType = SMCT_NONE;
  2432. sMsg.byPriority = 0;
  2433. sMsg.byParamSize = 0;
  2434. sprintf(sMsg.szMessage, MSG_PK_ERROR_2);
  2435. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2436. }
  2437. break;
  2438. case enumMSG_ID_PK_ERROR_3:
  2439. {
  2440. KSystemMessage sMsg;
  2441. sMsg.eType = SMT_NORMAL;
  2442. sMsg.byConfirmType = SMCT_NONE;
  2443. sMsg.byPriority = 0;
  2444. sMsg.byParamSize = 0;
  2445. sprintf(sMsg.szMessage, MSG_PK_ERROR_3);
  2446. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2447. }
  2448. break;
  2449. case enumMSG_ID_PK_ERROR_4:
  2450. {
  2451. KSystemMessage sMsg;
  2452. sMsg.eType = SMT_NORMAL;
  2453. sMsg.byConfirmType = SMCT_NONE;
  2454. sMsg.byPriority = 0;
  2455. sMsg.byParamSize = 0;
  2456. sprintf(sMsg.szMessage, MSG_PK_ERROR_4);
  2457. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2458. }
  2459. break;
  2460. case enumMSG_ID_PK_ERROR_5:
  2461. {
  2462. KSystemMessage sMsg;
  2463. sMsg.eType = SMT_NORMAL;
  2464. sMsg.byConfirmType = SMCT_NONE;
  2465. sMsg.byPriority = 0;
  2466. sMsg.byParamSize = 0;
  2467. sprintf(sMsg.szMessage, MSG_PK_ERROR_5);
  2468. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2469. }
  2470. break;
  2471. case enumMSG_ID_PK_ERROR_6:
  2472. {
  2473. KSystemMessage sMsg;
  2474. sMsg.eType = SMT_NORMAL;
  2475. sMsg.byConfirmType = SMCT_NONE;
  2476. sMsg.byPriority = 0;
  2477. sMsg.byParamSize = 0;
  2478. sprintf(sMsg.szMessage, MSG_PK_ERROR_6);
  2479. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2480. }
  2481. break;
  2482. case enumMSG_ID_PK_ERROR_7:
  2483. {
  2484. KSystemMessage sMsg;
  2485. sMsg.eType = SMT_NORMAL;
  2486. sMsg.byConfirmType = SMCT_NONE;
  2487. sMsg.byPriority = 0;
  2488. sMsg.byParamSize = 0;
  2489. sprintf(sMsg.szMessage, MSG_PK_ERROR_7);
  2490. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2491. }
  2492. break;
  2493. case enumMSG_ID_DEATH_LOSE_ITEM:
  2494. {
  2495. char szName[32];
  2496. memset(szName, 0, sizeof(szName));
  2497. memcpy(szName, &pShowMsg->m_lpBuf, pShowMsg->m_wLength + 1 + sizeof(LPVOID) - sizeof(SHOW_MSG_SYNC));
  2499. KSystemMessage sMsg;
  2500. sMsg.eType = SMT_NORMAL;
  2501. sMsg.byConfirmType = SMCT_NONE;
  2502. sMsg.byPriority = 0;
  2503. sMsg.byParamSize = 0;
  2504. sprintf(sMsg.szMessage, MSG_DEATH_LOSE_ITEM, szName);
  2505. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2506. }
  2507. break;
  2508. case enumMSG_ID_TONG_REFUSE_ADD:
  2509. {
  2510. char szName[32];
  2512. memset(szName, 0, sizeof(szName));
  2513. memcpy(szName, pMsg + sizeof(SHOW_MSG_SYNC) - sizeof(LPVOID), pShowMsg->m_wLength + 1 + sizeof(LPVOID) - sizeof(SHOW_MSG_SYNC));
  2515. KSystemMessage sMsg;
  2516. sMsg.eType = SMT_NORMAL;
  2517. sMsg.byConfirmType = SMCT_NONE;
  2518. sMsg.byPriority = 0;
  2519. sMsg.byParamSize = 0;
  2520. sprintf(sMsg.szMessage, MSG_TONG_REFUSE_ADD, szName);
  2521. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2522. }
  2523. break;
  2524. case enumMSG_ID_TONG_BE_KICK:
  2525. {
  2526. KSystemMessage sMsg;
  2527. sMsg.eType = SMT_NORMAL;
  2528. sMsg.byConfirmType = SMCT_NONE;
  2529. sMsg.byPriority = 0;
  2530. sMsg.byParamSize = 0;
  2531. sprintf(sMsg.szMessage, MSG_TONG_BE_KICKED);
  2532. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2534. KUiGameObjectWithName sUi;
  2535. strcpy(sUi.szName, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name);
  2536. sUi.nData = TONG_ACTION_DISMISS;
  2537. sUi.nParam = 0;
  2538. sUi.uParam = 0;
  2539. sUi.szString[0] = 0;
  2540. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, 1);
  2541. }
  2542. break;
  2543. case enumMSG_ID_TONG_LEAVE_SUCCESS:
  2544. {
  2545. KSystemMessage sMsg;
  2546. sMsg.eType = SMT_NORMAL;
  2547. sMsg.byConfirmType = SMCT_NONE;
  2548. sMsg.byPriority = 0;
  2549. sMsg.byParamSize = 0;
  2550. sprintf(sMsg.szMessage, MSG_TONG_LEAVE_SUCCESS);
  2551. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2552. }
  2553. break;
  2554. case enumMSG_ID_TONG_LEAVE_FAIL:
  2555. {
  2556. KSystemMessage sMsg;
  2557. sMsg.eType = SMT_NORMAL;
  2558. sMsg.byConfirmType = SMCT_NONE;
  2559. sMsg.byPriority = 0;
  2560. sMsg.byParamSize = 0;
  2561. sprintf(sMsg.szMessage, MSG_TONG_LEAVE_FAIL);
  2562. // CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2563. }
  2564. break;
  2565. case enumMSG_ID_TONG_CHANGE_AS_MASTER:
  2566. {
  2567. KSystemMessage sMsg;
  2568. sMsg.eType = SMT_NORMAL;
  2569. sMsg.byConfirmType = SMCT_NONE;
  2570. sMsg.byPriority = 0;
  2571. sMsg.byParamSize = 0;
  2572. sprintf(sMsg.szMessage, MSG_TONG_CHANGE_AS_MASTER);
  2573. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2575. KUiGameObjectWithName sUi;
  2576. strcpy(sUi.szName, Player[CLIENT_PLAYER_INDEX].m_cTong.m_szMasterName);
  2577. sUi.nData = TONG_ACTION_DEMISE;
  2578. sUi.nParam = 0;
  2579. sUi.uParam = 0;
  2580. sUi.szString[0] = 0;
  2581. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, 1);
  2582. }
  2583. break;
  2584. case enumMSG_ID_TONG_CHANGE_AS_MEMBER:
  2585. {
  2586. KSystemMessage sMsg;
  2587. sMsg.eType = SMT_NORMAL;
  2588. sMsg.byConfirmType = SMCT_NONE;
  2589. sMsg.byPriority = 0;
  2590. sMsg.byParamSize = 0;
  2591. sprintf(sMsg.szMessage, MSG_TONG_CHANGE_AS_MEMBER);
  2592. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2594. KUiGameObjectWithName sUi;
  2595. strcpy(sUi.szName, Player[CLIENT_PLAYER_INDEX].m_cTong.m_szMasterName);
  2596. sUi.nData = TONG_ACTION_DEMISE;
  2597. sUi.nParam = 0;
  2598. sUi.uParam = 0;
  2599. sUi.szString[0] = 0;
  2600. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, 1);
  2601. }
  2602. break;
  2604. default:
  2605. break;
  2606. }
  2607. }
  2609. void KProtocolProcess::SyncStateEffect(BYTE* pMsg)
  2610. {
  2611. STATE_EFFECT_SYNC* pSync = (STATE_EFFECT_SYNC *)pMsg;
  2613. int nDataNum = MAX_SKILL_STATE - (sizeof(STATE_EFFECT_SYNC) - pSync->m_wLength) / sizeof(KMagicAttrib);
  2614. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].SetStateSkillEffect(Player[CLIENT_PLAYER_INDEX].m_nIndex, pSync->m_dwSkillID, pSync->m_nLevel, pSync->m_MagicAttrib, nDataNum, pSync->m_nTime);
  2615. }
  2617. void KProtocolProcess::s2cTradeApplyStart(BYTE* pMsg)
  2618. {
  2619. Player[CLIENT_PLAYER_INDEX].s2cTradeApplyStart(pMsg);
  2620. }
  2622. void KProtocolProcess::s2cItemAutoMove(BYTE* pMsg)
  2623. {
  2624. ITEM_AUTO_MOVE_SYNC *pSync = (ITEM_AUTO_MOVE_SYNC*)pMsg;
  2625. ItemPos sSrc, sDest;
  2626. sSrc.nPlace = pSync->m_btSrcPos;
  2627. sSrc.nX = pSync->m_btSrcX;
  2628. sSrc.nY = pSync->m_btSrcY;
  2629. sDest.nPlace = pSync->m_btDestPos;
  2630. sDest.nX = pSync->m_btDestX;
  2631. sDest.nY = pSync->m_btDestY;
  2633. Player[CLIENT_PLAYER_INDEX].m_ItemList.AutoMoveItem(sSrc, sDest);
  2634. }
  2636. void KProtocolProcess::FinishedItemExchange(BYTE* pMsg)
  2637. {
  2638. Player[CLIENT_PLAYER_INDEX].m_ItemList.UnlockOperation();
  2639. }
  2641. extern IClientCallback* l_pDataChangedNotifyFunc;
  2643. void KProtocolProcess::s2cExtend(BYTE* pMsg)
  2644. {
  2645. EXTEND_HEADER* pHeader = (EXTEND_HEADER*)(pMsg + sizeof(tagExtendProtoHeader));
  2647. if (pHeader->ProtocolFamily == pf_playercommunity)
  2648. {
  2649. if (pHeader->ProtocolID == playercomm_s2c_notifychannelid)
  2650. {
  2651. PLAYERCOMM_NOTIFYCHANNELID* pNChann = (PLAYERCOMM_NOTIFYCHANNELID*)pHeader;
  2653. l_pDataChangedNotifyFunc->NotifyChannelID(pNChann->channel, pNChann->channelid, pNChann->cost);
  2654. }
  2655. }
  2656. }
  2658. void KProtocolProcess::s2cExtendChat(BYTE* pMsg)
  2659. {
  2660. tagExtendProtoHeader* pExHdr = (tagExtendProtoHeader*)pMsg;
  2661. void* pExPckg = pExHdr + 1;
  2662. BYTE protocol = *(BYTE*)(pExPckg);
  2664. if (protocol == chat_someonechat)
  2665. {
  2666. CHAT_SOMEONECHAT_SYNC* pCscSync = (CHAT_SOMEONECHAT_SYNC*)pExPckg;
  2668. l_pDataChangedNotifyFunc->MSNMessageArrival(
  2669. pCscSync->someone, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name,
  2670. (const char*)(pCscSync + 1), pCscSync->sentlen, true);
  2671. }
  2672. else if (protocol == chat_channelchat)
  2673. {
  2674. CHAT_CHANNELCHAT_SYNC* pCccSync = (CHAT_CHANNELCHAT_SYNC*)pExPckg;
  2676. l_pDataChangedNotifyFunc->ChannelMessageArrival(
  2677. pCccSync->channelid, pCccSync->someone,
  2678. (const char*)(pCccSync + 1), pCccSync->sentlen, true);
  2679. }
  2680. else if (protocol == chat_feedback)
  2681. {
  2682. ////X
  2683. CHAT_FEEDBACK* pCfb = (CHAT_FEEDBACK*)pExPckg;
  2684. DWORD* pChannelid = (DWORD*)(pCfb + 1);
  2686. if (*pChannelid == -1)
  2687. {//someone
  2688. char* pDstName = (char*)(pChannelid + 1);
  2689. BYTE* pSentlen = (BYTE*)(pDstName + _NAME_LEN);
  2690. void* pSent = pSentlen + 1;
  2692. l_pDataChangedNotifyFunc->MSNMessageArrival(
  2693. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name, pDstName,
  2694. (const char*)pSent, *pSentlen, pCfb->code != codeFail);
  2695. }
  2696. else
  2697. {//channel
  2698. BYTE* pSentlen = (BYTE*)(pChannelid + 1);
  2699. void* pSent = pSentlen + 1;
  2701. l_pDataChangedNotifyFunc->ChannelMessageArrival(
  2702. *pChannelid, Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].Name,
  2703. (const char*)pSent, *pSentlen, pCfb->code != codeFail);
  2704. }
  2705. ////X
  2706. }
  2707. }
  2710. static BOOL sParseUGName(const std::string& name, std::string* pUnit, std::string* pGroup)
  2711. {
  2712. static const char char_split = 'n';
  2714. size_t pos = name.find(char_split);
  2715. if (pos == name.npos)
  2716. {
  2717. if (pUnit)
  2718. pUnit->resize(0);
  2719. if (pGroup)
  2720. pGroup->assign(name);
  2721. }
  2722. else
  2723. {
  2724. std::string::const_iterator itSplit = name.begin() + pos;
  2726. if (pUnit)
  2727. pUnit->assign(name.begin(), itSplit);
  2728. if (pGroup)
  2729. pGroup->assign(itSplit + 1, name.end());
  2730. }
  2732. return TRUE;
  2733. }
  2735. void KProtocolProcess::s2cExtendFriend(BYTE* pMsg)
  2736. {
  2737. tagExtendProtoHeader* pExHdr = (tagExtendProtoHeader*)pMsg;
  2738. void* pExPckg = pExHdr + 1;
  2740. EXTEND_HEADER* pHeader = (EXTEND_HEADER*)(pExPckg);
  2742. if (pHeader->ProtocolFamily == pf_tong)
  2743. {
  2744. _ASSERT(FALSE);
  2745. //tong message
  2746. //...
  2747. }
  2748. else if (pHeader->ProtocolFamily == pf_friend)
  2749. {
  2750. if (pHeader->ProtocolID == friend_c2c_askaddfriend)
  2751. {
  2752. ASK_ADDFRIEND_SYNC* pAafSync = (ASK_ADDFRIEND_SYNC*)pHeader;
  2753. l_pDataChangedNotifyFunc->FriendInvite(pAafSync->srcrole);
  2754. }
  2755. else if (pHeader->ProtocolID == friend_c2c_repaddfriend)
  2756. {
  2757. REP_ADDFRIEND_SYNC* pRafSync = (REP_ADDFRIEND_SYNC*)pHeader;
  2758. l_pDataChangedNotifyFunc->AddFriend(pRafSync->srcrole, pRafSync->answer);
  2759. }
  2760. else if (pHeader->ProtocolID == friend_s2c_repsyncfriendlist)
  2761. {
  2762. REP_SYNCFRIENDLIST* pRsfl = (REP_SYNCFRIENDLIST*)pHeader;
  2763. char* pGroupTag = (char*)(pRsfl + 1);
  2764. if (*pGroupTag != specGroup)
  2765. goto on_error;
  2766. {{
  2767. char* pGroup = (char*)(pGroupTag + 1);
  2768. on_newgroup:
  2769. std::string theUnit, theGroup;
  2770. sParseUGName(std::string(pGroup), &theUnit, &theGroup);
  2772. for (char* pRoleTag = pGroup + strlen(pGroup) + 1; ; )
  2773. {
  2774. if (*pRoleTag == specOver)
  2775. goto on_over;
  2776. else if (*pRoleTag == specGroup)
  2777. {
  2778. pGroup = pRoleTag + 1;
  2779. goto on_newgroup;
  2780. }
  2781. else if (*pRoleTag == specRole)
  2782. {
  2783. char* pState = pRoleTag + 1;
  2784. char* pRole = pState + 1;
  2785. l_pDataChangedNotifyFunc->FriendInfo(pRole, (char*)theUnit.c_str(), (char*)theGroup.c_str(), (BYTE)*pState);
  2786. pRoleTag = pRole + strlen(pRole) + 1;
  2787. continue;
  2788. }
  2789. else
  2790. goto on_error;
  2791. }
  2792. }}
  2793. on_error:
  2794. _ASSERT(FALSE);
  2795. on_over:
  2796. 0;
  2797. }
  2798. else if (pHeader->ProtocolID == friend_s2c_friendstate)
  2799. {
  2800. FRIEND_STATE* pFs = (FRIEND_STATE*)pHeader;
  2801. for (char* pRole = (char*)(pFs + 1); *pRole; pRole += strlen(pRole) + 1)
  2802. l_pDataChangedNotifyFunc->FriendStatus(pRole, pFs->state);
  2803. }
  2804. else if (pHeader->ProtocolID == friend_s2c_syncassociate)
  2805. {
  2806. FRIEND_SYNCASSOCIATE* pFsa = (FRIEND_SYNCASSOCIATE*)pHeader;
  2808. char* szGroup = (char*)(pFsa + 1);
  2809. std::string group(szGroup);
  2811. std::string theUnit, theGroup;
  2812. sParseUGName(group, &theUnit, &theGroup);
  2813. _ASSERT(theGroup.empty());
  2815. for (char* szRole = szGroup + group.size() + 1; *szRole; szRole += strlen(szRole) + 1)
  2816. l_pDataChangedNotifyFunc->AddPeople((char*)theUnit.c_str(), szRole);
  2817. }
  2818. }
  2819. }
  2822. void KProtocolProcess::s2cExtendTong(BYTE* pMsg)
  2823. {
  2824. S2C_TONG_HEAD *pHead = (S2C_TONG_HEAD*)pMsg;
  2825. switch (pHead->m_btMsgId)
  2826. {
  2827. case enumTONG_SYNC_ID_CREATE_FAIL:
  2828. {
  2829. TONG_CREATE_FAIL_SYNC *pFail = (TONG_CREATE_FAIL_SYNC*)pMsg;
  2831. KSystemMessage sMsg;
  2832. sMsg.eType = SMT_NORMAL;
  2833. sMsg.byConfirmType = SMCT_NONE;
  2834. sMsg.byPriority = 0;
  2835. sMsg.byParamSize = 0;
  2837. sprintf(sMsg.szMessage, "帮会创建失败！");
  2838. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2840. switch (pFail->m_btFailId)
  2841. {
  2842. case enumTONG_CREATE_ERROR_ID1: // Player[m_nPlayerIndex].m_nIndex <= 0
  2843. break;
  2844. case enumTONG_CREATE_ERROR_ID2: // 交易过程中
  2845. break;
  2846. case enumTONG_CREATE_ERROR_ID3: // 帮会名问题
  2847. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR09);
  2848. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2849. break;
  2850. case enumTONG_CREATE_ERROR_ID4: // 帮会阵营问题
  2851. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR02);
  2852. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2853. break;
  2854. case enumTONG_CREATE_ERROR_ID5: // 已经是帮会成员
  2855. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR03);
  2856. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2857. break;
  2858. case enumTONG_CREATE_ERROR_ID6: // 自己的阵营问题
  2859. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR04);
  2860. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2861. break;
  2862. case enumTONG_CREATE_ERROR_ID7: // 等级问题
  2863. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR05);
  2864. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2865. break;
  2866. case enumTONG_CREATE_ERROR_ID8: // 钱问题
  2867. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR10);
  2868. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2869. break;
  2870. case enumTONG_CREATE_ERROR_ID9: // 组队不能建帮会
  2871. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR08);
  2872. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2873. break;
  2874. case enumTONG_CREATE_ERROR_ID10: // 帮会模块出错
  2875. break;
  2876. case enumTONG_CREATE_ERROR_ID11: // 名字字符串出错
  2877. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR11);
  2878. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2879. break;
  2880. case enumTONG_CREATE_ERROR_ID12: // 名字字符串过长
  2881. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR11);
  2882. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2883. break;
  2884. case enumTONG_CREATE_ERROR_ID13: // 帮会同名错误
  2885. sprintf(sMsg.szMessage, MSG_TONG_CREATE_ERROR11);
  2886. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  2887. break;
  2888. case enumTONG_CREATE_ERROR_ID14: // 帮会产生失败
  2889. break;
  2890. }
  2891. }
  2892. break;
  2893. case enumTONG_SYNC_ID_TRANSFER_ADD_APPLY:
  2894. {
  2895. TONG_APPLY_ADD_SYNC *pApply = (TONG_APPLY_ADD_SYNC*)pMsg;
  2896. char szName[32];
  2897. DWORD dwNameID;
  2898. int nPlayerIdx;
  2900. memset(szName, 0, sizeof(szName));
  2901. memcpy(szName, pApply->m_szName, pApply->m_wLength + 1 + sizeof(pApply->m_szName) - sizeof(TONG_APPLY_ADD_SYNC));
  2902. dwNameID = g_FileName2Id(szName);
  2903. nPlayerIdx = pApply->m_nPlayerIdx;
  2905. // 给界面发消息，收到申请，是否同意
  2906. KSystemMessage sMsg;
  2907. sprintf(sMsg.szMessage, "%s申请加入帮会！", szName);
  2908. sMsg.eType = SMT_CLIQUE;
  2909. sMsg.byConfirmType = SMCT_UI_TONG_JOIN_APPLY;
  2910. sMsg.byPriority = 3;
  2911. sMsg.byParamSize = sizeof(KUiPlayerItem);
  2913. KUiPlayerItem player;
  2914. strcpy(player.Name, szName);
  2915. player.nIndex = pApply->m_nPlayerIdx;
  2916. player.uId = 0;
  2917. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, (int)&player);
  2919. }
  2920. break;
  2921. case enumTONG_SYNC_ID_ADD:
  2922. {
  2923. TONG_Add_SYNC *pAdd = (TONG_Add_SYNC*)pMsg;
  2924. char szName[32], szTitle[32], szMaster[32];
  2926. memcpy(szName, pAdd->m_szTongName,sizeof(szName));
  2927. memcpy(szTitle, pAdd->m_szTitle, sizeof(szTitle));
  2928. memcpy(szMaster, pAdd->m_szMaster, sizeof(szMaster));
  2930. Player[CLIENT_PLAYER_INDEX].m_cTong.AddTong(pAdd->m_btCamp, szName, szTitle, szMaster);
  2931. // 通知界面更新数据
  2932. KUiGameObjectWithName sUi;
  2933. memset(&sUi, 0, sizeof(sUi));
  2934. strcpy(sUi.szName, szName);
  2935. sUi.nData = TONG_ACTION_APPLY;
  2936. strcpy(sUi.szString, szTitle);
  2937. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, 1);
  2938. /*------------------------------*/
  2939. CoreDataChanged(GDCNI_PLAYER_BASE_INFO, 0, 0);
  2940. }
  2941. break;
  2943. case enumTONG_SYNC_ID_HEAD_INFO:
  2944. {
  2945. TONG_HEAD_INFO_SYNC *pInfo = (TONG_HEAD_INFO_SYNC*)pMsg;
  2947. // 通知界面得到某帮会信息
  2948. int nIdx = NpcSet.SearchID(pInfo->m_dwNpcID);
  2949. if (nIdx <= 0)
  2950. break;
  2952. KUiPlayerRelationWithOther sUi;
  2953. sUi.nIndex = nIdx;
  2954. sUi.uId = Npc[nIdx].m_dwID;
  2955. if (nIdx == Player[CLIENT_PLAYER_INDEX].m_nIndex)
  2956. sUi.nRelation = Player[CLIENT_PLAYER_INDEX].m_cTong.GetFigure();
  2957. else
  2958. sUi.nRelation = -1;
  2959. sUi.nData = 0;
  2960. sUi.nParam = 0;
  2961. strcpy(sUi.Name, Npc[nIdx].Name);
  2963. KTongInfo sInfo;
  2964. memset(&sInfo, 0, sizeof(sInfo));
  2965. sInfo.nFaction = pInfo->m_btCamp;
  2966. sInfo.nMemberCount = (int)pInfo->m_dwMemberNum;
  2967. sInfo.nManagerCount = (int)pInfo->m_btManagerNum;
  2968. sInfo.nDirectorCount = (int)pInfo->m_btDirectorNum;
  2969. sInfo.nMoney = pInfo->m_dwMoney;
  2970. strcpy(sInfo.szMasterName, pInfo->m_sMember[0].m_szName);
  2971. strcpy(sInfo.szName, pInfo->m_szTongName);
  2973. CoreDataChanged(GDCNI_TONG_INFO, (unsigned int)&sUi, (unsigned int)&sInfo);
  2975. KUiGameObjectWithName sObj;
  2976. strcpy(sObj.szName, pInfo->m_szTongName);
  2977. sObj.nData = enumTONG_FIGURE_DIRECTOR;
  2978. sObj.nParam = 0;
  2979. sObj.uParam = defTONG_MAX_DIRECTOR;
  2980. sObj.szString[0] = 0;
  2982. KTongMemberItem sItem[defTONG_MAX_DIRECTOR];
  2983. memset(sItem, 0, sizeof(sItem));
  2984. for (int i = 0; i < pInfo->m_btDirectorNum; i++)
  2985. {
  2986. sItem[i].nData = enumTONG_FIGURE_DIRECTOR;
  2987. strcpy(sItem[i].Name, pInfo->m_sMember[i + 1].m_szName);
  2988. strcpy(sItem[i].szAgname, pInfo->m_sMember[i + 1].m_szTitle);
  2989. }
  2991. CoreDataChanged(GDCNI_TONG_MEMBER_LIST, (unsigned int)&sObj, (unsigned int)sItem);
  2992. }
  2993. break;
  2994. case enumTONG_SYNC_ID_SELF_INFO:
  2995. {
  2996. TONG_SELF_INFO_SYNC *pInfo = (TONG_SELF_INFO_SYNC*)pMsg;
  2997. Player[CLIENT_PLAYER_INDEX].m_cTong.SetSelfInfo(pInfo);
  2998. // 通知界面更新数据
  2999. CoreDataChanged(GDCNI_PLAYER_BASE_INFO, 0, 0);
  3000. }
  3001. break;
  3002. case enumTONG_SYNC_ID_MANAGER_INFO:
  3003. {
  3004. TONG_MANAGER_INFO_SYNC *pInfo = (TONG_MANAGER_INFO_SYNC*)pMsg;
  3006. // 通知界面得到某帮会队长信息
  3007. KUiGameObjectWithName sObj;
  3008. strcpy(sObj.szName, pInfo->m_szTongName);
  3009. sObj.nData = enumTONG_FIGURE_MANAGER;
  3010. sObj.nParam = pInfo->m_btStateNo;
  3011. sObj.uParam = pInfo->m_btCurNum;
  3012. sObj.szString[0] = 0;
  3014. KTongMemberItem sItem[defTONG_ONE_PAGE_MAX_NUM];
  3015. memset(sItem, 0, sizeof(sItem));
  3016. for (int i = 0; i < pInfo->m_btCurNum; i++)
  3017. {
  3018. sItem[i].nData = enumTONG_FIGURE_MANAGER;
  3019. strcpy(sItem[i].Name, pInfo->m_sMember[i].m_szName);
  3020. strcpy(sItem[i].szAgname, pInfo->m_sMember[i].m_szTitle);
  3021. }
  3023. CoreDataChanged(GDCNI_TONG_MEMBER_LIST, (unsigned int)&sObj, (unsigned int)sItem);
  3024. }
  3025. break;
  3026. case enumTONG_SYNC_ID_MEMBER_INFO:
  3027. {
  3028. TONG_MEMBER_INFO_SYNC *pInfo = (TONG_MEMBER_INFO_SYNC*)pMsg;
  3030. // 通知界面得到某帮会帮众信息
  3031. KUiGameObjectWithName sObj;
  3032. strcpy(sObj.szName, pInfo->m_szTongName);
  3033. sObj.nData = enumTONG_FIGURE_MEMBER;
  3034. sObj.nParam = pInfo->m_btStateNo;
  3035. sObj.uParam = pInfo->m_btCurNum;
  3036. sObj.szString[0] = 0;
  3038. KTongMemberItem sItem[defTONG_ONE_PAGE_MAX_NUM];
  3039. memset(sItem, 0, sizeof(sItem));
  3040. for (int i = 0; i < pInfo->m_btCurNum; i++)
  3041. {
  3042. sItem[i].nData = enumTONG_FIGURE_MEMBER;
  3043. strcpy(sItem[i].Name, pInfo->m_sMember[i].m_szName);
  3044. strcpy(sItem[i].szAgname, pInfo->m_szTitle);
  3045. }
  3047. CoreDataChanged(GDCNI_TONG_MEMBER_LIST, (unsigned int)&sObj, (unsigned int)sItem);
  3048. }
  3049. break;
  3050. case enumTONG_SYNC_ID_INSTATE:
  3051. {
  3052. TONG_INSTATE_SYNC *pInstate = (TONG_INSTATE_SYNC*)pMsg;
  3053. // 通知界面任命是否成功
  3054. KUiGameObjectWithName sUi;
  3055. strcpy(sUi.szName, pInstate->m_szName);
  3056. sUi.nData = TONG_ACTION_ASSIGN;
  3057. sUi.nParam = pInstate->m_btNewFigure;
  3058. sUi.uParam = pInstate->m_btOldFigure;
  3059. strcpy(sUi.szString, pInstate->m_szTitle);
  3060. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, pInstate->m_btSuccessFlag);
  3061. }
  3062. break;
  3063. case enumTONG_SYNC_ID_KICK:
  3064. {
  3065. TONG_KICK_SYNC *pKick = (TONG_KICK_SYNC*)pMsg;
  3066. // 通知界面踢人是否成功
  3067. KUiGameObjectWithName sUi;
  3068. strcpy(sUi.szName, pKick->m_szName);
  3069. sUi.nData = TONG_ACTION_DISMISS;
  3070. sUi.nParam = pKick->m_btFigure;
  3071. sUi.uParam = pKick->m_btPos;
  3072. sUi.szString[0] = 0;
  3073. CoreDataChanged(GDCNI_TONG_ACTION_RESULT, (unsigned int)&sUi, pKick->m_btSuccessFlag);
  3074. }
  3075. break;
  3076. case enumTONG_SYNC_ID_CHANGE_MASTER_FAIL:
  3077. {
  3078. TONG_CHANGE_MASTER_FAIL_SYNC *pFail = (TONG_CHANGE_MASTER_FAIL_SYNC*)pMsg;
  3080. switch (pFail->m_btFailID)
  3081. {
  3082. case 0: // 对方不在线
  3083. {
  3084. KSystemMessage sMsg;
  3085. sMsg.eType = SMT_NORMAL;
  3086. sMsg.byConfirmType = SMCT_NONE;
  3087. sMsg.byPriority = 0;
  3088. sMsg.byParamSize = 0;
  3089. sprintf(sMsg.szMessage, "传位失败，对方不在线！");
  3090. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  3091. }
  3092. break;
  3093. case 1: // 对方能力不够！
  3094. {
  3095. KSystemMessage sMsg;
  3096. sMsg.eType = SMT_NORMAL;
  3097. sMsg.byConfirmType = SMCT_NONE;
  3098. sMsg.byPriority = 0;
  3099. sMsg.byParamSize = 0;
  3100. sprintf(sMsg.szMessage, "传位失败，对方能力不够！");
  3101. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  3102. }
  3103. break;
  3104. case 2: // 名字不对！
  3105. {
  3106. KSystemMessage sMsg;
  3107. sMsg.eType = SMT_NORMAL;
  3108. sMsg.byConfirmType = SMCT_NONE;
  3109. sMsg.byPriority = 0;
  3110. sMsg.byParamSize = 0;
  3111. sprintf(sMsg.szMessage, "传位失败，本帮中无此人！");
  3112. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  3113. }
  3114. break;
  3116. default:
  3117. break;
  3118. }
  3119. }
  3120. break;
  3121. default:
  3122. break;
  3123. }
  3124. }
  3127. void KProtocolProcess::s2cChangeWeather(BYTE* pMsg)
  3128. {
  3129. g_ScenePlace.ChangeWeather(((SYNC_WEATHER*)pMsg)->WeatherID);
  3130. }
  3132. void KProtocolProcess::s2cPKSyncNormalFlag(BYTE* pMsg)
  3133. {
  3134. PK_NORMAL_FLAG_SYNC *pFlag = (PK_NORMAL_FLAG_SYNC*)pMsg;
  3135. Player[CLIENT_PLAYER_INDEX].m_cPK.SetNormalPKState(pFlag->m_btFlag);
  3136. }
  3138. void KProtocolProcess::s2cPKSyncEnmityState(BYTE* pMsg)
  3139. {
  3140. PK_ENMITY_STATE_SYNC *pState = (PK_ENMITY_STATE_SYNC*)pMsg;
  3141. char szName[32];
  3143. memset(szName, 0, sizeof(szName));
  3144. memcpy(szName, pState->m_szName, pState->m_wLength + 1 + sizeof(pState->m_szName) - sizeof(PK_ENMITY_STATE_SYNC));
  3145. Player[CLIENT_PLAYER_INDEX].m_cPK.SetEnmityPKState(pState->m_btState, pState->m_dwNpcID, szName);
  3146. }
  3148. void KProtocolProcess::s2cPKSyncExerciseState(BYTE* pMsg)
  3149. {
  3150. PK_EXERCISE_STATE_SYNC *pState = (PK_EXERCISE_STATE_SYNC*)pMsg;
  3151. char szName[32];
  3152. memset(szName, 0, sizeof(szName));
  3153. memcpy(szName, pState->m_szName, pState->m_wLength + 1 + sizeof(pState->m_szName) - sizeof(PK_EXERCISE_STATE_SYNC));
  3154. Player[CLIENT_PLAYER_INDEX].m_cPK.SetExercisePKState(pState->m_btState, pState->m_dwNpcID, szName);
  3155. }
  3157. void KProtocolProcess::s2cPKValueSync(BYTE* pMsg)
  3158. {
  3159. PK_VALUE_SYNC *pValue = (PK_VALUE_SYNC*)pMsg;
  3160. Player[CLIENT_PLAYER_INDEX].m_cPK.SetPKValue(pValue->m_nPKValue);
  3161. }
  3163. void KProtocolProcess::s2cViewEquip(BYTE* pMsg)
  3164. {
  3165. g_cViewItem.GetData(pMsg);
  3166. }
  3168. void KProtocolProcess::s2cTongCreate(BYTE* pMsg)
  3169. {
  3170. Player[CLIENT_PLAYER_INDEX].m_cTong.Create((TONG_CREATE_SYNC*)pMsg);
  3171. }
  3173. void KProtocolProcess::s2cNpcGoldChange(BYTE* pMsg)
  3174. {
  3175. NPC_GOLD_CHANGE_SYNC *pSync = (NPC_GOLD_CHANGE_SYNC*)pMsg;
  3177. int nIdx = NpcSet.SearchID(pSync->m_dwNpcID);
  3179. if (nIdx && Npc[nIdx].m_Kind == kind_normal)
  3180. {
  3181. Npc[nIdx].m_cGold.SetGoldCurrentType((int)pSync->m_wGoldFlag);
  3182. }
  3183. }
  3185. void KProtocolProcess::ItemChangeDurability(BYTE* pMsg)
  3186. {
  3187. ITEM_DURABILITY_CHANGE *pIDC = (ITEM_DURABILITY_CHANGE *)pMsg;
  3189. int nIdx = ItemSet.SearchID(pIDC->dwItemID);
  3191. if (nIdx)
  3192. {
  3193. Item[nIdx].SetDurability(Item[nIdx].GetDurability() + pIDC->nChange);
  3194. _ASSERT(Item[nIdx].GetDurability() > 0);
  3195. if (Item[nIdx].GetDurability() <= 3)
  3196. {
  3197. KSystemMessage sMsg;
  3198. sMsg.eType = SMT_NORMAL;
  3199. sMsg.byConfirmType = SMCT_NONE;
  3200. sMsg.byPriority = 1;
  3201. sMsg.byParamSize = 0;
  3202. sprintf(sMsg.szMessage, MSG_ITEM_NEARLY_DAMAGED, Item[nIdx].GetName());
  3203. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  3204. }
  3205. }
  3206. }
  3208. void KProtocolProcess::LadderList(BYTE* pMsg)
  3209. {
  3210. LADDER_LIST* pList = (LADDER_LIST *)pMsg;
  3211. KRankIndex *pLadderListIndex = NULL;
  3213. if (pList->nCount > 0 && pList->nCount < enumLadderEnd)
  3214. {
  3215. pLadderListIndex = new KRankIndex[pList->nCount];
  3216. }
  3217. if (pLadderListIndex)
  3218. {
  3219. for (int i = 0; i < pList->nCount; i++)
  3220. {
  3221. pLadderListIndex[i].usIndexId = pList->dwLadderID[i];
  3222. pLadderListIndex[i].bValueAppened = true;
  3223. pLadderListIndex[i].bSortFlag = true;
  3224. }
  3225. CoreDataChanged(GDCNII_RANK_INDEX_LIST_ARRIVE, pList->nCount, (int)pLadderListIndex);
  3226. delete [] pLadderListIndex;
  3227. pLadderListIndex = NULL;
  3228. }
  3229. }
  3231. void KProtocolProcess::LadderResult(BYTE* pMsg)
  3232. {
  3233. LADDER_DATA* pLadderData = (LADDER_DATA *)pMsg;
  3234. KRankMessage* pLadderMessage = NULL;
  3236. pLadderMessage = new KRankMessage[10];
  3237. if (pLadderMessage)
  3238. {
  3239. for (int i = 0; i < 10; i++)
  3240. {
  3241. pLadderMessage[i].usMsgLen = strlen(pLadderData->StatData[i].Name);
  3242. strcpy(pLadderMessage[i].szMsg, pLadderData->StatData[i].Name);
  3243. pLadderMessage[i].nValueAppend = pLadderData->StatData[i].nValue;
  3244. pLadderMessage[i].cSortFlag = (char)pLadderData->StatData[i].bySort;
  3245. }
  3246. unsigned int uParam = 10 | (((WORD)pLadderData->dwLadderID) << 16);
  3247. CoreDataChanged(GDCNII_RANK_INFORMATION_ARRIVE, uParam, (int)pLadderMessage);
  3248. delete [] pLadderMessage;
  3249. pLadderMessage = NULL;
  3250. }
  3251. }
  3252. #else
  3254. void KProtocolProcess::RemoveRole(int nIndex, BYTE * pProtocol)
  3255. {
  3257. }
  3259. void KProtocolProcess::NpcRequestCommand(int nIndex, BYTE* pProtocol)
  3260. {
  3261. NPC_REQUEST_COMMAND *pNpcRequestSync = (NPC_REQUEST_COMMAND *)pProtocol;
  3262. NpcSet.SyncNpc(pNpcRequestSync->ID, Player[nIndex].m_nNetConnectIdx);
  3263. }
  3265. //-------------------------------------------------------------------------
  3266. // 功能：客户端向服务器请求更新某个obj数据
  3267. //-------------------------------------------------------------------------
  3268. void KProtocolProcess::ObjRequestCommand(int nIndex, BYTE* pProtocol)
  3269. {
  3270. OBJ_CLIENT_SYNC_ADD *pObjClientSyncAdd = (OBJ_CLIENT_SYNC_ADD*)pProtocol;
  3271. ObjSet.SyncAdd(pObjClientSyncAdd->m_nID, Player[nIndex].m_nNetConnectIdx);
  3272. }
  3274. void KProtocolProcess::NpcWalkCommand(int nIndex, BYTE* pProtocol)
  3275. {
  3276. NPC_WALK_COMMAND* pNetCommand = (NPC_WALK_COMMAND *)pProtocol;
  3277. int ParamX = pNetCommand->nMpsX;
  3278. int ParamY = pNetCommand->nMpsY;
  3279. if (ParamX < 0)
  3280. {
  3281. ParamX = 0;
  3282. }
  3283. if (ParamY < 0)
  3284. {
  3285. ParamY = 0;
  3286. }
  3287. Npc[Player[nIndex].m_nIndex].SendCommand(do_walk, ParamX, ParamY);
  3288. }
  3290. void KProtocolProcess::NpcRunCommand(int nIndex, BYTE* pProtocol)
  3291. {
  3292. NPC_RUN_COMMAND* pNetCommand = (NPC_RUN_COMMAND *)pProtocol;
  3293. int ParamX = pNetCommand->nMpsX;
  3294. int ParamY = pNetCommand->nMpsY;
  3295. if (ParamX < 0)
  3296. {
  3297. ParamX = 0;
  3298. }
  3299. if (ParamY < 0)
  3300. {
  3301. ParamY = 0;
  3302. }
  3303. Npc[Player[nIndex].m_nIndex].SendCommand(do_run, ParamX, ParamY);
  3304. }
  3307. void KProtocolProcess::NpcSkillCommand(int nIndex, BYTE* pProtocol)
  3308. {
  3309. NPC_SKILL_COMMAND* pNetCommand = (NPC_SKILL_COMMAND *)pProtocol;
  3310. int ParamX = pNetCommand->nSkillID;
  3311. int ParamY = pNetCommand->nMpsX;
  3312. int ParamZ = pNetCommand->nMpsY;
  3313. // 参数合法性检查
  3314. if (ParamX <= 0 || ParamX > MAX_SKILL )
  3315. {
  3316. return ;
  3317. }
  3319. if (ParamZ < 0) 
  3320. return;
  3322. if (ParamY < 0)
  3323. {
  3324. if (ParamY != -1) 
  3325. return;
  3327. int nNpcIndex = Player[nIndex].FindAroundNpc((DWORD)ParamZ);
  3328. if (nNpcIndex > 0)
  3329. Npc[Player[nIndex].m_nIndex].SendCommand(do_skill, ParamX, ParamY, nNpcIndex);
  3330. }
  3331. else
  3332. Npc[Player[nIndex].m_nIndex].SendCommand(do_skill, ParamX, ParamY, ParamZ);
  3333. }
  3335. void KProtocolProcess::NpcJumpCommand(int nIndex, BYTE* pProtocol)
  3336. {
  3337. NPC_JUMP_COMMAND* pNetCommand = (NPC_JUMP_COMMAND *)pProtocol;
  3338. int ParamX = pNetCommand->nMpsX;
  3339. int ParamY = pNetCommand->nMpsY;
  3340. Npc[Player[nIndex].m_nIndex].SendCommand(do_jump, ParamX, ParamY);
  3341. }
  3343. void KProtocolProcess::NpcTalkCommand(int nIndex, BYTE* pProtocol)
  3344. {
  3345. }
  3347. void KProtocolProcess::PlayerTalkCommand(int nIndex, BYTE* pProtocol)
  3348. {
  3349. Npc[Player[nIndex].m_nIndex].DoPlayerTalk((char *)pProtocol + 1);
  3350. }
  3352. void KProtocolProcess::PlayerApplyTeamInfo(int nIndex, BYTE* pProtocol)
  3353. {
  3354. Player[nIndex].S2CSendTeamInfo(pProtocol);
  3355. }
  3357. void KProtocolProcess::PlayerApplyCreateTeam(int nIndex, BYTE* pProtocol)
  3358. {
  3359. Player[nIndex].CreateTeam(pProtocol);
  3360. }
  3362. void KProtocolProcess::PlayerApplyTeamOpenClose(int nIndex, BYTE* pProtocol)
  3363. {
  3364. Player[nIndex].SetTeamState(pProtocol);
  3365. }
  3367. void KProtocolProcess::PlayerApplyAddTeam(int nIndex, BYTE* pProtocol)
  3368. {
  3369. Player[nIndex].S2CSendAddTeamInfo(pProtocol);
  3370. }
  3372. void KProtocolProcess::PlayerAcceptTeamMember(int nIndex, BYTE* pProtocol)
  3373. {
  3374. Player[nIndex].AddTeamMember(pProtocol);
  3375. }
  3377. void KProtocolProcess::PlayerApplyLeaveTeam(int nIndex, BYTE* pProtocol)
  3378. {
  3379. Player[nIndex].LeaveTeam(pProtocol);
  3380. }
  3382. void KProtocolProcess::PlayerApplyTeamKickMember(int nIndex, BYTE* pProtocol)
  3383. {
  3384. Player[nIndex].TeamKickOne(pProtocol);
  3385. }
  3387. void KProtocolProcess::PlayerApplyTeamChangeCaptain(int nIndex, BYTE* pProtocol)
  3388. {
  3389. Player[nIndex].TeamChangeCaptain(pProtocol);
  3390. }
  3392. void KProtocolProcess::PlayerApplyTeamDismiss(int nIndex, BYTE* pProtocol)
  3393. {
  3394. Player[nIndex].TeamDismiss(pProtocol);
  3395. }
  3397. void KProtocolProcess::PlayerApplySetPK(int nIndex, BYTE* pProtocol)
  3398. {
  3399. Player[nIndex].SetPK(pProtocol);
  3400. }
  3402. void KProtocolProcess::PlayerApplyFactionData(int nIndex, BYTE* pProtocol)
  3403. {
  3404. Player[nIndex].SendFactionData(pProtocol);
  3405. }
  3407. void KProtocolProcess::PlayerSendChat(int nIndex, BYTE* pProtocol)
  3408. {
  3409. Player[nIndex].ServerSendChat(pProtocol);
  3410. }
  3412. void KProtocolProcess::PlayerAddBaseAttribute(int nIndex, BYTE* pProtocol)
  3413. {
  3414. Player[nIndex].AddBaseAttribute(pProtocol);
  3415. }
  3417. void KProtocolProcess::PlayerApplyAddSkillPoint(int nIndex, BYTE* pProtocol)
  3418. {
  3419. Player[nIndex].AddSkillPoint(pProtocol);
  3420. }
  3422. void KProtocolProcess::PlayerEatItem(int nIndex, BYTE* pProtocol)
  3423. {
  3424. if (Player[nIndex].CheckTrading())
  3425. return;
  3426. Player[nIndex].EatItem(pProtocol);
  3427. }
  3429. void KProtocolProcess::PlayerPickUpItem(int nIndex, BYTE* pProtocol)
  3430. {
  3431. if (Player[nIndex].CheckTrading())
  3432. return;
  3433. Player[nIndex].ServerPickUpItem(pProtocol);
  3434. }
  3436. void KProtocolProcess::PlayerMoveItem(int nIndex, BYTE* pProtocol)
  3437. {
  3438. Player[nIndex].ServerMoveItem(pProtocol);
  3439. }
  3441. void KProtocolProcess::PlayerSellItem(int nIndex, BYTE* pProtocol)
  3442. {
  3443. if (Player[nIndex].CheckTrading())
  3444. return;
  3445. Player[nIndex].SellItem(pProtocol);
  3446. }
  3448. void KProtocolProcess::PlayerBuyItem(int nIndex, BYTE* pProtocol)
  3449. {
  3450. if (Player[nIndex].CheckTrading())
  3451. return;
  3452. Player[nIndex].BuyItem(pProtocol);
  3453. }
  3455. void KProtocolProcess::PlayerDropItem(int nIndex, BYTE* pProtocol)
  3456. {
  3457. if (Player[nIndex].CheckTrading())
  3458. return;
  3459. Player[nIndex].ServerThrowAwayItem(pProtocol);
  3460. }
  3462. void KProtocolProcess::PlayerSelUI(int nIndex, BYTE* pProtocol)
  3463. {
  3464. Player[nIndex].ProcessPlayerSelectFromUI(pProtocol);
  3465. }
  3467. void KProtocolProcess::ChatSetChannel(int nIndex, BYTE* pProtocol)
  3468. {
  3469. Player[nIndex].ChatSetTakeChannel(pProtocol);
  3470. }
  3472. void KProtocolProcess::ChatApplyAddFriend(int nIndex, BYTE* pProtocol)
  3473. {
  3474. Player[nIndex].ChatTransmitApplyAddFriend(pProtocol);
  3475. }
  3477. void KProtocolProcess::ChatAddFriend(int nIndex, BYTE* pProtocol)
  3478. {
  3479. Player[nIndex].ChatAddFriend(pProtocol);
  3480. }
  3482. void KProtocolProcess::ChatRefuseFriend(int nIndex, BYTE* pProtocol)
  3483. {
  3484. Player[nIndex].ChatRefuseFriend(pProtocol);
  3485. }
  3487. void KProtocolProcess::ChatApplyReSendAllFriendName(int nIndex, BYTE* pProtocol)
  3488. {
  3489. Player[nIndex].ChatResendAllFriend(pProtocol);
  3490. }
  3492. void KProtocolProcess::ChatApplySendOneFriendName(int nIndex, BYTE* pProtocol)
  3493. {
  3494. Player[nIndex].ChatSendOneFriendData(pProtocol);
  3495. }
  3497. void KProtocolProcess::ChatDeleteFriend(int nIndex, BYTE* pProtocol)
  3498. {
  3499. Player[nIndex].ChatDeleteFriend(pProtocol);
  3500. }
  3502. void KProtocolProcess::ChatReDeleteFriend(int nIndex, BYTE* pProtocol)
  3503. {
  3504. Player[nIndex].ChatRedeleteFriend(pProtocol);
  3505. }
  3507. void KProtocolProcess::TradeApplyOpen(int nIndex, BYTE* pProtocol)
  3508. {
  3509. Player[nIndex].TradeApplyOpen(pProtocol);
  3510. }
  3512. void KProtocolProcess::TradeApplyClose(int nIndex, BYTE* pProtocol)
  3513. {
  3514. Player[nIndex].TradeApplyClose(pProtocol);
  3515. }
  3517. void KProtocolProcess::TradeApplyStart(int nIndex, BYTE* pProtocol)
  3518. {
  3519. Player[nIndex].TradeApplyStart(pProtocol);
  3520. }
  3522. void KProtocolProcess::TradeMoveMoney(int nIndex, BYTE* pProtocol)
  3523. {
  3524. Player[nIndex].TradeMoveMoney(pProtocol);
  3525. }
  3527. void KProtocolProcess::TradeDecision(int nIndex, BYTE* pProtocol)
  3528. {
  3529. Player[nIndex].TradeDecision(pProtocol);
  3530. }
  3532. void KProtocolProcess::DialogNpc(int nIndex, BYTE * pProtocol)
  3533. {
  3534. Player[nIndex].DialogNpc(pProtocol) ;
  3535. }
  3537. void KProtocolProcess::TeamInviteAdd(int nIndex, BYTE * pProtocol)
  3538. {
  3539. Player[nIndex].m_cTeam.InviteAdd(nIndex, (TEAM_INVITE_ADD_COMMAND*)pProtocol);
  3540. }
  3542. void KProtocolProcess::ChangeAuraSkill(int nIndex, BYTE * pProtocol)
  3543. {
  3544. SKILL_CHANGEAURASKILL_COMMAND * pCommand = (SKILL_CHANGEAURASKILL_COMMAND*) pProtocol;
  3545. Npc[Player[nIndex].m_nIndex].SetAuraSkill(pCommand->m_nAuraSkill);
  3546. }
  3548. void KProtocolProcess::TeamReplyInvite(int nIndex, BYTE * pProtocol)
  3549. {
  3550. TEAM_REPLY_INVITE_COMMAND *pReply = (TEAM_REPLY_INVITE_COMMAND*)pProtocol;
  3551. if (!pProtocol ||
  3552. pReply->m_nIndex <= 0 ||
  3553. pReply->m_nIndex >= MAX_PLAYER ||
  3554. Player[pReply->m_nIndex].m_nIndex <= 0)
  3555. return;
  3556. if (pReply->m_btResult && Player[nIndex].m_cTeam.GetCanTeamFlag() == FALSE)
  3557. {
  3558. SHOW_MSG_SYNC sMsg;
  3559. sMsg.ProtocolType = s2c_msgshow;
  3560. sMsg.m_wMsgID = enumMSG_ID_CANNOT_ADD_TEAM;
  3561. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  3562. g_pServer->PackDataToClient(Player[nIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  3563. return;
  3564. }
  3565. Player[pReply->m_nIndex].m_cTeam.GetInviteReply(pReply->m_nIndex, nIndex, pReply->m_btResult);
  3566. }
  3568. //void KProtocolProcess::ReplyPing(int nIndex, BYTE* pProtocol)
  3569. //{
  3570. // if (nIndex <= 0 || nIndex >= MAX_PLAYER)
  3571. // return;
  3572. //
  3573. // PING_COMMAND PingCmd, *pPingCmd;
  3574. //
  3575. // pPingCmd = (PING_COMMAND *)pProtocol;
  3576. //
  3577. // PingCmd.ProtocolType = s2c_ping;
  3578. // PingCmd.m_dwTime = pPingCmd->m_dwTime;
  3579. // g_pServer->SendData(Player[nIndex].m_nNetConnectIdx, &PingCmd, sizeof(PING_COMMAND));
  3580. // Player[nIndex].m_uLastPingTime = g_SubWorldSet.GetGameTime();
  3581. //}
  3583. void KProtocolProcess::NpcSitCommand(int nIndex, BYTE* pProtocol)
  3584. {
  3585. NPC_SIT_COMMAND *pSitCmd;
  3587. pSitCmd = (NPC_SIT_COMMAND *)pProtocol;
  3589. if (nIndex <= 0 || nIndex >= MAX_PLAYER)
  3590. return;
  3592. if (Player[nIndex].m_nIndex <= 0 || Player[nIndex].m_nIndex >= MAX_NPC)
  3593. return;
  3595. if (pSitCmd->m_btSitFlag)
  3596. Npc[Player[nIndex].m_nIndex].SendCommand(do_sit);
  3597. else
  3598. Npc[Player[nIndex].m_nIndex].SendCommand(do_stand);
  3599. // if (Npc[Player[nIndex].m_nIndex].m_Doing != do_sit)
  3600. // Npc[Player[nIndex].m_nIndex].SendCommand(do_sit);
  3601. // else
  3602. // Npc[Player[nIndex].m_nIndex].SendCommand(do_stand);
  3603. }
  3605. void KProtocolProcess::ObjMouseClick(int nIndex, BYTE* pProtocol)
  3606. {
  3607. if (Player[nIndex].CheckTrading())
  3608. return;
  3610. int nSubWorldIdx, nRegionIdx, nObjIdx;
  3611. int nPlayerX, nPlayerY, nObjX, nObjY;
  3612. OBJ_MOUSE_CLICK_SYNC  *pObj = (OBJ_MOUSE_CLICK_SYNC*)pProtocol;
  3614. nSubWorldIdx = Npc[Player[nIndex].m_nIndex].m_SubWorldIndex;
  3615. nRegionIdx = SubWorld[nSubWorldIdx].FindRegion(pObj->m_dwRegionID);
  3616. if (nRegionIdx < 0)
  3617. return;
  3618. nObjIdx = SubWorld[nSubWorldIdx].m_Region[nRegionIdx].FindObject(pObj->m_nObjID);
  3619. if (nObjIdx <= 0)
  3620. return;
  3622. SubWorld[nSubWorldIdx].Map2Mps(
  3623. Npc[Player[nIndex].m_nIndex].m_RegionIndex,
  3624. Npc[Player[nIndex].m_nIndex].m_MapX,
  3625. Npc[Player[nIndex].m_nIndex].m_MapY,
  3626. Npc[Player[nIndex].m_nIndex].m_OffX,
  3627. Npc[Player[nIndex].m_nIndex].m_OffY,
  3628. &nPlayerX,
  3629. &nPlayerY);
  3630. SubWorld[nSubWorldIdx].Map2Mps(
  3631. nRegionIdx,
  3632. Object[nObjIdx].m_nMapX,
  3633. Object[nObjIdx].m_nMapY,
  3634. Object[nObjIdx].m_nOffX,
  3635. Object[nObjIdx].m_nOffY,
  3636. &nObjX,
  3637. &nObjY);
  3638. /*
  3639. Obj_Kind_MapObj = 0, // 地图物件，主要用于地图动画
  3640. Obj_Kind_Body, // npc 的尸体
  3641. Obj_Kind_Box, // 宝箱
  3642. Obj_Kind_Item, // 掉在地上的装备
  3643. Obj_Kind_Money, // 掉在地上的钱
  3644. Obj_Kind_LoopSound, // 循环音效
  3645. Obj_Kind_RandSound, // 随机音效
  3646. Obj_Kind_Light, // 光源（3D模式中发光的东西）
  3647. Obj_Kind_Door, // 门类
  3648. Obj_Kind_Trap, // 陷阱
  3649. Obj_Kind_Prop, // 小道具，可重生
  3650. Obj_Kind_Num, // 物件的种类数
  3651. */
  3652. switch (Object[nObjIdx].m_nKind)
  3653. {
  3654. case Obj_Kind_Box:
  3655. if (g_GetDistance(nPlayerX, nPlayerY, nObjX, nObjY) > defMAX_EXEC_OBJ_SCRIPT_DISTANCE)
  3656. break;
  3657. if (Object[nObjIdx].m_nState == OBJ_BOX_STATE_CLOSE)
  3658. Object[nObjIdx].ExecScript(nIndex);
  3659. break;
  3660. case Obj_Kind_Door:
  3661. break;
  3662. case Obj_Kind_Prop:
  3663. if (g_GetDistance(nPlayerX, nPlayerY, nObjX, nObjY) > defMAX_EXEC_OBJ_SCRIPT_DISTANCE)
  3664. break;
  3665. if (Object[nObjIdx].m_nState == OBJ_PROP_STATE_DISPLAY)
  3666. Object[nObjIdx].ExecScript(nIndex);
  3667. break;
  3668. }
  3669. }
  3671. void KProtocolProcess::StoreMoneyCommand(int nIndex, BYTE* pProtocol)
  3672. {
  3673. STORE_MONEY_COMMAND* pCommand = (STORE_MONEY_COMMAND *)pProtocol;
  3675. if (pCommand->m_byDir) // 取钱
  3676. Player[nIndex].m_ItemList.ExchangeMoney(room_repository, room_equipment, pCommand->m_dwMoney);
  3677. else // 存钱
  3678. Player[nIndex].m_ItemList.ExchangeMoney(room_equipment, room_repository, pCommand->m_dwMoney);
  3680. }
  3682. void KProtocolProcess::NpcReviveCommand(int nIndex, BYTE* pProtocol)
  3683. {
  3684. // NPC_REVIVE_COMMAND* pCommand = (NPC_REVIVE_COMMAND *)pProtocol;
  3686. Player[nIndex].Revive(REMOTE_REVIVE_TYPE);
  3687. }
  3689. void KProtocolProcess::c2sTradeReplyStart(int nIndex, BYTE* pProtocol)
  3690. {
  3691. Player[nIndex].c2sTradeReplyStart(pProtocol);
  3692. }
  3694. void KProtocolProcess::c2sPKApplyChangeNormalFlag(int nIndex, BYTE* pProtocol)
  3695. {
  3696. PK_APPLY_NORMAL_FLAG_COMMAND *pApply = (PK_APPLY_NORMAL_FLAG_COMMAND*)pProtocol;
  3697. Player[nIndex].m_cPK.SetNormalPKState(pApply->m_btFlag);
  3698. }
  3700. void KProtocolProcess::c2sPKApplyEnmity(int nIndex, BYTE* pProtocol)
  3701. {
  3702. PK_APPLY_ENMITY_COMMAND *pApply = (PK_APPLY_ENMITY_COMMAND*)pProtocol;
  3703. if (Player[nIndex].m_nIndex && !Npc[Player[nIndex].m_nIndex].m_FightMode)
  3704. {
  3705. SHOW_MSG_SYNC sMsg;
  3706. sMsg.ProtocolType = s2c_msgshow;
  3707. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_1;
  3708. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  3709. g_pServer->PackDataToClient(Player[nIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  3710. return;
  3711. }
  3712. if (pApply->m_dwNpcID <= 0 || pApply->m_dwNpcID >= MAX_NPC)
  3713. return;
  3714. int nNpcIdx = Player[nIndex].FindAroundNpc(pApply->m_dwNpcID);
  3715. if (nNpcIdx <= 0)
  3716. return;
  3717. if (Npc[nNpcIdx].m_Kind != kind_player || Npc[nNpcIdx].GetPlayerIdx() <= 0)
  3718. return;
  3720. Player[nIndex].m_cPK.EnmityPKOpen(Npc[nNpcIdx].GetPlayerIdx());
  3721. }
  3723. #define defMAX_VIEW_EQUIP_TIME 30
  3724. void KProtocolProcess::c2sViewEquip(int nIndex, BYTE* pProtocol)
  3725. {
  3726. if (g_SubWorldSet.GetGameTime() - Player[nIndex].m_nViewEquipTime < defMAX_VIEW_EQUIP_TIME)
  3727. return;
  3728. Player[nIndex].m_nViewEquipTime = g_SubWorldSet.GetGameTime();
  3730. VIEW_EQUIP_COMMAND *pView = (VIEW_EQUIP_COMMAND*)pProtocol;
  3731. if (pView->m_dwNpcID == Npc[Player[nIndex].m_nIndex].m_dwID)
  3732. return;
  3733. int nPlayerIdx = Player[nIndex].FindAroundPlayer(pView->m_dwNpcID);
  3734. if (nPlayerIdx <= 0)
  3735. return;
  3736. Player[nPlayerIdx].SendEquipItemInfo(nIndex);
  3737. }
  3739. void KProtocolProcess::LadderQuery(int nIndex, BYTE* pProtocol)
  3740. {
  3741. LADDER_QUERY* pLQ = (LADDER_QUERY *)pProtocol;
  3742. if (nIndex > 0 && nIndex < MAX_PLAYER)
  3743. {
  3744. int lnID = Player[nIndex].m_nNetConnectIdx;
  3745. if (lnID >= 0)
  3746. {
  3747. LADDER_DATA LadderData;
  3748. LadderData.ProtocolType = s2c_ladderresult;
  3749. LadderData.dwLadderID = pLQ->dwLadderID;
  3750. void* pData = (void *)Ladder.GetTopTen(LadderData.dwLadderID);
  3751. if (pData)
  3752. {
  3753. memcpy(LadderData.StatData, pData, sizeof(LadderData.StatData));
  3754. g_pServer->PackDataToClient(lnID, &LadderData, sizeof(LadderData));
  3755. }
  3756. }
  3757. }
  3758. }
  3760. void KProtocolProcess::ItemRepair(int nIndex, BYTE* pProtocol)
  3761. {
  3762. ITEM_REPAIR *pIR = (ITEM_REPAIR *)pProtocol;
  3763. if (nIndex > 0 && nIndex < MAX_PLAYER)
  3764. {
  3765. Player[nIndex].RepairItem(pIR->dwItemID);
  3766. }
  3767. }
  3768. #endif