1. #include "StdAfx.h"
  2. #include "PythonNetworkStream.h"
  3. #include "Packet.h"
  5. #include "PythonGuild.h"
  6. #include "PythonCharacterManager.h"
  7. #include "PythonPlayer.h"
  8. #include "PythonBackground.h"
  9. #include "PythonMiniMap.h"
  10. #include "PythonTextTail.h"
  11. #include "PythonItem.h"
  12. #include "PythonChat.h"
  13. #include "PythonShop.h"
  14. #include "PythonExchange.h"
  15. #include "PythonQuest.h"
  16. #include "PythonEventManager.h"
  17. #include "PythonMessenger.h"
  18. #include "PythonApplication.h"
  20. #include "../EterPack/EterPackManager.h"
  21. #include "../gamelib/ItemManager.h"
  23. #include "AbstractApplication.h"
  24. #include "AbstractCharacterManager.h"
  25. #include "InstanceBase.h"
  27. #include "ProcessCRC.h"
  29. BOOL gs_bEmpireLanuageEnable = TRUE;
  31. void CPythonNetworkStream::__RefreshAlignmentWindow()
  32. {
  33. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshAlignment", Py_BuildValue("()"));
  34. }
  36. void CPythonNetworkStream::__RefreshTargetBoardByVID(DWORD dwVID)
  37. {
  38. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByVID", Py_BuildValue("(i)", dwVID));
  39. }
  41. void CPythonNetworkStream::__RefreshTargetBoardByName(const char * c_szName)
  42. {
  43. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByName", Py_BuildValue("(s)", c_szName));
  44. }
  46. void CPythonNetworkStream::__RefreshTargetBoard()
  47. {
  48. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoard", Py_BuildValue("()"));
  49. }
  51. void CPythonNetworkStream::__RefreshGuildWindowGradePage()
  52. {
  53. m_isRefreshGuildWndGradePage=true;
  54. }
  56. void CPythonNetworkStream::__RefreshGuildWindowSkillPage()
  57. {
  58. m_isRefreshGuildWndSkillPage=true;
  59. }
  61. void CPythonNetworkStream::__RefreshGuildWindowMemberPageGradeComboBox()
  62. {
  63. m_isRefreshGuildWndMemberPageGradeComboBox=true;
  64. }
  66. void CPythonNetworkStream::__RefreshGuildWindowMemberPage()
  67. {
  68. m_isRefreshGuildWndMemberPage=true;
  69. }
  71. void CPythonNetworkStream::__RefreshGuildWindowBoardPage()
  72. {
  73. m_isRefreshGuildWndBoardPage=true;
  74. }
  76. void CPythonNetworkStream::__RefreshGuildWindowInfoPage()
  77. {
  78. m_isRefreshGuildWndInfoPage=true;
  79. }
  81. void CPythonNetworkStream::__RefreshMessengerWindow()
  82. {
  83. m_isRefreshMessengerWnd=true;
  84. }
  86. void CPythonNetworkStream::__RefreshSafeboxWindow()
  87. {
  88. m_isRefreshSafeboxWnd=true;
  89. }
  91. void CPythonNetworkStream::__RefreshMallWindow()
  92. {
  93. m_isRefreshMallWnd=true;
  94. }
  96. void CPythonNetworkStream::__RefreshSkillWindow()
  97. {
  98. m_isRefreshSkillWnd=true;
  99. }
  101. void CPythonNetworkStream::__RefreshExchangeWindow()
  102. {
  103. m_isRefreshExchangeWnd=true;
  104. }
  106. void CPythonNetworkStream::__RefreshStatus()
  107. {
  108. m_isRefreshStatus=true;
  109. }
  111. void CPythonNetworkStream::__RefreshCharacterWindow()
  112. {
  113. m_isRefreshCharacterWnd=true;
  114. }
  116. void CPythonNetworkStream::__RefreshInventoryWindow()
  117. {
  118. m_isRefreshInventoryWnd=true;
  119. }
  121. void CPythonNetworkStream::__RefreshEquipmentWindow()
  122. {
  123. m_isRefreshEquipmentWnd=true;
  124. }
  126. void CPythonNetworkStream::__SetGuildID(DWORD id)
  127. {
  128. if (m_dwGuildID != id)
  129. {
  130. m_dwGuildID = id;
  131. IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
  133. for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
  134. if (!strncmp(m_akSimplePlayerInfo[i].szName, rkPlayer.GetName(), CHARACTER_NAME_MAX_LEN))
  135. {
  136. m_adwGuildID[i] = id;
  138. std::string guildName;
  139. if (CPythonGuild::Instance().GetGuildName(id, &guildName))
  140. {
  141. m_astrGuildName[i] = guildName;
  142. }
  143. else
  144. {
  145. m_astrGuildName[i] = "";
  146. }
  147. }
  148. }
  149. }
  151. struct PERF_PacketInfo
  152. {
  153. DWORD dwCount;
  154. DWORD dwTime;
  156. PERF_PacketInfo()
  157. {
  158. dwCount=0;
  159. dwTime=0;
  160. }
  161. };
  164. #ifdef __PERFORMANCE_CHECK__
  166. class PERF_PacketTimeAnalyzer
  167. {
  168. public:
  169. ~PERF_PacketTimeAnalyzer()
  170. {
  171. FILE* fp=fopen("perf_dispatch_packet_result.txt", "w");
  173. for (std::map<DWORD, PERF_PacketInfo>::iterator i=m_kMap_kPacketInfo.begin(); i!=m_kMap_kPacketInfo.end(); ++i)
  174. {
  175. if (i->second.dwTime>0)
  176. fprintf(fp, "header %d: count %d, time %d, tpc %d\n", i->first, i->second.dwCount, i->second.dwTime, i->second.dwTime/i->second.dwCount);
  177. }
  178. fclose(fp);
  179. }
  181. public:
  182. std::map<DWORD, PERF_PacketInfo> m_kMap_kPacketInfo;
  183. };
  185. PERF_PacketTimeAnalyzer gs_kPacketTimeAnalyzer;
  187. #endif
  189. // Game Phase ---------------------------------------------------------------------------
  190. void CPythonNetworkStream::GamePhase()
  191. {
  192. if (!m_kQue_stHack.empty())
  193. {
  194. __SendHack(m_kQue_stHack.front().c_str());
  195. m_kQue_stHack.pop_front();
  196. }
  198. TPacketHeader header = 0;
  199. bool ret = true;
  201. #ifdef __PERFORMANCE_CHECK__
  202. DWORD timeBeginDispatch=timeGetTime();
  204. static std::map<DWORD, PERF_PacketInfo> kMap_kPacketInfo;
  205. kMap_kPacketInfo.clear();
  206. #endif
  208. const DWORD MAX_RECV_COUNT = 4;
  209. const DWORD SAFE_RECV_BUFSIZE = 8192;
  210. DWORD dwRecvCount = 0;
  212. while (ret)
  213. {
  214. if(dwRecvCount++ >= MAX_RECV_COUNT-1 && GetRecvBufferSize() < SAFE_RECV_BUFSIZE
  215. && m_strPhase == "Game") //phase_game ÀÌ ¾Æ´Ï¾îµµ ¿©±â·Î µé¾î¿À´Â °æ¿ì°¡ ÀÖ´Ù.
  216. break;
  218. if (!CheckPacket(&header))
  219. break;
  221. #ifdef __PERFORMANCE_CHECK__
  222. DWORD timeBeginPacket=timeGetTime();
  223. #endif
  225. switch (header)
  226. {
  227. case HEADER_GC_OBSERVER_ADD:
  228. ret = RecvObserverAddPacket();
  229. break;
  230. case HEADER_GC_OBSERVER_REMOVE:
  231. ret = RecvObserverRemovePacket();
  232. break;
  233. case HEADER_GC_OBSERVER_MOVE:
  234. ret = RecvObserverMovePacket();
  235. break;
  236. case HEADER_GC_WARP:
  237. ret = RecvWarpPacket();
  238. break;
  240. case HEADER_GC_PHASE:
  241. ret = RecvPhasePacket();
  242. return; // µµÁß¿¡ Phase °¡ ¹Ù²î¸é ÀÏ´Ü ¹«Á¶°Ç GamePhase Å»Ãâ - [levites]
  243. break;
  245. case HEADER_GC_PVP:
  246. ret = RecvPVPPacket();
  247. break;
  249. case HEADER_GC_DUEL_START:
  250. ret = RecvDuelStartPacket();
  251. break;
  253. case HEADER_GC_CHARACTER_ADD:
  254. ret = RecvCharacterAppendPacket();
  255. break;
  257. case HEADER_GC_CHAR_ADDITIONAL_INFO:
  258. ret = RecvCharacterAdditionalInfo();
  259. break;
  261. case HEADER_GC_CHARACTER_ADD2:
  262. ret = RecvCharacterAppendPacketNew();
  263. break;
  265. case HEADER_GC_CHARACTER_UPDATE:
  266. ret = RecvCharacterUpdatePacket();
  267. break;
  269. case HEADER_GC_CHARACTER_UPDATE2:
  270. ret = RecvCharacterUpdatePacketNew();
  271. break;
  273. case HEADER_GC_CHARACTER_DEL:
  274. ret = RecvCharacterDeletePacket();
  275. break;
  277. case HEADER_GC_CHAT:
  278. ret = RecvChatPacket();
  279. break;
  281. case HEADER_GC_SYNC_POSITION:
  282. ret = RecvSyncPositionPacket();
  283. break;
  285. case HEADER_GC_OWNERSHIP:
  286. ret = RecvOwnerShipPacket();
  287. break;
  289. case HEADER_GC_WHISPER:
  290. ret = RecvWhisperPacket();
  291. break;
  293. case HEADER_GC_CHARACTER_MOVE:
  294. ret = RecvCharacterMovePacket();
  295. break;
  297. // Position
  298. case HEADER_GC_CHARACTER_POSITION:
  299. ret = RecvCharacterPositionPacket();
  300. break;
  302. // Battle Packet
  303. case HEADER_GC_STUN:
  304. ret = RecvStunPacket();
  305. break;
  307. case HEADER_GC_DEAD:
  308. ret = RecvDeadPacket();
  309. break;
  311. case HEADER_GC_PLAYER_POINT_CHANGE:
  312. ret = RecvPointChange();
  313. break;
  315. // item packet.
  316. case HEADER_GC_ITEM_SET:
  317. ret = RecvItemSetPacket();
  318. break;
  320. case HEADER_GC_ITEM_SET2:
  321. ret = RecvItemSetPacket2();
  322. break;
  324. case HEADER_GC_ITEM_USE:
  325. ret = RecvItemUsePacket();
  326. break;
  328. case HEADER_GC_ITEM_UPDATE:
  329. ret = RecvItemUpdatePacket();
  330. break;
  332. case HEADER_GC_ITEM_GROUND_ADD:
  333. ret = RecvItemGroundAddPacket();
  334. break;
  336. case HEADER_GC_ITEM_GROUND_DEL:
  337. ret = RecvItemGroundDelPacket();
  338. break;
  340. case HEADER_GC_ITEM_OWNERSHIP:
  341. ret = RecvItemOwnership();
  342. break;
  344. case HEADER_GC_QUICKSLOT_ADD:
  345. ret = RecvQuickSlotAddPacket();
  346. break;
  348. case HEADER_GC_QUICKSLOT_DEL:
  349. ret = RecvQuickSlotDelPacket();
  350. break;
  352. case HEADER_GC_QUICKSLOT_SWAP:
  353. ret = RecvQuickSlotMovePacket();
  354. break;
  356. case HEADER_GC_MOTION:
  357. ret = RecvMotionPacket();
  358. break;
  360. case HEADER_GC_SHOP:
  361. ret = RecvShopPacket();
  362. break;
  364. case HEADER_GC_SHOP_SIGN:
  365. ret = RecvShopSignPacket();
  366. break;
  368. case HEADER_GC_OFFLINE_SHOP:
  369. ret = RecvOfflineShopPacket();
  370. break;
  372. case HEADER_GC_OFFLINE_SHOP_SIGN:
  373. ret = RecvOfflineShopSignPacket();
  374. break;
  376. case HEADER_GC_EXCHANGE:
  377. ret = RecvExchangePacket();
  378. break;
  380. case HEADER_GC_QUEST_INFO:
  381. ret = RecvQuestInfoPacket();
  382. break;
  384. case HEADER_GC_REQUEST_MAKE_GUILD:
  385. ret = RecvRequestMakeGuild();
  386. break;
  388. case HEADER_GC_PING:
  389. ret = RecvPingPacket();
  390. break;
  392. case HEADER_GC_SCRIPT:
  393. ret = RecvScriptPacket();
  394. break;
  396. case HEADER_GC_QUEST_CONFIRM:
  397. ret = RecvQuestConfirmPacket();
  398. break;
  400. case HEADER_GC_TARGET:
  401. ret = RecvTargetPacket();
  402. break;
  404. case HEADER_GC_DAMAGE_INFO:
  405. ret = RecvDamageInfoPacket();
  406. break;
  408. case HEADER_GC_MOUNT:
  409. ret = RecvMountPacket();
  410. break;
  412. case HEADER_GC_CHANGE_SPEED:
  413. ret = RecvChangeSpeedPacket();
  414. break;
  416. case HEADER_GC_PLAYER_POINTS:
  417. ret = __RecvPlayerPoints();
  418. break;
  420. case HEADER_GC_CREATE_FLY:
  421. ret = RecvCreateFlyPacket();
  422. break;
  424. case HEADER_GC_FLY_TARGETING:
  425. ret = RecvFlyTargetingPacket();
  426. break;
  428. case HEADER_GC_ADD_FLY_TARGETING:
  429. ret = RecvAddFlyTargetingPacket();
  430. break;
  432. case HEADER_GC_SKILL_LEVEL:
  433. ret = RecvSkillLevel();
  434. break;
  436. case HEADER_GC_SKILL_LEVEL_NEW:
  437. ret = RecvSkillLevelNew();
  438. break;
  440. case HEADER_GC_MESSENGER:
  441. ret = RecvMessenger();
  442. break;
  444. case HEADER_GC_GUILD:
  445. ret = RecvGuild();
  446. break;
  448. case HEADER_GC_PARTY_INVITE:
  449. ret = RecvPartyInvite();
  450. break;
  452. case HEADER_GC_PARTY_ADD:
  453. ret = RecvPartyAdd();
  454. break;
  456. case HEADER_GC_PARTY_UPDATE:
  457. ret = RecvPartyUpdate();
  458. break;
  460. case HEADER_GC_PARTY_REMOVE:
  461. ret = RecvPartyRemove();
  462. break;
  464. case HEADER_GC_PARTY_LINK:
  465. ret = RecvPartyLink();
  466. break;
  468. case HEADER_GC_PARTY_UNLINK:
  469. ret = RecvPartyUnlink();
  470. break;
  472. case HEADER_GC_PARTY_PARAMETER:
  473. ret = RecvPartyParameter();
  474. break;
  476. case HEADER_GC_SAFEBOX_SET:
  477. ret = RecvSafeBoxSetPacket();
  478. break;
  480. case HEADER_GC_SAFEBOX_DEL:
  481. ret = RecvSafeBoxDelPacket();
  482. break;
  484. case HEADER_GC_SAFEBOX_WRONG_PASSWORD:
  485. ret = RecvSafeBoxWrongPasswordPacket();
  486. break;
  488. case HEADER_GC_SAFEBOX_SIZE:
  489. ret = RecvSafeBoxSizePacket();
  490. break;
  492. case HEADER_GC_SAFEBOX_MONEY_CHANGE:
  493. ret = RecvSafeBoxMoneyChangePacket();
  494. break;
  496. case HEADER_GC_FISHING:
  497. ret = RecvFishing();
  498. break;
  500. case HEADER_GC_DUNGEON:
  501. ret = RecvDungeon();
  502. break;
  504. case HEADER_GC_TIME:
  505. ret = RecvTimePacket();
  506. break;
  508. case HEADER_GC_WALK_MODE:
  509. ret = RecvWalkModePacket();
  510. break;
  512. case HEADER_GC_CHANGE_SKILL_GROUP:
  513. ret = RecvChangeSkillGroupPacket();
  514. break;
  516. case HEADER_GC_REFINE_INFORMATION:
  517. ret = RecvRefineInformationPacket();
  518. break;
  520. case HEADER_GC_REFINE_INFORMATION_NEW:
  521. ret = RecvRefineInformationPacketNew();
  522. break;
  524. case HEADER_GC_SEPCIAL_EFFECT:
  525. ret = RecvSpecialEffect();
  526. break;
  528. case HEADER_GC_NPC_POSITION:
  529. ret = RecvNPCList();
  530. break;
  532. case HEADER_GC_CHANNEL:
  533. ret = RecvChannelPacket();
  534. break;
  536. case HEADER_GC_VIEW_EQUIP:
  537. ret = RecvViewEquipPacket();
  538. break;
  540. case HEADER_GC_LAND_LIST:
  541. ret = RecvLandPacket();
  542. break;
  544. //case HEADER_GC_TARGET_CREATE:
  545. // ret = RecvTargetCreatePacket();
  546. // break;
  548. case HEADER_GC_TARGET_CREATE_NEW:
  549. ret = RecvTargetCreatePacketNew();
  550. break;
  552. case HEADER_GC_TARGET_UPDATE:
  553. ret = RecvTargetUpdatePacket();
  554. break;
  556. case HEADER_GC_TARGET_DELETE:
  557. ret = RecvTargetDeletePacket();
  558. break;
  560. case HEADER_GC_AFFECT_ADD:
  561. ret = RecvAffectAddPacket();
  562. break;
  564. case HEADER_GC_AFFECT_REMOVE:
  565. ret = RecvAffectRemovePacket();
  566. break;
  568. case HEADER_GC_MALL_OPEN:
  569. ret = RecvMallOpenPacket();
  570. break;
  572. case HEADER_GC_MALL_SET:
  573. ret = RecvMallItemSetPacket();
  574. break;
  576. case HEADER_GC_MALL_DEL:
  577. ret = RecvMallItemDelPacket();
  578. break;
  580. case HEADER_GC_LOVER_INFO:
  581. ret = RecvLoverInfoPacket();
  582. break;
  584. case HEADER_GC_LOVE_POINT_UPDATE:
  585. ret = RecvLovePointUpdatePacket();
  586. break;
  588. case HEADER_GC_DIG_MOTION:
  589. ret = RecvDigMotionPacket();
  590. break;
  592. case HEADER_GC_HANDSHAKE:
  593. RecvHandshakePacket();
  594. return;
  595. break;
  597. case HEADER_GC_HANDSHAKE_OK:
  598. RecvHandshakeOKPacket();
  599. return;
  600. break;
  602. case HEADER_GC_HYBRIDCRYPT_KEYS:
  603. RecvHybridCryptKeyPacket();
  604. return;
  605. break;
  607. case HEADER_GC_HYBRIDCRYPT_SDB:
  608. RecvHybridCryptSDBPacket();
  609. return;
  610. break;
  613. #ifdef _IMPROVED_PACKET_ENCRYPTION_
  614. case HEADER_GC_KEY_AGREEMENT:
  615. RecvKeyAgreementPacket();
  616. return;
  617. break;
  619. case HEADER_GC_KEY_AGREEMENT_COMPLETED:
  620. RecvKeyAgreementCompletedPacket();
  621. return;
  622. break;
  623. #endif
  625. case HEADER_GC_HS_REQUEST:
  626. ret = RecvHSCheckRequest();
  627. break;
  629. case HEADER_GC_XTRAP_CS1_REQUEST:
  630. ret = RecvXTrapVerifyRequest();
  631. break;
  633. case HEADER_GC_SPECIFIC_EFFECT:
  634. ret = RecvSpecificEffect();
  635. break;
  637. case HEADER_GC_DRAGON_SOUL_REFINE:
  638. #ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
  639. case HEADER_GC_SUPPORT_SHAMAN_SKILL:
  640. ret = RecvSupportShamanUseSkill();
  641. break;
  642. #endif
  643. ret = RecvDragonSoulRefine();
  644. break;
  646. default:
  647. ret = RecvDefaultPacket(header);
  648. break;
  649. }
  650. #ifdef __PERFORMANCE_CHECK__
  651. DWORD timeEndPacket=timeGetTime();
  653. {
  654. PERF_PacketInfo& rkPacketInfo=kMap_kPacketInfo[header];
  655. rkPacketInfo.dwCount++;
  656. rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
  657. }
  659. {
  660. PERF_PacketInfo& rkPacketInfo=gs_kPacketTimeAnalyzer.m_kMap_kPacketInfo[header];
  661. rkPacketInfo.dwCount++;
  662. rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
  663. }
  664. #endif
  665. }
  667. #ifdef __PERFORMANCE_CHECK__
  668. DWORD timeEndDispatch=timeGetTime();
  670. if (timeEndDispatch-timeBeginDispatch>2)
  671. {
  672. static FILE* fp=fopen("perf_dispatch_packet.txt", "w");
  674. fprintf(fp, "delay %d\n", timeEndDispatch-timeBeginDispatch);
  675. for (std::map<DWORD, PERF_PacketInfo>::iterator i=kMap_kPacketInfo.begin(); i!=kMap_kPacketInfo.end(); ++i)
  676. {
  677. if (i->second.dwTime>0)
  678. fprintf(fp, "header %d: count %d, time %d\n", i->first, i->second.dwCount, i->second.dwTime);
  679. }
  680. fputs("=====================================================\n", fp);
  681. fflush(fp);
  682. }
  683. #endif
  685. if (!ret)
  686. RecvErrorPacket(header);
  688. static DWORD s_nextRefreshTime = ELTimer_GetMSec();
  690. DWORD curTime = ELTimer_GetMSec();
  691. if (s_nextRefreshTime > curTime)
  692. return;
  696. if (m_isRefreshCharacterWnd)
  697. {
  698. m_isRefreshCharacterWnd=false;
  699. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
  700. s_nextRefreshTime = curTime + 300;
  701. }
  703. if (m_isRefreshEquipmentWnd)
  704. {
  705. m_isRefreshEquipmentWnd=false;
  706. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEquipment", Py_BuildValue("()"));
  707. s_nextRefreshTime = curTime + 300;
  708. }
  710. if (m_isRefreshInventoryWnd)
  711. {
  712. m_isRefreshInventoryWnd=false;
  713. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshInventory", Py_BuildValue("()"));
  714. s_nextRefreshTime = curTime + 300;
  715. }
  717. if (m_isRefreshExchangeWnd)
  718. {
  719. m_isRefreshExchangeWnd=false;
  720. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshExchange", Py_BuildValue("()"));
  721. s_nextRefreshTime = curTime + 300;
  722. }
  724. if (m_isRefreshSkillWnd)
  725. {
  726. m_isRefreshSkillWnd=false;
  727. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSkill", Py_BuildValue("()"));
  728. s_nextRefreshTime = curTime + 300;
  729. }
  731. if (m_isRefreshSafeboxWnd)
  732. {
  733. m_isRefreshSafeboxWnd=false;
  734. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafebox", Py_BuildValue("()"));
  735. s_nextRefreshTime = curTime + 300;
  736. }
  738. if (m_isRefreshMallWnd)
  739. {
  740. m_isRefreshMallWnd=false;
  741. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMall", Py_BuildValue("()"));
  742. s_nextRefreshTime = curTime + 300;
  743. }
  745. if (m_isRefreshStatus)
  746. {
  747. m_isRefreshStatus=false;
  748. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()"));
  749. s_nextRefreshTime = curTime + 300;
  750. }
  752. if (m_isRefreshMessengerWnd)
  753. {
  754. m_isRefreshMessengerWnd=false;
  755. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMessenger", Py_BuildValue("()"));
  756. s_nextRefreshTime = curTime + 300;
  757. }
  759. if (m_isRefreshGuildWndInfoPage)
  760. {
  761. m_isRefreshGuildWndInfoPage=false;
  762. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildInfoPage", Py_BuildValue("()"));
  763. s_nextRefreshTime = curTime + 300;
  764. }
  766. if (m_isRefreshGuildWndBoardPage)
  767. {
  768. m_isRefreshGuildWndBoardPage=false;
  769. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildBoardPage", Py_BuildValue("()"));
  770. s_nextRefreshTime = curTime + 300;
  771. }
  773. if (m_isRefreshGuildWndMemberPage)
  774. {
  775. m_isRefreshGuildWndMemberPage=false;
  776. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPage", Py_BuildValue("()"));
  777. s_nextRefreshTime = curTime + 300;
  778. }
  780. if (m_isRefreshGuildWndMemberPageGradeComboBox)
  781. {
  782. m_isRefreshGuildWndMemberPageGradeComboBox=false;
  783. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPageGradeComboBox", Py_BuildValue("()"));
  784. s_nextRefreshTime = curTime + 300;
  785. }
  787. if (m_isRefreshGuildWndSkillPage)
  788. {
  789. m_isRefreshGuildWndSkillPage=false;
  790. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildSkillPage", Py_BuildValue("()"));
  791. s_nextRefreshTime = curTime + 300;
  792. }
  794. if (m_isRefreshGuildWndGradePage)
  795. {
  796. m_isRefreshGuildWndGradePage=false;
  797. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGradePage", Py_BuildValue("()"));
  798. s_nextRefreshTime = curTime + 300;
  799. }
  800. }
  802. void CPythonNetworkStream::__InitializeGamePhase()
  803. {
  804. __ServerTimeSync_Initialize();
  806. m_isRefreshStatus=false;
  807. m_isRefreshCharacterWnd=false;
  808. m_isRefreshEquipmentWnd=false;
  809. m_isRefreshInventoryWnd=false;
  810. m_isRefreshExchangeWnd=false;
  811. m_isRefreshSkillWnd=false;
  812. m_isRefreshSafeboxWnd=false;
  813. m_isRefreshMallWnd=false;
  814. m_isRefreshMessengerWnd=false;
  815. m_isRefreshGuildWndInfoPage=false;
  816. m_isRefreshGuildWndBoardPage=false;
  817. m_isRefreshGuildWndMemberPage=false;
  818. m_isRefreshGuildWndMemberPageGradeComboBox=false;
  819. m_isRefreshGuildWndSkillPage=false;
  820. m_isRefreshGuildWndGradePage=false;
  822. m_EmoticonStringVector.clear();
  824. m_pInstTarget = NULL;
  825. }
  827. void CPythonNetworkStream::Warp(LONG lGlobalX, LONG lGlobalY)
  828. {
  829. CPythonBackground& rkBgMgr=CPythonBackground::Instance();
  830. rkBgMgr.Destroy();
  831. rkBgMgr.Create();
  832. rkBgMgr.Warp(lGlobalX, lGlobalY);
  833. //rkBgMgr.SetShadowLevel(CPythonBackground::SHADOW_ALL);
  834. rkBgMgr.RefreshShadowLevel();
  836. // NOTE : Warp ÇßÀ»¶§ CenterPositionÀÇ Height°¡ 0À̱⠶§¹®¿¡ Ä«¸Ş¶ó°¡ ¶¥¹Ù´Ú¿¡ ¹ÚÇôÀÖ°Ô µÊ
  837. // ¿òÁ÷À϶§¸¶´Ù Height°¡ °»½Å µÇ±â ¶§¹®À̹ǷΠ¸ÊÀ» À̵¿Çϸé PositionÀ» °­Á¦·Î Çѹø
  838. // ¼ÂÆÃÇØÁØ´Ù - [levites]
  839. LONG lLocalX = lGlobalX;
  840. LONG lLocalY = lGlobalY;
  841. __GlobalPositionToLocalPosition(lLocalX, lLocalY);
  842. float fHeight = CPythonBackground::Instance().GetHeight(float(lLocalX), float(lLocalY));
  844. IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
  845. rkApp.SetCenterPosition(float(lLocalX), float(lLocalY), fHeight);
  847. __ShowMapName(lLocalX, lLocalY);
  848. }
  850. void CPythonNetworkStream::__ShowMapName(LONG lLocalX, LONG lLocalY)
  851. {
  852. const std::string & c_rstrMapFileName = CPythonBackground::Instance().GetWarpMapName();
  853. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ShowMapName", Py_BuildValue("(sii)", c_rstrMapFileName.c_str(), lLocalX, lLocalY));
  854. }
  856. void CPythonNetworkStream::__LeaveGamePhase()
  857. {
  858. CInstanceBase::ClearPVPKeySystem();
  860. __ClearNetworkActorManager();
  862. m_bComboSkillFlag = FALSE;
  864. IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
  865. rkChrMgr.Destroy();
  867. CPythonItem& rkItemMgr=CPythonItem::Instance();
  868. rkItemMgr.Destroy();
  869. }
  871. void CPythonNetworkStream::SetGamePhase()
  872. {
  873. if ("Game"!=m_strPhase)
  874. m_phaseLeaveFunc.Run();
  876. Tracen("");
  877. Tracen("## Network - Game Phase ##");
  878. Tracen("");
  880. m_strPhase = "Game";
  882. m_dwChangingPhaseTime = ELTimer_GetMSec();
  883. m_phaseProcessFunc.Set(this, &CPythonNetworkStream::GamePhase);
  884. m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveGamePhase);
  886. // Main Character µî·ÏO
  888. IAbstractPlayer & rkPlayer = IAbstractPlayer::GetSingleton();
  889. rkPlayer.SetMainCharacterIndex(GetMainActorVID());
  891. __RefreshStatus();
  892. }
  894. bool CPythonNetworkStream::RecvObserverAddPacket()
  895. {
  896. TPacketGCObserverAdd kObserverAddPacket;
  897. if (!Recv(sizeof(kObserverAddPacket), &kObserverAddPacket))
  898. return false;
  900. CPythonMiniMap::Instance().AddObserver(
  901. kObserverAddPacket.vid,
  902. kObserverAddPacket.x*100.0f,
  903. kObserverAddPacket.y*100.0f);
  905. return true;
  906. }
  908. bool CPythonNetworkStream::RecvObserverRemovePacket()
  909. {
  910. TPacketGCObserverAdd kObserverRemovePacket;
  911. if (!Recv(sizeof(kObserverRemovePacket), &kObserverRemovePacket))
  912. return false;
  914. CPythonMiniMap::Instance().RemoveObserver(
  915. kObserverRemovePacket.vid
  916. );
  918. return true;
  919. }
  921. bool CPythonNetworkStream::RecvObserverMovePacket()
  922. {
  923. TPacketGCObserverMove kObserverMovePacket;
  924. if (!Recv(sizeof(kObserverMovePacket), &kObserverMovePacket))
  925. return false;
  927. CPythonMiniMap::Instance().MoveObserver(
  928. kObserverMovePacket.vid,
  929. kObserverMovePacket.x*100.0f,
  930. kObserverMovePacket.y*100.0f);
  932. return true;
  933. }
  936. bool CPythonNetworkStream::RecvWarpPacket()
  937. {
  938. TPacketGCWarp kWarpPacket;
  940. if (!Recv(sizeof(kWarpPacket), &kWarpPacket))
  941. return false;
  943. __DirectEnterMode_Set(m_dwSelectedCharacterIndex);
  945. CNetworkStream::Connect((DWORD)kWarpPacket.lAddr, kWarpPacket.wPort);
  947. return true;
  948. }
  950. bool CPythonNetworkStream::RecvDuelStartPacket()
  951. {
  952. TPacketGCDuelStart kDuelStartPacket;
  953. if (!Recv(sizeof(kDuelStartPacket), &kDuelStartPacket))
  954. return false;
  956. DWORD count = (kDuelStartPacket.wSize - sizeof(kDuelStartPacket))/sizeof(DWORD);
  958. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  960. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  961. if (!pkInstMain)
  962. {
  963. TraceError("CPythonNetworkStream::RecvDuelStartPacket - MainCharacter is NULL");
  964. return false;
  965. }
  966. DWORD dwVIDSrc = pkInstMain->GetVirtualID();
  967. DWORD dwVIDDest;
  969. for ( DWORD i = 0; i < count; i++)
  970. {
  971. Recv(sizeof(dwVIDDest),&dwVIDDest);
  972. CInstanceBase::InsertDUELKey(dwVIDSrc,dwVIDDest);
  973. }
  975. if(count == 0)
  976. pkInstMain->SetDuelMode(CInstanceBase::DUEL_CANNOTATTACK);
  977. else
  978. pkInstMain->SetDuelMode(CInstanceBase::DUEL_START);
  980. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  982. rkChrMgr.RefreshAllPCTextTail();
  984. return true;
  985. }
  987. bool CPythonNetworkStream::RecvPVPPacket()
  988. {
  989. TPacketGCPVP kPVPPacket;
  990. if (!Recv(sizeof(kPVPPacket), &kPVPPacket))
  991. return false;
  993. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  994. CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
  996. switch (kPVPPacket.bMode)
  997. {
  998. case PVP_MODE_AGREE:
  999. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1001. // »ó´ë°¡ ³ª(Dst)¿¡°Ô µ¿ÀǸ¦ ±¸ÇßÀ»¶§
  1002. if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDDst))
  1003. rkPlayer.RememberChallengeInstance(kPVPPacket.dwVIDSrc);
  1005. // »ó´ë¿¡°Ô µ¿ÀǸ¦ ±¸ÇÑ µ¿¾È¿¡´Â ´ë°á ºÒ´É
  1006. if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDSrc))
  1007. rkPlayer.RememberCantFightInstance(kPVPPacket.dwVIDDst);
  1008. break;
  1009. case PVP_MODE_REVENGE:
  1010. {
  1011. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1013. DWORD dwKiller = kPVPPacket.dwVIDSrc;
  1014. DWORD dwVictim = kPVPPacket.dwVIDDst;
  1016. // ³»(victim)°¡ »ó´ë¿¡°Ô º¹¼öÇÒ ¼ö ÀÖÀ»¶§
  1017. if (rkPlayer.IsMainCharacterIndex(dwVictim))
  1018. rkPlayer.RememberRevengeInstance(dwKiller);
  1020. // »ó´ë(victim)°¡ ³ª¿¡°Ô º¹¼öÇÏ´Â µ¿¾È¿¡´Â ´ë°á ºÒ´É
  1021. if (rkPlayer.IsMainCharacterIndex(dwKiller))
  1022. rkPlayer.RememberCantFightInstance(dwVictim);
  1023. break;
  1024. }
  1026. case PVP_MODE_FIGHT:
  1027. rkChrMgr.InsertPVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1028. rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
  1029. rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
  1030. break;
  1031. case PVP_MODE_NONE:
  1032. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1033. rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
  1034. rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
  1035. break;
  1036. }
  1038. // NOTE : PVP Åä±Û½Ã TargetBoard ¸¦ ¾÷µ¥ÀÌÆ® ÇÕ´Ï´Ù.
  1039. __RefreshTargetBoardByVID(kPVPPacket.dwVIDSrc);
  1040. __RefreshTargetBoardByVID(kPVPPacket.dwVIDDst);
  1042. return true;
  1043. }
  1045. // DELETEME
  1046. /*
  1047. void CPythonNetworkStream::__SendWarpPacket()
  1048. {
  1049. TPacketCGWarp kWarpPacket;
  1050. kWarpPacket.bHeader=HEADER_GC_WARP;
  1051. if (!Send(sizeof(kWarpPacket), &kWarpPacket))
  1052. {
  1053. return;
  1054. }
  1055. }
  1056. */
  1057. void CPythonNetworkStream::NotifyHack(const char* c_szMsg)
  1058. {
  1059. if (!m_kQue_stHack.empty())
  1060. if (c_szMsg==m_kQue_stHack.back())
  1061. return;
  1063. m_kQue_stHack.push_back(c_szMsg);
  1064. }
  1066. bool CPythonNetworkStream::__SendHack(const char* c_szMsg)
  1067. {
  1068. Tracen(c_szMsg);
  1070. TPacketCGHack kPacketHack;
  1071. kPacketHack.bHeader=HEADER_CG_HACK;
  1072. strncpy(kPacketHack.szBuf, c_szMsg, sizeof(kPacketHack.szBuf)-1);
  1074. if (!Send(sizeof(kPacketHack), &kPacketHack))
  1075. return false;
  1077. return SendSequence();
  1078. }
  1080. bool CPythonNetworkStream::SendMessengerAddByVIDPacket(DWORD vid)
  1081. {
  1082. TPacketCGMessenger packet;
  1083. packet.header = HEADER_CG_MESSENGER;
  1084. packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_VID;
  1085. if (!Send(sizeof(packet), &packet))
  1086. return false;
  1087. if (!Send(sizeof(vid), &vid))
  1088. return false;
  1089. return SendSequence();
  1090. }
  1092. bool CPythonNetworkStream::SendMessengerAddByNamePacket(const char * c_szName)
  1093. {
  1094. TPacketCGMessenger packet;
  1095. packet.header = HEADER_CG_MESSENGER;
  1096. packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_NAME;
  1097. if (!Send(sizeof(packet), &packet))
  1098. return false;
  1099. char szName[CHARACTER_NAME_MAX_LEN];
  1100. strncpy(szName, c_szName, CHARACTER_NAME_MAX_LEN-1);
  1101. szName[CHARACTER_NAME_MAX_LEN-1] = '\0'; // #720: ¸Ş½ÅÀú À̸§ °ü·Ã ¹öÆÛ ¿À¹öÇÃ·Î¿ì ¹ö±× ¼öÁ¤
  1103. if (!Send(sizeof(szName), &szName))
  1104. return false;
  1105. Tracef(" SendMessengerAddByNamePacket : %s\n", c_szName);
  1106. return SendSequence();
  1107. }
  1109. bool CPythonNetworkStream::SendMessengerRemovePacket(const char * c_szKey, const char * c_szName)
  1110. {
  1111. TPacketCGMessenger packet;
  1112. packet.header = HEADER_CG_MESSENGER;
  1113. packet.subheader = MESSENGER_SUBHEADER_CG_REMOVE;
  1114. if (!Send(sizeof(packet), &packet))
  1115. return false;
  1116. char szKey[CHARACTER_NAME_MAX_LEN];
  1117. strncpy(szKey, c_szKey, CHARACTER_NAME_MAX_LEN-1);
  1118. if (!Send(sizeof(szKey), &szKey))
  1119. return false;
  1120. __RefreshTargetBoardByName(c_szName);
  1121. return SendSequence();
  1122. }
  1124. bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1125. {
  1126. NANOBEGIN
  1127. if (!__CanActMainInstance())
  1128. return true;
  1130. if (fDstRot < 0.0f)
  1131. fDstRot = 360 + fDstRot;
  1132. else if (fDstRot > 360.0f)
  1133. fDstRot = fmodf(fDstRot, 360.0f);
  1135. // TODO: ³ªÁß¿¡ ÆĞŶÀ̸§À» ¹Ù²ÙÀÚ
  1136. TPacketCGMove kStatePacket;
  1137. kStatePacket.bHeader = HEADER_CG_CHARACTER_MOVE;
  1138. kStatePacket.bFunc = eFunc;
  1139. kStatePacket.bArg = uArg;
  1140. kStatePacket.bRot = fDstRot/5.0f;
  1141. kStatePacket.lX = long(c_rkPPosDst.x);
  1142. kStatePacket.lY = long(c_rkPPosDst.y);
  1143. kStatePacket.dwTime = ELTimer_GetServerMSec();
  1145. assert(kStatePacket.lX >= 0 && kStatePacket.lX < 204800);
  1147. __LocalPositionToGlobalPosition(kStatePacket.lX, kStatePacket.lY);
  1149. if (!Send(sizeof(kStatePacket), &kStatePacket))
  1150. {
  1151. Tracenf("CPythonNetworkStream::SendCharacterStatePacket(dwCmdTime=%u, fDstPos=(%f, %f), fDstRot=%f, eFunc=%d uArg=%d) - PACKET SEND ERROR",
  1152. kStatePacket.dwTime,
  1153. float(kStatePacket.lX),
  1154. float(kStatePacket.lY),
  1155. fDstRot,
  1156. kStatePacket.bFunc,
  1157. kStatePacket.bArg);
  1158. return false;
  1159. }
  1160. NANOEND
  1161. return SendSequence();
  1162. }
  1164. // NOTE : SlotIndex´Â ÀÓ½Ã
  1165. bool CPythonNetworkStream::SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID)
  1166. {
  1167. TPacketCGUseSkill UseSkillPacket;
  1168. UseSkillPacket.bHeader = HEADER_CG_USE_SKILL;
  1169. UseSkillPacket.dwVnum = dwSkillIndex;
  1170. UseSkillPacket.dwTargetVID = dwTargetVID;
  1171. if (!Send(sizeof(TPacketCGUseSkill), &UseSkillPacket))
  1172. {
  1173. Tracen("CPythonNetworkStream::SendUseSkillPacket - SEND PACKET ERROR");
  1174. return false;
  1175. }
  1177. return SendSequence();
  1178. }
  1180. bool CPythonNetworkStream::SendChatPacket(const char * c_szChat, BYTE byType)
  1181. {
  1182. if (strlen(c_szChat) == 0)
  1183. return true;
  1185. if (strlen(c_szChat) >= 512)
  1186. return true;
  1188. if (c_szChat[0] == '/')
  1189. {
  1190. if (1 == strlen(c_szChat))
  1191. {
  1192. if (!m_strLastCommand.empty())
  1193. c_szChat = m_strLastCommand.c_str();
  1194. }
  1195. else
  1196. {
  1197. m_strLastCommand = c_szChat;
  1198. }
  1199. }
  1201. if (ClientCommand(c_szChat))
  1202. return true;
  1204. int iTextLen = strlen(c_szChat) + 1;
  1205. TPacketCGChat ChatPacket;
  1206. ChatPacket.header = HEADER_CG_CHAT;
  1207. ChatPacket.length = sizeof(ChatPacket) + iTextLen;
  1208. ChatPacket.type = byType;
  1210. if (!Send(sizeof(ChatPacket), &ChatPacket))
  1211. return false;
  1213. if (!Send(iTextLen, c_szChat))
  1214. return false;
  1216. return SendSequence();
  1217. }
  1219. //////////////////////////////////////////////////////////////////////////
  1220. // Emoticon
  1221. void CPythonNetworkStream::RegisterEmoticonString(const char * pcEmoticonString)
  1222. {
  1223. if (m_EmoticonStringVector.size() >= CInstanceBase::EMOTICON_NUM)
  1224. {
  1225. TraceError("Can't register emoticon string... vector is full (size:%d)", m_EmoticonStringVector.size() );
  1226. return;
  1227. }
  1228. m_EmoticonStringVector.push_back(pcEmoticonString);
  1229. }
  1231. bool CPythonNetworkStream::ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon)
  1232. {
  1233. for (DWORD dwEmoticonIndex = 0; dwEmoticonIndex < m_EmoticonStringVector.size() ; ++dwEmoticonIndex)
  1234. {
  1235. if (strlen(pChatMsg) > m_EmoticonStringVector[dwEmoticonIndex].size())
  1236. continue;
  1238. const char * pcFind = strstr(pChatMsg, m_EmoticonStringVector[dwEmoticonIndex].c_str());
  1240. if (pcFind != pChatMsg)
  1241. continue;
  1243. *pdwEmoticon = dwEmoticonIndex;
  1245. return true;
  1246. }
  1248. return false;
  1249. }
  1250. // Emoticon
  1251. //////////////////////////////////////////////////////////////////////////
  1253. void CPythonNetworkStream::__ConvertEmpireText(DWORD dwEmpireID, char* szText)
  1254. {
  1255. if (dwEmpireID<1 || dwEmpireID>3)
  1256. return;
  1258. UINT uHanPos;
  1260. STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1];
  1262. BYTE* pbText=(BYTE*)szText;
  1263. while (*pbText)
  1264. {
  1265. if (*pbText & 0x80)
  1266. {
  1267. if (pbText[0]>=0xb0 && pbText[0]<=0xc8 && pbText[1]>=0xa1 && pbText[1]<=0xfe)
  1268. {
  1269. uHanPos=(pbText[0]-0xb0)*(0xfe-0xa1+1)+(pbText[1]-0xa1);
  1270. pbText[0]=rkTextConvTable.aacHan[uHanPos][0];
  1271. pbText[1]=rkTextConvTable.aacHan[uHanPos][1];
  1272. }
  1273. pbText+=2;
  1274. }
  1275. else
  1276. {
  1277. if (*pbText>='a' && *pbText<='z')
  1278. {
  1279. *pbText=rkTextConvTable.acLower[*pbText-'a'];
  1280. }
  1281. else if (*pbText>='A' && *pbText<='Z')
  1282. {
  1283. *pbText=rkTextConvTable.acUpper[*pbText-'A'];
  1284. }
  1285. pbText++;
  1286. }
  1287. }
  1288. }
  1290. bool CPythonNetworkStream::RecvChatPacket()
  1291. {
  1292. TPacketGCChat kChat;
  1293. char buf[1024 + 1];
  1294. char line[1024 + 1];
  1296. if (!Recv(sizeof(kChat), &kChat))
  1297. return false;
  1299. UINT uChatSize=kChat.size - sizeof(kChat);
  1301. if (!Recv(uChatSize, buf))
  1302. return false;
  1304. buf[uChatSize]='\0';
  1306. // À¯·´ ¾Æ¶ø ¹öÀü ó¸®
  1307. // "À̸§: ³»¿ë" ÀÔ·ÂÀ» "³»¿ë: À̸§" ¼ø¼­·Î Ãâ·ÂÇϱâ À§ÇØ ÅÇ(0x08)À» ³ÖÀ½
  1308. // ÅÇÀ» ¾Æ¶ø¾î ±âÈ£·Î ó¸®ÇØ (¿µ¾î1) : (¿µ¾î2) ·Î ÀԷµǾ (¿µ¾î2) : (¿µ¾î1) ·Î Ãâ·ÂÇÏ°Ô ¸¸µç´Ù
  1309. if (LocaleService_IsEUROPE() && GetDefaultCodePage() == 1256)
  1310. {
  1311. char * p = strchr(buf, ':');
  1312. if (p && p[1] == ' ')
  1313. p[1] = 0x08;
  1314. }
  1316. if (kChat.type >= CHAT_TYPE_MAX_NUM)
  1317. return true;
  1319. if (CHAT_TYPE_COMMAND == kChat.type)
  1320. {
  1321. ServerCommand(buf);
  1322. return true;
  1323. }
  1325. if (kChat.dwVID != 0)
  1326. {
  1327. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1328. CInstanceBase * pkInstChatter = rkChrMgr.GetInstancePtr(kChat.dwVID);
  1329. if (NULL == pkInstChatter)
  1330. return true;
  1332. switch (kChat.type)
  1333. {
  1334. case CHAT_TYPE_TALKING: /* ±×³É äÆà */
  1335. case CHAT_TYPE_PARTY: /* ÆÄƼ¸» */
  1336. case CHAT_TYPE_GUILD: /* ±æµå¸» */
  1337. case CHAT_TYPE_SHOUT: /* ¿ÜÄ¡±â */
  1338. case CHAT_TYPE_WHISPER: // ¼­¹ö¿Í´Â ¿¬µ¿µÇÁö ¾Ê´Â Only Client Enum
  1339. {
  1340. char * p = strchr(buf, ':');
  1342. if (p)
  1343. p += 2;
  1344. else
  1345. p = buf;
  1347. DWORD dwEmoticon;
  1349. if (ParseEmoticon(p, &dwEmoticon))
  1350. {
  1351. pkInstChatter->SetEmoticon(dwEmoticon);
  1352. return true;
  1353. }
  1354. else
  1355. {
  1356. if (gs_bEmpireLanuageEnable)
  1357. {
  1358. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  1359. if (pkInstMain)
  1360. if (!pkInstMain->IsSameEmpire(*pkInstChatter))
  1361. __ConvertEmpireText(pkInstChatter->GetEmpireID(), p);
  1362. }
  1364. if (m_isEnableChatInsultFilter)
  1365. {
  1366. if (false == pkInstChatter->IsNPC() && false == pkInstChatter->IsEnemy())
  1367. {
  1368. __FilterInsult(p, strlen(p));
  1369. }
  1370. }
  1372. _snprintf(line, sizeof(line), "%s", p);
  1373. }
  1374. }
  1375. break;
  1376. case CHAT_TYPE_COMMAND: /* ¸í·É */
  1377. case CHAT_TYPE_INFO: /* Á¤º¸ (¾ÆÀÌÅÛÀ» Áı¾ú´Ù, °æÇèÄ¡¸¦ ¾ò¾ú´Ù. µî) */
  1378. case CHAT_TYPE_NOTICE: /* °øÁö»çÇ× */
  1379. case CHAT_TYPE_BIG_NOTICE:
  1380. case CHAT_TYPE_MAX_NUM:
  1381. default:
  1382. _snprintf(line, sizeof(line), "%s", buf);
  1383. break;
  1384. }
  1386. if (CHAT_TYPE_SHOUT != kChat.type)
  1387. {
  1388. CPythonTextTail::Instance().RegisterChatTail(kChat.dwVID, line);
  1389. }
  1391. if (pkInstChatter->IsPC())
  1392. CPythonChat::Instance().AppendChat(kChat.type, buf);
  1393. }
  1394. else
  1395. {
  1396. if (CHAT_TYPE_NOTICE == kChat.type)
  1397. {
  1398. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetTipMessage", Py_BuildValue("(s)", buf));
  1399. }
  1400. else if (CHAT_TYPE_BIG_NOTICE == kChat.type)
  1401. {
  1402. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetBigMessage", Py_BuildValue("(s)", buf));
  1403. }
  1404. else if (CHAT_TYPE_SHOUT == kChat.type)
  1405. {
  1406. char * p = strchr(buf, ':');
  1408. if (p)
  1409. {
  1410. if (m_isEnableChatInsultFilter)
  1411. __FilterInsult(p, strlen(p));
  1412. }
  1413. }
  1415. CPythonChat::Instance().AppendChat(kChat.type, buf);
  1417. }
  1418. return true;
  1419. }
  1421. bool CPythonNetworkStream::RecvWhisperPacket()
  1422. {
  1423. TPacketGCWhisper whisperPacket;
  1424. char buf[512 + 1];
  1426. if (!Recv(sizeof(whisperPacket), &whisperPacket))
  1427. return false;
  1429. assert(whisperPacket.wSize - sizeof(whisperPacket) < 512);
  1431. if (!Recv(whisperPacket.wSize - sizeof(whisperPacket), &buf))
  1432. return false;
  1434. buf[whisperPacket.wSize - sizeof(whisperPacket)] = '\0';
  1436. static char line[256];
  1437. if (CPythonChat::WHISPER_TYPE_CHAT == whisperPacket.bType || CPythonChat::WHISPER_TYPE_GM == whisperPacket.bType)
  1438. {
  1439. _snprintf(line, sizeof(line), "%s : %s", whisperPacket.szNameFrom, buf);
  1440. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisper", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, line));
  1441. }
  1442. else if (CPythonChat::WHISPER_TYPE_SYSTEM == whisperPacket.bType || CPythonChat::WHISPER_TYPE_ERROR == whisperPacket.bType)
  1443. {
  1444. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperSystemMessage", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
  1445. }
  1446. else
  1447. {
  1448. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperError", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
  1449. }
  1451. return true;
  1452. }
  1454. bool CPythonNetworkStream::SendWhisperPacket(const char * name, const char * c_szChat)
  1455. {
  1456. if (strlen(c_szChat) >= 255)
  1457. return true;
  1459. int iTextLen = strlen(c_szChat) + 1;
  1460. TPacketCGWhisper WhisperPacket;
  1461. WhisperPacket.bHeader = HEADER_CG_WHISPER;
  1462. WhisperPacket.wSize = sizeof(WhisperPacket) + iTextLen;
  1464. strncpy(WhisperPacket.szNameTo, name, sizeof(WhisperPacket.szNameTo) - 1);
  1466. if (!Send(sizeof(WhisperPacket), &WhisperPacket))
  1467. return false;
  1469. if (!Send(iTextLen, c_szChat))
  1470. return false;
  1472. return SendSequence();
  1473. }
  1475. bool CPythonNetworkStream::SendMobileMessagePacket(const char * name, const char * c_szChat)
  1476. {
  1477. int iTextLen = strlen(c_szChat) + 1;
  1478. TPacketCGSMS SMSPacket;
  1479. SMSPacket.bHeader = HEADER_CG_SMS;
  1480. SMSPacket.wSize = sizeof(SMSPacket) + iTextLen;
  1482. strncpy(SMSPacket.szNameTo, name, sizeof(SMSPacket.szNameTo) - 1);
  1484. if (!Send(sizeof(SMSPacket), &SMSPacket))
  1485. return false;
  1487. if (!Send(iTextLen, c_szChat))
  1488. return false;
  1490. return SendSequence();
  1491. }
  1493. bool CPythonNetworkStream::RecvPointChange()
  1494. {
  1495. TPacketGCPointChange PointChange;
  1497. if (!Recv(sizeof(TPacketGCPointChange), &PointChange))
  1498. {
  1499. Tracen("Recv Point Change Packet Error");
  1500. return false;
  1501. }
  1503. CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
  1504. rkChrMgr.ShowPointEffect(PointChange.Type, PointChange.dwVID);
  1506. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
  1508. // ÀÚ½ÅÀÇ Point°¡ º¯°æµÇ¾úÀ» °æ¿ì..
  1509. if (pInstance)
  1510. if (PointChange.dwVID == pInstance->GetVirtualID())
  1511. {
  1512. CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
  1513. rkPlayer.SetStatus(PointChange.Type, PointChange.value);
  1515. switch (PointChange.Type)
  1516. {
  1517. case POINT_STAT_RESET_COUNT:
  1518. __RefreshStatus();
  1519. break;
  1520. case POINT_LEVEL:
  1521. case POINT_ST:
  1522. case POINT_DX:
  1523. case POINT_HT:
  1524. case POINT_IQ:
  1525. __RefreshStatus();
  1526. __RefreshSkillWindow();
  1527. break;
  1528. case POINT_SKILL:
  1529. case POINT_SUB_SKILL:
  1530. case POINT_HORSE_SKILL:
  1531. __RefreshSkillWindow();
  1532. break;
  1533. case POINT_ENERGY:
  1534. if (PointChange.value == 0)
  1535. {
  1536. rkPlayer.SetStatus(POINT_ENERGY_END_TIME, 0);
  1537. }
  1538. __RefreshStatus();
  1539. break;
  1540. default:
  1541. __RefreshStatus();
  1542. break;
  1543. }
  1545. if (POINT_GOLD == PointChange.Type)
  1546. {
  1547. if (PointChange.amount > 0)
  1548. {
  1549. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickMoney", Py_BuildValue("(i)", PointChange.amount));
  1550. }
  1551. }
  1552. }
  1554. return true;
  1555. }
  1557. bool CPythonNetworkStream::RecvStunPacket()
  1558. {
  1559. TPacketGCStun StunPacket;
  1561. if (!Recv(sizeof(StunPacket), &StunPacket))
  1562. {
  1563. Tracen("CPythonNetworkStream::RecvStunPacket Error");
  1564. return false;
  1565. }
  1567. //Tracef("RecvStunPacket %d\n", StunPacket.vid);
  1569. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1570. CInstanceBase * pkInstSel = rkChrMgr.GetInstancePtr(StunPacket.vid);
  1572. if (pkInstSel)
  1573. {
  1574. if (CPythonCharacterManager::Instance().GetMainInstancePtr()==pkInstSel)
  1575. pkInstSel->Die();
  1576. else
  1577. pkInstSel->Stun();
  1578. }
  1580. return true;
  1581. }
  1583. bool CPythonNetworkStream::RecvDeadPacket()
  1584. {
  1585. TPacketGCDead DeadPacket;
  1586. if (!Recv(sizeof(DeadPacket), &DeadPacket))
  1587. {
  1588. Tracen("CPythonNetworkStream::RecvDeadPacket Error");
  1589. return false;
  1590. }
  1592. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1593. CInstanceBase * pkChrInstSel = rkChrMgr.GetInstancePtr(DeadPacket.vid);
  1594. if (pkChrInstSel)
  1595. {
  1596. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  1597. if (pkInstMain==pkChrInstSel)
  1598. {
  1599. Tracenf("ÁÖÀΰø »ç¸Á");
  1600. if (false == pkInstMain->GetDuelMode())
  1601. {
  1602. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnGameOver", Py_BuildValue("()"));
  1603. }
  1604. CPythonPlayer::Instance().NotifyDeadMainCharacter();
  1605. }
  1607. pkChrInstSel->Die();
  1608. }
  1610. return true;
  1611. }
  1613. bool CPythonNetworkStream::SendCharacterPositionPacket(BYTE iPosition)
  1614. {
  1615. TPacketCGPosition PositionPacket;
  1617. PositionPacket.header = HEADER_CG_CHARACTER_POSITION;
  1618. PositionPacket.position = iPosition;
  1620. if (!Send(sizeof(TPacketCGPosition), &PositionPacket))
  1621. {
  1622. Tracen("Send Character Position Packet Error");
  1623. return false;
  1624. }
  1626. return SendSequence();
  1627. }
  1629. bool CPythonNetworkStream::SendOnClickPacket(DWORD vid)
  1630. {
  1631. TPacketCGOnClick OnClickPacket;
  1632. OnClickPacket.header = HEADER_CG_ON_CLICK;
  1633. OnClickPacket.vid = vid;
  1635. if (!Send(sizeof(OnClickPacket), &OnClickPacket))
  1636. {
  1637. Tracen("Send On_Click Packet Error");
  1638. return false;
  1639. }
  1641. Tracef("SendOnClickPacket\n");
  1642. return SendSequence();
  1643. }
  1645. bool CPythonNetworkStream::RecvCharacterPositionPacket()
  1646. {
  1647. TPacketGCPosition PositionPacket;
  1649. if (!Recv(sizeof(TPacketGCPosition), &PositionPacket))
  1650. return false;
  1652. CInstanceBase * pChrInstance = CPythonCharacterManager::Instance().GetInstancePtr(PositionPacket.vid);
  1654. if (!pChrInstance)
  1655. return true;
  1657. //pChrInstance->UpdatePosition(PositionPacket.position);
  1659. return true;
  1660. }
  1662. bool CPythonNetworkStream::RecvMotionPacket()
  1663. {
  1664. TPacketGCMotion MotionPacket;
  1666. if (!Recv(sizeof(TPacketGCMotion), &MotionPacket))
  1667. return false;
  1669. CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.vid);
  1670. CInstanceBase * pVictimInstance = NULL;
  1672. if (0 != MotionPacket.victim_vid)
  1673. pVictimInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.victim_vid);
  1675. if (!pMainInstance)
  1676. return false;
  1678. return true;
  1679. }
  1681. bool CPythonNetworkStream::RecvShopPacket()
  1682. {
  1683. std::vector<char> vecBuffer;
  1684. vecBuffer.clear();
  1686. TPacketGCShop packet_shop;
  1687. if (!Recv(sizeof(packet_shop), &packet_shop))
  1688. return false;
  1690. int iSize = packet_shop.size - sizeof(packet_shop);
  1691. if (iSize > 0)
  1692. {
  1693. vecBuffer.resize(iSize);
  1694. if (!Recv(iSize, &vecBuffer[0]))
  1695. return false;
  1696. }
  1698. switch (packet_shop.subheader)
  1699. {
  1700. case SHOP_SUBHEADER_GC_START:
  1701. {
  1702. CPythonShop::Instance().Clear();
  1704. DWORD dwVID = *(DWORD *)&vecBuffer[0];
  1706. TPacketGCShopStart * pShopStartPacket = (TPacketGCShopStart *)&vecBuffer[4];
  1707. for (BYTE iItemIndex = 0; iItemIndex < SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
  1708. {
  1709. CPythonShop::Instance().SetItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
  1710. }
  1712. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
  1713. }
  1714. break;
  1716. case SHOP_SUBHEADER_GC_START_EX:
  1717. {
  1718. CPythonShop::Instance().Clear();
  1720. TPacketGCShopStartEx * pShopStartPacket = (TPacketGCShopStartEx *)&vecBuffer[0];
  1721. size_t read_point = sizeof(TPacketGCShopStartEx);
  1723. DWORD dwVID = pShopStartPacket->owner_vid;
  1724. BYTE shop_tab_count = pShopStartPacket->shop_tab_count;
  1726. CPythonShop::instance().SetTabCount(shop_tab_count);
  1728. for (size_t i = 0; i < shop_tab_count; i++)
  1729. {
  1730. TPacketGCShopStartEx::TSubPacketShopTab* pPackTab = (TPacketGCShopStartEx::TSubPacketShopTab*)&vecBuffer[read_point];
  1731. read_point += sizeof(TPacketGCShopStartEx::TSubPacketShopTab);
  1733. CPythonShop::instance().SetTabCoinType(i, pPackTab->coin_type);
  1734. CPythonShop::instance().SetTabName(i, pPackTab->name);
  1736. struct packet_shop_item* item = &pPackTab->items[0];
  1738. for (BYTE j = 0; j < SHOP_HOST_ITEM_MAX_NUM; j++)
  1739. {
  1740. TShopItemData* itemData = (item + j);
  1741. CPythonShop::Instance().SetItemData(i, j, *itemData);
  1742. }
  1743. }
  1745. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
  1746. }
  1747. break;
  1750. case SHOP_SUBHEADER_GC_END:
  1751. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndShop", Py_BuildValue("()"));
  1752. break;
  1754. case SHOP_SUBHEADER_GC_UPDATE_ITEM:
  1755. {
  1756. TPacketGCShopUpdateItem * pShopUpdateItemPacket = (TPacketGCShopUpdateItem *)&vecBuffer[0];
  1757. CPythonShop::Instance().SetItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item);
  1758. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShop", Py_BuildValue("()"));
  1759. }
  1760. break;
  1762. case SHOP_SUBHEADER_GC_UPDATE_PRICE:
  1763. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetShopSellingPrice", Py_BuildValue("(i)", *(int *)&vecBuffer[0]));
  1764. break;
  1766. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY:
  1767. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY"));
  1768. break;
  1770. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX:
  1771. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY_EX"));
  1772. break;
  1774. case SHOP_SUBHEADER_GC_SOLDOUT:
  1775. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT"));
  1776. break;
  1778. case SHOP_SUBHEADER_GC_INVENTORY_FULL:
  1779. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL"));
  1780. break;
  1782. case SHOP_SUBHEADER_GC_INVALID_POS:
  1783. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS"));
  1784. break;
  1786. default:
  1787. TraceError("CPythonNetworkStream::RecvShopPacket: Unknown subheader\n");
  1788. break;
  1789. }
  1791. return true;
  1792. }
  1794. bool CPythonNetworkStream::RecvExchangePacket()
  1795. {
  1796. TPacketGCExchange exchange_packet;
  1798. if (!Recv(sizeof(exchange_packet), &exchange_packet))
  1799. return false;
  1801. switch (exchange_packet.subheader)
  1802. {
  1803. case EXCHANGE_SUBHEADER_GC_START:
  1804. CPythonExchange::Instance().Clear();
  1805. CPythonExchange::Instance().Start();
  1806. CPythonExchange::Instance().SetSelfName(CPythonPlayer::Instance().GetName());
  1808. {
  1809. CInstanceBase * pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr(exchange_packet.arg1);
  1811. if (pCharacterInstance)
  1812. {
  1813. CPythonExchange::Instance().SetTargetName(pCharacterInstance->GetNameString());
  1814. }
  1815. }
  1817. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartExchange", Py_BuildValue("()"));
  1818. break;
  1820. case EXCHANGE_SUBHEADER_GC_ITEM_ADD:
  1821. if (exchange_packet.is_me)
  1822. {
  1823. int iSlotIndex = exchange_packet.arg2.cell;
  1824. CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
  1825. for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
  1826. CPythonExchange::Instance().SetItemMetinSocketToSelf(iSlotIndex, i, exchange_packet.alValues[i]);
  1827. for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
  1828. CPythonExchange::Instance().SetItemAttributeToSelf(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
  1829. }
  1830. else
  1831. {
  1832. int iSlotIndex = exchange_packet.arg2.cell;
  1833. CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
  1834. for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
  1835. CPythonExchange::Instance().SetItemMetinSocketToTarget(iSlotIndex, i, exchange_packet.alValues[i]);
  1836. for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
  1837. CPythonExchange::Instance().SetItemAttributeToTarget(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
  1838. }
  1840. __RefreshExchangeWindow();
  1841. __RefreshInventoryWindow();
  1842. break;
  1844. case EXCHANGE_SUBHEADER_GC_ITEM_DEL:
  1845. if (exchange_packet.is_me)
  1846. {
  1847. CPythonExchange::Instance().DelItemOfSelf((BYTE) exchange_packet.arg1);
  1848. }
  1849. else
  1850. {
  1851. CPythonExchange::Instance().DelItemOfTarget((BYTE) exchange_packet.arg1);
  1852. }
  1853. __RefreshExchangeWindow();
  1854. __RefreshInventoryWindow();
  1855. break;
  1857. case EXCHANGE_SUBHEADER_GC_ELK_ADD:
  1858. if (exchange_packet.is_me)
  1859. CPythonExchange::Instance().SetElkToSelf(exchange_packet.arg1);
  1860. else
  1861. CPythonExchange::Instance().SetElkToTarget(exchange_packet.arg1);
  1863. __RefreshExchangeWindow();
  1864. break;
  1866. case EXCHANGE_SUBHEADER_GC_ACCEPT:
  1867. if (exchange_packet.is_me)
  1868. {
  1869. CPythonExchange::Instance().SetAcceptToSelf((BYTE) exchange_packet.arg1);
  1870. }
  1871. else
  1872. {
  1873. CPythonExchange::Instance().SetAcceptToTarget((BYTE) exchange_packet.arg1);
  1874. }
  1875. __RefreshExchangeWindow();
  1876. break;
  1878. case EXCHANGE_SUBHEADER_GC_END:
  1879. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndExchange", Py_BuildValue("()"));
  1880. __RefreshInventoryWindow();
  1881. CPythonExchange::Instance().End();
  1882. break;
  1884. case EXCHANGE_SUBHEADER_GC_ALREADY:
  1885. Tracef("trade_already");
  1886. break;
  1888. case EXCHANGE_SUBHEADER_GC_LESS_ELK:
  1889. Tracef("trade_less_elk");
  1890. break;
  1891. };
  1893. return true;
  1894. }
  1896. bool CPythonNetworkStream::RecvQuestInfoPacket()
  1897. {
  1898. TPacketGCQuestInfo QuestInfo;
  1900. if (!Peek(sizeof(TPacketGCQuestInfo), &QuestInfo))
  1901. {
  1902. Tracen("Recv Quest Info Packet Error #1");
  1903. TraceError("Recv Quest Info Packet Error #1");
  1904. return false;
  1905. }
  1907. if (!Peek(QuestInfo.size))
  1908. {
  1909. Tracen("Recv Quest Info Packet Error #2");
  1910. TraceError("Recv Quest Info Packet Error #2");
  1911. return false;
  1912. }
  1914. Recv(sizeof(TPacketGCQuestInfo));
  1916. const BYTE & c_rFlag = QuestInfo.flag;
  1918. enum
  1919. {
  1920. QUEST_PACKET_TYPE_NONE,
  1921. QUEST_PACKET_TYPE_BEGIN,
  1922. QUEST_PACKET_TYPE_UPDATE,
  1923. QUEST_PACKET_TYPE_END,
  1924. };
  1926. BYTE byQuestPacketType = QUEST_PACKET_TYPE_NONE;
  1928. if (0 != (c_rFlag & QUEST_SEND_IS_BEGIN))
  1929. {
  1930. BYTE isBegin = QuestInfo.isBegin;
  1932. if (isBegin)
  1933. byQuestPacketType = QUEST_PACKET_TYPE_BEGIN;
  1934. else
  1935. byQuestPacketType = QUEST_PACKET_TYPE_END;
  1936. }
  1937. else
  1938. {
  1939. byQuestPacketType = QUEST_PACKET_TYPE_UPDATE;
  1940. }
  1942. // Recv Data Start
  1943. char szTitle[30 + 1] = "";
  1944. char szClockName[16 + 1] = "";
  1945. int iClockValue = 0;
  1946. char szCounterName[16 + 1] = "";
  1947. int iCounterValue = 0;
  1948. char szIconFileName[24 + 1] = "";
  1950. if (0 != (c_rFlag & QUEST_SEND_TITLE))
  1951. {
  1952. strncpy(szTitle, QuestInfo.szTitle, sizeof(szTitle));
  1954. szTitle[30]='\0';
  1955. }
  1957. if (0 != (c_rFlag & QUEST_SEND_CLOCK_NAME))
  1958. {
  1959. strncpy(szClockName, QuestInfo.szClockName, sizeof(szClockName));
  1961. szClockName[16]='\0';
  1962. }
  1964. if (0 != (c_rFlag & QUEST_SEND_CLOCK_VALUE))
  1965. {
  1966. iClockValue = QuestInfo.iClockValue;
  1967. }
  1969. if (0 != (c_rFlag & QUEST_SEND_COUNTER_NAME))
  1970. {
  1971. strncpy(szCounterName, QuestInfo.szCounterName, sizeof(szCounterName));
  1973. szCounterName[16]='\0';
  1974. }
  1976. if (0 != (c_rFlag & QUEST_SEND_COUNTER_VALUE))
  1977. {
  1978. iCounterValue = QuestInfo.iCounterValue;
  1979. }
  1981. if (0 != (c_rFlag & QUEST_SEND_ICON_FILE))
  1982. {
  1983. strncpy(szIconFileName, QuestInfo.szIconFileName, sizeof(szIconFileName));
  1985. szIconFileName[24]='\0';
  1986. }
  1987. // Recv Data End
  1989. CPythonQuest& rkQuest=CPythonQuest::Instance();
  1991. // Process Start
  1992. if (QUEST_PACKET_TYPE_END == byQuestPacketType)
  1993. {
  1994. rkQuest.DeleteQuestInstance(QuestInfo.index);
  1995. }
  1996. else if (QUEST_PACKET_TYPE_UPDATE == byQuestPacketType)
  1997. {
  1998. if (!rkQuest.IsQuest(QuestInfo.index))
  1999. {
  2000. rkQuest.MakeQuest(QuestInfo.index);
  2001. }
  2003. if (strlen(szTitle) > 0)
  2004. rkQuest.SetQuestTitle(QuestInfo.index, szTitle);
  2005. if (strlen(szClockName) > 0)
  2006. rkQuest.SetQuestClockName(QuestInfo.index, szClockName);
  2007. if (strlen(szCounterName) > 0)
  2008. rkQuest.SetQuestCounterName(QuestInfo.index, szCounterName);
  2009. if (strlen(szIconFileName) > 0)
  2010. rkQuest.SetQuestIconFileName(QuestInfo.index, szIconFileName);
  2012. if (c_rFlag & QUEST_SEND_CLOCK_VALUE)
  2013. rkQuest.SetQuestClockValue(QuestInfo.index, iClockValue);
  2014. if (c_rFlag & QUEST_SEND_COUNTER_VALUE)
  2015. rkQuest.SetQuestCounterValue(QuestInfo.index, iCounterValue);
  2016. }
  2017. else if (QUEST_PACKET_TYPE_BEGIN == byQuestPacketType)
  2018. {
  2019. CPythonQuest::SQuestInstance QuestInstance;
  2020. QuestInstance.dwIndex = QuestInfo.index;
  2021. QuestInstance.strTitle = szTitle;
  2022. QuestInstance.strClockName = szClockName;
  2023. QuestInstance.iClockValue = iClockValue;
  2024. QuestInstance.strCounterName = szCounterName;
  2025. QuestInstance.iCounterValue = iCounterValue;
  2026. QuestInstance.strIconFileName = szIconFileName;
  2027. CPythonQuest::Instance().RegisterQuestInstance(QuestInstance);
  2028. }
  2029. // Process Start End
  2030. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshQuest", Py_BuildValue("()"));
  2031. return true;
  2032. }
  2034. bool CPythonNetworkStream::RecvQuestConfirmPacket()
  2035. {
  2036. TPacketGCQuestConfirm kQuestConfirmPacket;
  2037. if (!Recv(sizeof(kQuestConfirmPacket), &kQuestConfirmPacket))
  2038. {
  2039. Tracen("RecvQuestConfirmPacket Error");
  2040. return false;
  2041. }
  2043. PyObject * poArg = Py_BuildValue("(sii)", kQuestConfirmPacket.msg, kQuestConfirmPacket.timeout, kQuestConfirmPacket.requestPID);
  2044. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OnQuestConfirm", poArg);
  2045. return true;
  2046. }
  2048. bool CPythonNetworkStream::RecvRequestMakeGuild()
  2049. {
  2050. TPacketGCBlank blank;
  2051. if (!Recv(sizeof(blank), &blank))
  2052. {
  2053. Tracen("RecvRequestMakeGuild Packet Error");
  2054. return false;
  2055. }
  2057. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AskGuildName", Py_BuildValue("()"));
  2059. return true;
  2060. }
  2062. void CPythonNetworkStream::ToggleGameDebugInfo()
  2063. {
  2064. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ToggleDebugInfo", Py_BuildValue("()"));
  2065. }
  2067. bool CPythonNetworkStream::SendExchangeStartPacket(DWORD vid)
  2068. {
  2069. if (!__CanActMainInstance())
  2070. return true;
  2072. TPacketCGExchange packet;
  2074. packet.header = HEADER_CG_EXCHANGE;
  2075. packet.subheader = EXCHANGE_SUBHEADER_CG_START;
  2076. packet.arg1 = vid;
  2078. if (!Send(sizeof(packet), &packet))
  2079. {
  2080. Tracef("send_trade_start_packet Error\n");
  2081. return false;
  2082. }
  2084. Tracef("send_trade_start_packet vid %d \n", vid);
  2085. return SendSequence();
  2086. }
  2088. bool CPythonNetworkStream::SendExchangeElkAddPacket(DWORD elk)
  2089. {
  2090. if (!__CanActMainInstance())
  2091. return true;
  2093. TPacketCGExchange packet;
  2095. packet.header = HEADER_CG_EXCHANGE;
  2096. packet.subheader = EXCHANGE_SUBHEADER_CG_ELK_ADD;
  2097. packet.arg1 = elk;
  2099. if (!Send(sizeof(packet), &packet))
  2100. {
  2101. Tracef("send_trade_elk_add_packet Error\n");
  2102. return false;
  2103. }
  2105. return SendSequence();
  2106. }
  2108. bool CPythonNetworkStream::SendExchangeItemAddPacket(TItemPos ItemPos, BYTE byDisplayPos)
  2109. {
  2110. if (!__CanActMainInstance())
  2111. return true;
  2113. TPacketCGExchange packet;
  2115. packet.header = HEADER_CG_EXCHANGE;
  2116. packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_ADD;
  2117. packet.Pos = ItemPos;
  2118. packet.arg2 = byDisplayPos;
  2120. if (!Send(sizeof(packet), &packet))
  2121. {
  2122. Tracef("send_trade_item_add_packet Error\n");
  2123. return false;
  2124. }
  2126. return SendSequence();
  2127. }
  2129. bool CPythonNetworkStream::SendExchangeItemDelPacket(BYTE pos)
  2130. {
  2131. assert(!"Can't be called function - CPythonNetworkStream::SendExchangeItemDelPacket");
  2132. return true;
  2134. if (!__CanActMainInstance())
  2135. return true;
  2137. TPacketCGExchange packet;
  2139. packet.header = HEADER_CG_EXCHANGE;
  2140. packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_DEL;
  2141. packet.arg1 = pos;
  2143. if (!Send(sizeof(packet), &packet))
  2144. {
  2145. Tracef("send_trade_item_del_packet Error\n");
  2146. return false;
  2147. }
  2149. return SendSequence();
  2150. }
  2152. bool CPythonNetworkStream::SendExchangeAcceptPacket()
  2153. {
  2154. if (!__CanActMainInstance())
  2155. return true;
  2157. TPacketCGExchange packet;
  2159. packet.header = HEADER_CG_EXCHANGE;
  2160. packet.subheader = EXCHANGE_SUBHEADER_CG_ACCEPT;
  2162. if (!Send(sizeof(packet), &packet))
  2163. {
  2164. Tracef("send_trade_accept_packet Error\n");
  2165. return false;
  2166. }
  2168. return SendSequence();
  2169. }
  2171. bool CPythonNetworkStream::SendExchangeExitPacket()
  2172. {
  2173. if (!__CanActMainInstance())
  2174. return true;
  2176. TPacketCGExchange packet;
  2178. packet.header = HEADER_CG_EXCHANGE;
  2179. packet.subheader = EXCHANGE_SUBHEADER_CG_CANCEL;
  2181. if (!Send(sizeof(packet), &packet))
  2182. {
  2183. Tracef("send_trade_exit_packet Error\n");
  2184. return false;
  2185. }
  2187. return SendSequence();
  2188. }
  2190. // PointReset °³ÀÓ½Ã
  2191. bool CPythonNetworkStream::SendPointResetPacket()
  2192. {
  2193. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartPointReset", Py_BuildValue("()"));
  2194. return true;
  2195. }
  2197. bool CPythonNetworkStream::__IsPlayerAttacking()
  2198. {
  2199. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  2200. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  2201. if (!pkInstMain)
  2202. return false;
  2204. if (!pkInstMain->IsAttacking())
  2205. return false;
  2207. return true;
  2208. }
  2210. bool CPythonNetworkStream::RecvScriptPacket()
  2211. {
  2212. TPacketGCScript ScriptPacket;
  2214. if (!Recv(sizeof(TPacketGCScript), &ScriptPacket))
  2215. {
  2216. TraceError("RecvScriptPacket_RecvError");
  2217. return false;
  2218. }
  2220. if (ScriptPacket.size < sizeof(TPacketGCScript))
  2221. {
  2222. TraceError("RecvScriptPacket_SizeError");
  2223. return false;
  2224. }
  2226. ScriptPacket.size -= sizeof(TPacketGCScript);
  2228. static string str;
  2229. str = "";
  2230. str.resize(ScriptPacket.size+1);
  2232. if (!Recv(ScriptPacket.size, &str[0]))
  2233. return false;
  2235. str[str.size()-1] = '\0';
  2237. int iIndex = CPythonEventManager::Instance().RegisterEventSetFromString(str);
  2239. if (-1 != iIndex)
  2240. {
  2241. CPythonEventManager::Instance().SetVisibleLineCount(iIndex, 30);
  2242. CPythonNetworkStream::Instance().OnScriptEventStart(ScriptPacket.skin,iIndex);
  2243. }
  2245. return true;
  2246. }
  2248. bool CPythonNetworkStream::SendScriptAnswerPacket(int iAnswer)
  2249. {
  2250. TPacketCGScriptAnswer ScriptAnswer;
  2252. ScriptAnswer.header = HEADER_CG_SCRIPT_ANSWER;
  2253. ScriptAnswer.answer = (BYTE) iAnswer;
  2254. if (!Send(sizeof(TPacketCGScriptAnswer), &ScriptAnswer))
  2255. {
  2256. Tracen("Send Script Answer Packet Error");
  2257. return false;
  2258. }
  2260. return SendSequence();
  2261. }
  2263. bool CPythonNetworkStream::SendScriptButtonPacket(unsigned int iIndex)
  2264. {
  2265. TPacketCGScriptButton ScriptButton;
  2267. ScriptButton.header = HEADER_CG_SCRIPT_BUTTON;
  2268. ScriptButton.idx = iIndex;
  2269. if (!Send(sizeof(TPacketCGScriptButton), &ScriptButton))
  2270. {
  2271. Tracen("Send Script Button Packet Error");
  2272. return false;
  2273. }
  2275. return SendSequence();
  2276. }
  2278. bool CPythonNetworkStream::SendAnswerMakeGuildPacket(const char * c_szName)
  2279. {
  2280. TPacketCGAnswerMakeGuild Packet;
  2282. Packet.header = HEADER_CG_ANSWER_MAKE_GUILD;
  2283. strncpy(Packet.guild_name, c_szName, GUILD_NAME_MAX_LEN);
  2284. Packet.guild_name[GUILD_NAME_MAX_LEN] = '\0';
  2286. if (!Send(sizeof(Packet), &Packet))
  2287. {
  2288. Tracen("SendAnswerMakeGuild Packet Error");
  2289. return false;
  2290. }
  2292. // Tracef(" SendAnswerMakeGuildPacket : %s", c_szName);
  2293. return SendSequence();
  2294. }
  2296. bool CPythonNetworkStream::SendQuestInputStringPacket(const char * c_szString)
  2297. {
  2298. TPacketCGQuestInputString Packet;
  2299. Packet.bHeader = HEADER_CG_QUEST_INPUT_STRING;
  2300. strncpy(Packet.szString, c_szString, QUEST_INPUT_STRING_MAX_NUM);
  2302. if (!Send(sizeof(Packet), &Packet))
  2303. {
  2304. Tracen("SendQuestInputStringPacket Error");
  2305. return false;
  2306. }
  2308. return SendSequence();
  2309. }
  2311. bool CPythonNetworkStream::SendQuestConfirmPacket(BYTE byAnswer, DWORD dwPID)
  2312. {
  2313. TPacketCGQuestConfirm kPacket;
  2314. kPacket.header = HEADER_CG_QUEST_CONFIRM;
  2315. kPacket.answer = byAnswer;
  2316. kPacket.requestPID = dwPID;
  2318. if (!Send(sizeof(kPacket), &kPacket))
  2319. {
  2320. Tracen("SendQuestConfirmPacket Error");
  2321. return false;
  2322. }
  2324. Tracenf(" SendQuestConfirmPacket : %d, %d", byAnswer, dwPID);
  2325. return SendSequence();
  2326. }
  2328. bool CPythonNetworkStream::RecvSkillCoolTimeEnd()
  2329. {
  2330. TPacketGCSkillCoolTimeEnd kPacketSkillCoolTimeEnd;
  2331. if (!Recv(sizeof(kPacketSkillCoolTimeEnd), &kPacketSkillCoolTimeEnd))
  2332. {
  2333. Tracen("CPythonNetworkStream::RecvSkillCoolTimeEnd - RecvError");
  2334. return false;
  2335. }
  2337. CPythonPlayer::Instance().EndSkillCoolTime(kPacketSkillCoolTimeEnd.bSkill);
  2339. return true;
  2340. }
  2342. bool CPythonNetworkStream::RecvSkillLevel()
  2343. {
  2344. assert(!"CPythonNetworkStream::RecvSkillLevel - »ç¿ëÇÏÁö ¾Ê´Â ÇÔ¼ö");
  2345. TPacketGCSkillLevel packet;
  2346. if (!Recv(sizeof(TPacketGCSkillLevel), &packet))
  2347. {
  2348. Tracen("CPythonNetworkStream::RecvSkillLevel - RecvError");
  2349. return false;
  2350. }
  2352. DWORD dwSlotIndex;
  2354. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2355. for (int i = 0; i < SKILL_MAX_NUM; ++i)
  2356. {
  2357. if (rkPlayer.GetSkillSlotIndex(i, &dwSlotIndex))
  2358. rkPlayer.SetSkillLevel(dwSlotIndex, packet.abSkillLevels[i]);
  2359. }
  2361. __RefreshSkillWindow();
  2362. __RefreshStatus();
  2363. Tracef(" >> RecvSkillLevel\n");
  2364. return true;
  2365. }
  2367. bool CPythonNetworkStream::RecvSkillLevelNew()
  2368. {
  2369. TPacketGCSkillLevelNew packet;
  2371. if (!Recv(sizeof(TPacketGCSkillLevelNew), &packet))
  2372. {
  2373. Tracen("CPythonNetworkStream::RecvSkillLevelNew - RecvError");
  2374. return false;
  2375. }
  2377. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2379. rkPlayer.SetSkill(7, 0);
  2380. rkPlayer.SetSkill(8, 0);
  2382. for (int i = 0; i < SKILL_MAX_NUM; ++i)
  2383. {
  2384. TPlayerSkill & rPlayerSkill = packet.skills[i];
  2386. if (i >= 112 && i <= 115 && rPlayerSkill.bLevel)
  2387. rkPlayer.SetSkill(7, i);
  2389. if (i >= 116 && i <= 119 && rPlayerSkill.bLevel)
  2390. rkPlayer.SetSkill(8, i);
  2392. rkPlayer.SetSkillLevel_(i, rPlayerSkill.bMasterType, rPlayerSkill.bLevel);
  2393. }
  2395. __RefreshSkillWindow();
  2396. __RefreshStatus();
  2397. //Tracef(" >> RecvSkillLevelNew\n");
  2398. return true;
  2399. }
  2402. bool CPythonNetworkStream::RecvDamageInfoPacket()
  2403. {
  2404. TPacketGCDamageInfo DamageInfoPacket;
  2406. if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket))
  2407. {
  2408. Tracen("Recv Target Packet Error");
  2409. return false;
  2410. }
  2412. CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVID);
  2413. bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr());
  2414. bool bTarget = (pInstTarget==m_pInstTarget);
  2415. if (pInstTarget)
  2416. {
  2417. if(DamageInfoPacket.damage >= 0)
  2418. pInstTarget->AddDamageEffect(DamageInfoPacket.damage,DamageInfoPacket.flag,bSelf,bTarget);
  2419. else
  2420. TraceError("Damage is equal or below 0.");
  2421. }
  2423. return true;
  2424. }
  2425. bool CPythonNetworkStream::RecvTargetPacket()
  2426. {
  2427. TPacketGCTarget TargetPacket;
  2429. if (!Recv(sizeof(TPacketGCTarget), &TargetPacket))
  2430. {
  2431. Tracen("Recv Target Packet Error");
  2432. return false;
  2433. }
  2435. CInstanceBase * pInstPlayer = CPythonCharacterManager::Instance().GetMainInstancePtr();
  2436. CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(TargetPacket.dwVID);
  2437. if (pInstPlayer && pInstTarget)
  2438. {
  2439. if (!pInstTarget->IsDead())
  2440. {
  2441. if (pInstTarget->IsPC() || pInstTarget->IsBuilding())
  2442. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoardIfDifferent", Py_BuildValue("(i)", TargetPacket.dwVID));
  2443. else if (pInstPlayer->CanViewTargetHP(*pInstTarget))
  2444. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHPTargetBoard", Py_BuildValue("(ii)", TargetPacket.dwVID, TargetPacket.bHPPercent));
  2445. else
  2446. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  2448. m_pInstTarget = pInstTarget;
  2449. }
  2450. }
  2451. else
  2452. {
  2453. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  2454. }
  2456. return true;
  2457. }
  2459. bool CPythonNetworkStream::RecvMountPacket()
  2460. {
  2461. TPacketGCMount MountPacket;
  2463. if (!Recv(sizeof(TPacketGCMount), &MountPacket))
  2464. {
  2465. Tracen("Recv Mount Packet Error");
  2466. return false;
  2467. }
  2469. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(MountPacket.vid);
  2471. if (pInstance)
  2472. {
  2473. // Mount
  2474. if (0 != MountPacket.mount_vid)
  2475. {
  2476. // pInstance->Ride(MountPacket.pos, MountPacket.mount_vid);
  2477. }
  2478. // Unmount
  2479. else
  2480. {
  2481. // pInstance->Unride(MountPacket.pos, MountPacket.x, MountPacket.y);
  2482. }
  2483. }
  2485. if (CPythonPlayer::Instance().IsMainCharacterIndex(MountPacket.vid))
  2486. {
  2487. // CPythonPlayer::Instance().SetRidingVehicleIndex(MountPacket.mount_vid);
  2488. }
  2490. return true;
  2491. }
  2493. bool CPythonNetworkStream::RecvChangeSpeedPacket()
  2494. {
  2495. TPacketGCChangeSpeed SpeedPacket;
  2497. if (!Recv(sizeof(TPacketGCChangeSpeed), &SpeedPacket))
  2498. {
  2499. Tracen("Recv Speed Packet Error");
  2500. return false;
  2501. }
  2503. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(SpeedPacket.vid);
  2505. if (!pInstance)
  2506. return true;
  2508. // pInstance->SetWalkSpeed(SpeedPacket.walking_speed);
  2509. // pInstance->SetRunSpeed(SpeedPacket.running_speed);
  2510. return true;
  2511. }
  2513. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2514. // Recv
  2516. bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim)
  2517. {
  2518. if (!__CanActMainInstance())
  2519. return true;
  2521. #ifdef ATTACK_TIME_LOG
  2522. static DWORD prevTime = timeGetTime();
  2523. DWORD curTime = timeGetTime();
  2524. TraceError("TIME: %.4f(%.4f) ATTACK_PACKET: %d TARGET: %d", curTime/1000.0f, (curTime-prevTime)/1000.0f, uMotAttack, dwVIDVictim);
  2525. prevTime = curTime;
  2526. #endif
  2528. TPacketCGAttack kPacketAtk;
  2530. kPacketAtk.header = HEADER_CG_ATTACK;
  2531. kPacketAtk.bType = uMotAttack;
  2532. kPacketAtk.dwVictimVID = dwVIDVictim;
  2534. if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk))
  2535. {
  2536. Tracen("Send Battle Attack Packet Error");
  2537. return false;
  2538. }
  2540. return SendSequence();
  2541. }
  2543. bool CPythonNetworkStream::SendSpecial(int nLen, void * pvBuf)
  2544. {
  2545. BYTE bHeader = *(BYTE *) pvBuf;
  2547. switch (bHeader)
  2548. {
  2549. case HEADER_CG_ATTACK:
  2550. {
  2551. TPacketCGAttack * pkPacketAtk = (TPacketCGAttack *) pvBuf;
  2552. pkPacketAtk->bCRCMagicCubeProcPiece = GetProcessCRCMagicCubePiece();
  2553. pkPacketAtk->bCRCMagicCubeFilePiece = GetProcessCRCMagicCubePiece();
  2554. return Send(nLen, pvBuf);
  2555. }
  2556. break;
  2557. }
  2559. return Send(nLen, pvBuf);
  2560. }
  2562. bool CPythonNetworkStream::RecvAddFlyTargetingPacket()
  2563. {
  2564. TPacketGCFlyTargeting kPacket;
  2565. if (!Recv(sizeof(kPacket), &kPacket))
  2566. return false;
  2568. __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
  2570. Tracef("VID [%d]°¡ Ÿ°ÙÀ» Ãß°¡ ¼³Á¤\n",kPacket.dwShooterVID);
  2572. CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2574. CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
  2576. if (!pShooter)
  2577. {
  2578. #ifndef _DEBUG
  2579. TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
  2580. #endif
  2581. return true;
  2582. }
  2584. CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
  2586. if (kPacket.dwTargetVID && pTarget)
  2587. {
  2588. pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(pTarget->GetGraphicThingInstancePtr());
  2589. }
  2590. else
  2591. {
  2592. float h = CPythonBackground::Instance().GetHeight(kPacket.lX,kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
  2593. pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
  2594. //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
  2595. }
  2597. return true;
  2598. }
  2600. bool CPythonNetworkStream::RecvFlyTargetingPacket()
  2601. {
  2602. TPacketGCFlyTargeting kPacket;
  2603. if (!Recv(sizeof(kPacket), &kPacket))
  2604. return false;
  2606. __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
  2608. //Tracef("CPythonNetworkStream::RecvFlyTargetingPacket - VID [%d]\n",kPacket.dwShooterVID);
  2610. CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2612. CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
  2614. if (!pShooter)
  2615. {
  2616. #ifdef _DEBUG
  2617. TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
  2618. #endif
  2619. return true;
  2620. }
  2622. CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
  2624. if (kPacket.dwTargetVID && pTarget)
  2625. {
  2626. pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(pTarget->GetGraphicThingInstancePtr());
  2627. }
  2628. else
  2629. {
  2630. float h = CPythonBackground::Instance().GetHeight(kPacket.lX, kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
  2631. pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
  2632. //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
  2633. }
  2635. return true;
  2636. }
  2638. bool CPythonNetworkStream::SendShootPacket(UINT uSkill)
  2639. {
  2640. TPacketCGShoot kPacketShoot;
  2641. kPacketShoot.bHeader=HEADER_CG_SHOOT;
  2642. kPacketShoot.bType=uSkill;
  2644. if (!Send(sizeof(kPacketShoot), &kPacketShoot))
  2645. {
  2646. Tracen("SendShootPacket Error");
  2647. return false;
  2648. }
  2650. return SendSequence();
  2651. }
  2653. bool CPythonNetworkStream::SendAddFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
  2654. {
  2655. TPacketCGFlyTargeting packet;
  2657. //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2659. packet.bHeader = HEADER_CG_ADD_FLY_TARGETING;
  2660. packet.dwTargetVID = dwTargetVID;
  2661. packet.lX = kPPosTarget.x;
  2662. packet.lY = kPPosTarget.y;
  2664. __LocalPositionToGlobalPosition(packet.lX, packet.lY);
  2666. if (!Send(sizeof(packet), &packet))
  2667. {
  2668. Tracen("Send FlyTargeting Packet Error");
  2669. return false;
  2670. }
  2672. return SendSequence();
  2673. }
  2676. bool CPythonNetworkStream::SendFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
  2677. {
  2678. TPacketCGFlyTargeting packet;
  2680. //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2682. packet.bHeader = HEADER_CG_FLY_TARGETING;
  2683. packet.dwTargetVID = dwTargetVID;
  2684. packet.lX = kPPosTarget.x;
  2685. packet.lY = kPPosTarget.y;
  2687. __LocalPositionToGlobalPosition(packet.lX, packet.lY);
  2689. if (!Send(sizeof(packet), &packet))
  2690. {
  2691. Tracen("Send FlyTargeting Packet Error");
  2692. return false;
  2693. }
  2695. return SendSequence();
  2696. }
  2698. bool CPythonNetworkStream::RecvCreateFlyPacket()
  2699. {
  2700. TPacketGCCreateFly kPacket;
  2701. if (!Recv(sizeof(TPacketGCCreateFly), &kPacket))
  2702. return false;
  2704. CFlyingManager& rkFlyMgr = CFlyingManager::Instance();
  2705. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  2707. CInstanceBase * pkStartInst = rkChrMgr.GetInstancePtr(kPacket.dwStartVID);
  2708. CInstanceBase * pkEndInst = rkChrMgr.GetInstancePtr(kPacket.dwEndVID);
  2709. if (!pkStartInst || !pkEndInst)
  2710. return true;
  2712. rkFlyMgr.CreateIndexedFly(kPacket.bType, pkStartInst->GetGraphicThingInstancePtr(), pkEndInst->GetGraphicThingInstancePtr());
  2714. return true;
  2715. }
  2717. bool CPythonNetworkStream::SendTargetPacket(DWORD dwVID)
  2718. {
  2719. TPacketCGTarget packet;
  2720. packet.header = HEADER_CG_TARGET;
  2721. packet.dwVID = dwVID;
  2723. if (!Send(sizeof(packet), &packet))
  2724. {
  2725. Tracen("Send Target Packet Error");
  2726. return false;
  2727. }
  2729. return SendSequence();
  2730. }
  2732. bool CPythonNetworkStream::SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY)
  2733. {
  2734. TPacketCGSyncPositionElement kSyncPos;
  2735. kSyncPos.dwVID=dwVictimVID;
  2736. kSyncPos.lX=dwVictimX;
  2737. kSyncPos.lY=dwVictimY;
  2739. __LocalPositionToGlobalPosition(kSyncPos.lX, kSyncPos.lY);
  2741. if (!Send(sizeof(kSyncPos), &kSyncPos))
  2742. {
  2743. Tracen("CPythonNetworkStream::SendSyncPositionElementPacket - ERROR");
  2744. return false;
  2745. }
  2747. return true;
  2748. }
  2750. bool CPythonNetworkStream::RecvMessenger()
  2751. {
  2752. TPacketGCMessenger p;
  2753. if (!Recv(sizeof(p), &p))
  2754. return false;
  2756. int iSize = p.size - sizeof(p);
  2757. char char_name[24+1];
  2759. switch (p.subheader)
  2760. {
  2761. case MESSENGER_SUBHEADER_GC_LIST:
  2762. {
  2763. TPacketGCMessengerListOnline on;
  2764. while(iSize)
  2765. {
  2766. if (!Recv(sizeof(TPacketGCMessengerListOffline),&on))
  2767. return false;
  2769. if (!Recv(on.length, char_name))
  2770. return false;
  2772. char_name[on.length] = 0;
  2774. if (on.connected & MESSENGER_CONNECTED_STATE_ONLINE)
  2775. CPythonMessenger::Instance().OnFriendLogin(char_name);
  2776. else
  2777. CPythonMessenger::Instance().OnFriendLogout(char_name);
  2779. if (on.connected & MESSENGER_CONNECTED_STATE_MOBILE)
  2780. CPythonMessenger::Instance().SetMobile(char_name, TRUE);
  2782. iSize -= sizeof(TPacketGCMessengerListOffline);
  2783. iSize -= on.length;
  2784. }
  2785. break;
  2786. }
  2788. case MESSENGER_SUBHEADER_GC_LOGIN:
  2789. {
  2790. TPacketGCMessengerLogin p;
  2791. if (!Recv(sizeof(p),&p))
  2792. return false;
  2793. if (!Recv(p.length, char_name))
  2794. return false;
  2795. char_name[p.length] = 0;
  2796. CPythonMessenger::Instance().OnFriendLogin(char_name);
  2797. __RefreshTargetBoardByName(char_name);
  2798. break;
  2799. }
  2801. case MESSENGER_SUBHEADER_GC_LOGOUT:
  2802. {
  2803. TPacketGCMessengerLogout logout;
  2804. if (!Recv(sizeof(logout),&logout))
  2805. return false;
  2806. if (!Recv(logout.length, char_name))
  2807. return false;
  2808. char_name[logout.length] = 0;
  2809. CPythonMessenger::Instance().OnFriendLogout(char_name);
  2810. break;
  2811. }
  2813. case MESSENGER_SUBHEADER_GC_MOBILE:
  2814. {
  2815. BYTE byState; // ¸ğ¹ÙÀÏ ¹øÈ£°¡ ¾ø¾îÁ³´ÂÁö Ç÷¡±×
  2816. BYTE byLength;
  2817. if (!Recv(sizeof(byState), &byState))
  2818. return false;
  2819. if (!Recv(sizeof(byLength), &byLength))
  2820. return false;
  2821. if (!Recv(byLength, char_name))
  2822. return false;
  2823. char_name[byLength] = 0;
  2824. CPythonMessenger::Instance().SetMobile(char_name, byState);
  2825. break;
  2826. }
  2827. }
  2828. return true;
  2829. }
  2831. //////////////////////////////////////////////////////////////////////////
  2832. // Party
  2834. bool CPythonNetworkStream::SendPartyInvitePacket(DWORD dwVID)
  2835. {
  2836. TPacketCGPartyInvite kPartyInvitePacket;
  2837. kPartyInvitePacket.header = HEADER_CG_PARTY_INVITE;
  2838. kPartyInvitePacket.vid = dwVID;
  2840. if (!Send(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
  2841. {
  2842. Tracenf("CPythonNetworkStream::SendPartyInvitePacket [%ud] - PACKET SEND ERROR", dwVID);
  2843. return false;
  2844. }
  2846. Tracef(" << SendPartyInvitePacket : %d\n", dwVID);
  2847. return SendSequence();
  2848. }
  2850. bool CPythonNetworkStream::SendPartyInviteAnswerPacket(DWORD dwLeaderVID, BYTE byAnswer)
  2851. {
  2852. TPacketCGPartyInviteAnswer kPartyInviteAnswerPacket;
  2853. kPartyInviteAnswerPacket.header = HEADER_CG_PARTY_INVITE_ANSWER;
  2854. kPartyInviteAnswerPacket.leader_pid = dwLeaderVID;
  2855. kPartyInviteAnswerPacket.accept = byAnswer;
  2857. if (!Send(sizeof(kPartyInviteAnswerPacket), &kPartyInviteAnswerPacket))
  2858. {
  2859. Tracenf("CPythonNetworkStream::SendPartyInviteAnswerPacket [%ud %ud] - PACKET SEND ERROR", dwLeaderVID, byAnswer);
  2860. return false;
  2861. }
  2863. Tracef(" << SendPartyInviteAnswerPacket : %d, %d\n", dwLeaderVID, byAnswer);
  2864. return SendSequence();
  2865. }
  2867. bool CPythonNetworkStream::SendPartyRemovePacket(DWORD dwPID)
  2868. {
  2869. TPacketCGPartyRemove kPartyInviteRemove;
  2870. kPartyInviteRemove.header = HEADER_CG_PARTY_REMOVE;
  2871. kPartyInviteRemove.pid = dwPID;
  2873. if (!Send(sizeof(kPartyInviteRemove), &kPartyInviteRemove))
  2874. {
  2875. Tracenf("CPythonNetworkStream::SendPartyRemovePacket [%ud] - PACKET SEND ERROR", dwPID);
  2876. return false;
  2877. }
  2879. Tracef(" << SendPartyRemovePacket : %d\n", dwPID);
  2880. return SendSequence();
  2881. }
  2883. bool CPythonNetworkStream::SendPartySetStatePacket(DWORD dwVID, BYTE byState, BYTE byFlag)
  2884. {
  2885. TPacketCGPartySetState kPartySetState;
  2886. kPartySetState.byHeader = HEADER_CG_PARTY_SET_STATE;
  2887. kPartySetState.dwVID = dwVID;
  2888. kPartySetState.byState = byState;
  2889. kPartySetState.byFlag = byFlag;
  2891. if (!Send(sizeof(kPartySetState), &kPartySetState))
  2892. {
  2893. Tracenf("CPythonNetworkStream::SendPartySetStatePacket(%ud, %ud) - PACKET SEND ERROR", dwVID, byState);
  2894. return false;
  2895. }
  2897. Tracef(" << SendPartySetStatePacket : %d, %d, %d\n", dwVID, byState, byFlag);
  2898. return SendSequence();
  2899. }
  2901. bool CPythonNetworkStream::SendPartyUseSkillPacket(BYTE bySkillIndex, DWORD dwVID)
  2902. {
  2903. TPacketCGPartyUseSkill kPartyUseSkill;
  2904. kPartyUseSkill.byHeader = HEADER_CG_PARTY_USE_SKILL;
  2905. kPartyUseSkill.bySkillIndex = bySkillIndex;
  2906. kPartyUseSkill.dwTargetVID = dwVID;
  2908. if (!Send(sizeof(kPartyUseSkill), &kPartyUseSkill))
  2909. {
  2910. Tracenf("CPythonNetworkStream::SendPartyUseSkillPacket(%ud, %ud) - PACKET SEND ERROR", bySkillIndex, dwVID);
  2911. return false;
  2912. }
  2914. Tracef(" << SendPartyUseSkillPacket : %d, %d\n", bySkillIndex, dwVID);
  2915. return SendSequence();
  2916. }
  2918. bool CPythonNetworkStream::SendPartyParameterPacket(BYTE byDistributeMode)
  2919. {
  2920. TPacketCGPartyParameter kPartyParameter;
  2921. kPartyParameter.bHeader = HEADER_CG_PARTY_PARAMETER;
  2922. kPartyParameter.bDistributeMode = byDistributeMode;
  2924. if (!Send(sizeof(kPartyParameter), &kPartyParameter))
  2925. {
  2926. Tracenf("CPythonNetworkStream::SendPartyParameterPacket(%d) - PACKET SEND ERROR", byDistributeMode);
  2927. return false;
  2928. }
  2930. Tracef(" << SendPartyParameterPacket : %d\n", byDistributeMode);
  2931. return SendSequence();
  2932. }
  2934. bool CPythonNetworkStream::RecvPartyInvite()
  2935. {
  2936. TPacketGCPartyInvite kPartyInvitePacket;
  2937. if (!Recv(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
  2938. return false;
  2940. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kPartyInvitePacket.leader_pid);
  2941. if (!pInstance)
  2942. {
  2943. TraceError(" CPythonNetworkStream::RecvPartyInvite - Failed to find leader instance [%d]\n", kPartyInvitePacket.leader_pid);
  2944. return true;
  2945. }
  2947. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvPartyInviteQuestion", Py_BuildValue("(is)", kPartyInvitePacket.leader_pid, pInstance->GetNameString()));
  2948. Tracef(" >> RecvPartyInvite : %d, %s\n", kPartyInvitePacket.leader_pid, pInstance->GetNameString());
  2950. return true;
  2951. }
  2953. bool CPythonNetworkStream::RecvPartyAdd()
  2954. {
  2955. TPacketGCPartyAdd kPartyAddPacket;
  2956. if (!Recv(sizeof(kPartyAddPacket), &kPartyAddPacket))
  2957. return false;
  2959. CPythonPlayer::Instance().AppendPartyMember(kPartyAddPacket.pid, kPartyAddPacket.name);
  2960. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AddPartyMember", Py_BuildValue("(is)", kPartyAddPacket.pid, kPartyAddPacket.name));
  2961. Tracef(" >> RecvPartyAdd : %d, %s\n", kPartyAddPacket.pid, kPartyAddPacket.name);
  2963. return true;
  2964. }
  2966. bool CPythonNetworkStream::RecvPartyUpdate()
  2967. {
  2968. TPacketGCPartyUpdate kPartyUpdatePacket;
  2969. if (!Recv(sizeof(kPartyUpdatePacket), &kPartyUpdatePacket))
  2970. return false;
  2972. CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
  2973. if (!CPythonPlayer::Instance().GetPartyMemberPtr(kPartyUpdatePacket.pid, &pPartyMemberInfo))
  2974. return true;
  2976. BYTE byOldState = pPartyMemberInfo->byState;
  2978. CPythonPlayer::Instance().UpdatePartyMemberInfo(kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
  2979. for (int i = 0; i < PARTY_AFFECT_SLOT_MAX_NUM; ++i)
  2980. {
  2981. CPythonPlayer::Instance().UpdatePartyMemberAffect(kPartyUpdatePacket.pid, i, kPartyUpdatePacket.affects[i]);
  2982. }
  2984. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UpdatePartyMemberInfo", Py_BuildValue("(i)", kPartyUpdatePacket.pid));
  2986. // ¸¸¾à ¸®´õ°¡ ¹Ù²î¾ú´Ù¸é, TargetBoard ÀÇ ¹öÆ°À» ¾÷µ¥ÀÌÆ® ÇÑ´Ù.
  2987. DWORD dwVID;
  2988. if (CPythonPlayer::Instance().PartyMemberPIDToVID(kPartyUpdatePacket.pid, &dwVID))
  2989. if (byOldState != kPartyUpdatePacket.state)
  2990. {
  2991. __RefreshTargetBoardByVID(dwVID);
  2992. }
  2994. // Tracef(" >> RecvPartyUpdate : %d, %d, %d\n", kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
  2996. return true;
  2997. }
  2999. bool CPythonNetworkStream::RecvPartyRemove()
  3000. {
  3001. TPacketGCPartyRemove kPartyRemovePacket;
  3002. if (!Recv(sizeof(kPartyRemovePacket), &kPartyRemovePacket))
  3003. return false;
  3005. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RemovePartyMember", Py_BuildValue("(i)", kPartyRemovePacket.pid));
  3006. Tracef(" >> RecvPartyRemove : %d\n", kPartyRemovePacket.pid);
  3008. return true;
  3009. }
  3011. bool CPythonNetworkStream::RecvPartyLink()
  3012. {
  3013. TPacketGCPartyLink kPartyLinkPacket;
  3014. if (!Recv(sizeof(kPartyLinkPacket), &kPartyLinkPacket))
  3015. return false;
  3017. CPythonPlayer::Instance().LinkPartyMember(kPartyLinkPacket.pid, kPartyLinkPacket.vid);
  3018. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "LinkPartyMember", Py_BuildValue("(ii)", kPartyLinkPacket.pid, kPartyLinkPacket.vid));
  3019. Tracef(" >> RecvPartyLink : %d, %d\n", kPartyLinkPacket.pid, kPartyLinkPacket.vid);
  3021. return true;
  3022. }
  3024. bool CPythonNetworkStream::RecvPartyUnlink()
  3025. {
  3026. TPacketGCPartyUnlink kPartyUnlinkPacket;
  3027. if (!Recv(sizeof(kPartyUnlinkPacket), &kPartyUnlinkPacket))
  3028. return false;
  3030. CPythonPlayer::Instance().UnlinkPartyMember(kPartyUnlinkPacket.pid);
  3032. if (CPythonPlayer::Instance().IsMainCharacterIndex(kPartyUnlinkPacket.vid))
  3033. {
  3034. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkAllPartyMember", Py_BuildValue("()"));
  3035. }
  3036. else
  3037. {
  3038. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkPartyMember", Py_BuildValue("(i)", kPartyUnlinkPacket.pid));
  3039. }
  3041. Tracef(" >> RecvPartyUnlink : %d, %d\n", kPartyUnlinkPacket.pid, kPartyUnlinkPacket.vid);
  3043. return true;
  3044. }
  3046. bool CPythonNetworkStream::RecvPartyParameter()
  3047. {
  3048. TPacketGCPartyParameter kPartyParameterPacket;
  3049. if (!Recv(sizeof(kPartyParameterPacket), &kPartyParameterPacket))
  3050. return false;
  3052. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ChangePartyParameter", Py_BuildValue("(i)", kPartyParameterPacket.bDistributeMode));
  3053. Tracef(" >> RecvPartyParameter : %d\n", kPartyParameterPacket.bDistributeMode);
  3055. return true;
  3056. }
  3058. // Party
  3059. //////////////////////////////////////////////////////////////////////////
  3062. //////////////////////////////////////////////////////////////////////////
  3063. // Guild
  3065. bool CPythonNetworkStream::SendGuildAddMemberPacket(DWORD dwVID)
  3066. {
  3067. TPacketCGGuild GuildPacket;
  3068. GuildPacket.byHeader = HEADER_CG_GUILD;
  3069. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_ADD_MEMBER;
  3070. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3071. return false;
  3072. if (!Send(sizeof(dwVID), &dwVID))
  3073. return false;
  3075. Tracef(" SendGuildAddMemberPacket\n", dwVID);
  3076. return SendSequence();
  3077. }
  3079. bool CPythonNetworkStream::SendGuildRemoveMemberPacket(DWORD dwPID)
  3080. {
  3081. TPacketCGGuild GuildPacket;
  3082. GuildPacket.byHeader = HEADER_CG_GUILD;
  3083. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REMOVE_MEMBER;
  3084. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3085. return false;
  3086. if (!Send(sizeof(dwPID), &dwPID))
  3087. return false;
  3089. Tracef(" SendGuildRemoveMemberPacket %d\n", dwPID);
  3090. return SendSequence();
  3091. }
  3093. bool CPythonNetworkStream::SendGuildChangeGradeNamePacket(BYTE byGradeNumber, const char * c_szName)
  3094. {
  3095. TPacketCGGuild GuildPacket;
  3096. GuildPacket.byHeader = HEADER_CG_GUILD;
  3097. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME;
  3098. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3099. return false;
  3100. if (!Send(sizeof(byGradeNumber), &byGradeNumber))
  3101. return false;
  3103. char szName[GUILD_GRADE_NAME_MAX_LEN+1];
  3104. strncpy(szName, c_szName, GUILD_GRADE_NAME_MAX_LEN);
  3105. szName[GUILD_GRADE_NAME_MAX_LEN] = '\0';
  3107. if (!Send(sizeof(szName), &szName))
  3108. return false;
  3110. Tracef(" SendGuildChangeGradeNamePacket %d, %s\n", byGradeNumber, c_szName);
  3111. return SendSequence();
  3112. }
  3114. bool CPythonNetworkStream::SendGuildChangeGradeAuthorityPacket(BYTE byGradeNumber, BYTE byAuthority)
  3115. {
  3116. TPacketCGGuild GuildPacket;
  3117. GuildPacket.byHeader = HEADER_CG_GUILD;
  3118. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY;
  3119. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3120. return false;
  3121. if (!Send(sizeof(byGradeNumber), &byGradeNumber))
  3122. return false;
  3123. if (!Send(sizeof(byAuthority), &byAuthority))
  3124. return false;
  3126. Tracef(" SendGuildChangeGradeAuthorityPacket %d, %d\n", byGradeNumber, byAuthority);
  3127. return SendSequence();
  3128. }
  3130. bool CPythonNetworkStream::SendGuildOfferPacket(DWORD dwExperience)
  3131. {
  3132. TPacketCGGuild GuildPacket;
  3133. GuildPacket.byHeader = HEADER_CG_GUILD;
  3134. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_OFFER;
  3135. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3136. return false;
  3137. if (!Send(sizeof(dwExperience), &dwExperience))
  3138. return false;
  3140. Tracef(" SendGuildOfferPacket %d\n", dwExperience);
  3141. return SendSequence();
  3142. }
  3144. bool CPythonNetworkStream::SendGuildPostCommentPacket(const char * c_szMessage)
  3145. {
  3146. TPacketCGGuild GuildPacket;
  3147. GuildPacket.byHeader = HEADER_CG_GUILD;
  3148. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_POST_COMMENT;
  3149. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3150. return false;
  3152. BYTE bySize = BYTE(strlen(c_szMessage)) + 1;
  3153. if (!Send(sizeof(bySize), &bySize))
  3154. return false;
  3155. if (!Send(bySize, c_szMessage))
  3156. return false;
  3158. Tracef(" SendGuildPostCommentPacket %d, %s\n", bySize, c_szMessage);
  3159. return SendSequence();
  3160. }
  3162. bool CPythonNetworkStream::SendGuildDeleteCommentPacket(DWORD dwIndex)
  3163. {
  3164. TPacketCGGuild GuildPacket;
  3165. GuildPacket.byHeader = HEADER_CG_GUILD;
  3166. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DELETE_COMMENT;
  3167. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3168. return false;
  3170. if (!Send(sizeof(dwIndex), &dwIndex))
  3171. return false;
  3173. Tracef(" SendGuildDeleteCommentPacket %d\n", dwIndex);
  3174. return SendSequence();
  3175. }
  3177. bool CPythonNetworkStream::SendGuildRefreshCommentsPacket(DWORD dwHighestIndex)
  3178. {
  3179. static DWORD s_LastTime = timeGetTime() - 1001;
  3181. if (timeGetTime() - s_LastTime < 1000)
  3182. return true;
  3183. s_LastTime = timeGetTime();
  3185. TPacketCGGuild GuildPacket;
  3186. GuildPacket.byHeader = HEADER_CG_GUILD;
  3187. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REFRESH_COMMENT;
  3188. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3189. return false;
  3191. Tracef(" SendGuildRefreshCommentPacket %d\n", dwHighestIndex);
  3192. return SendSequence();
  3193. }
  3195. bool CPythonNetworkStream::SendGuildChangeMemberGradePacket(DWORD dwPID, BYTE byGrade)
  3196. {
  3197. TPacketCGGuild GuildPacket;
  3198. GuildPacket.byHeader = HEADER_CG_GUILD;
  3199. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE;
  3200. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3201. return false;
  3203. if (!Send(sizeof(dwPID), &dwPID))
  3204. return false;
  3205. if (!Send(sizeof(byGrade), &byGrade))
  3206. return false;
  3208. Tracef(" SendGuildChangeMemberGradePacket %d, %d\n", dwPID, byGrade);
  3209. return SendSequence();
  3210. }
  3212. bool CPythonNetworkStream::SendGuildUseSkillPacket(DWORD dwSkillID, DWORD dwTargetVID)
  3213. {
  3214. TPacketCGGuild GuildPacket;
  3215. GuildPacket.byHeader = HEADER_CG_GUILD;
  3216. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_USE_SKILL;
  3217. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3218. return false;
  3220. if (!Send(sizeof(dwSkillID), &dwSkillID))
  3221. return false;
  3222. if (!Send(sizeof(dwTargetVID), &dwTargetVID))
  3223. return false;
  3225. Tracef(" SendGuildUseSkillPacket %d, %d\n", dwSkillID, dwTargetVID);
  3226. return SendSequence();
  3227. }
  3229. bool CPythonNetworkStream::SendGuildChangeMemberGeneralPacket(DWORD dwPID, BYTE byFlag)
  3230. {
  3231. TPacketCGGuild GuildPacket;
  3232. GuildPacket.byHeader = HEADER_CG_GUILD;
  3233. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL;
  3234. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3235. return false;
  3237. if (!Send(sizeof(dwPID), &dwPID))
  3238. return false;
  3239. if (!Send(sizeof(byFlag), &byFlag))
  3240. return false;
  3242. Tracef(" SendGuildChangeMemberGeneralFlagPacket %d, %d\n", dwPID, byFlag);
  3243. return SendSequence();
  3244. }
  3246. bool CPythonNetworkStream::SendGuildInviteAnswerPacket(DWORD dwGuildID, BYTE byAnswer)
  3247. {
  3248. TPacketCGGuild GuildPacket;
  3249. GuildPacket.byHeader = HEADER_CG_GUILD;
  3250. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER;
  3251. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3252. return false;
  3254. if (!Send(sizeof(dwGuildID), &dwGuildID))
  3255. return false;
  3256. if (!Send(sizeof(byAnswer), &byAnswer))
  3257. return false;
  3259. Tracef(" SendGuildInviteAnswerPacket %d, %d\n", dwGuildID, byAnswer);
  3260. return SendSequence();
  3261. }
  3263. bool CPythonNetworkStream::SendGuildChargeGSPPacket(DWORD dwMoney)
  3264. {
  3265. TPacketCGGuild GuildPacket;
  3266. GuildPacket.byHeader = HEADER_CG_GUILD;
  3267. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHARGE_GSP;
  3268. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3269. return false;
  3271. if (!Send(sizeof(dwMoney), &dwMoney))
  3272. return false;
  3274. Tracef(" SendGuildChargeGSPPacket %d\n", dwMoney);
  3275. return SendSequence();
  3276. }
  3278. bool CPythonNetworkStream::SendGuildDepositMoneyPacket(DWORD dwMoney)
  3279. {
  3280. TPacketCGGuild GuildPacket;
  3281. GuildPacket.byHeader = HEADER_CG_GUILD;
  3282. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DEPOSIT_MONEY;
  3283. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3284. return false;
  3285. if (!Send(sizeof(dwMoney), &dwMoney))
  3286. return false;
  3288. Tracef(" SendGuildDepositMoneyPacket %d\n", dwMoney);
  3289. return SendSequence();
  3290. }
  3292. bool CPythonNetworkStream::SendGuildWithdrawMoneyPacket(DWORD dwMoney)
  3293. {
  3294. TPacketCGGuild GuildPacket;
  3295. GuildPacket.byHeader = HEADER_CG_GUILD;
  3296. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_WITHDRAW_MONEY;
  3297. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3298. return false;
  3299. if (!Send(sizeof(dwMoney), &dwMoney))
  3300. return false;
  3302. Tracef(" SendGuildWithdrawMoneyPacket %d\n", dwMoney);
  3303. return SendSequence();
  3304. }
  3306. bool CPythonNetworkStream::RecvGuild()
  3307. {
  3308. TPacketGCGuild GuildPacket;
  3309. if (!Recv(sizeof(GuildPacket), &GuildPacket))
  3310. return false;
  3312. switch(GuildPacket.subheader)
  3313. {
  3314. case GUILD_SUBHEADER_GC_LOGIN:
  3315. {
  3316. DWORD dwPID;
  3317. if (!Recv(sizeof(DWORD), &dwPID))
  3318. return false;
  3320. // Messenger
  3321. CPythonGuild::TGuildMemberData * pGuildMemberData;
  3322. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
  3323. if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
  3324. CPythonMessenger::Instance().LoginGuildMember(pGuildMemberData->strName.c_str());
  3326. //Tracef(" <Login> %d\n", dwPID);
  3327. break;
  3328. }
  3329. case GUILD_SUBHEADER_GC_LOGOUT:
  3330. {
  3331. DWORD dwPID;
  3332. if (!Recv(sizeof(DWORD), &dwPID))
  3333. return false;
  3335. // Messenger
  3336. CPythonGuild::TGuildMemberData * pGuildMemberData;
  3337. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
  3338. if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
  3339. CPythonMessenger::Instance().LogoutGuildMember(pGuildMemberData->strName.c_str());
  3341. //Tracef(" <Logout> %d\n", dwPID);
  3342. break;
  3343. }
  3344. case GUILD_SUBHEADER_GC_REMOVE:
  3345. {
  3346. DWORD dwPID;
  3347. if (!Recv(sizeof(dwPID), &dwPID))
  3348. return false;
  3350. // Main Player ÀÏ °æ¿ì DeleteGuild
  3351. if (CPythonGuild::Instance().IsMainPlayer(dwPID))
  3352. {
  3353. CPythonGuild::Instance().Destroy();
  3354. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "DeleteGuild", Py_BuildValue("()"));
  3355. CPythonMessenger::Instance().RemoveAllGuildMember();
  3356. __SetGuildID(0);
  3357. __RefreshMessengerWindow();
  3358. __RefreshTargetBoard();
  3359. __RefreshCharacterWindow();
  3360. }
  3361. else
  3362. {
  3363. // Get Member Name
  3364. std::string strMemberName = "";
  3365. CPythonGuild::TGuildMemberData * pData;
  3366. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pData))
  3367. {
  3368. strMemberName = pData->strName;
  3369. CPythonMessenger::Instance().RemoveGuildMember(pData->strName.c_str());
  3370. }
  3372. CPythonGuild::Instance().RemoveMember(dwPID);
  3374. // Refresh
  3375. __RefreshTargetBoardByName(strMemberName.c_str());
  3376. __RefreshGuildWindowMemberPage();
  3377. }
  3379. Tracef(" <Remove> %d\n", dwPID);
  3380. break;
  3381. }
  3382. case GUILD_SUBHEADER_GC_LIST:
  3383. {
  3384. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3386. for (; iPacketSize > 0;)
  3387. {
  3388. TPacketGCGuildSubMember memberPacket;
  3389. if (!Recv(sizeof(memberPacket), &memberPacket))
  3390. return false;
  3392. char szName[CHARACTER_NAME_MAX_LEN+1] = "";
  3393. if (memberPacket.byNameFlag)
  3394. {
  3395. if (!Recv(sizeof(szName), &szName))
  3396. return false;
  3398. iPacketSize -= CHARACTER_NAME_MAX_LEN+1;
  3399. }
  3400. else
  3401. {
  3402. CPythonGuild::TGuildMemberData * pMemberData;
  3403. if (CPythonGuild::Instance().GetMemberDataPtrByPID(memberPacket.pid, &pMemberData))
  3404. {
  3405. strncpy(szName, pMemberData->strName.c_str(), CHARACTER_NAME_MAX_LEN);
  3406. }
  3407. }
  3409. //Tracef(" <List> %d : %s, %d (%d, %d, %d)\n", memberPacket.pid, szName, memberPacket.byGrade, memberPacket.byJob, memberPacket.byLevel, memberPacket.dwOffer);
  3411. CPythonGuild::SGuildMemberData GuildMemberData;
  3412. GuildMemberData.dwPID = memberPacket.pid;
  3413. GuildMemberData.byGrade = memberPacket.byGrade;
  3414. GuildMemberData.strName = szName;
  3415. GuildMemberData.byJob = memberPacket.byJob;
  3416. GuildMemberData.byLevel = memberPacket.byLevel;
  3417. GuildMemberData.dwOffer = memberPacket.dwOffer;
  3418. GuildMemberData.byGeneralFlag = memberPacket.byIsGeneral;
  3419. CPythonGuild::Instance().RegisterMember(GuildMemberData);
  3421. // Messenger
  3422. if (strcmp(szName, CPythonPlayer::Instance().GetName()))
  3423. CPythonMessenger::Instance().AppendGuildMember(szName);
  3425. __RefreshTargetBoardByName(szName);
  3427. iPacketSize -= sizeof(memberPacket);
  3428. }
  3430. __RefreshGuildWindowInfoPage();
  3431. __RefreshGuildWindowMemberPage();
  3432. __RefreshMessengerWindow();
  3433. __RefreshCharacterWindow();
  3434. break;
  3435. }
  3436. case GUILD_SUBHEADER_GC_GRADE:
  3437. {
  3438. BYTE byCount;
  3439. if (!Recv(sizeof(byCount), &byCount))
  3440. return false;
  3442. for (BYTE i = 0; i < byCount; ++ i)
  3443. {
  3444. BYTE byIndex;
  3445. if (!Recv(sizeof(byCount), &byIndex))
  3446. return false;
  3447. TPacketGCGuildSubGrade GradePacket;
  3448. if (!Recv(sizeof(GradePacket), &GradePacket))
  3449. return false;
  3451. CPythonGuild::Instance().SetGradeData(byIndex, CPythonGuild::SGuildGradeData(GradePacket.auth_flag, GradePacket.grade_name));
  3452. //Tracef(" <Grade> [%d/%d] : %s, %d\n", byIndex, byCount, GradePacket.grade_name, GradePacket.auth_flag);
  3453. }
  3454. __RefreshGuildWindowGradePage();
  3455. __RefreshGuildWindowMemberPageGradeComboBox();
  3456. break;
  3457. }
  3458. case GUILD_SUBHEADER_GC_GRADE_NAME:
  3459. {
  3460. BYTE byGradeNumber;
  3461. if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
  3462. return false;
  3464. char szGradeName[GUILD_GRADE_NAME_MAX_LEN+1] = "";
  3465. if (!Recv(sizeof(szGradeName), &szGradeName))
  3466. return false;
  3468. CPythonGuild::Instance().SetGradeName(byGradeNumber, szGradeName);
  3469. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
  3471. Tracef(" <Change Grade Name> %d, %s\n", byGradeNumber, szGradeName);
  3472. __RefreshGuildWindowGradePage();
  3473. __RefreshGuildWindowMemberPageGradeComboBox();
  3474. break;
  3475. }
  3476. case GUILD_SUBHEADER_GC_GRADE_AUTH:
  3477. {
  3478. BYTE byGradeNumber;
  3479. if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
  3480. return false;
  3481. BYTE byAuthorityFlag;
  3482. if (!Recv(sizeof(byAuthorityFlag), &byAuthorityFlag))
  3483. return false;
  3485. CPythonGuild::Instance().SetGradeAuthority(byGradeNumber, byAuthorityFlag);
  3486. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
  3488. Tracef(" <Change Grade Authority> %d, %d\n", byGradeNumber, byAuthorityFlag);
  3489. __RefreshGuildWindowGradePage();
  3490. break;
  3491. }
  3492. case GUILD_SUBHEADER_GC_INFO:
  3493. {
  3494. TPacketGCGuildInfo GuildInfo;
  3495. if (!Recv(sizeof(GuildInfo), &GuildInfo))
  3496. return false;
  3498. CPythonGuild::Instance().EnableGuild();
  3499. CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
  3500. strncpy(rGuildInfo.szGuildName, GuildInfo.name, GUILD_NAME_MAX_LEN);
  3501. rGuildInfo.szGuildName[GUILD_NAME_MAX_LEN] = '\0';
  3503. rGuildInfo.dwGuildID = GuildInfo.guild_id;
  3504. rGuildInfo.dwMasterPID = GuildInfo.master_pid;
  3505. rGuildInfo.dwGuildLevel = GuildInfo.level;
  3506. rGuildInfo.dwCurrentExperience = GuildInfo.exp;
  3507. rGuildInfo.dwCurrentMemberCount = GuildInfo.member_count;
  3508. rGuildInfo.dwMaxMemberCount = GuildInfo.max_member_count;
  3509. rGuildInfo.dwGuildMoney = GuildInfo.gold;
  3510. rGuildInfo.bHasLand = GuildInfo.hasLand;
  3512. //Tracef(" <Info> %s, %d, %d : %d\n", GuildInfo.name, GuildInfo.master_pid, GuildInfo.level, rGuildInfo.bHasLand);
  3513. __RefreshGuildWindowInfoPage();
  3514. break;
  3515. }
  3516. case GUILD_SUBHEADER_GC_COMMENTS:
  3517. {
  3518. BYTE byCount;
  3519. if (!Recv(sizeof(byCount), &byCount))
  3520. return false;
  3522. CPythonGuild::Instance().ClearComment();
  3523. //Tracef(" >>> Comments Count : %d\n", byCount);
  3525. for (BYTE i = 0; i < byCount; ++i)
  3526. {
  3527. DWORD dwCommentID;
  3528. if (!Recv(sizeof(dwCommentID), &dwCommentID))
  3529. return false;
  3531. char szName[CHARACTER_NAME_MAX_LEN+1] = "";
  3532. if (!Recv(sizeof(szName), &szName))
  3533. return false;
  3535. char szComment[GULID_COMMENT_MAX_LEN+1] = "";
  3536. if (!Recv(sizeof(szComment), &szComment))
  3537. return false;
  3539. //Tracef(" [Comment-%d] : %s, %s\n", dwCommentID, szName, szComment);
  3540. CPythonGuild::Instance().RegisterComment(dwCommentID, szName, szComment);
  3541. }
  3543. __RefreshGuildWindowBoardPage();
  3544. break;
  3545. }
  3546. case GUILD_SUBHEADER_GC_CHANGE_EXP:
  3547. {
  3548. BYTE byLevel;
  3549. if (!Recv(sizeof(byLevel), &byLevel))
  3550. return false;
  3551. DWORD dwEXP;
  3552. if (!Recv(sizeof(dwEXP), &dwEXP))
  3553. return false;
  3554. CPythonGuild::Instance().SetGuildEXP(byLevel, dwEXP);
  3555. Tracef(" <ChangeEXP> %d, %d\n", byLevel, dwEXP);
  3556. __RefreshGuildWindowInfoPage();
  3557. break;
  3558. }
  3559. case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE:
  3560. {
  3561. DWORD dwPID;
  3562. if (!Recv(sizeof(dwPID), &dwPID))
  3563. return false;
  3564. BYTE byGrade;
  3565. if (!Recv(sizeof(byGrade), &byGrade))
  3566. return false;
  3567. CPythonGuild::Instance().ChangeGuildMemberGrade(dwPID, byGrade);
  3568. Tracef(" <ChangeMemberGrade> %d, %d\n", dwPID, byGrade);
  3569. __RefreshGuildWindowMemberPage();
  3570. break;
  3571. }
  3572. case GUILD_SUBHEADER_GC_SKILL_INFO:
  3573. {
  3574. CPythonGuild::TGuildSkillData & rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
  3575. if (!Recv(sizeof(rSkillData.bySkillPoint), &rSkillData.bySkillPoint))
  3576. return false;
  3577. if (!Recv(sizeof(rSkillData.bySkillLevel), rSkillData.bySkillLevel))
  3578. return false;
  3579. if (!Recv(sizeof(rSkillData.wGuildPoint), &rSkillData.wGuildPoint))
  3580. return false;
  3581. if (!Recv(sizeof(rSkillData.wMaxGuildPoint), &rSkillData.wMaxGuildPoint))
  3582. return false;
  3584. Tracef(" <SkillInfo> %d / %d, %d\n", rSkillData.bySkillPoint, rSkillData.wGuildPoint, rSkillData.wMaxGuildPoint);
  3585. __RefreshGuildWindowSkillPage();
  3586. break;
  3587. }
  3588. case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL:
  3589. {
  3590. DWORD dwPID;
  3591. if (!Recv(sizeof(dwPID), &dwPID))
  3592. return false;
  3593. BYTE byFlag;
  3594. if (!Recv(sizeof(byFlag), &byFlag))
  3595. return false;
  3597. CPythonGuild::Instance().ChangeGuildMemberGeneralFlag(dwPID, byFlag);
  3598. Tracef(" <ChangeMemberGeneralFlag> %d, %d\n", dwPID, byFlag);
  3599. __RefreshGuildWindowMemberPage();
  3600. break;
  3601. }
  3602. case GUILD_SUBHEADER_GC_GUILD_INVITE:
  3603. {
  3604. DWORD dwGuildID;
  3605. if (!Recv(sizeof(dwGuildID), &dwGuildID))
  3606. return false;
  3607. char szGuildName[GUILD_NAME_MAX_LEN+1];
  3608. if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
  3609. return false;
  3611. szGuildName[GUILD_NAME_MAX_LEN] = 0;
  3613. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvGuildInviteQuestion", Py_BuildValue("(is)", dwGuildID, szGuildName));
  3614. Tracef(" <Guild Invite> %d, %s\n", dwGuildID, szGuildName);
  3615. break;
  3616. }
  3617. case GUILD_SUBHEADER_GC_WAR:
  3618. {
  3619. TPacketGCGuildWar kGuildWar;
  3620. if (!Recv(sizeof(kGuildWar), &kGuildWar))
  3621. return false;
  3623. switch (kGuildWar.bWarState)
  3624. {
  3625. case GUILD_WAR_SEND_DECLARE:
  3626. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_SEND_DECLARE\n");
  3627. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3628. "BINARY_GuildWar_OnSendDeclare",
  3629. Py_BuildValue("(i)", kGuildWar.dwGuildOpp)
  3630. );
  3631. break;
  3632. case GUILD_WAR_RECV_DECLARE:
  3633. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_RECV_DECLARE\n");
  3634. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3635. "BINARY_GuildWar_OnRecvDeclare",
  3636. Py_BuildValue("(ii)", kGuildWar.dwGuildOpp, kGuildWar.bType)
  3637. );
  3638. break;
  3639. case GUILD_WAR_ON_WAR:
  3640. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_ON_WAR : %d, %d\n", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp);
  3641. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3642. "BINARY_GuildWar_OnStart",
  3643. Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
  3644. );
  3645. CPythonGuild::Instance().StartGuildWar(kGuildWar.dwGuildOpp);
  3646. break;
  3647. case GUILD_WAR_END:
  3648. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_END\n");
  3649. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3650. "BINARY_GuildWar_OnEnd",
  3651. Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
  3652. );
  3653. CPythonGuild::Instance().EndGuildWar(kGuildWar.dwGuildOpp);
  3654. break;
  3655. }
  3656. break;
  3657. }
  3658. case GUILD_SUBHEADER_GC_GUILD_NAME:
  3659. {
  3660. DWORD dwID;
  3661. char szGuildName[GUILD_NAME_MAX_LEN+1];
  3663. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3665. int nItemSize = sizeof(dwID) + GUILD_NAME_MAX_LEN;
  3667. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_NAME");
  3669. for (; iPacketSize > 0;)
  3670. {
  3671. if (!Recv(sizeof(dwID), &dwID))
  3672. return false;
  3674. if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
  3675. return false;
  3677. szGuildName[GUILD_NAME_MAX_LEN] = 0;
  3679. //Tracef(" >> GulidName [%d : %s]\n", dwID, szGuildName);
  3680. CPythonGuild::Instance().RegisterGuildName(dwID, szGuildName);
  3681. iPacketSize -= nItemSize;
  3682. }
  3683. break;
  3684. }
  3685. case GUILD_SUBHEADER_GC_GUILD_WAR_LIST:
  3686. {
  3687. DWORD dwSrcGuildID;
  3688. DWORD dwDstGuildID;
  3690. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3691. int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
  3693. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_LIST");
  3695. for (; iPacketSize > 0;)
  3696. {
  3697. if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
  3698. return false;
  3700. if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
  3701. return false;
  3703. Tracef(" >> GulidWarList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
  3704. CInstanceBase::InsertGVGKey(dwSrcGuildID, dwDstGuildID);
  3705. CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
  3706. iPacketSize -= nItemSize;
  3707. }
  3708. break;
  3709. }
  3710. case GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST:
  3711. {
  3712. DWORD dwSrcGuildID;
  3713. DWORD dwDstGuildID;
  3715. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3716. int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
  3718. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST");
  3720. for (; iPacketSize > 0;)
  3721. {
  3723. if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
  3724. return false;
  3726. if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
  3727. return false;
  3729. Tracef(" >> GulidWarEndList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
  3730. CInstanceBase::RemoveGVGKey(dwSrcGuildID, dwDstGuildID);
  3731. CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
  3732. iPacketSize -= nItemSize;
  3733. }
  3734. break;
  3735. }
  3736. case GUILD_SUBHEADER_GC_WAR_POINT:
  3737. {
  3738. TPacketGuildWarPoint GuildWarPoint;
  3739. if (!Recv(sizeof(GuildWarPoint), &GuildWarPoint))
  3740. return false;
  3742. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3743. "BINARY_GuildWar_OnRecvPoint",
  3744. Py_BuildValue("(iii)", GuildWarPoint.dwGainGuildID, GuildWarPoint.dwOpponentGuildID, GuildWarPoint.lPoint)
  3745. );
  3746. break;
  3747. }
  3748. case GUILD_SUBHEADER_GC_MONEY_CHANGE:
  3749. {
  3750. DWORD dwMoney;
  3751. if (!Recv(sizeof(dwMoney), &dwMoney))
  3752. return false;
  3754. CPythonGuild::Instance().SetGuildMoney(dwMoney);
  3756. __RefreshGuildWindowInfoPage();
  3757. Tracef(" >> Guild Money Change : %d\n", dwMoney);
  3758. break;
  3759. }
  3760. }
  3762. return true;
  3763. }
  3765. // Guild
  3766. //////////////////////////////////////////////////////////////////////////
  3769. /////////////////////////////////////////////////////////////////////////
  3770. // Fishing
  3772. bool CPythonNetworkStream::SendFishingPacket(int iRotation)
  3773. {
  3774. BYTE byHeader = HEADER_CG_FISHING;
  3775. if (!Send(sizeof(byHeader), &byHeader))
  3776. return false;
  3777. BYTE byPacketRotation = iRotation / 5;
  3778. if (!Send(sizeof(BYTE), &byPacketRotation))
  3779. return false;
  3781. return SendSequence();
  3782. }
  3784. bool CPythonNetworkStream::SendGiveItemPacket(DWORD dwTargetVID, TItemPos ItemPos, int iItemCount)
  3785. {
  3786. TPacketCGGiveItem GiveItemPacket;
  3787. GiveItemPacket.byHeader = HEADER_CG_GIVE_ITEM;
  3788. GiveItemPacket.dwTargetVID = dwTargetVID;
  3789. GiveItemPacket.ItemPos = ItemPos;
  3790. GiveItemPacket.byItemCount = iItemCount;
  3792. if (!Send(sizeof(GiveItemPacket), &GiveItemPacket))
  3793. return false;
  3795. return SendSequence();
  3796. }
  3798. bool CPythonNetworkStream::RecvFishing()
  3799. {
  3800. TPacketGCFishing FishingPacket;
  3801. if (!Recv(sizeof(FishingPacket), &FishingPacket))
  3802. return false;
  3804. CInstanceBase * pFishingInstance = NULL;
  3805. if (FISHING_SUBHEADER_GC_FISH != FishingPacket.subheader)
  3806. {
  3807. pFishingInstance = CPythonCharacterManager::Instance().GetInstancePtr(FishingPacket.info);
  3808. if (!pFishingInstance)
  3809. return true;
  3810. }
  3812. switch (FishingPacket.subheader)
  3813. {
  3814. case FISHING_SUBHEADER_GC_START:
  3815. pFishingInstance->StartFishing(float(FishingPacket.dir) * 5.0f);
  3816. break;
  3817. case FISHING_SUBHEADER_GC_STOP:
  3818. if (pFishingInstance->IsFishing())
  3819. pFishingInstance->StopFishing();
  3820. break;
  3821. case FISHING_SUBHEADER_GC_REACT:
  3822. if (pFishingInstance->IsFishing())
  3823. {
  3824. pFishingInstance->SetFishEmoticon(); // Fish Emoticon
  3825. pFishingInstance->ReactFishing();
  3826. }
  3827. break;
  3828. case FISHING_SUBHEADER_GC_SUCCESS:
  3829. pFishingInstance->CatchSuccess();
  3830. break;
  3831. case FISHING_SUBHEADER_GC_FAIL:
  3832. pFishingInstance->CatchFail();
  3833. if (pFishingInstance == CPythonCharacterManager::Instance().GetMainInstancePtr())
  3834. {
  3835. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingFailure", Py_BuildValue("()"));
  3836. }
  3837. break;
  3838. case FISHING_SUBHEADER_GC_FISH:
  3839. {
  3840. DWORD dwFishID = FishingPacket.info;
  3842. if (0 == FishingPacket.info)
  3843. {
  3844. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotifyUnknown", Py_BuildValue("()"));
  3845. return true;
  3846. }
  3848. CItemData * pItemData;
  3849. if (!CItemManager::Instance().GetItemDataPointer(dwFishID, &pItemData))
  3850. return true;
  3852. CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
  3853. if (!pMainInstance)
  3854. return true;
  3856. if (pMainInstance->IsFishing())
  3857. {
  3858. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotify", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
  3859. }
  3860. else
  3861. {
  3862. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingSuccess", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
  3863. }
  3864. break;
  3865. }
  3866. }
  3868. return true;
  3869. }
  3870. // Fishing
  3871. /////////////////////////////////////////////////////////////////////////
  3873. /////////////////////////////////////////////////////////////////////////
  3874. // Dungeon
  3875. bool CPythonNetworkStream::RecvDungeon()
  3876. {
  3877. TPacketGCDungeon DungeonPacket;
  3878. if (!Recv(sizeof(DungeonPacket), &DungeonPacket))
  3879. return false;
  3881. switch (DungeonPacket.subheader)
  3882. {
  3883. case DUNGEON_SUBHEADER_GC_TIME_ATTACK_START:
  3884. {
  3885. break;
  3886. }
  3887. case DUNGEON_SUBHEADER_GC_DESTINATION_POSITION:
  3888. {
  3889. unsigned long ulx, uly;
  3890. if (!Recv(sizeof(ulx), &ulx))
  3891. return false;
  3892. if (!Recv(sizeof(uly), &uly))
  3893. return false;
  3895. CPythonPlayer::Instance().SetDungeonDestinationPosition(ulx, uly);
  3896. break;
  3897. }
  3898. }
  3900. return true;
  3901. }
  3902. // Dungeon
  3903. /////////////////////////////////////////////////////////////////////////
  3905. /////////////////////////////////////////////////////////////////////////
  3906. // MyShop
  3907. bool CPythonNetworkStream::SendBuildPrivateShopPacket(const char * c_szName, const std::vector<TShopItemTable> & c_rSellingItemStock)
  3908. {
  3909. TPacketCGMyShop packet;
  3910. packet.bHeader = HEADER_CG_MYSHOP;
  3911. strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN);
  3912. packet.bCount = c_rSellingItemStock.size();
  3913. if (!Send(sizeof(packet), &packet))
  3914. return false;
  3916. for (std::vector<TShopItemTable>::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor)
  3917. {
  3918. const TShopItemTable & c_rItem = *itor;
  3919. if (!Send(sizeof(c_rItem), &c_rItem))
  3920. return false;
  3921. }
  3923. return SendSequence();
  3924. }
  3926. bool CPythonNetworkStream::RecvShopSignPacket()
  3927. {
  3928. TPacketGCShopSign p;
  3929. if (!Recv(sizeof(TPacketGCShopSign), &p))
  3930. return false;
  3932. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  3934. if (0 == strlen(p.szSign))
  3935. {
  3936. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3937. "BINARY_PrivateShop_Disappear",
  3938. Py_BuildValue("(i)", p.dwVID)
  3939. );
  3941. if (rkPlayer.IsMainCharacterIndex(p.dwVID))
  3942. rkPlayer.ClosePrivateShop();
  3943. }
  3944. else
  3945. {
  3946. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3947. "BINARY_PrivateShop_Appear",
  3948. Py_BuildValue("(is)", p.dwVID, p.szSign)
  3949. );
  3951. if (rkPlayer.IsMainCharacterIndex(p.dwVID))
  3952. rkPlayer.OpenPrivateShop();
  3953. }
  3955. return true;
  3956. }
  3957. /////////////////////////////////////////////////////////////////////////
  3959. bool CPythonNetworkStream::SendBuildOfflineShopPacket(const char * c_szName, const std::vector<TShopItemTable> & c_rSellingItemStock, BYTE bTime)
  3960. {
  3961. TPacketCGMyOfflineShop packet;
  3962. packet.bHeader = HEADER_CG_MY_OFFLINE_SHOP;
  3963. strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN);
  3964. packet.bCount = c_rSellingItemStock.size();
  3965. packet.bTime = bTime;
  3966. if (!Send(sizeof(packet), &packet))
  3967. return false;
  3969. for (std::vector<TShopItemTable>::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor)
  3970. {
  3971. const TShopItemTable & c_rItem = *itor;
  3972. if (!Send(sizeof(c_rItem), &c_rItem))
  3973. return false;
  3974. }
  3976. return SendSequence();
  3977. }
  3979. bool CPythonNetworkStream::RecvOfflineShopSignPacket()
  3980. {
  3981. TPacketGCShopSign p;
  3982. if (!Recv(sizeof(TPacketGCShopSign), &p))
  3983. return false;
  3985. if (0 == strlen(p.szSign))
  3986. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID));
  3987. else
  3988. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Appear", Py_BuildValue("(is)", p.dwVID, p.szSign));
  3990. return true;
  3991. }
  3993. bool CPythonNetworkStream::RecvOfflineShopPacket()
  3994. {
  3995. std::vector<char> vecBuffer;
  3996. vecBuffer.clear();
  3998. TPacketGCShop packet_shop;
  3999. if (!Recv(sizeof(packet_shop), &packet_shop))
  4000. return false;
  4002. int iSize = packet_shop.size - sizeof(packet_shop);
  4003. if (iSize > 0)
  4004. {
  4005. vecBuffer.resize(iSize);
  4006. if (!Recv(iSize, &vecBuffer[0]))
  4007. return false;
  4008. }
  4010. switch (packet_shop.subheader)
  4011. {
  4012. case SHOP_SUBHEADER_GC_START:
  4013. {
  4014. CPythonShop::Instance().Clear();
  4016. DWORD dwVID = *(DWORD *)&vecBuffer[0];
  4018. TPacketGCOfflineShopStart * pShopStartPacket = (TPacketGCOfflineShopStart *)&vecBuffer[4];
  4019. for (BYTE iItemIndex = 0; iItemIndex < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
  4020. {
  4021. CPythonShop::Instance().SetOfflineShopItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
  4022. }
  4024. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartOfflineShop", Py_BuildValue("(i)", dwVID));
  4025. }
  4026. break;
  4028. case SHOP_SUBHEADER_GC_END:
  4029. CPythonShop::instance().Clear();
  4030. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndOfflineShop", Py_BuildValue("()"));
  4031. break;
  4033. case SHOP_SUBHEADER_GC_UPDATE_ITEM:
  4034. {
  4035. TPacketGCShopUpdateOfflineShopItem * pShopUpdateItemPacket = (TPacketGCShopUpdateOfflineShopItem *)&vecBuffer[0];
  4036. CPythonShop::Instance().SetOfflineShopItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item);
  4037. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()"));
  4038. }
  4039. break;
  4041. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY:
  4042. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY"));
  4043. break;
  4045. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX:
  4046. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY_EX"));
  4047. break;
  4049. case SHOP_SUBHEADER_GC_SOLD_OUT:
  4050. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT"));
  4051. break;
  4053. case SHOP_SUBHEADER_GC_INVENTORY_FULL:
  4054. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL"));
  4055. break;
  4057. case SHOP_SUBHEADER_GC_INVALID_POS:
  4058. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS"));
  4059. break;
  4061. default:
  4062. TraceError("CPythonNetworkStream::RecvOfflineShopPacket: Unknown subheader %d\n", packet_shop.subheader);
  4063. break;
  4064. }
  4066. return true;
  4067. }
  4069. bool CPythonNetworkStream::RecvTimePacket()
  4070. {
  4071. TPacketGCTime TimePacket;
  4072. if (!Recv(sizeof(TimePacket), &TimePacket))
  4073. return false;
  4075. IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
  4076. rkApp.SetServerTime(TimePacket.time);
  4078. return true;
  4079. }
  4081. bool CPythonNetworkStream::RecvWalkModePacket()
  4082. {
  4083. TPacketGCWalkMode WalkModePacket;
  4084. if (!Recv(sizeof(WalkModePacket), &WalkModePacket))
  4085. return false;
  4087. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(WalkModePacket.vid);
  4088. if (pInstance)
  4089. {
  4090. if (WALKMODE_RUN == WalkModePacket.mode)
  4091. {
  4092. pInstance->SetRunMode();
  4093. }
  4094. else
  4095. {
  4096. pInstance->SetWalkMode();
  4097. }
  4098. }
  4100. return true;
  4101. }
  4103. bool CPythonNetworkStream::RecvChangeSkillGroupPacket()
  4104. {
  4105. TPacketGCChangeSkillGroup ChangeSkillGroup;
  4106. if (!Recv(sizeof(ChangeSkillGroup), &ChangeSkillGroup))
  4107. return false;
  4109. m_dwMainActorSkillGroup = ChangeSkillGroup.skill_group;
  4111. CPythonPlayer::Instance().NEW_ClearSkillData();
  4112. __RefreshCharacterWindow();
  4113. return true;
  4114. }
  4116. void CPythonNetworkStream::__TEST_SetSkillGroupFake(int iIndex)
  4117. {
  4118. m_dwMainActorSkillGroup = DWORD(iIndex);
  4120. CPythonPlayer::Instance().NEW_ClearSkillData();
  4121. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
  4122. }
  4124. bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType)
  4125. {
  4126. TPacketCGRefine kRefinePacket;
  4127. kRefinePacket.header = HEADER_CG_REFINE;
  4128. kRefinePacket.pos = byPos;
  4129. kRefinePacket.type = byType;
  4131. if (!Send(sizeof(kRefinePacket), &kRefinePacket))
  4132. return false;
  4134. return SendSequence();
  4135. }
  4137. bool CPythonNetworkStream::SendSelectItemPacket(DWORD dwItemPos)
  4138. {
  4139. TPacketCGScriptSelectItem kScriptSelectItem;
  4140. kScriptSelectItem.header = HEADER_CG_SCRIPT_SELECT_ITEM;
  4141. kScriptSelectItem.selection = dwItemPos;
  4143. if (!Send(sizeof(kScriptSelectItem), &kScriptSelectItem))
  4144. return false;
  4146. return SendSequence();
  4147. }
  4149. bool CPythonNetworkStream::RecvRefineInformationPacket()
  4150. {
  4151. TPacketGCRefineInformation kRefineInfoPacket;
  4152. if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
  4153. return false;
  4155. TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
  4156. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  4157. "OpenRefineDialog",
  4158. Py_BuildValue("(iiii)",
  4159. kRefineInfoPacket.pos,
  4160. kRefineInfoPacket.refine_table.result_vnum,
  4161. rkRefineTable.cost,
  4162. rkRefineTable.prob));
  4164. for (int i = 0; i < rkRefineTable.material_count; ++i)
  4165. {
  4166. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
  4167. }
  4169. #ifdef _DEBUG
  4170. Tracef(" >> RecvRefineInformationPacket(pos=%d, result_vnum=%d, cost=%d, prob=%d)\n",
  4171. kRefineInfoPacket.pos,
  4172. kRefineInfoPacket.refine_table.result_vnum,
  4173. rkRefineTable.cost,
  4174. rkRefineTable.prob);
  4175. #endif
  4177. return true;
  4178. }
  4180. bool CPythonNetworkStream::RecvRefineInformationPacketNew()
  4181. {
  4182. TPacketGCRefineInformationNew kRefineInfoPacket;
  4183. if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
  4184. return false;
  4186. TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
  4187. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  4188. "OpenRefineDialog",
  4189. Py_BuildValue("(iiiii)",
  4190. kRefineInfoPacket.pos,
  4191. kRefineInfoPacket.refine_table.result_vnum,
  4192. rkRefineTable.cost,
  4193. rkRefineTable.prob,
  4194. kRefineInfoPacket.type)
  4195. );
  4197. for (int i = 0; i < rkRefineTable.material_count; ++i)
  4198. {
  4199. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
  4200. }
  4202. #ifdef _DEBUG
  4203. Tracef(" >> RecvRefineInformationPacketNew(pos=%d, result_vnum=%d, cost=%d, prob=%d, type=%d)\n",
  4204. kRefineInfoPacket.pos,
  4205. kRefineInfoPacket.refine_table.result_vnum,
  4206. rkRefineTable.cost,
  4207. rkRefineTable.prob,
  4208. kRefineInfoPacket.type);
  4209. #endif
  4211. return true;
  4212. }
  4214. bool CPythonNetworkStream::RecvNPCList()
  4215. {
  4216. TPacketGCNPCPosition kNPCPosition;
  4217. if (!Recv(sizeof(kNPCPosition), &kNPCPosition))
  4218. return false;
  4220. assert(int(kNPCPosition.size)-sizeof(kNPCPosition) == kNPCPosition.count*sizeof(TNPCPosition) && "HEADER_GC_NPC_POSITION");
  4222. CPythonMiniMap::Instance().ClearAtlasMarkInfo();
  4224. for (int i = 0; i < kNPCPosition.count; ++i)
  4225. {
  4226. TNPCPosition NPCPosition;
  4227. if (!Recv(sizeof(TNPCPosition), &NPCPosition))
  4228. return false;
  4230. CPythonMiniMap::Instance().RegisterAtlasMark(NPCPosition.bType, NPCPosition.name, NPCPosition.x, NPCPosition.y);
  4231. }
  4233. return true;
  4234. }
  4236. bool CPythonNetworkStream::__SendCRCReportPacket()
  4237. {
  4238. /*
  4239. DWORD dwProcessCRC = 0;
  4240. DWORD dwFileCRC = 0;
  4241. CFilename exeFileName;
  4242. //LPCVOID c_pvBaseAddress = NULL;
  4244. GetExeCRC(dwProcessCRC, dwFileCRC);
  4246. CFilename strRootPackFileName = CEterPackManager::Instance().GetRootPacketFileName();
  4247. strRootPackFileName.ChangeDosPath();
  4249. TPacketCGCRCReport kReportPacket;
  4251. kReportPacket.header = HEADER_CG_CRC_REPORT;
  4252. kReportPacket.byPackMode = CEterPackManager::Instance().GetSearchMode();
  4253. kReportPacket.dwBinaryCRC32 = dwFileCRC;
  4254. kReportPacket.dwProcessCRC32 = dwProcessCRC;
  4255. kReportPacket.dwRootPackCRC32 = GetFileCRC32(strRootPackFileName.c_str());
  4257. if (!Send(sizeof(kReportPacket), &kReportPacket))
  4258. Tracef("SendClientReportPacket Error");
  4260. return SendSequence();
  4261. */
  4262. return true;
  4263. }
  4265. bool CPythonNetworkStream::SendClientVersionPacket()
  4266. {
  4267. std::string filename;
  4269. GetExcutedFileName(filename);
  4271. filename = CFileNameHelper::NoPath(filename);
  4272. CFileNameHelper::ChangeDosPath(filename);
  4274. if (LocaleService_IsEUROPE() && false == LocaleService_IsYMIR())
  4275. {
  4276. TPacketCGClientVersion2 kVersionPacket;
  4277. kVersionPacket.header = HEADER_CG_CLIENT_VERSION2;
  4278. strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
  4279. strncpy(kVersionPacket.timestamp, "1215955205", sizeof(kVersionPacket.timestamp)-1); // # python time.time ¾ÕÀÚ¸®
  4280. //strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1); // old_string_ver
  4281. //strncpy(kVersionPacket.timestamp, "1218055205", sizeof(kVersionPacket.timestamp)-1); // new_future
  4282. //strncpy(kVersionPacket.timestamp, "1214055205", sizeof(kVersionPacket.timestamp)-1); // old_past
  4284. if (!Send(sizeof(kVersionPacket), &kVersionPacket))
  4285. Tracef("SendClientReportPacket Error");
  4286. }
  4287. else
  4288. {
  4289. TPacketCGClientVersion kVersionPacket;
  4290. kVersionPacket.header = HEADER_CG_CLIENT_VERSION;
  4291. strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
  4292. strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1);
  4294. if (!Send(sizeof(kVersionPacket), &kVersionPacket))
  4295. Tracef("SendClientReportPacket Error");
  4296. }
  4297. return SendSequence();
  4298. }
  4300. bool CPythonNetworkStream::RecvAffectAddPacket()
  4301. {
  4302. TPacketGCAffectAdd kAffectAdd;
  4303. if (!Recv(sizeof(kAffectAdd), &kAffectAdd))
  4304. return false;
  4306. TPacketAffectElement & rkElement = kAffectAdd.elem;
  4307. if (rkElement.bPointIdxApplyOn == POINT_ENERGY)
  4308. {
  4309. CPythonPlayer::instance().SetStatus (POINT_ENERGY_END_TIME, CPythonApplication::Instance().GetServerTimeStamp() + rkElement.lDuration);
  4310. __RefreshStatus();
  4311. }
  4312. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_AddAffect", Py_BuildValue("(iiii)", rkElement.dwType, rkElement.bPointIdxApplyOn, rkElement.lApplyValue, rkElement.lDuration));
  4314. return true;
  4315. }
  4317. bool CPythonNetworkStream::RecvAffectRemovePacket()
  4318. {
  4319. TPacketGCAffectRemove kAffectRemove;
  4320. if (!Recv(sizeof(kAffectRemove), &kAffectRemove))
  4321. return false;
  4323. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_RemoveAffect", Py_BuildValue("(ii)", kAffectRemove.dwType, kAffectRemove.bApplyOn));
  4325. return true;
  4326. }
  4328. bool CPythonNetworkStream::RecvChannelPacket()
  4329. {
  4330. TPacketGCChannel kChannelPacket;
  4331. if (!Recv(sizeof(kChannelPacket), &kChannelPacket))
  4332. return false;
  4334. //Tracef(" >> CPythonNetworkStream::RecvChannelPacket(channel=%d)\n", kChannelPacket.channel);
  4336. #ifdef ENABLE_MOVE_CHANNEL
  4337. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshChannel", Py_BuildValue("(i)", kChannelPacket.channel));
  4338. #endif
  4340. return true;
  4341. }
  4343. bool CPythonNetworkStream::RecvViewEquipPacket()
  4344. {
  4345. TPacketGCViewEquip kViewEquipPacket;
  4346. if (!Recv(sizeof(kViewEquipPacket), &kViewEquipPacket))
  4347. return false;
  4349. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenEquipmentDialog", Py_BuildValue("(i)", kViewEquipPacket.dwVID));
  4351. for (int i = 0; i < WEAR_MAX_NUM; ++i)
  4352. {
  4353. TEquipmentItemSet & rItemSet = kViewEquipPacket.equips[i];
  4354. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogItem", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, rItemSet.vnum, rItemSet.count));
  4356. for (int j = 0; j < ITEM_SOCKET_SLOT_MAX_NUM; ++j)
  4357. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogSocket", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, j, rItemSet.alSockets[j]));
  4359. for (int k = 0; k < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++k)
  4360. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogAttr", Py_BuildValue("(iiiii)", kViewEquipPacket.dwVID, i, k, rItemSet.aAttr[k].bType, rItemSet.aAttr[k].sValue));
  4361. }
  4363. return true;
  4364. }
  4366. bool CPythonNetworkStream::RecvLandPacket()
  4367. {
  4368. TPacketGCLandList kLandList;
  4369. if (!Recv(sizeof(kLandList), &kLandList))
  4370. return false;
  4371. std::vector<DWORD> kVec_dwGuildID;
  4372. CPythonMiniMap & rkMiniMap = CPythonMiniMap::Instance();
  4373. CPythonBackground & rkBG = CPythonBackground::Instance();
  4374. CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
  4375. rkMiniMap.ClearGuildArea();
  4376. rkBG.ClearGuildArea();
  4377. int iPacketSize = (kLandList.size - sizeof(TPacketGCLandList));
  4378. for (; iPacketSize > 0; iPacketSize-=sizeof(TLandPacketElement))
  4379. {
  4380. TLandPacketElement kElement;
  4381. if (!Recv(sizeof(TLandPacketElement), &kElement))
  4382. return false;
  4383. rkMiniMap.RegisterGuildArea(kElement.dwID,
  4384. kElement.dwGuildID,
  4385. kElement.x,
  4386. kElement.y,
  4387. kElement.width,
  4388. kElement.height);
  4389. if (pMainInstance)
  4390. if (kElement.dwGuildID == pMainInstance->GetGuildID())
  4391. {
  4392. rkBG.RegisterGuildArea(kElement.x,
  4393. kElement.y,
  4394. kElement.x+kElement.width,
  4395. kElement.y+kElement.height);
  4396. }
  4397. if (0 != kElement.dwGuildID)
  4398. kVec_dwGuildID.push_back(kElement.dwGuildID);
  4399. }
  4400. #ifdef fix_header254
  4401. if (kVec_dwGuildID.size()>0)
  4402. __DownloadSymbol(kVec_dwGuildID);
  4403. #endif
  4404. return true;
  4405. }
  4407. bool CPythonNetworkStream::RecvTargetCreatePacket()
  4408. {
  4409. TPacketGCTargetCreate kTargetCreate;
  4410. if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
  4411. return false;
  4413. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4414. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
  4416. //#ifdef _DEBUG
  4417. // char szBuf[256+1];
  4418. // _snprintf(szBuf, sizeof(szBuf), "Ÿ°ÙÀÌ »ı¼º µÇ¾ú½À´Ï´Ù [%d:%s]", kTargetCreate.lID, kTargetCreate.szTargetName);
  4419. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4420. // Tracef(" >> RecvTargetCreatePacket %d : %s\n", kTargetCreate.lID, kTargetCreate.szTargetName);
  4421. //#endif
  4423. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
  4424. return true;
  4425. }
  4427. bool CPythonNetworkStream::RecvTargetCreatePacketNew()
  4428. {
  4429. TPacketGCTargetCreateNew kTargetCreate;
  4430. if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
  4431. return false;
  4433. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4434. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4435. if (CREATE_TARGET_TYPE_LOCATION == kTargetCreate.byType)
  4436. {
  4437. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
  4438. }
  4439. else
  4440. {
  4441. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
  4442. rkpyBG.CreateTargetEffect(kTargetCreate.lID, kTargetCreate.dwVID);
  4443. }
  4445. //#ifdef _DEBUG
  4446. // char szBuf[256+1];
  4447. // _snprintf(szBuf, sizeof(szBuf), "ij¸¯ÅÍ Å¸°ÙÀÌ »ı¼º µÇ¾ú½À´Ï´Ù [%d:%s:%d]", kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
  4448. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4449. // Tracef(" >> RecvTargetCreatePacketNew %d : %d/%d\n", kTargetCreate.lID, kTargetCreate.byType, kTargetCreate.dwVID);
  4450. //#endif
  4452. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
  4453. return true;
  4454. }
  4456. bool CPythonNetworkStream::RecvTargetUpdatePacket()
  4457. {
  4458. TPacketGCTargetUpdate kTargetUpdate;
  4459. if (!Recv(sizeof(kTargetUpdate), &kTargetUpdate))
  4460. return false;
  4462. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4463. rkpyMiniMap.UpdateTarget(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4465. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4466. rkpyBG.CreateTargetEffect(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4468. //#ifdef _DEBUG
  4469. // char szBuf[256+1];
  4470. // _snprintf(szBuf, sizeof(szBuf), "Ÿ°ÙÀÇ À§Ä¡°¡ °»½Å µÇ¾ú½À´Ï´Ù [%d:%d/%d]", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4471. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4472. // Tracef(" >> RecvTargetUpdatePacket %d : %d, %d\n", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4473. //#endif
  4475. return true;
  4476. }
  4478. bool CPythonNetworkStream::RecvTargetDeletePacket()
  4479. {
  4480. TPacketGCTargetDelete kTargetDelete;
  4481. if (!Recv(sizeof(kTargetDelete), &kTargetDelete))
  4482. return false;
  4484. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4485. rkpyMiniMap.DeleteTarget(kTargetDelete.lID);
  4487. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4488. rkpyBG.DeleteTargetEffect(kTargetDelete.lID);
  4490. //#ifdef _DEBUG
  4491. // Tracef(" >> RecvTargetDeletePacket %d\n", kTargetDelete.lID);
  4492. //#endif
  4494. return true;
  4495. }
  4497. bool CPythonNetworkStream::RecvLoverInfoPacket()
  4498. {
  4499. TPacketGCLoverInfo kLoverInfo;
  4500. if (!Recv(sizeof(kLoverInfo), &kLoverInfo))
  4501. return false;
  4503. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_LoverInfo", Py_BuildValue("(si)", kLoverInfo.szName, kLoverInfo.byLovePoint));
  4504. #ifdef _DEBUG
  4505. Tracef("RECV LOVER INFO : %s, %d\n", kLoverInfo.szName, kLoverInfo.byLovePoint);
  4506. #endif
  4507. return true;
  4508. }
  4510. bool CPythonNetworkStream::RecvLovePointUpdatePacket()
  4511. {
  4512. TPacketGCLovePointUpdate kLovePointUpdate;
  4513. if (!Recv(sizeof(kLovePointUpdate), &kLovePointUpdate))
  4514. return false;
  4516. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_UpdateLovePoint", Py_BuildValue("(i)", kLovePointUpdate.byLovePoint));
  4517. #ifdef _DEBUG
  4518. Tracef("RECV LOVE POINT UPDATE : %d\n", kLovePointUpdate.byLovePoint);
  4519. #endif
  4520. return true;
  4521. }
  4523. bool CPythonNetworkStream::RecvDigMotionPacket()
  4524. {
  4525. TPacketGCDigMotion kDigMotion;
  4526. if (!Recv(sizeof(kDigMotion), &kDigMotion))
  4527. return false;
  4529. #ifdef _DEBUG
  4530. Tracef(" Dig Motion [%d/%d]\n", kDigMotion.vid, kDigMotion.count);
  4531. #endif
  4533. IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
  4534. CInstanceBase * pkInstMain = rkChrMgr.GetInstancePtr(kDigMotion.vid);
  4535. CInstanceBase * pkInstTarget = rkChrMgr.GetInstancePtr(kDigMotion.target_vid);
  4536. if (NULL == pkInstMain)
  4537. return true;
  4539. if (pkInstTarget)
  4540. pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
  4542. for (int i = 0; i < kDigMotion.count; ++i)
  4543. pkInstMain->PushOnceMotion(CRaceMotionData::NAME_DIG);
  4545. return true;
  4546. }
  4549. // ¿ëÈ¥¼® °­È­
  4550. bool CPythonNetworkStream::SendDragonSoulRefinePacket(BYTE bRefineType, TItemPos* pos)
  4551. {
  4552. TPacketCGDragonSoulRefine pk;
  4553. pk.header = HEADER_CG_DRAGON_SOUL_REFINE;
  4554. pk.bSubType = bRefineType;
  4555. memcpy (pk.ItemGrid, pos, sizeof (TItemPos) * DS_REFINE_WINDOW_MAX_NUM);
  4556. if (!Send(sizeof (pk), &pk))
  4557. {
  4558. return false;
  4559. }
  4560. return true;
  4561. }