API tools faq
paste
Kyuukyoku

Untitled

Kyuukyoku
Apr 19th, 2020
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 120.64 KB | None | 0 0
raw download clone embed print report
  1. #include "StdAfx.h"
  2. #include "PythonNetworkStream.h"
  3. #include "Packet.h"
  4.  
  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"
  19.  
  20. #include "../EterPack/EterPackManager.h"
  21. #include "../gamelib/ItemManager.h"
  22.  
  23. #include "AbstractApplication.h"
  24. #include "AbstractCharacterManager.h"
  25. #include "InstanceBase.h"
  26.  
  27. #include "ProcessCRC.h"
  28.  
  29. BOOL gs_bEmpireLanuageEnable = TRUE;
  30.  
  31. void CPythonNetworkStream::__RefreshAlignmentWindow()
  32. {
  33. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshAlignment", Py_BuildValue("()"));
  34. }
  35.  
  36. void CPythonNetworkStream::__RefreshTargetBoardByVID(DWORD dwVID)
  37. {
  38. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByVID", Py_BuildValue("(i)", dwVID));
  39. }
  40.  
  41. void CPythonNetworkStream::__RefreshTargetBoardByName(const char * c_szName)
  42. {
  43. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByName", Py_BuildValue("(s)", c_szName));
  44. }
  45.  
  46. void CPythonNetworkStream::__RefreshTargetBoard()
  47. {
  48. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoard", Py_BuildValue("()"));
  49. }
  50.  
  51. void CPythonNetworkStream::__RefreshGuildWindowGradePage()
  52. {
  53. m_isRefreshGuildWndGradePage=true;
  54. }
  55.  
  56. void CPythonNetworkStream::__RefreshGuildWindowSkillPage()
  57. {
  58. m_isRefreshGuildWndSkillPage=true;
  59. }
  60.  
  61. void CPythonNetworkStream::__RefreshGuildWindowMemberPageGradeComboBox()
  62. {
  63. m_isRefreshGuildWndMemberPageGradeComboBox=true;
  64. }
  65.  
  66. void CPythonNetworkStream::__RefreshGuildWindowMemberPage()
  67. {
  68. m_isRefreshGuildWndMemberPage=true;
  69. }
  70.  
  71. void CPythonNetworkStream::__RefreshGuildWindowBoardPage()
  72. {
  73. m_isRefreshGuildWndBoardPage=true;
  74. }
  75.  
  76. void CPythonNetworkStream::__RefreshGuildWindowInfoPage()
  77. {
  78. m_isRefreshGuildWndInfoPage=true;
  79. }
  80.  
  81. void CPythonNetworkStream::__RefreshMessengerWindow()
  82. {
  83. m_isRefreshMessengerWnd=true;
  84. }
  85.  
  86. void CPythonNetworkStream::__RefreshSafeboxWindow()
  87. {
  88. m_isRefreshSafeboxWnd=true;
  89. }
  90.  
  91. void CPythonNetworkStream::__RefreshMallWindow()
  92. {
  93. m_isRefreshMallWnd=true;
  94. }
  95.  
  96. void CPythonNetworkStream::__RefreshSkillWindow()
  97. {
  98. m_isRefreshSkillWnd=true;
  99. }
  100.  
  101. void CPythonNetworkStream::__RefreshExchangeWindow()
  102. {
  103. m_isRefreshExchangeWnd=true;
  104. }
  105.  
  106. void CPythonNetworkStream::__RefreshStatus()
  107. {
  108. m_isRefreshStatus=true;
  109. }
  110.  
  111. void CPythonNetworkStream::__RefreshCharacterWindow()
  112. {
  113. m_isRefreshCharacterWnd=true;
  114. }
  115.  
  116. void CPythonNetworkStream::__RefreshInventoryWindow()
  117. {
  118. m_isRefreshInventoryWnd=true;
  119. }
  120.  
  121. void CPythonNetworkStream::__RefreshEquipmentWindow()
  122. {
  123. m_isRefreshEquipmentWnd=true;
  124. }
  125.  
  126. void CPythonNetworkStream::__SetGuildID(DWORD id)
  127. {
  128. if (m_dwGuildID != id)
  129. {
  130. m_dwGuildID = id;
  131. IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
  132.  
  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;
  137.  
  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. }
  150.  
  151. struct PERF_PacketInfo
  152. {
  153. DWORD dwCount;
  154. DWORD dwTime;
  155.  
  156. PERF_PacketInfo()
  157. {
  158. dwCount=0;
  159. dwTime=0;
  160. }
  161. };
  162.  
  163.  
  164. #ifdef __PERFORMANCE_CHECK__
  165.  
  166. class PERF_PacketTimeAnalyzer
  167. {
  168. public:
  169. ~PERF_PacketTimeAnalyzer()
  170. {
  171. FILE* fp=fopen("perf_dispatch_packet_result.txt", "w");
  172.  
  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. }
  180.  
  181. public:
  182. std::map<DWORD, PERF_PacketInfo> m_kMap_kPacketInfo;
  183. };
  184.  
  185. PERF_PacketTimeAnalyzer gs_kPacketTimeAnalyzer;
  186.  
  187. #endif
  188.  
  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. }
  197.  
  198. TPacketHeader header = 0;
  199. bool ret = true;
  200.  
  201. #ifdef __PERFORMANCE_CHECK__
  202. DWORD timeBeginDispatch=timeGetTime();
  203.  
  204. static std::map<DWORD, PERF_PacketInfo> kMap_kPacketInfo;
  205. kMap_kPacketInfo.clear();
  206. #endif
  207.  
  208. const DWORD MAX_RECV_COUNT = 4;
  209. const DWORD SAFE_RECV_BUFSIZE = 8192;
  210. DWORD dwRecvCount = 0;
  211.  
  212. while (ret)
  213. {
  214. if(dwRecvCount++ >= MAX_RECV_COUNT-1 && GetRecvBufferSize() < SAFE_RECV_BUFSIZE
  215. && m_strPhase == "Game") //phase_game 이 아니어도 여기로 들어오는 경우가 있다.
  216. break;
  217.  
  218. if (!CheckPacket(&header))
  219. break;
  220.  
  221. #ifdef __PERFORMANCE_CHECK__
  222. DWORD timeBeginPacket=timeGetTime();
  223. #endif
  224.  
  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;
  239.  
  240. case HEADER_GC_PHASE:
  241. ret = RecvPhasePacket();
  242. return; // 도중에 Phase 가 바뀌면 일단 무조건 GamePhase 탈출 - [levites]
  243. break;
  244.  
  245. case HEADER_GC_PVP:
  246. ret = RecvPVPPacket();
  247. break;
  248.  
  249. case HEADER_GC_DUEL_START:
  250. ret = RecvDuelStartPacket();
  251. break;
  252.  
  253. case HEADER_GC_CHARACTER_ADD:
  254. ret = RecvCharacterAppendPacket();
  255. break;
  256.  
  257. case HEADER_GC_CHAR_ADDITIONAL_INFO:
  258. ret = RecvCharacterAdditionalInfo();
  259. break;
  260.  
  261. case HEADER_GC_CHARACTER_ADD2:
  262. ret = RecvCharacterAppendPacketNew();
  263. break;
  264.  
  265. case HEADER_GC_CHARACTER_UPDATE:
  266. ret = RecvCharacterUpdatePacket();
  267. break;
  268.  
  269. case HEADER_GC_CHARACTER_UPDATE2:
  270. ret = RecvCharacterUpdatePacketNew();
  271. break;
  272.  
  273. case HEADER_GC_CHARACTER_DEL:
  274. ret = RecvCharacterDeletePacket();
  275. break;
  276.  
  277. case HEADER_GC_CHAT:
  278. ret = RecvChatPacket();
  279. break;
  280.  
  281. case HEADER_GC_SYNC_POSITION:
  282. ret = RecvSyncPositionPacket();
  283. break;
  284.  
  285. case HEADER_GC_OWNERSHIP:
  286. ret = RecvOwnerShipPacket();
  287. break;
  288.  
  289. case HEADER_GC_WHISPER:
  290. ret = RecvWhisperPacket();
  291. break;
  292.  
  293. case HEADER_GC_CHARACTER_MOVE:
  294. ret = RecvCharacterMovePacket();
  295. break;
  296.  
  297. // Position
  298. case HEADER_GC_CHARACTER_POSITION:
  299. ret = RecvCharacterPositionPacket();
  300. break;
  301.  
  302. // Battle Packet
  303. case HEADER_GC_STUN:
  304. ret = RecvStunPacket();
  305. break;
  306.  
  307. case HEADER_GC_DEAD:
  308. ret = RecvDeadPacket();
  309. break;
  310.  
  311. case HEADER_GC_PLAYER_POINT_CHANGE:
  312. ret = RecvPointChange();
  313. break;
  314.  
  315. // item packet.
  316. case HEADER_GC_ITEM_SET:
  317. ret = RecvItemSetPacket();
  318. break;
  319.  
  320. case HEADER_GC_ITEM_SET2:
  321. ret = RecvItemSetPacket2();
  322. break;
  323.  
  324. case HEADER_GC_ITEM_USE:
  325. ret = RecvItemUsePacket();
  326. break;
  327.  
  328. case HEADER_GC_ITEM_UPDATE:
  329. ret = RecvItemUpdatePacket();
  330. break;
  331.  
  332. case HEADER_GC_ITEM_GROUND_ADD:
  333. ret = RecvItemGroundAddPacket();
  334. break;
  335.  
  336. case HEADER_GC_ITEM_GROUND_DEL:
  337. ret = RecvItemGroundDelPacket();
  338. break;
  339.  
  340. case HEADER_GC_ITEM_OWNERSHIP:
  341. ret = RecvItemOwnership();
  342. break;
  343.  
  344. case HEADER_GC_QUICKSLOT_ADD:
  345. ret = RecvQuickSlotAddPacket();
  346. break;
  347.  
  348. case HEADER_GC_QUICKSLOT_DEL:
  349. ret = RecvQuickSlotDelPacket();
  350. break;
  351.  
  352. case HEADER_GC_QUICKSLOT_SWAP:
  353. ret = RecvQuickSlotMovePacket();
  354. break;
  355.  
  356. case HEADER_GC_MOTION:
  357. ret = RecvMotionPacket();
  358. break;
  359.  
  360. case HEADER_GC_SHOP:
  361. ret = RecvShopPacket();
  362. break;
  363.  
  364. case HEADER_GC_SHOP_SIGN:
  365. ret = RecvShopSignPacket();
  366. break;
  367.  
  368. case HEADER_GC_EXCHANGE:
  369. ret = RecvExchangePacket();
  370. break;
  371.  
  372. case HEADER_GC_QUEST_INFO:
  373. ret = RecvQuestInfoPacket();
  374. break;
  375.  
  376. case HEADER_GC_REQUEST_MAKE_GUILD:
  377. ret = RecvRequestMakeGuild();
  378. break;
  379.  
  380. case HEADER_GC_PING:
  381. ret = RecvPingPacket();
  382. break;
  383.  
  384. case HEADER_GC_SCRIPT:
  385. ret = RecvScriptPacket();
  386. break;
  387.  
  388. case HEADER_GC_QUEST_CONFIRM:
  389. ret = RecvQuestConfirmPacket();
  390. break;
  391.  
  392. case HEADER_GC_TARGET:
  393. ret = RecvTargetPacket();
  394. break;
  395.  
  396. case HEADER_GC_DAMAGE_INFO:
  397. ret = RecvDamageInfoPacket();
  398. break;
  399.  
  400. case HEADER_GC_MOUNT:
  401. ret = RecvMountPacket();
  402. break;
  403.  
  404. case HEADER_GC_CHANGE_SPEED:
  405. ret = RecvChangeSpeedPacket();
  406. break;
  407.  
  408. case HEADER_GC_PLAYER_POINTS:
  409. ret = __RecvPlayerPoints();
  410. break;
  411.  
  412. case HEADER_GC_CREATE_FLY:
  413. ret = RecvCreateFlyPacket();
  414. break;
  415.  
  416. case HEADER_GC_FLY_TARGETING:
  417. ret = RecvFlyTargetingPacket();
  418. break;
  419.  
  420. case HEADER_GC_ADD_FLY_TARGETING:
  421. ret = RecvAddFlyTargetingPacket();
  422. break;
  423.  
  424. case HEADER_GC_SKILL_LEVEL:
  425. ret = RecvSkillLevel();
  426. break;
  427.  
  428. case HEADER_GC_SKILL_LEVEL_NEW:
  429. ret = RecvSkillLevelNew();
  430. break;
  431.  
  432. case HEADER_GC_MESSENGER:
  433. ret = RecvMessenger();
  434. break;
  435.  
  436. case HEADER_GC_GUILD:
  437. ret = RecvGuild();
  438. break;
  439.  
  440. case HEADER_GC_PARTY_INVITE:
  441. ret = RecvPartyInvite();
  442. break;
  443.  
  444. case HEADER_GC_PARTY_ADD:
  445. ret = RecvPartyAdd();
  446. break;
  447.  
  448. case HEADER_GC_PARTY_UPDATE:
  449. ret = RecvPartyUpdate();
  450. break;
  451.  
  452. case HEADER_GC_PARTY_REMOVE:
  453. ret = RecvPartyRemove();
  454. break;
  455.  
  456. case HEADER_GC_PARTY_LINK:
  457. ret = RecvPartyLink();
  458. break;
  459.  
  460. case HEADER_GC_PARTY_UNLINK:
  461. ret = RecvPartyUnlink();
  462. break;
  463.  
  464. case HEADER_GC_PARTY_PARAMETER:
  465. ret = RecvPartyParameter();
  466. break;
  467.  
  468. case HEADER_GC_SAFEBOX_SET:
  469. ret = RecvSafeBoxSetPacket();
  470. break;
  471.  
  472. case HEADER_GC_SAFEBOX_DEL:
  473. ret = RecvSafeBoxDelPacket();
  474. break;
  475.  
  476. case HEADER_GC_SAFEBOX_WRONG_PASSWORD:
  477. ret = RecvSafeBoxWrongPasswordPacket();
  478. break;
  479.  
  480. case HEADER_GC_SAFEBOX_SIZE:
  481. ret = RecvSafeBoxSizePacket();
  482. break;
  483.  
  484. case HEADER_GC_SAFEBOX_MONEY_CHANGE:
  485. ret = RecvSafeBoxMoneyChangePacket();
  486. break;
  487.  
  488. case HEADER_GC_FISHING:
  489. ret = RecvFishing();
  490. break;
  491.  
  492. case HEADER_GC_DUNGEON:
  493. ret = RecvDungeon();
  494. break;
  495.  
  496. case HEADER_GC_TIME:
  497. ret = RecvTimePacket();
  498. break;
  499.  
  500. case HEADER_GC_WALK_MODE:
  501. ret = RecvWalkModePacket();
  502. break;
  503.  
  504. case HEADER_GC_CHANGE_SKILL_GROUP:
  505. ret = RecvChangeSkillGroupPacket();
  506. break;
  507.  
  508. case HEADER_GC_REFINE_INFORMATION:
  509. ret = RecvRefineInformationPacket();
  510. break;
  511.  
  512. case HEADER_GC_REFINE_INFORMATION_NEW:
  513. ret = RecvRefineInformationPacketNew();
  514. break;
  515.  
  516. case HEADER_GC_SEPCIAL_EFFECT:
  517. ret = RecvSpecialEffect();
  518. break;
  519.  
  520. case HEADER_GC_NPC_POSITION:
  521. ret = RecvNPCList();
  522. break;
  523.  
  524. case HEADER_GC_CHANNEL:
  525. ret = RecvChannelPacket();
  526. break;
  527.  
  528. case HEADER_GC_VIEW_EQUIP:
  529. ret = RecvViewEquipPacket();
  530. break;
  531.  
  532. case HEADER_GC_LAND_LIST:
  533. ret = RecvLandPacket();
  534. break;
  535.  
  536. //case HEADER_GC_TARGET_CREATE:
  537. // ret = RecvTargetCreatePacket();
  538. // break;
  539.  
  540. case HEADER_GC_TARGET_CREATE_NEW:
  541. ret = RecvTargetCreatePacketNew();
  542. break;
  543.  
  544. case HEADER_GC_TARGET_UPDATE:
  545. ret = RecvTargetUpdatePacket();
  546. break;
  547.  
  548. case HEADER_GC_TARGET_DELETE:
  549. ret = RecvTargetDeletePacket();
  550. break;
  551.  
  552. case HEADER_GC_AFFECT_ADD:
  553. ret = RecvAffectAddPacket();
  554. break;
  555.  
  556. case HEADER_GC_AFFECT_REMOVE:
  557. ret = RecvAffectRemovePacket();
  558. break;
  559.  
  560. case HEADER_GC_MALL_OPEN:
  561. ret = RecvMallOpenPacket();
  562. break;
  563.  
  564. case HEADER_GC_MALL_SET:
  565. ret = RecvMallItemSetPacket();
  566. break;
  567.  
  568. case HEADER_GC_MALL_DEL:
  569. ret = RecvMallItemDelPacket();
  570. break;
  571.  
  572. case HEADER_GC_LOVER_INFO:
  573. ret = RecvLoverInfoPacket();
  574. break;
  575.  
  576. case HEADER_GC_LOVE_POINT_UPDATE:
  577. ret = RecvLovePointUpdatePacket();
  578. break;
  579.  
  580. case HEADER_GC_DIG_MOTION:
  581. ret = RecvDigMotionPacket();
  582. break;
  583.  
  584. case HEADER_GC_HANDSHAKE:
  585. RecvHandshakePacket();
  586. return;
  587. break;
  588.  
  589. case HEADER_GC_HANDSHAKE_OK:
  590. RecvHandshakeOKPacket();
  591. return;
  592. break;
  593.  
  594. case HEADER_GC_HYBRIDCRYPT_KEYS:
  595. RecvHybridCryptKeyPacket();
  596. return;
  597. break;
  598.  
  599. case HEADER_GC_HYBRIDCRYPT_SDB:
  600. RecvHybridCryptSDBPacket();
  601. return;
  602. break;
  603.  
  604.  
  605. #ifdef _IMPROVED_PACKET_ENCRYPTION_
  606. case HEADER_GC_KEY_AGREEMENT:
  607. RecvKeyAgreementPacket();
  608. return;
  609. break;
  610.  
  611. case HEADER_GC_KEY_AGREEMENT_COMPLETED:
  612. RecvKeyAgreementCompletedPacket();
  613. return;
  614. break;
  615. #endif
  616.  
  617. case HEADER_GC_HS_REQUEST:
  618. ret = RecvHSCheckRequest();
  619. break;
  620.  
  621. case HEADER_GC_XTRAP_CS1_REQUEST:
  622. ret = RecvXTrapVerifyRequest();
  623. break;
  624.  
  625. case HEADER_GC_SPECIFIC_EFFECT:
  626. ret = RecvSpecificEffect();
  627. break;
  628.  
  629. case HEADER_GC_DRAGON_SOUL_REFINE:
  630. ret = RecvDragonSoulRefine();
  631. break;
  632.  
  633. default:
  634. ret = RecvDefaultPacket(header);
  635. break;
  636. }
  637. #ifdef __PERFORMANCE_CHECK__
  638. DWORD timeEndPacket=timeGetTime();
  639.  
  640. {
  641. PERF_PacketInfo& rkPacketInfo=kMap_kPacketInfo[header];
  642. rkPacketInfo.dwCount++;
  643. rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
  644. }
  645.  
  646. {
  647. PERF_PacketInfo& rkPacketInfo=gs_kPacketTimeAnalyzer.m_kMap_kPacketInfo[header];
  648. rkPacketInfo.dwCount++;
  649. rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
  650. }
  651. #endif
  652. }
  653.  
  654. #ifdef __PERFORMANCE_CHECK__
  655. DWORD timeEndDispatch=timeGetTime();
  656.  
  657. if (timeEndDispatch-timeBeginDispatch>2)
  658. {
  659. static FILE* fp=fopen("perf_dispatch_packet.txt", "w");
  660.  
  661. fprintf(fp, "delay %d\n", timeEndDispatch-timeBeginDispatch);
  662. for (std::map<DWORD, PERF_PacketInfo>::iterator i=kMap_kPacketInfo.begin(); i!=kMap_kPacketInfo.end(); ++i)
  663. {
  664. if (i->second.dwTime>0)
  665. fprintf(fp, "header %d: count %d, time %d\n", i->first, i->second.dwCount, i->second.dwTime);
  666. }
  667. fputs("=====================================================\n", fp);
  668. fflush(fp);
  669. }
  670. #endif
  671.  
  672. if (!ret)
  673. RecvErrorPacket(header);
  674.  
  675. static DWORD s_nextRefreshTime = ELTimer_GetMSec();
  676.  
  677. DWORD curTime = ELTimer_GetMSec();
  678. if (s_nextRefreshTime > curTime)
  679. return;
  680.  
  681.  
  682.  
  683. if (m_isRefreshCharacterWnd)
  684. {
  685. m_isRefreshCharacterWnd=false;
  686. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
  687. s_nextRefreshTime = curTime + 300;
  688. }
  689.  
  690. if (m_isRefreshEquipmentWnd)
  691. {
  692. m_isRefreshEquipmentWnd=false;
  693. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEquipment", Py_BuildValue("()"));
  694. s_nextRefreshTime = curTime + 300;
  695. }
  696.  
  697. if (m_isRefreshInventoryWnd)
  698. {
  699. m_isRefreshInventoryWnd=false;
  700. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshInventory", Py_BuildValue("()"));
  701. s_nextRefreshTime = curTime + 300;
  702. }
  703.  
  704. if (m_isRefreshExchangeWnd)
  705. {
  706. m_isRefreshExchangeWnd=false;
  707. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshExchange", Py_BuildValue("()"));
  708. s_nextRefreshTime = curTime + 300;
  709. }
  710.  
  711. if (m_isRefreshSkillWnd)
  712. {
  713. m_isRefreshSkillWnd=false;
  714. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSkill", Py_BuildValue("()"));
  715. s_nextRefreshTime = curTime + 300;
  716. }
  717.  
  718. if (m_isRefreshSafeboxWnd)
  719. {
  720. m_isRefreshSafeboxWnd=false;
  721. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafebox", Py_BuildValue("()"));
  722. s_nextRefreshTime = curTime + 300;
  723. }
  724.  
  725. if (m_isRefreshMallWnd)
  726. {
  727. m_isRefreshMallWnd=false;
  728. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMall", Py_BuildValue("()"));
  729. s_nextRefreshTime = curTime + 300;
  730. }
  731.  
  732. if (m_isRefreshStatus)
  733. {
  734. m_isRefreshStatus=false;
  735. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()"));
  736. s_nextRefreshTime = curTime + 300;
  737. }
  738.  
  739. if (m_isRefreshMessengerWnd)
  740. {
  741. m_isRefreshMessengerWnd=false;
  742. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMessenger", Py_BuildValue("()"));
  743. s_nextRefreshTime = curTime + 300;
  744. }
  745.  
  746. if (m_isRefreshGuildWndInfoPage)
  747. {
  748. m_isRefreshGuildWndInfoPage=false;
  749. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildInfoPage", Py_BuildValue("()"));
  750. s_nextRefreshTime = curTime + 300;
  751. }
  752.  
  753. if (m_isRefreshGuildWndBoardPage)
  754. {
  755. m_isRefreshGuildWndBoardPage=false;
  756. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildBoardPage", Py_BuildValue("()"));
  757. s_nextRefreshTime = curTime + 300;
  758. }
  759.  
  760. if (m_isRefreshGuildWndMemberPage)
  761. {
  762. m_isRefreshGuildWndMemberPage=false;
  763. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPage", Py_BuildValue("()"));
  764. s_nextRefreshTime = curTime + 300;
  765. }
  766.  
  767. if (m_isRefreshGuildWndMemberPageGradeComboBox)
  768. {
  769. m_isRefreshGuildWndMemberPageGradeComboBox=false;
  770. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPageGradeComboBox", Py_BuildValue("()"));
  771. s_nextRefreshTime = curTime + 300;
  772. }
  773.  
  774. if (m_isRefreshGuildWndSkillPage)
  775. {
  776. m_isRefreshGuildWndSkillPage=false;
  777. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildSkillPage", Py_BuildValue("()"));
  778. s_nextRefreshTime = curTime + 300;
  779. }
  780.  
  781. if (m_isRefreshGuildWndGradePage)
  782. {
  783. m_isRefreshGuildWndGradePage=false;
  784. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGradePage", Py_BuildValue("()"));
  785. s_nextRefreshTime = curTime + 300;
  786. }
  787. }
  788.  
  789. void CPythonNetworkStream::__InitializeGamePhase()
  790. {
  791. __ServerTimeSync_Initialize();
  792.  
  793. m_isRefreshStatus=false;
  794. m_isRefreshCharacterWnd=false;
  795. m_isRefreshEquipmentWnd=false;
  796. m_isRefreshInventoryWnd=false;
  797. m_isRefreshExchangeWnd=false;
  798. m_isRefreshSkillWnd=false;
  799. m_isRefreshSafeboxWnd=false;
  800. m_isRefreshMallWnd=false;
  801. m_isRefreshMessengerWnd=false;
  802. m_isRefreshGuildWndInfoPage=false;
  803. m_isRefreshGuildWndBoardPage=false;
  804. m_isRefreshGuildWndMemberPage=false;
  805. m_isRefreshGuildWndMemberPageGradeComboBox=false;
  806. m_isRefreshGuildWndSkillPage=false;
  807. m_isRefreshGuildWndGradePage=false;
  808.  
  809. m_EmoticonStringVector.clear();
  810.  
  811. m_pInstTarget = NULL;
  812. }
  813.  
  814. void CPythonNetworkStream::Warp(LONG lGlobalX, LONG lGlobalY)
  815. {
  816. CPythonBackground& rkBgMgr=CPythonBackground::Instance();
  817. rkBgMgr.Destroy();
  818. rkBgMgr.Create();
  819. rkBgMgr.Warp(lGlobalX, lGlobalY);
  820. //rkBgMgr.SetShadowLevel(CPythonBackground::SHADOW_ALL);
  821. rkBgMgr.RefreshShadowLevel();
  822.  
  823. // NOTE : Warp 했을때 CenterPosition의 Height가 0이기 때문에 카메라가 땅바닥에 박혀있게 됨
  824. // 움직일때마다 Height가 갱신 되기 때문이므로 맵을 이동하면 Position을 강제로 한번
  825. // 셋팅해준다 - [levites]
  826. LONG lLocalX = lGlobalX;
  827. LONG lLocalY = lGlobalY;
  828. __GlobalPositionToLocalPosition(lLocalX, lLocalY);
  829. float fHeight = CPythonBackground::Instance().GetHeight(float(lLocalX), float(lLocalY));
  830.  
  831. IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
  832. rkApp.SetCenterPosition(float(lLocalX), float(lLocalY), fHeight);
  833.  
  834. __ShowMapName(lLocalX, lLocalY);
  835. }
  836.  
  837. void CPythonNetworkStream::__ShowMapName(LONG lLocalX, LONG lLocalY)
  838. {
  839. const std::string & c_rstrMapFileName = CPythonBackground::Instance().GetWarpMapName();
  840. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ShowMapName", Py_BuildValue("(sii)", c_rstrMapFileName.c_str(), lLocalX, lLocalY));
  841. }
  842.  
  843. void CPythonNetworkStream::__LeaveGamePhase()
  844. {
  845. CInstanceBase::ClearPVPKeySystem();
  846.  
  847. __ClearNetworkActorManager();
  848.  
  849. m_bComboSkillFlag = FALSE;
  850.  
  851. IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
  852. rkChrMgr.Destroy();
  853.  
  854. CPythonItem& rkItemMgr=CPythonItem::Instance();
  855. rkItemMgr.Destroy();
  856. }
  857.  
  858. void CPythonNetworkStream::SetGamePhase()
  859. {
  860. if ("Game"!=m_strPhase)
  861. m_phaseLeaveFunc.Run();
  862.  
  863. Tracen("");
  864. Tracen("## Network - Game Phase ##");
  865. Tracen("");
  866.  
  867. m_strPhase = "Game";
  868.  
  869. m_dwChangingPhaseTime = ELTimer_GetMSec();
  870. m_phaseProcessFunc.Set(this, &CPythonNetworkStream::GamePhase);
  871. m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveGamePhase);
  872.  
  873. // Main Character 등록O
  874.  
  875. IAbstractPlayer & rkPlayer = IAbstractPlayer::GetSingleton();
  876. rkPlayer.SetMainCharacterIndex(GetMainActorVID());
  877.  
  878. __RefreshStatus();
  879. }
  880.  
  881. bool CPythonNetworkStream::RecvObserverAddPacket()
  882. {
  883. TPacketGCObserverAdd kObserverAddPacket;
  884. if (!Recv(sizeof(kObserverAddPacket), &kObserverAddPacket))
  885. return false;
  886.  
  887. CPythonMiniMap::Instance().AddObserver(
  888. kObserverAddPacket.vid,
  889. kObserverAddPacket.x*100.0f,
  890. kObserverAddPacket.y*100.0f);
  891.  
  892. return true;
  893. }
  894.  
  895. bool CPythonNetworkStream::RecvObserverRemovePacket()
  896. {
  897. TPacketGCObserverAdd kObserverRemovePacket;
  898. if (!Recv(sizeof(kObserverRemovePacket), &kObserverRemovePacket))
  899. return false;
  900.  
  901. CPythonMiniMap::Instance().RemoveObserver(
  902. kObserverRemovePacket.vid
  903. );
  904.  
  905. return true;
  906. }
  907.  
  908. bool CPythonNetworkStream::RecvObserverMovePacket()
  909. {
  910. TPacketGCObserverMove kObserverMovePacket;
  911. if (!Recv(sizeof(kObserverMovePacket), &kObserverMovePacket))
  912. return false;
  913.  
  914. CPythonMiniMap::Instance().MoveObserver(
  915. kObserverMovePacket.vid,
  916. kObserverMovePacket.x*100.0f,
  917. kObserverMovePacket.y*100.0f);
  918.  
  919. return true;
  920. }
  921.  
  922.  
  923. bool CPythonNetworkStream::RecvWarpPacket()
  924. {
  925. TPacketGCWarp kWarpPacket;
  926.  
  927. if (!Recv(sizeof(kWarpPacket), &kWarpPacket))
  928. return false;
  929.  
  930. __DirectEnterMode_Set(m_dwSelectedCharacterIndex);
  931.  
  932. CNetworkStream::Connect((DWORD)kWarpPacket.lAddr, kWarpPacket.wPort);
  933.  
  934. return true;
  935. }
  936.  
  937. bool CPythonNetworkStream::RecvDuelStartPacket()
  938. {
  939. TPacketGCDuelStart kDuelStartPacket;
  940. if (!Recv(sizeof(kDuelStartPacket), &kDuelStartPacket))
  941. return false;
  942.  
  943. DWORD count = (kDuelStartPacket.wSize - sizeof(kDuelStartPacket))/sizeof(DWORD);
  944.  
  945. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  946.  
  947. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  948. if (!pkInstMain)
  949. {
  950. TraceError("CPythonNetworkStream::RecvDuelStartPacket - MainCharacter is NULL");
  951. return false;
  952. }
  953. DWORD dwVIDSrc = pkInstMain->GetVirtualID();
  954. DWORD dwVIDDest;
  955.  
  956. for ( DWORD i = 0; i < count; i++)
  957. {
  958. Recv(sizeof(dwVIDDest),&dwVIDDest);
  959. CInstanceBase::InsertDUELKey(dwVIDSrc,dwVIDDest);
  960. }
  961.  
  962. if(count == 0)
  963. pkInstMain->SetDuelMode(CInstanceBase::DUEL_CANNOTATTACK);
  964. else
  965. pkInstMain->SetDuelMode(CInstanceBase::DUEL_START);
  966.  
  967. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  968.  
  969. rkChrMgr.RefreshAllPCTextTail();
  970.  
  971. return true;
  972. }
  973.  
  974. bool CPythonNetworkStream::RecvPVPPacket()
  975. {
  976. TPacketGCPVP kPVPPacket;
  977. if (!Recv(sizeof(kPVPPacket), &kPVPPacket))
  978. return false;
  979.  
  980. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  981. CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
  982.  
  983. switch (kPVPPacket.bMode)
  984. {
  985. case PVP_MODE_AGREE:
  986. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  987.  
  988. // 상대가 나(Dst)에게 동의를 구했을때
  989. if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDDst))
  990. rkPlayer.RememberChallengeInstance(kPVPPacket.dwVIDSrc);
  991.  
  992. // 상대에게 동의를 구한 동안에는 대결 불능
  993. if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDSrc))
  994. rkPlayer.RememberCantFightInstance(kPVPPacket.dwVIDDst);
  995. break;
  996. case PVP_MODE_REVENGE:
  997. {
  998. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  999.  
  1000. DWORD dwKiller = kPVPPacket.dwVIDSrc;
  1001. DWORD dwVictim = kPVPPacket.dwVIDDst;
  1002.  
  1003. // 내(victim)가 상대에게 복수할 수 있을때
  1004. if (rkPlayer.IsMainCharacterIndex(dwVictim))
  1005. rkPlayer.RememberRevengeInstance(dwKiller);
  1006.  
  1007. // 상대(victim)가 나에게 복수하는 동안에는 대결 불능
  1008. if (rkPlayer.IsMainCharacterIndex(dwKiller))
  1009. rkPlayer.RememberCantFightInstance(dwVictim);
  1010. break;
  1011. }
  1012.  
  1013. case PVP_MODE_FIGHT:
  1014. rkChrMgr.InsertPVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1015. rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
  1016. rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
  1017. break;
  1018. case PVP_MODE_NONE:
  1019. rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
  1020. rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
  1021. rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
  1022. break;
  1023. }
  1024.  
  1025. // NOTE : PVP 토글시 TargetBoard 를 업데이트 합니다.
  1026. __RefreshTargetBoardByVID(kPVPPacket.dwVIDSrc);
  1027. __RefreshTargetBoardByVID(kPVPPacket.dwVIDDst);
  1028.  
  1029. return true;
  1030. }
  1031.  
  1032. // DELETEME
  1033. /*
  1034. void CPythonNetworkStream::__SendWarpPacket()
  1035. {
  1036. TPacketCGWarp kWarpPacket;
  1037. kWarpPacket.bHeader=HEADER_GC_WARP;
  1038. if (!Send(sizeof(kWarpPacket), &kWarpPacket))
  1039. {
  1040. return;
  1041. }
  1042. }
  1043. */
  1044. void CPythonNetworkStream::NotifyHack(const char* c_szMsg)
  1045. {
  1046. if (!m_kQue_stHack.empty())
  1047. if (c_szMsg==m_kQue_stHack.back())
  1048. return;
  1049.  
  1050. m_kQue_stHack.push_back(c_szMsg);
  1051. }
  1052.  
  1053. bool CPythonNetworkStream::__SendHack(const char* c_szMsg)
  1054. {
  1055. Tracen(c_szMsg);
  1056.  
  1057. TPacketCGHack kPacketHack;
  1058. kPacketHack.bHeader=HEADER_CG_HACK;
  1059. strncpy(kPacketHack.szBuf, c_szMsg, sizeof(kPacketHack.szBuf)-1);
  1060.  
  1061. if (!Send(sizeof(kPacketHack), &kPacketHack))
  1062. return false;
  1063.  
  1064. return SendSequence();
  1065. }
  1066.  
  1067. bool CPythonNetworkStream::SendMessengerAddByVIDPacket(DWORD vid)
  1068. {
  1069. TPacketCGMessenger packet;
  1070. packet.header = HEADER_CG_MESSENGER;
  1071. packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_VID;
  1072. if (!Send(sizeof(packet), &packet))
  1073. return false;
  1074. if (!Send(sizeof(vid), &vid))
  1075. return false;
  1076. return SendSequence();
  1077. }
  1078.  
  1079. bool CPythonNetworkStream::SendMessengerAddByNamePacket(const char * c_szName)
  1080. {
  1081. TPacketCGMessenger packet;
  1082. packet.header = HEADER_CG_MESSENGER;
  1083. packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_NAME;
  1084. if (!Send(sizeof(packet), &packet))
  1085. return false;
  1086. char szName[CHARACTER_NAME_MAX_LEN];
  1087. strncpy(szName, c_szName, CHARACTER_NAME_MAX_LEN-1);
  1088. szName[CHARACTER_NAME_MAX_LEN-1] = '\0'; // #720: 메신저 이름 관련 버퍼 오버플로우 버그 수정
  1089.  
  1090. if (!Send(sizeof(szName), &szName))
  1091. return false;
  1092. Tracef(" SendMessengerAddByNamePacket : %s\n", c_szName);
  1093. return SendSequence();
  1094. }
  1095.  
  1096. bool CPythonNetworkStream::SendMessengerRemovePacket(const char * c_szKey, const char * c_szName)
  1097. {
  1098. TPacketCGMessenger packet;
  1099. packet.header = HEADER_CG_MESSENGER;
  1100. packet.subheader = MESSENGER_SUBHEADER_CG_REMOVE;
  1101. if (!Send(sizeof(packet), &packet))
  1102. return false;
  1103. char szKey[CHARACTER_NAME_MAX_LEN];
  1104. strncpy(szKey, c_szKey, CHARACTER_NAME_MAX_LEN-1);
  1105. if (!Send(sizeof(szKey), &szKey))
  1106. return false;
  1107. __RefreshTargetBoardByName(c_szName);
  1108. return SendSequence();
  1109. }
  1110.  
  1111. bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1112. {
  1113. NANOBEGIN
  1114. if (!__CanActMainInstance())
  1115. return true;
  1116.  
  1117. if (fDstRot < 0.0f)
  1118. fDstRot = 360 + fDstRot;
  1119. else if (fDstRot > 360.0f)
  1120. fDstRot = fmodf(fDstRot, 360.0f);
  1121.  
  1122. // TODO: 나중에 패킷이름을 바꾸자
  1123. TPacketCGMove kStatePacket;
  1124. kStatePacket.bHeader = HEADER_CG_CHARACTER_MOVE;
  1125. kStatePacket.bFunc = eFunc;
  1126. kStatePacket.bArg = uArg;
  1127. kStatePacket.bRot = fDstRot/5.0f;
  1128. kStatePacket.lX = long(c_rkPPosDst.x);
  1129. kStatePacket.lY = long(c_rkPPosDst.y);
  1130. kStatePacket.dwTime = ELTimer_GetServerMSec();
  1131.  
  1132. assert(kStatePacket.lX >= 0 && kStatePacket.lX < 204800);
  1133.  
  1134. __LocalPositionToGlobalPosition(kStatePacket.lX, kStatePacket.lY);
  1135.  
  1136. if (!Send(sizeof(kStatePacket), &kStatePacket))
  1137. {
  1138. Tracenf("CPythonNetworkStream::SendCharacterStatePacket(dwCmdTime=%u, fDstPos=(%f, %f), fDstRot=%f, eFunc=%d uArg=%d) - PACKET SEND ERROR",
  1139. kStatePacket.dwTime,
  1140. float(kStatePacket.lX),
  1141. float(kStatePacket.lY),
  1142. fDstRot,
  1143. kStatePacket.bFunc,
  1144. kStatePacket.bArg);
  1145. return false;
  1146. }
  1147. NANOEND
  1148. return SendSequence();
  1149. }
  1150.  
  1151. // NOTE : SlotIndex는 임시
  1152. bool CPythonNetworkStream::SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID)
  1153. {
  1154. TPacketCGUseSkill UseSkillPacket;
  1155. UseSkillPacket.bHeader = HEADER_CG_USE_SKILL;
  1156. UseSkillPacket.dwVnum = dwSkillIndex;
  1157. UseSkillPacket.dwTargetVID = dwTargetVID;
  1158. if (!Send(sizeof(TPacketCGUseSkill), &UseSkillPacket))
  1159. {
  1160. Tracen("CPythonNetworkStream::SendUseSkillPacket - SEND PACKET ERROR");
  1161. return false;
  1162. }
  1163.  
  1164. return SendSequence();
  1165. }
  1166.  
  1167. bool CPythonNetworkStream::SendChatPacket(const char * c_szChat, BYTE byType)
  1168. {
  1169. if (strlen(c_szChat) == 0)
  1170. return true;
  1171.  
  1172. if (strlen(c_szChat) >= 512)
  1173. return true;
  1174.  
  1175. if (c_szChat[0] == '/')
  1176. {
  1177. if (1 == strlen(c_szChat))
  1178. {
  1179. if (!m_strLastCommand.empty())
  1180. c_szChat = m_strLastCommand.c_str();
  1181. }
  1182. else
  1183. {
  1184. m_strLastCommand = c_szChat;
  1185. }
  1186. }
  1187.  
  1188. if (ClientCommand(c_szChat))
  1189. return true;
  1190.  
  1191. int iTextLen = strlen(c_szChat) + 1;
  1192. TPacketCGChat ChatPacket;
  1193. ChatPacket.header = HEADER_CG_CHAT;
  1194. ChatPacket.length = sizeof(ChatPacket) + iTextLen;
  1195. ChatPacket.type = byType;
  1196.  
  1197. if (!Send(sizeof(ChatPacket), &ChatPacket))
  1198. return false;
  1199.  
  1200. if (!Send(iTextLen, c_szChat))
  1201. return false;
  1202.  
  1203. return SendSequence();
  1204. }
  1205.  
  1206. //////////////////////////////////////////////////////////////////////////
  1207. // Emoticon
  1208. void CPythonNetworkStream::RegisterEmoticonString(const char * pcEmoticonString)
  1209. {
  1210. if (m_EmoticonStringVector.size() >= CInstanceBase::EMOTICON_NUM)
  1211. {
  1212. TraceError("Can't register emoticon string... vector is full (size:%d)", m_EmoticonStringVector.size() );
  1213. return;
  1214. }
  1215. m_EmoticonStringVector.push_back(pcEmoticonString);
  1216. }
  1217.  
  1218. bool CPythonNetworkStream::ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon)
  1219. {
  1220. for (DWORD dwEmoticonIndex = 0; dwEmoticonIndex < m_EmoticonStringVector.size() ; ++dwEmoticonIndex)
  1221. {
  1222. if (strlen(pChatMsg) > m_EmoticonStringVector[dwEmoticonIndex].size())
  1223. continue;
  1224.  
  1225. const char * pcFind = strstr(pChatMsg, m_EmoticonStringVector[dwEmoticonIndex].c_str());
  1226.  
  1227. if (pcFind != pChatMsg)
  1228. continue;
  1229.  
  1230. *pdwEmoticon = dwEmoticonIndex;
  1231.  
  1232. return true;
  1233. }
  1234.  
  1235. return false;
  1236. }
  1237. // Emoticon
  1238. //////////////////////////////////////////////////////////////////////////
  1239.  
  1240. void CPythonNetworkStream::__ConvertEmpireText(DWORD dwEmpireID, char* szText)
  1241. {
  1242. if (dwEmpireID<1 || dwEmpireID>3)
  1243. return;
  1244.  
  1245. UINT uHanPos;
  1246.  
  1247. STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1];
  1248.  
  1249. BYTE* pbText=(BYTE*)szText;
  1250. while (*pbText)
  1251. {
  1252. if (*pbText & 0x80)
  1253. {
  1254. if (pbText[0]>=0xb0 && pbText[0]<=0xc8 && pbText[1]>=0xa1 && pbText[1]<=0xfe)
  1255. {
  1256. uHanPos=(pbText[0]-0xb0)*(0xfe-0xa1+1)+(pbText[1]-0xa1);
  1257. pbText[0]=rkTextConvTable.aacHan[uHanPos][0];
  1258. pbText[1]=rkTextConvTable.aacHan[uHanPos][1];
  1259. }
  1260. pbText+=2;
  1261. }
  1262. else
  1263. {
  1264. if (*pbText>='a' && *pbText<='z')
  1265. {
  1266. *pbText=rkTextConvTable.acLower[*pbText-'a'];
  1267. }
  1268. else if (*pbText>='A' && *pbText<='Z')
  1269. {
  1270. *pbText=rkTextConvTable.acUpper[*pbText-'A'];
  1271. }
  1272. pbText++;
  1273. }
  1274. }
  1275. }
  1276.  
  1277. bool CPythonNetworkStream::RecvChatPacket()
  1278. {
  1279. TPacketGCChat kChat;
  1280. char buf[1024 + 1];
  1281. char line[1024 + 1];
  1282.  
  1283. if (!Recv(sizeof(kChat), &kChat))
  1284. return false;
  1285.  
  1286. UINT uChatSize=kChat.size - sizeof(kChat);
  1287.  
  1288. if (!Recv(uChatSize, buf))
  1289. return false;
  1290.  
  1291. buf[uChatSize]='\0';
  1292.  
  1293. // 유럽 아랍 버전 처리
  1294. // "이름: 내용" 입력을 "내용: 이름" 순서로 출력하기 위해 탭(0x08)을 넣음
  1295. // 탭을 아랍어 기호로 처리해 (영어1) : (영어2) 로 입력되어도 (영어2) : (영어1) 로 출력하게 만든다
  1296. if (LocaleService_IsEUROPE() && GetDefaultCodePage() == 1256)
  1297. {
  1298. char * p = strchr(buf, ':');
  1299. if (p && p[1] == ' ')
  1300. p[1] = 0x08;
  1301. }
  1302.  
  1303. if (kChat.type >= CHAT_TYPE_MAX_NUM)
  1304. return true;
  1305.  
  1306. if (CHAT_TYPE_COMMAND == kChat.type)
  1307. {
  1308. ServerCommand(buf);
  1309. return true;
  1310. }
  1311.  
  1312. if (kChat.dwVID != 0)
  1313. {
  1314. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1315. CInstanceBase * pkInstChatter = rkChrMgr.GetInstancePtr(kChat.dwVID);
  1316. if (NULL == pkInstChatter)
  1317. return true;
  1318.  
  1319. switch (kChat.type)
  1320. {
  1321. case CHAT_TYPE_TALKING: /* 그냥 채팅 */
  1322. case CHAT_TYPE_PARTY: /* 파티말 */
  1323. case CHAT_TYPE_GUILD: /* 길드말 */
  1324. case CHAT_TYPE_SHOUT: /* 외치기 */
  1325. case CHAT_TYPE_WHISPER: // 서버와는 연동되지 않는 Only Client Enum
  1326. {
  1327. char * p = strchr(buf, ':');
  1328.  
  1329. if (p)
  1330. p += 2;
  1331. else
  1332. p = buf;
  1333.  
  1334. DWORD dwEmoticon;
  1335.  
  1336. if (ParseEmoticon(p, &dwEmoticon))
  1337. {
  1338. pkInstChatter->SetEmoticon(dwEmoticon);
  1339. return true;
  1340. }
  1341. else
  1342. {
  1343. if (gs_bEmpireLanuageEnable)
  1344. {
  1345. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  1346. if (pkInstMain)
  1347. if (!pkInstMain->IsSameEmpire(*pkInstChatter))
  1348. __ConvertEmpireText(pkInstChatter->GetEmpireID(), p);
  1349. }
  1350.  
  1351. if (m_isEnableChatInsultFilter)
  1352. {
  1353. if (false == pkInstChatter->IsNPC() && false == pkInstChatter->IsEnemy())
  1354. {
  1355. __FilterInsult(p, strlen(p));
  1356. }
  1357. }
  1358.  
  1359. _snprintf(line, sizeof(line), "%s", p);
  1360. }
  1361. }
  1362. break;
  1363. case CHAT_TYPE_COMMAND: /* 명령 */
  1364. case CHAT_TYPE_INFO: /* 정보 (아이템을 집었다, 경험치를 얻었다. 등) */
  1365. case CHAT_TYPE_NOTICE: /* 공지사항 */
  1366. case CHAT_TYPE_BIG_NOTICE:
  1367. case CHAT_TYPE_MAX_NUM:
  1368. default:
  1369. _snprintf(line, sizeof(line), "%s", buf);
  1370. break;
  1371. }
  1372.  
  1373. if (CHAT_TYPE_SHOUT != kChat.type)
  1374. {
  1375. CPythonTextTail::Instance().RegisterChatTail(kChat.dwVID, line);
  1376. }
  1377.  
  1378. if (pkInstChatter->IsPC())
  1379. CPythonChat::Instance().AppendChat(kChat.type, buf);
  1380. }
  1381. else
  1382. {
  1383. if (CHAT_TYPE_NOTICE == kChat.type)
  1384. {
  1385. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetTipMessage", Py_BuildValue("(s)", buf));
  1386. }
  1387. else if (CHAT_TYPE_BIG_NOTICE == kChat.type)
  1388. {
  1389. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetBigMessage", Py_BuildValue("(s)", buf));
  1390. }
  1391. else if (CHAT_TYPE_SHOUT == kChat.type)
  1392. {
  1393. char * p = strchr(buf, ':');
  1394.  
  1395. if (p)
  1396. {
  1397. if (m_isEnableChatInsultFilter)
  1398. __FilterInsult(p, strlen(p));
  1399. }
  1400. }
  1401.  
  1402. CPythonChat::Instance().AppendChat(kChat.type, buf);
  1403.  
  1404. }
  1405. return true;
  1406. }
  1407.  
  1408. bool CPythonNetworkStream::RecvWhisperPacket()
  1409. {
  1410. TPacketGCWhisper whisperPacket;
  1411. char buf[512 + 1];
  1412.  
  1413. if (!Recv(sizeof(whisperPacket), &whisperPacket))
  1414. return false;
  1415.  
  1416. assert(whisperPacket.wSize - sizeof(whisperPacket) < 512);
  1417.  
  1418. if (!Recv(whisperPacket.wSize - sizeof(whisperPacket), &buf))
  1419. return false;
  1420.  
  1421. buf[whisperPacket.wSize - sizeof(whisperPacket)] = '\0';
  1422.  
  1423. static char line[256];
  1424. if (CPythonChat::WHISPER_TYPE_CHAT == whisperPacket.bType || CPythonChat::WHISPER_TYPE_GM == whisperPacket.bType)
  1425. {
  1426. _snprintf(line, sizeof(line), "%s : %s", whisperPacket.szNameFrom, buf);
  1427. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisper", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, line));
  1428. }
  1429. else if (CPythonChat::WHISPER_TYPE_SYSTEM == whisperPacket.bType || CPythonChat::WHISPER_TYPE_ERROR == whisperPacket.bType)
  1430. {
  1431. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperSystemMessage", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
  1432. }
  1433. else
  1434. {
  1435. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperError", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
  1436. }
  1437.  
  1438. return true;
  1439. }
  1440.  
  1441. bool CPythonNetworkStream::SendWhisperPacket(const char * name, const char * c_szChat)
  1442. {
  1443. if (strlen(c_szChat) >= 255)
  1444. return true;
  1445.  
  1446. int iTextLen = strlen(c_szChat) + 1;
  1447. TPacketCGWhisper WhisperPacket;
  1448. WhisperPacket.bHeader = HEADER_CG_WHISPER;
  1449. WhisperPacket.wSize = sizeof(WhisperPacket) + iTextLen;
  1450.  
  1451. strncpy(WhisperPacket.szNameTo, name, sizeof(WhisperPacket.szNameTo) - 1);
  1452.  
  1453. if (!Send(sizeof(WhisperPacket), &WhisperPacket))
  1454. return false;
  1455.  
  1456. if (!Send(iTextLen, c_szChat))
  1457. return false;
  1458.  
  1459. return SendSequence();
  1460. }
  1461.  
  1462. bool CPythonNetworkStream::SendMobileMessagePacket(const char * name, const char * c_szChat)
  1463. {
  1464. int iTextLen = strlen(c_szChat) + 1;
  1465. TPacketCGSMS SMSPacket;
  1466. SMSPacket.bHeader = HEADER_CG_SMS;
  1467. SMSPacket.wSize = sizeof(SMSPacket) + iTextLen;
  1468.  
  1469. strncpy(SMSPacket.szNameTo, name, sizeof(SMSPacket.szNameTo) - 1);
  1470.  
  1471. if (!Send(sizeof(SMSPacket), &SMSPacket))
  1472. return false;
  1473.  
  1474. if (!Send(iTextLen, c_szChat))
  1475. return false;
  1476.  
  1477. return SendSequence();
  1478. }
  1479.  
  1480. bool CPythonNetworkStream::RecvPointChange()
  1481. {
  1482. TPacketGCPointChange PointChange;
  1483.  
  1484. if (!Recv(sizeof(TPacketGCPointChange), &PointChange))
  1485. {
  1486. Tracen("Recv Point Change Packet Error");
  1487. return false;
  1488. }
  1489.  
  1490. CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
  1491. rkChrMgr.ShowPointEffect(PointChange.Type, PointChange.dwVID);
  1492.  
  1493. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
  1494.  
  1495. // 자신의 Point가 변경되었을 경우..
  1496. if (pInstance)
  1497. if (PointChange.dwVID == pInstance->GetVirtualID())
  1498. {
  1499. CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
  1500. rkPlayer.SetStatus(PointChange.Type, PointChange.value);
  1501.  
  1502. switch (PointChange.Type)
  1503. {
  1504. case POINT_STAT_RESET_COUNT:
  1505. __RefreshStatus();
  1506. break;
  1507. case POINT_LEVEL:
  1508. case POINT_ST:
  1509. case POINT_DX:
  1510. case POINT_HT:
  1511. case POINT_IQ:
  1512. __RefreshStatus();
  1513. __RefreshSkillWindow();
  1514. break;
  1515. case POINT_SKILL:
  1516. case POINT_SUB_SKILL:
  1517. case POINT_HORSE_SKILL:
  1518. __RefreshSkillWindow();
  1519. break;
  1520. case POINT_ENERGY:
  1521. if (PointChange.value == 0)
  1522. {
  1523. rkPlayer.SetStatus(POINT_ENERGY_END_TIME, 0);
  1524. }
  1525. __RefreshStatus();
  1526. break;
  1527. default:
  1528. __RefreshStatus();
  1529. break;
  1530. }
  1531.  
  1532. if (POINT_GOLD == PointChange.Type)
  1533. {
  1534. if (PointChange.amount > 0)
  1535. {
  1536. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickMoney", Py_BuildValue("(i)", PointChange.amount));
  1537. }
  1538. }
  1539. }
  1540.  
  1541. return true;
  1542. }
  1543.  
  1544. bool CPythonNetworkStream::RecvStunPacket()
  1545. {
  1546. TPacketGCStun StunPacket;
  1547.  
  1548. if (!Recv(sizeof(StunPacket), &StunPacket))
  1549. {
  1550. Tracen("CPythonNetworkStream::RecvStunPacket Error");
  1551. return false;
  1552. }
  1553.  
  1554. //Tracef("RecvStunPacket %d\n", StunPacket.vid);
  1555.  
  1556. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1557. CInstanceBase * pkInstSel = rkChrMgr.GetInstancePtr(StunPacket.vid);
  1558.  
  1559. if (pkInstSel)
  1560. {
  1561. if (CPythonCharacterManager::Instance().GetMainInstancePtr()==pkInstSel)
  1562. pkInstSel->Die();
  1563. else
  1564. pkInstSel->Stun();
  1565. }
  1566.  
  1567. return true;
  1568. }
  1569.  
  1570. bool CPythonNetworkStream::RecvDeadPacket()
  1571. {
  1572. TPacketGCDead DeadPacket;
  1573. if (!Recv(sizeof(DeadPacket), &DeadPacket))
  1574. {
  1575. Tracen("CPythonNetworkStream::RecvDeadPacket Error");
  1576. return false;
  1577. }
  1578.  
  1579. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  1580. CInstanceBase * pkChrInstSel = rkChrMgr.GetInstancePtr(DeadPacket.vid);
  1581. if (pkChrInstSel)
  1582. {
  1583. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  1584. if (pkInstMain==pkChrInstSel)
  1585. {
  1586. Tracenf("주인공 사망");
  1587. if (false == pkInstMain->GetDuelMode())
  1588. {
  1589. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnGameOver", Py_BuildValue("()"));
  1590. }
  1591. CPythonPlayer::Instance().NotifyDeadMainCharacter();
  1592. }
  1593.  
  1594. pkChrInstSel->Die();
  1595. }
  1596.  
  1597. return true;
  1598. }
  1599.  
  1600. bool CPythonNetworkStream::SendCharacterPositionPacket(BYTE iPosition)
  1601. {
  1602. TPacketCGPosition PositionPacket;
  1603.  
  1604. PositionPacket.header = HEADER_CG_CHARACTER_POSITION;
  1605. PositionPacket.position = iPosition;
  1606.  
  1607. if (!Send(sizeof(TPacketCGPosition), &PositionPacket))
  1608. {
  1609. Tracen("Send Character Position Packet Error");
  1610. return false;
  1611. }
  1612.  
  1613. return SendSequence();
  1614. }
  1615.  
  1616. bool CPythonNetworkStream::SendOnClickPacket(DWORD vid)
  1617. {
  1618. TPacketCGOnClick OnClickPacket;
  1619. OnClickPacket.header = HEADER_CG_ON_CLICK;
  1620. OnClickPacket.vid = vid;
  1621.  
  1622. if (!Send(sizeof(OnClickPacket), &OnClickPacket))
  1623. {
  1624. Tracen("Send On_Click Packet Error");
  1625. return false;
  1626. }
  1627.  
  1628. Tracef("SendOnClickPacket\n");
  1629. return SendSequence();
  1630. }
  1631.  
  1632. bool CPythonNetworkStream::RecvCharacterPositionPacket()
  1633. {
  1634. TPacketGCPosition PositionPacket;
  1635.  
  1636. if (!Recv(sizeof(TPacketGCPosition), &PositionPacket))
  1637. return false;
  1638.  
  1639. CInstanceBase * pChrInstance = CPythonCharacterManager::Instance().GetInstancePtr(PositionPacket.vid);
  1640.  
  1641. if (!pChrInstance)
  1642. return true;
  1643.  
  1644. //pChrInstance->UpdatePosition(PositionPacket.position);
  1645.  
  1646. return true;
  1647. }
  1648.  
  1649. bool CPythonNetworkStream::RecvMotionPacket()
  1650. {
  1651. TPacketGCMotion MotionPacket;
  1652.  
  1653. if (!Recv(sizeof(TPacketGCMotion), &MotionPacket))
  1654. return false;
  1655.  
  1656. CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.vid);
  1657. CInstanceBase * pVictimInstance = NULL;
  1658.  
  1659. if (0 != MotionPacket.victim_vid)
  1660. pVictimInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.victim_vid);
  1661.  
  1662. if (!pMainInstance)
  1663. return false;
  1664.  
  1665. return true;
  1666. }
  1667.  
  1668. bool CPythonNetworkStream::RecvShopPacket()
  1669. {
  1670. std::vector<char> vecBuffer;
  1671. vecBuffer.clear();
  1672.  
  1673. TPacketGCShop packet_shop;
  1674. if (!Recv(sizeof(packet_shop), &packet_shop))
  1675. return false;
  1676.  
  1677. int iSize = packet_shop.size - sizeof(packet_shop);
  1678. if (iSize > 0)
  1679. {
  1680. vecBuffer.resize(iSize);
  1681. if (!Recv(iSize, &vecBuffer[0]))
  1682. return false;
  1683. }
  1684.  
  1685. switch (packet_shop.subheader)
  1686. {
  1687. case SHOP_SUBHEADER_GC_START:
  1688. {
  1689. CPythonShop::Instance().Clear();
  1690.  
  1691. DWORD dwVID = *(DWORD *)&vecBuffer[0];
  1692.  
  1693. TPacketGCShopStart * pShopStartPacket = (TPacketGCShopStart *)&vecBuffer[4];
  1694. for (BYTE iItemIndex = 0; iItemIndex < SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
  1695. {
  1696. CPythonShop::Instance().SetItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
  1697. }
  1698.  
  1699. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
  1700. }
  1701. break;
  1702.  
  1703. case SHOP_SUBHEADER_GC_START_EX:
  1704. {
  1705. CPythonShop::Instance().Clear();
  1706.  
  1707. TPacketGCShopStartEx * pShopStartPacket = (TPacketGCShopStartEx *)&vecBuffer[0];
  1708. size_t read_point = sizeof(TPacketGCShopStartEx);
  1709.  
  1710. DWORD dwVID = pShopStartPacket->owner_vid;
  1711. BYTE shop_tab_count = pShopStartPacket->shop_tab_count;
  1712.  
  1713. CPythonShop::instance().SetTabCount(shop_tab_count);
  1714.  
  1715. for (size_t i = 0; i < shop_tab_count; i++)
  1716. {
  1717. TPacketGCShopStartEx::TSubPacketShopTab* pPackTab = (TPacketGCShopStartEx::TSubPacketShopTab*)&vecBuffer[read_point];
  1718. read_point += sizeof(TPacketGCShopStartEx::TSubPacketShopTab);
  1719.  
  1720. CPythonShop::instance().SetTabCoinType(i, pPackTab->coin_type);
  1721. CPythonShop::instance().SetTabName(i, pPackTab->name);
  1722.  
  1723. struct packet_shop_item* item = &pPackTab->items[0];
  1724.  
  1725. for (BYTE j = 0; j < SHOP_HOST_ITEM_MAX_NUM; j++)
  1726. {
  1727. TShopItemData* itemData = (item + j);
  1728. CPythonShop::Instance().SetItemData(i, j, *itemData);
  1729. }
  1730. }
  1731.  
  1732. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
  1733. }
  1734. break;
  1735.  
  1736.  
  1737. case SHOP_SUBHEADER_GC_END:
  1738. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndShop", Py_BuildValue("()"));
  1739. break;
  1740.  
  1741. case SHOP_SUBHEADER_GC_UPDATE_ITEM:
  1742. {
  1743. TPacketGCShopUpdateItem * pShopUpdateItemPacket = (TPacketGCShopUpdateItem *)&vecBuffer[0];
  1744. CPythonShop::Instance().SetItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item);
  1745. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShop", Py_BuildValue("()"));
  1746. }
  1747. break;
  1748.  
  1749. case SHOP_SUBHEADER_GC_UPDATE_PRICE:
  1750. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetShopSellingPrice", Py_BuildValue("(i)", *(int *)&vecBuffer[0]));
  1751. break;
  1752.  
  1753. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY:
  1754. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY"));
  1755. break;
  1756.  
  1757. case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX:
  1758. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY_EX"));
  1759. break;
  1760.  
  1761. case SHOP_SUBHEADER_GC_SOLDOUT:
  1762. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT"));
  1763. break;
  1764.  
  1765. case SHOP_SUBHEADER_GC_INVENTORY_FULL:
  1766. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL"));
  1767. break;
  1768.  
  1769. case SHOP_SUBHEADER_GC_INVALID_POS:
  1770. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS"));
  1771. break;
  1772.  
  1773. default:
  1774. TraceError("CPythonNetworkStream::RecvShopPacket: Unknown subheader\n");
  1775. break;
  1776. }
  1777.  
  1778. return true;
  1779. }
  1780.  
  1781. bool CPythonNetworkStream::RecvExchangePacket()
  1782. {
  1783. TPacketGCExchange exchange_packet;
  1784.  
  1785. if (!Recv(sizeof(exchange_packet), &exchange_packet))
  1786. return false;
  1787.  
  1788. switch (exchange_packet.subheader)
  1789. {
  1790. case EXCHANGE_SUBHEADER_GC_START:
  1791. CPythonExchange::Instance().Clear();
  1792. CPythonExchange::Instance().Start();
  1793. CPythonExchange::Instance().SetSelfName(CPythonPlayer::Instance().GetName());
  1794.  
  1795. {
  1796. CInstanceBase * pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr(exchange_packet.arg1);
  1797.  
  1798. if (pCharacterInstance)
  1799. CPythonExchange::Instance().SetTargetName(pCharacterInstance->GetNameString());
  1800. }
  1801.  
  1802. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartExchange", Py_BuildValue("()"));
  1803. break;
  1804.  
  1805. case EXCHANGE_SUBHEADER_GC_ITEM_ADD:
  1806. if (exchange_packet.is_me)
  1807. {
  1808. int iSlotIndex = exchange_packet.arg2.cell;
  1809. CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
  1810. for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
  1811. CPythonExchange::Instance().SetItemMetinSocketToSelf(iSlotIndex, i, exchange_packet.alValues[i]);
  1812. for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
  1813. CPythonExchange::Instance().SetItemAttributeToSelf(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
  1814. }
  1815. else
  1816. {
  1817. int iSlotIndex = exchange_packet.arg2.cell;
  1818. CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
  1819. for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
  1820. CPythonExchange::Instance().SetItemMetinSocketToTarget(iSlotIndex, i, exchange_packet.alValues[i]);
  1821. for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
  1822. CPythonExchange::Instance().SetItemAttributeToTarget(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
  1823. }
  1824.  
  1825. __RefreshExchangeWindow();
  1826. __RefreshInventoryWindow();
  1827. break;
  1828.  
  1829. case EXCHANGE_SUBHEADER_GC_ITEM_DEL:
  1830. if (exchange_packet.is_me)
  1831. {
  1832. CPythonExchange::Instance().DelItemOfSelf((BYTE) exchange_packet.arg1);
  1833. }
  1834. else
  1835. {
  1836. CPythonExchange::Instance().DelItemOfTarget((BYTE) exchange_packet.arg1);
  1837. }
  1838. __RefreshExchangeWindow();
  1839. __RefreshInventoryWindow();
  1840. break;
  1841.  
  1842. case EXCHANGE_SUBHEADER_GC_ELK_ADD:
  1843. if (exchange_packet.is_me)
  1844. CPythonExchange::Instance().SetElkToSelf(exchange_packet.arg1);
  1845. else
  1846. CPythonExchange::Instance().SetElkToTarget(exchange_packet.arg1);
  1847.  
  1848. __RefreshExchangeWindow();
  1849. break;
  1850.  
  1851. case EXCHANGE_SUBHEADER_GC_ACCEPT:
  1852. if (exchange_packet.is_me)
  1853. {
  1854. CPythonExchange::Instance().SetAcceptToSelf((BYTE) exchange_packet.arg1);
  1855. }
  1856. else
  1857. {
  1858. CPythonExchange::Instance().SetAcceptToTarget((BYTE) exchange_packet.arg1);
  1859. }
  1860. __RefreshExchangeWindow();
  1861. break;
  1862.  
  1863. case EXCHANGE_SUBHEADER_GC_END:
  1864. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndExchange", Py_BuildValue("()"));
  1865. __RefreshInventoryWindow();
  1866. CPythonExchange::Instance().End();
  1867. break;
  1868.  
  1869. case EXCHANGE_SUBHEADER_GC_ALREADY:
  1870. Tracef("trade_already");
  1871. break;
  1872.  
  1873. case EXCHANGE_SUBHEADER_GC_LESS_ELK:
  1874. Tracef("trade_less_elk");
  1875. break;
  1876. };
  1877.  
  1878. return true;
  1879. }
  1880.  
  1881. bool CPythonNetworkStream::RecvQuestInfoPacket()
  1882. {
  1883. TPacketGCQuestInfo QuestInfo;
  1884.  
  1885. if (!Peek(sizeof(TPacketGCQuestInfo), &QuestInfo))
  1886. {
  1887. Tracen("Recv Quest Info Packet Error #1");
  1888. return false;
  1889. }
  1890.  
  1891. if (!Peek(QuestInfo.size))
  1892. {
  1893. Tracen("Recv Quest Info Packet Error #2");
  1894. return false;
  1895. }
  1896.  
  1897. Recv(sizeof(TPacketGCQuestInfo));
  1898.  
  1899. const BYTE & c_rFlag = QuestInfo.flag;
  1900.  
  1901. enum
  1902. {
  1903. QUEST_PACKET_TYPE_NONE,
  1904. QUEST_PACKET_TYPE_BEGIN,
  1905. QUEST_PACKET_TYPE_UPDATE,
  1906. QUEST_PACKET_TYPE_END,
  1907. };
  1908.  
  1909. BYTE byQuestPacketType = QUEST_PACKET_TYPE_NONE;
  1910.  
  1911. if (0 != (c_rFlag & QUEST_SEND_IS_BEGIN))
  1912. {
  1913. BYTE isBegin;
  1914. if (!Recv(sizeof(isBegin), &isBegin))
  1915. return false;
  1916.  
  1917. if (isBegin)
  1918. byQuestPacketType = QUEST_PACKET_TYPE_BEGIN;
  1919. else
  1920. byQuestPacketType = QUEST_PACKET_TYPE_END;
  1921. }
  1922. else
  1923. {
  1924. byQuestPacketType = QUEST_PACKET_TYPE_UPDATE;
  1925. }
  1926.  
  1927. // Recv Data Start
  1928. char szTitle[30 + 1] = "";
  1929. char szClockName[16 + 1] = "";
  1930. int iClockValue = 0;
  1931. char szCounterName[16 + 1] = "";
  1932. int iCounterValue = 0;
  1933. char szIconFileName[24 + 1] = "";
  1934.  
  1935. if (0 != (c_rFlag & QUEST_SEND_TITLE))
  1936. {
  1937. if (!Recv(sizeof(szTitle), &szTitle))
  1938. return false;
  1939.  
  1940. szTitle[30]='\0';
  1941. }
  1942. if (0 != (c_rFlag & QUEST_SEND_CLOCK_NAME))
  1943. {
  1944. if (!Recv(sizeof(szClockName), &szClockName))
  1945. return false;
  1946.  
  1947. szClockName[16]='\0';
  1948. }
  1949. if (0 != (c_rFlag & QUEST_SEND_CLOCK_VALUE))
  1950. {
  1951. if (!Recv(sizeof(iClockValue), &iClockValue))
  1952. return false;
  1953. }
  1954. if (0 != (c_rFlag & QUEST_SEND_COUNTER_NAME))
  1955. {
  1956. if (!Recv(sizeof(szCounterName), &szCounterName))
  1957. return false;
  1958.  
  1959. szCounterName[16]='\0';
  1960. }
  1961. if (0 != (c_rFlag & QUEST_SEND_COUNTER_VALUE))
  1962. {
  1963. if (!Recv(sizeof(iCounterValue), &iCounterValue))
  1964. return false;
  1965. }
  1966. if (0 != (c_rFlag & QUEST_SEND_ICON_FILE))
  1967. {
  1968. if (!Recv(sizeof(szIconFileName), &szIconFileName))
  1969. return false;
  1970.  
  1971. szIconFileName[24]='\0';
  1972. }
  1973. // Recv Data End
  1974.  
  1975. CPythonQuest& rkQuest=CPythonQuest::Instance();
  1976.  
  1977. // Process Start
  1978. if (QUEST_PACKET_TYPE_END == byQuestPacketType)
  1979. {
  1980. rkQuest.DeleteQuestInstance(QuestInfo.index);
  1981. }
  1982. else if (QUEST_PACKET_TYPE_UPDATE == byQuestPacketType)
  1983. {
  1984. if (!rkQuest.IsQuest(QuestInfo.index))
  1985. {
  1986. rkQuest.MakeQuest(QuestInfo.index);
  1987. }
  1988.  
  1989. if (strlen(szTitle) > 0)
  1990. rkQuest.SetQuestTitle(QuestInfo.index, szTitle);
  1991. if (strlen(szClockName) > 0)
  1992. rkQuest.SetQuestClockName(QuestInfo.index, szClockName);
  1993. if (strlen(szCounterName) > 0)
  1994. rkQuest.SetQuestCounterName(QuestInfo.index, szCounterName);
  1995. if (strlen(szIconFileName) > 0)
  1996. rkQuest.SetQuestIconFileName(QuestInfo.index, szIconFileName);
  1997.  
  1998. if (c_rFlag & QUEST_SEND_CLOCK_VALUE)
  1999. rkQuest.SetQuestClockValue(QuestInfo.index, iClockValue);
  2000. if (c_rFlag & QUEST_SEND_COUNTER_VALUE)
  2001. rkQuest.SetQuestCounterValue(QuestInfo.index, iCounterValue);
  2002. }
  2003. else if (QUEST_PACKET_TYPE_BEGIN == byQuestPacketType)
  2004. {
  2005. CPythonQuest::SQuestInstance QuestInstance;
  2006. QuestInstance.dwIndex = QuestInfo.index;
  2007. QuestInstance.strTitle = szTitle;
  2008. QuestInstance.strClockName = szClockName;
  2009. QuestInstance.iClockValue = iClockValue;
  2010. QuestInstance.strCounterName = szCounterName;
  2011. QuestInstance.iCounterValue = iCounterValue;
  2012. QuestInstance.strIconFileName = szIconFileName;
  2013. CPythonQuest::Instance().RegisterQuestInstance(QuestInstance);
  2014. }
  2015. // Process Start End
  2016.  
  2017. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshQuest", Py_BuildValue("()"));
  2018. return true;
  2019. }
  2020.  
  2021. bool CPythonNetworkStream::RecvQuestConfirmPacket()
  2022. {
  2023. TPacketGCQuestConfirm kQuestConfirmPacket;
  2024. if (!Recv(sizeof(kQuestConfirmPacket), &kQuestConfirmPacket))
  2025. {
  2026. Tracen("RecvQuestConfirmPacket Error");
  2027. return false;
  2028. }
  2029.  
  2030. PyObject * poArg = Py_BuildValue("(sii)", kQuestConfirmPacket.msg, kQuestConfirmPacket.timeout, kQuestConfirmPacket.requestPID);
  2031. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OnQuestConfirm", poArg);
  2032. return true;
  2033. }
  2034.  
  2035. bool CPythonNetworkStream::RecvRequestMakeGuild()
  2036. {
  2037. TPacketGCBlank blank;
  2038. if (!Recv(sizeof(blank), &blank))
  2039. {
  2040. Tracen("RecvRequestMakeGuild Packet Error");
  2041. return false;
  2042. }
  2043.  
  2044. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AskGuildName", Py_BuildValue("()"));
  2045.  
  2046. return true;
  2047. }
  2048.  
  2049. void CPythonNetworkStream::ToggleGameDebugInfo()
  2050. {
  2051. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ToggleDebugInfo", Py_BuildValue("()"));
  2052. }
  2053.  
  2054. bool CPythonNetworkStream::SendExchangeStartPacket(DWORD vid)
  2055. {
  2056. if (!__CanActMainInstance())
  2057. return true;
  2058.  
  2059. TPacketCGExchange packet;
  2060.  
  2061. packet.header = HEADER_CG_EXCHANGE;
  2062. packet.subheader = EXCHANGE_SUBHEADER_CG_START;
  2063. packet.arg1 = vid;
  2064.  
  2065. if (!Send(sizeof(packet), &packet))
  2066. {
  2067. Tracef("send_trade_start_packet Error\n");
  2068. return false;
  2069. }
  2070.  
  2071. Tracef("send_trade_start_packet vid %d \n", vid);
  2072. return SendSequence();
  2073. }
  2074.  
  2075. bool CPythonNetworkStream::SendExchangeElkAddPacket(DWORD elk)
  2076. {
  2077. if (!__CanActMainInstance())
  2078. return true;
  2079.  
  2080. TPacketCGExchange packet;
  2081.  
  2082. packet.header = HEADER_CG_EXCHANGE;
  2083. packet.subheader = EXCHANGE_SUBHEADER_CG_ELK_ADD;
  2084. packet.arg1 = elk;
  2085.  
  2086. if (!Send(sizeof(packet), &packet))
  2087. {
  2088. Tracef("send_trade_elk_add_packet Error\n");
  2089. return false;
  2090. }
  2091.  
  2092. return SendSequence();
  2093. }
  2094.  
  2095. bool CPythonNetworkStream::SendExchangeItemAddPacket(TItemPos ItemPos, BYTE byDisplayPos)
  2096. {
  2097. if (!__CanActMainInstance())
  2098. return true;
  2099.  
  2100. TPacketCGExchange packet;
  2101.  
  2102. packet.header = HEADER_CG_EXCHANGE;
  2103. packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_ADD;
  2104. packet.Pos = ItemPos;
  2105. packet.arg2 = byDisplayPos;
  2106.  
  2107. if (!Send(sizeof(packet), &packet))
  2108. {
  2109. Tracef("send_trade_item_add_packet Error\n");
  2110. return false;
  2111. }
  2112.  
  2113. return SendSequence();
  2114. }
  2115.  
  2116. bool CPythonNetworkStream::SendExchangeItemDelPacket(BYTE pos)
  2117. {
  2118. assert(!"Can't be called function - CPythonNetworkStream::SendExchangeItemDelPacket");
  2119. return true;
  2120.  
  2121. if (!__CanActMainInstance())
  2122. return true;
  2123.  
  2124. TPacketCGExchange packet;
  2125.  
  2126. packet.header = HEADER_CG_EXCHANGE;
  2127. packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_DEL;
  2128. packet.arg1 = pos;
  2129.  
  2130. if (!Send(sizeof(packet), &packet))
  2131. {
  2132. Tracef("send_trade_item_del_packet Error\n");
  2133. return false;
  2134. }
  2135.  
  2136. return SendSequence();
  2137. }
  2138.  
  2139. bool CPythonNetworkStream::SendExchangeAcceptPacket()
  2140. {
  2141. if (!__CanActMainInstance())
  2142. return true;
  2143.  
  2144. TPacketCGExchange packet;
  2145.  
  2146. packet.header = HEADER_CG_EXCHANGE;
  2147. packet.subheader = EXCHANGE_SUBHEADER_CG_ACCEPT;
  2148.  
  2149. if (!Send(sizeof(packet), &packet))
  2150. {
  2151. Tracef("send_trade_accept_packet Error\n");
  2152. return false;
  2153. }
  2154.  
  2155. return SendSequence();
  2156. }
  2157.  
  2158. bool CPythonNetworkStream::SendExchangeExitPacket()
  2159. {
  2160. if (!__CanActMainInstance())
  2161. return true;
  2162.  
  2163. TPacketCGExchange packet;
  2164.  
  2165. packet.header = HEADER_CG_EXCHANGE;
  2166. packet.subheader = EXCHANGE_SUBHEADER_CG_CANCEL;
  2167.  
  2168. if (!Send(sizeof(packet), &packet))
  2169. {
  2170. Tracef("send_trade_exit_packet Error\n");
  2171. return false;
  2172. }
  2173.  
  2174. return SendSequence();
  2175. }
  2176.  
  2177. // PointReset 개임시
  2178. bool CPythonNetworkStream::SendPointResetPacket()
  2179. {
  2180. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartPointReset", Py_BuildValue("()"));
  2181. return true;
  2182. }
  2183.  
  2184. bool CPythonNetworkStream::__IsPlayerAttacking()
  2185. {
  2186. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  2187. CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
  2188. if (!pkInstMain)
  2189. return false;
  2190.  
  2191. if (!pkInstMain->IsAttacking())
  2192. return false;
  2193.  
  2194. return true;
  2195. }
  2196.  
  2197. bool CPythonNetworkStream::RecvScriptPacket()
  2198. {
  2199. TPacketGCScript ScriptPacket;
  2200.  
  2201. if (!Recv(sizeof(TPacketGCScript), &ScriptPacket))
  2202. {
  2203. TraceError("RecvScriptPacket_RecvError");
  2204. return false;
  2205. }
  2206.  
  2207. if (ScriptPacket.size < sizeof(TPacketGCScript))
  2208. {
  2209. TraceError("RecvScriptPacket_SizeError");
  2210. return false;
  2211. }
  2212.  
  2213. ScriptPacket.size -= sizeof(TPacketGCScript);
  2214.  
  2215. static string str;
  2216. str = "";
  2217. str.resize(ScriptPacket.size+1);
  2218.  
  2219. if (!Recv(ScriptPacket.size, &str[0]))
  2220. return false;
  2221.  
  2222. str[str.size()-1] = '\0';
  2223.  
  2224. int iIndex = CPythonEventManager::Instance().RegisterEventSetFromString(str);
  2225.  
  2226. if (-1 != iIndex)
  2227. {
  2228. CPythonEventManager::Instance().SetVisibleLineCount(iIndex, 30);
  2229. CPythonNetworkStream::Instance().OnScriptEventStart(ScriptPacket.skin,iIndex);
  2230. }
  2231.  
  2232. return true;
  2233. }
  2234.  
  2235. bool CPythonNetworkStream::SendScriptAnswerPacket(int iAnswer)
  2236. {
  2237. TPacketCGScriptAnswer ScriptAnswer;
  2238.  
  2239. ScriptAnswer.header = HEADER_CG_SCRIPT_ANSWER;
  2240. ScriptAnswer.answer = (BYTE) iAnswer;
  2241. if (!Send(sizeof(TPacketCGScriptAnswer), &ScriptAnswer))
  2242. {
  2243. Tracen("Send Script Answer Packet Error");
  2244. return false;
  2245. }
  2246.  
  2247. return SendSequence();
  2248. }
  2249.  
  2250. bool CPythonNetworkStream::SendScriptButtonPacket(unsigned int iIndex)
  2251. {
  2252. TPacketCGScriptButton ScriptButton;
  2253.  
  2254. ScriptButton.header = HEADER_CG_SCRIPT_BUTTON;
  2255. ScriptButton.idx = iIndex;
  2256. if (!Send(sizeof(TPacketCGScriptButton), &ScriptButton))
  2257. {
  2258. Tracen("Send Script Button Packet Error");
  2259. return false;
  2260. }
  2261.  
  2262. return SendSequence();
  2263. }
  2264.  
  2265. bool CPythonNetworkStream::SendAnswerMakeGuildPacket(const char * c_szName)
  2266. {
  2267. TPacketCGAnswerMakeGuild Packet;
  2268.  
  2269. Packet.header = HEADER_CG_ANSWER_MAKE_GUILD;
  2270. strncpy(Packet.guild_name, c_szName, GUILD_NAME_MAX_LEN);
  2271. Packet.guild_name[GUILD_NAME_MAX_LEN] = '\0';
  2272.  
  2273. if (!Send(sizeof(Packet), &Packet))
  2274. {
  2275. Tracen("SendAnswerMakeGuild Packet Error");
  2276. return false;
  2277. }
  2278.  
  2279. // Tracef(" SendAnswerMakeGuildPacket : %s", c_szName);
  2280. return SendSequence();
  2281. }
  2282.  
  2283. bool CPythonNetworkStream::SendQuestInputStringPacket(const char * c_szString)
  2284. {
  2285. TPacketCGQuestInputString Packet;
  2286. Packet.bHeader = HEADER_CG_QUEST_INPUT_STRING;
  2287. strncpy(Packet.szString, c_szString, QUEST_INPUT_STRING_MAX_NUM);
  2288.  
  2289. if (!Send(sizeof(Packet), &Packet))
  2290. {
  2291. Tracen("SendQuestInputStringPacket Error");
  2292. return false;
  2293. }
  2294.  
  2295. return SendSequence();
  2296. }
  2297.  
  2298. bool CPythonNetworkStream::SendQuestConfirmPacket(BYTE byAnswer, DWORD dwPID)
  2299. {
  2300. TPacketCGQuestConfirm kPacket;
  2301. kPacket.header = HEADER_CG_QUEST_CONFIRM;
  2302. kPacket.answer = byAnswer;
  2303. kPacket.requestPID = dwPID;
  2304.  
  2305. if (!Send(sizeof(kPacket), &kPacket))
  2306. {
  2307. Tracen("SendQuestConfirmPacket Error");
  2308. return false;
  2309. }
  2310.  
  2311. Tracenf(" SendQuestConfirmPacket : %d, %d", byAnswer, dwPID);
  2312. return SendSequence();
  2313. }
  2314.  
  2315. bool CPythonNetworkStream::RecvSkillCoolTimeEnd()
  2316. {
  2317. TPacketGCSkillCoolTimeEnd kPacketSkillCoolTimeEnd;
  2318. if (!Recv(sizeof(kPacketSkillCoolTimeEnd), &kPacketSkillCoolTimeEnd))
  2319. {
  2320. Tracen("CPythonNetworkStream::RecvSkillCoolTimeEnd - RecvError");
  2321. return false;
  2322. }
  2323.  
  2324. CPythonPlayer::Instance().EndSkillCoolTime(kPacketSkillCoolTimeEnd.bSkill);
  2325.  
  2326. return true;
  2327. }
  2328.  
  2329. bool CPythonNetworkStream::RecvSkillLevel()
  2330. {
  2331. assert(!"CPythonNetworkStream::RecvSkillLevel - 사용하지 않는 함수");
  2332. TPacketGCSkillLevel packet;
  2333. if (!Recv(sizeof(TPacketGCSkillLevel), &packet))
  2334. {
  2335. Tracen("CPythonNetworkStream::RecvSkillLevel - RecvError");
  2336. return false;
  2337. }
  2338.  
  2339. DWORD dwSlotIndex;
  2340.  
  2341. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2342. for (int i = 0; i < SKILL_MAX_NUM; ++i)
  2343. {
  2344. if (rkPlayer.GetSkillSlotIndex(i, &dwSlotIndex))
  2345. rkPlayer.SetSkillLevel(dwSlotIndex, packet.abSkillLevels[i]);
  2346. }
  2347.  
  2348. __RefreshSkillWindow();
  2349. __RefreshStatus();
  2350. Tracef(" >> RecvSkillLevel\n");
  2351. return true;
  2352. }
  2353.  
  2354. bool CPythonNetworkStream::RecvSkillLevelNew()
  2355. {
  2356. TPacketGCSkillLevelNew packet;
  2357.  
  2358. if (!Recv(sizeof(TPacketGCSkillLevelNew), &packet))
  2359. {
  2360. Tracen("CPythonNetworkStream::RecvSkillLevelNew - RecvError");
  2361. return false;
  2362. }
  2363.  
  2364. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2365.  
  2366. rkPlayer.SetSkill(7, 0);
  2367. rkPlayer.SetSkill(8, 0);
  2368.  
  2369. for (int i = 0; i < SKILL_MAX_NUM; ++i)
  2370. {
  2371. TPlayerSkill & rPlayerSkill = packet.skills[i];
  2372.  
  2373. if (i >= 112 && i <= 115 && rPlayerSkill.bLevel)
  2374. rkPlayer.SetSkill(7, i);
  2375.  
  2376. if (i >= 116 && i <= 119 && rPlayerSkill.bLevel)
  2377. rkPlayer.SetSkill(8, i);
  2378.  
  2379. rkPlayer.SetSkillLevel_(i, rPlayerSkill.bMasterType, rPlayerSkill.bLevel);
  2380. }
  2381.  
  2382. __RefreshSkillWindow();
  2383. __RefreshStatus();
  2384. //Tracef(" >> RecvSkillLevelNew\n");
  2385. return true;
  2386. }
  2387.  
  2388.  
  2389. bool CPythonNetworkStream::RecvDamageInfoPacket()
  2390. {
  2391. TPacketGCDamageInfo DamageInfoPacket;
  2392.  
  2393. if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket))
  2394. {
  2395. Tracen("Recv Target Packet Error");
  2396. return false;
  2397. }
  2398.  
  2399. CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVID);
  2400. bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr());
  2401. bool bTarget = (pInstTarget==m_pInstTarget);
  2402. if (pInstTarget)
  2403. {
  2404. if(DamageInfoPacket.damage >= 0)
  2405. pInstTarget->AddDamageEffect(DamageInfoPacket.damage,DamageInfoPacket.flag,bSelf,bTarget);
  2406. else
  2407. TraceError("Damage is equal or below 0.");
  2408. }
  2409.  
  2410. return true;
  2411. }
  2412. bool CPythonNetworkStream::RecvTargetPacket()
  2413. {
  2414. TPacketGCTarget TargetPacket;
  2415.  
  2416. if (!Recv(sizeof(TPacketGCTarget), &TargetPacket))
  2417. {
  2418. Tracen("Recv Target Packet Error");
  2419. return false;
  2420. }
  2421.  
  2422. CInstanceBase * pInstPlayer = CPythonCharacterManager::Instance().GetMainInstancePtr();
  2423. CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(TargetPacket.dwVID);
  2424. if (pInstPlayer && pInstTarget)
  2425. {
  2426. if (!pInstTarget->IsDead())
  2427. {
  2428. if (pInstTarget->IsPC() || pInstTarget->IsBuilding())
  2429. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoardIfDifferent", Py_BuildValue("(i)", TargetPacket.dwVID));
  2430. else if (pInstPlayer->CanViewTargetHP(*pInstTarget))
  2431. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHPTargetBoard", Py_BuildValue("(ii)", TargetPacket.dwVID, TargetPacket.bHPPercent));
  2432. else
  2433. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  2434.  
  2435. m_pInstTarget = pInstTarget;
  2436. }
  2437. }
  2438. else
  2439. {
  2440. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
  2441. }
  2442.  
  2443. return true;
  2444. }
  2445.  
  2446. bool CPythonNetworkStream::RecvMountPacket()
  2447. {
  2448. TPacketGCMount MountPacket;
  2449.  
  2450. if (!Recv(sizeof(TPacketGCMount), &MountPacket))
  2451. {
  2452. Tracen("Recv Mount Packet Error");
  2453. return false;
  2454. }
  2455.  
  2456. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(MountPacket.vid);
  2457.  
  2458. if (pInstance)
  2459. {
  2460. // Mount
  2461. if (0 != MountPacket.mount_vid)
  2462. {
  2463. // pInstance->Ride(MountPacket.pos, MountPacket.mount_vid);
  2464. }
  2465. // Unmount
  2466. else
  2467. {
  2468. // pInstance->Unride(MountPacket.pos, MountPacket.x, MountPacket.y);
  2469. }
  2470. }
  2471.  
  2472. if (CPythonPlayer::Instance().IsMainCharacterIndex(MountPacket.vid))
  2473. {
  2474. // CPythonPlayer::Instance().SetRidingVehicleIndex(MountPacket.mount_vid);
  2475. }
  2476.  
  2477. return true;
  2478. }
  2479.  
  2480. bool CPythonNetworkStream::RecvChangeSpeedPacket()
  2481. {
  2482. TPacketGCChangeSpeed SpeedPacket;
  2483.  
  2484. if (!Recv(sizeof(TPacketGCChangeSpeed), &SpeedPacket))
  2485. {
  2486. Tracen("Recv Speed Packet Error");
  2487. return false;
  2488. }
  2489.  
  2490. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(SpeedPacket.vid);
  2491.  
  2492. if (!pInstance)
  2493. return true;
  2494.  
  2495. // pInstance->SetWalkSpeed(SpeedPacket.walking_speed);
  2496. // pInstance->SetRunSpeed(SpeedPacket.running_speed);
  2497. return true;
  2498. }
  2499.  
  2500. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2501. // Recv
  2502.  
  2503. bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim)
  2504. {
  2505. if (!__CanActMainInstance())
  2506. return true;
  2507.  
  2508. #ifdef ATTACK_TIME_LOG
  2509. static DWORD prevTime = timeGetTime();
  2510. DWORD curTime = timeGetTime();
  2511. TraceError("TIME: %.4f(%.4f) ATTACK_PACKET: %d TARGET: %d", curTime/1000.0f, (curTime-prevTime)/1000.0f, uMotAttack, dwVIDVictim);
  2512. prevTime = curTime;
  2513. #endif
  2514.  
  2515. TPacketCGAttack kPacketAtk;
  2516.  
  2517. kPacketAtk.header = HEADER_CG_ATTACK;
  2518. kPacketAtk.bType = uMotAttack;
  2519. kPacketAtk.dwVictimVID = dwVIDVictim;
  2520.  
  2521. if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk))
  2522. {
  2523. Tracen("Send Battle Attack Packet Error");
  2524. return false;
  2525. }
  2526.  
  2527. return SendSequence();
  2528. }
  2529.  
  2530. bool CPythonNetworkStream::SendSpecial(int nLen, void * pvBuf)
  2531. {
  2532. BYTE bHeader = *(BYTE *) pvBuf;
  2533.  
  2534. switch (bHeader)
  2535. {
  2536. case HEADER_CG_ATTACK:
  2537. {
  2538. TPacketCGAttack * pkPacketAtk = (TPacketCGAttack *) pvBuf;
  2539. pkPacketAtk->bCRCMagicCubeProcPiece = GetProcessCRCMagicCubePiece();
  2540. pkPacketAtk->bCRCMagicCubeFilePiece = GetProcessCRCMagicCubePiece();
  2541. return Send(nLen, pvBuf);
  2542. }
  2543. break;
  2544. }
  2545.  
  2546. return Send(nLen, pvBuf);
  2547. }
  2548.  
  2549. bool CPythonNetworkStream::RecvAddFlyTargetingPacket()
  2550. {
  2551. TPacketGCFlyTargeting kPacket;
  2552. if (!Recv(sizeof(kPacket), &kPacket))
  2553. return false;
  2554.  
  2555. __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
  2556.  
  2557. Tracef("VID [%d]가 타겟을 추가 설정\n",kPacket.dwShooterVID);
  2558.  
  2559. CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2560.  
  2561. CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
  2562.  
  2563. if (!pShooter)
  2564. {
  2565. #ifndef _DEBUG
  2566. TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
  2567. #endif
  2568. return true;
  2569. }
  2570.  
  2571. CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
  2572.  
  2573. if (kPacket.dwTargetVID && pTarget)
  2574. {
  2575. pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(pTarget->GetGraphicThingInstancePtr());
  2576. }
  2577. else
  2578. {
  2579. float h = CPythonBackground::Instance().GetHeight(kPacket.lX,kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
  2580. pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
  2581. //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
  2582. }
  2583.  
  2584. return true;
  2585. }
  2586.  
  2587. bool CPythonNetworkStream::RecvFlyTargetingPacket()
  2588. {
  2589. TPacketGCFlyTargeting kPacket;
  2590. if (!Recv(sizeof(kPacket), &kPacket))
  2591. return false;
  2592.  
  2593. __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
  2594.  
  2595. //Tracef("CPythonNetworkStream::RecvFlyTargetingPacket - VID [%d]\n",kPacket.dwShooterVID);
  2596.  
  2597. CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2598.  
  2599. CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
  2600.  
  2601. if (!pShooter)
  2602. {
  2603. #ifdef _DEBUG
  2604. TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
  2605. #endif
  2606. return true;
  2607. }
  2608.  
  2609. CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
  2610.  
  2611. if (kPacket.dwTargetVID && pTarget)
  2612. {
  2613. pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(pTarget->GetGraphicThingInstancePtr());
  2614. }
  2615. else
  2616. {
  2617. float h = CPythonBackground::Instance().GetHeight(kPacket.lX, kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
  2618. pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
  2619. //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
  2620. }
  2621.  
  2622. return true;
  2623. }
  2624.  
  2625. bool CPythonNetworkStream::SendShootPacket(UINT uSkill)
  2626. {
  2627. TPacketCGShoot kPacketShoot;
  2628. kPacketShoot.bHeader=HEADER_CG_SHOOT;
  2629. kPacketShoot.bType=uSkill;
  2630.  
  2631. if (!Send(sizeof(kPacketShoot), &kPacketShoot))
  2632. {
  2633. Tracen("SendShootPacket Error");
  2634. return false;
  2635. }
  2636.  
  2637. return SendSequence();
  2638. }
  2639.  
  2640. bool CPythonNetworkStream::SendAddFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
  2641. {
  2642. TPacketCGFlyTargeting packet;
  2643.  
  2644. //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2645.  
  2646. packet.bHeader = HEADER_CG_ADD_FLY_TARGETING;
  2647. packet.dwTargetVID = dwTargetVID;
  2648. packet.lX = kPPosTarget.x;
  2649. packet.lY = kPPosTarget.y;
  2650.  
  2651. __LocalPositionToGlobalPosition(packet.lX, packet.lY);
  2652.  
  2653. if (!Send(sizeof(packet), &packet))
  2654. {
  2655. Tracen("Send FlyTargeting Packet Error");
  2656. return false;
  2657. }
  2658.  
  2659. return SendSequence();
  2660. }
  2661.  
  2662.  
  2663. bool CPythonNetworkStream::SendFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
  2664. {
  2665. TPacketCGFlyTargeting packet;
  2666.  
  2667. //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
  2668.  
  2669. packet.bHeader = HEADER_CG_FLY_TARGETING;
  2670. packet.dwTargetVID = dwTargetVID;
  2671. packet.lX = kPPosTarget.x;
  2672. packet.lY = kPPosTarget.y;
  2673.  
  2674. __LocalPositionToGlobalPosition(packet.lX, packet.lY);
  2675.  
  2676. if (!Send(sizeof(packet), &packet))
  2677. {
  2678. Tracen("Send FlyTargeting Packet Error");
  2679. return false;
  2680. }
  2681.  
  2682. return SendSequence();
  2683. }
  2684.  
  2685. bool CPythonNetworkStream::RecvCreateFlyPacket()
  2686. {
  2687. TPacketGCCreateFly kPacket;
  2688. if (!Recv(sizeof(TPacketGCCreateFly), &kPacket))
  2689. return false;
  2690.  
  2691. CFlyingManager& rkFlyMgr = CFlyingManager::Instance();
  2692. CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
  2693.  
  2694. CInstanceBase * pkStartInst = rkChrMgr.GetInstancePtr(kPacket.dwStartVID);
  2695. CInstanceBase * pkEndInst = rkChrMgr.GetInstancePtr(kPacket.dwEndVID);
  2696. if (!pkStartInst || !pkEndInst)
  2697. return true;
  2698.  
  2699. rkFlyMgr.CreateIndexedFly(kPacket.bType, pkStartInst->GetGraphicThingInstancePtr(), pkEndInst->GetGraphicThingInstancePtr());
  2700.  
  2701. return true;
  2702. }
  2703.  
  2704. bool CPythonNetworkStream::SendTargetPacket(DWORD dwVID)
  2705. {
  2706. TPacketCGTarget packet;
  2707. packet.header = HEADER_CG_TARGET;
  2708. packet.dwVID = dwVID;
  2709.  
  2710. if (!Send(sizeof(packet), &packet))
  2711. {
  2712. Tracen("Send Target Packet Error");
  2713. return false;
  2714. }
  2715.  
  2716. return SendSequence();
  2717. }
  2718.  
  2719. bool CPythonNetworkStream::SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY)
  2720. {
  2721. TPacketCGSyncPositionElement kSyncPos;
  2722. kSyncPos.dwVID=dwVictimVID;
  2723. kSyncPos.lX=dwVictimX;
  2724. kSyncPos.lY=dwVictimY;
  2725.  
  2726. __LocalPositionToGlobalPosition(kSyncPos.lX, kSyncPos.lY);
  2727.  
  2728. if (!Send(sizeof(kSyncPos), &kSyncPos))
  2729. {
  2730. Tracen("CPythonNetworkStream::SendSyncPositionElementPacket - ERROR");
  2731. return false;
  2732. }
  2733.  
  2734. return true;
  2735. }
  2736.  
  2737. bool CPythonNetworkStream::RecvMessenger()
  2738. {
  2739. TPacketGCMessenger p;
  2740. if (!Recv(sizeof(p), &p))
  2741. return false;
  2742.  
  2743. int iSize = p.size - sizeof(p);
  2744. char char_name[24+1];
  2745.  
  2746. switch (p.subheader)
  2747. {
  2748. case MESSENGER_SUBHEADER_GC_LIST:
  2749. {
  2750. TPacketGCMessengerListOnline on;
  2751. while(iSize)
  2752. {
  2753. if (!Recv(sizeof(TPacketGCMessengerListOffline),&on))
  2754. return false;
  2755.  
  2756. if (!Recv(on.length, char_name))
  2757. return false;
  2758.  
  2759. char_name[on.length] = 0;
  2760.  
  2761. if (on.connected & MESSENGER_CONNECTED_STATE_ONLINE)
  2762. CPythonMessenger::Instance().OnFriendLogin(char_name);
  2763. else
  2764. CPythonMessenger::Instance().OnFriendLogout(char_name);
  2765.  
  2766. if (on.connected & MESSENGER_CONNECTED_STATE_MOBILE)
  2767. CPythonMessenger::Instance().SetMobile(char_name, TRUE);
  2768.  
  2769. iSize -= sizeof(TPacketGCMessengerListOffline);
  2770. iSize -= on.length;
  2771. }
  2772. break;
  2773. }
  2774.  
  2775. case MESSENGER_SUBHEADER_GC_LOGIN:
  2776. {
  2777. TPacketGCMessengerLogin p;
  2778. if (!Recv(sizeof(p),&p))
  2779. return false;
  2780. if (!Recv(p.length, char_name))
  2781. return false;
  2782. char_name[p.length] = 0;
  2783. CPythonMessenger::Instance().OnFriendLogin(char_name);
  2784. __RefreshTargetBoardByName(char_name);
  2785. break;
  2786. }
  2787.  
  2788. case MESSENGER_SUBHEADER_GC_LOGOUT:
  2789. {
  2790. TPacketGCMessengerLogout logout;
  2791. if (!Recv(sizeof(logout),&logout))
  2792. return false;
  2793. if (!Recv(logout.length, char_name))
  2794. return false;
  2795. char_name[logout.length] = 0;
  2796. CPythonMessenger::Instance().OnFriendLogout(char_name);
  2797. break;
  2798. }
  2799.  
  2800. case MESSENGER_SUBHEADER_GC_MOBILE:
  2801. {
  2802. BYTE byState; // 모바일 번호가 없어졌는지 플래그
  2803. BYTE byLength;
  2804. if (!Recv(sizeof(byState), &byState))
  2805. return false;
  2806. if (!Recv(sizeof(byLength), &byLength))
  2807. return false;
  2808. if (!Recv(byLength, char_name))
  2809. return false;
  2810. char_name[byLength] = 0;
  2811. CPythonMessenger::Instance().SetMobile(char_name, byState);
  2812. break;
  2813. }
  2814. }
  2815. return true;
  2816. }
  2817.  
  2818. //////////////////////////////////////////////////////////////////////////
  2819. // Party
  2820.  
  2821. bool CPythonNetworkStream::SendPartyInvitePacket(DWORD dwVID)
  2822. {
  2823. TPacketCGPartyInvite kPartyInvitePacket;
  2824. kPartyInvitePacket.header = HEADER_CG_PARTY_INVITE;
  2825. kPartyInvitePacket.vid = dwVID;
  2826.  
  2827. if (!Send(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
  2828. {
  2829. Tracenf("CPythonNetworkStream::SendPartyInvitePacket [%ud] - PACKET SEND ERROR", dwVID);
  2830. return false;
  2831. }
  2832.  
  2833. Tracef(" << SendPartyInvitePacket : %d\n", dwVID);
  2834. return SendSequence();
  2835. }
  2836.  
  2837. bool CPythonNetworkStream::SendPartyInviteAnswerPacket(DWORD dwLeaderVID, BYTE byAnswer)
  2838. {
  2839. TPacketCGPartyInviteAnswer kPartyInviteAnswerPacket;
  2840. kPartyInviteAnswerPacket.header = HEADER_CG_PARTY_INVITE_ANSWER;
  2841. kPartyInviteAnswerPacket.leader_pid = dwLeaderVID;
  2842. kPartyInviteAnswerPacket.accept = byAnswer;
  2843.  
  2844. if (!Send(sizeof(kPartyInviteAnswerPacket), &kPartyInviteAnswerPacket))
  2845. {
  2846. Tracenf("CPythonNetworkStream::SendPartyInviteAnswerPacket [%ud %ud] - PACKET SEND ERROR", dwLeaderVID, byAnswer);
  2847. return false;
  2848. }
  2849.  
  2850. Tracef(" << SendPartyInviteAnswerPacket : %d, %d\n", dwLeaderVID, byAnswer);
  2851. return SendSequence();
  2852. }
  2853.  
  2854. bool CPythonNetworkStream::SendPartyRemovePacket(DWORD dwPID)
  2855. {
  2856. TPacketCGPartyRemove kPartyInviteRemove;
  2857. kPartyInviteRemove.header = HEADER_CG_PARTY_REMOVE;
  2858. kPartyInviteRemove.pid = dwPID;
  2859.  
  2860. if (!Send(sizeof(kPartyInviteRemove), &kPartyInviteRemove))
  2861. {
  2862. Tracenf("CPythonNetworkStream::SendPartyRemovePacket [%ud] - PACKET SEND ERROR", dwPID);
  2863. return false;
  2864. }
  2865.  
  2866. Tracef(" << SendPartyRemovePacket : %d\n", dwPID);
  2867. return SendSequence();
  2868. }
  2869.  
  2870. bool CPythonNetworkStream::SendPartySetStatePacket(DWORD dwVID, BYTE byState, BYTE byFlag)
  2871. {
  2872. TPacketCGPartySetState kPartySetState;
  2873. kPartySetState.byHeader = HEADER_CG_PARTY_SET_STATE;
  2874. kPartySetState.dwVID = dwVID;
  2875. kPartySetState.byState = byState;
  2876. kPartySetState.byFlag = byFlag;
  2877.  
  2878. if (!Send(sizeof(kPartySetState), &kPartySetState))
  2879. {
  2880. Tracenf("CPythonNetworkStream::SendPartySetStatePacket(%ud, %ud) - PACKET SEND ERROR", dwVID, byState);
  2881. return false;
  2882. }
  2883.  
  2884. Tracef(" << SendPartySetStatePacket : %d, %d, %d\n", dwVID, byState, byFlag);
  2885. return SendSequence();
  2886. }
  2887.  
  2888. bool CPythonNetworkStream::SendPartyUseSkillPacket(BYTE bySkillIndex, DWORD dwVID)
  2889. {
  2890. TPacketCGPartyUseSkill kPartyUseSkill;
  2891. kPartyUseSkill.byHeader = HEADER_CG_PARTY_USE_SKILL;
  2892. kPartyUseSkill.bySkillIndex = bySkillIndex;
  2893. kPartyUseSkill.dwTargetVID = dwVID;
  2894.  
  2895. if (!Send(sizeof(kPartyUseSkill), &kPartyUseSkill))
  2896. {
  2897. Tracenf("CPythonNetworkStream::SendPartyUseSkillPacket(%ud, %ud) - PACKET SEND ERROR", bySkillIndex, dwVID);
  2898. return false;
  2899. }
  2900.  
  2901. Tracef(" << SendPartyUseSkillPacket : %d, %d\n", bySkillIndex, dwVID);
  2902. return SendSequence();
  2903. }
  2904.  
  2905. bool CPythonNetworkStream::SendPartyParameterPacket(BYTE byDistributeMode)
  2906. {
  2907. TPacketCGPartyParameter kPartyParameter;
  2908. kPartyParameter.bHeader = HEADER_CG_PARTY_PARAMETER;
  2909. kPartyParameter.bDistributeMode = byDistributeMode;
  2910.  
  2911. if (!Send(sizeof(kPartyParameter), &kPartyParameter))
  2912. {
  2913. Tracenf("CPythonNetworkStream::SendPartyParameterPacket(%d) - PACKET SEND ERROR", byDistributeMode);
  2914. return false;
  2915. }
  2916.  
  2917. Tracef(" << SendPartyParameterPacket : %d\n", byDistributeMode);
  2918. return SendSequence();
  2919. }
  2920.  
  2921. bool CPythonNetworkStream::RecvPartyInvite()
  2922. {
  2923. TPacketGCPartyInvite kPartyInvitePacket;
  2924. if (!Recv(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
  2925. return false;
  2926.  
  2927. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kPartyInvitePacket.leader_pid);
  2928. if (!pInstance)
  2929. {
  2930. TraceError(" CPythonNetworkStream::RecvPartyInvite - Failed to find leader instance [%d]\n", kPartyInvitePacket.leader_pid);
  2931. return true;
  2932. }
  2933.  
  2934. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvPartyInviteQuestion", Py_BuildValue("(is)", kPartyInvitePacket.leader_pid, pInstance->GetNameString()));
  2935. Tracef(" >> RecvPartyInvite : %d, %s\n", kPartyInvitePacket.leader_pid, pInstance->GetNameString());
  2936.  
  2937. return true;
  2938. }
  2939.  
  2940. bool CPythonNetworkStream::RecvPartyAdd()
  2941. {
  2942. TPacketGCPartyAdd kPartyAddPacket;
  2943. if (!Recv(sizeof(kPartyAddPacket), &kPartyAddPacket))
  2944. return false;
  2945.  
  2946. CPythonPlayer::Instance().AppendPartyMember(kPartyAddPacket.pid, kPartyAddPacket.name);
  2947. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AddPartyMember", Py_BuildValue("(is)", kPartyAddPacket.pid, kPartyAddPacket.name));
  2948. Tracef(" >> RecvPartyAdd : %d, %s\n", kPartyAddPacket.pid, kPartyAddPacket.name);
  2949.  
  2950. return true;
  2951. }
  2952.  
  2953. bool CPythonNetworkStream::RecvPartyUpdate()
  2954. {
  2955. TPacketGCPartyUpdate kPartyUpdatePacket;
  2956. if (!Recv(sizeof(kPartyUpdatePacket), &kPartyUpdatePacket))
  2957. return false;
  2958.  
  2959. CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
  2960. if (!CPythonPlayer::Instance().GetPartyMemberPtr(kPartyUpdatePacket.pid, &pPartyMemberInfo))
  2961. return true;
  2962.  
  2963. BYTE byOldState = pPartyMemberInfo->byState;
  2964.  
  2965. CPythonPlayer::Instance().UpdatePartyMemberInfo(kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
  2966. for (int i = 0; i < PARTY_AFFECT_SLOT_MAX_NUM; ++i)
  2967. {
  2968. CPythonPlayer::Instance().UpdatePartyMemberAffect(kPartyUpdatePacket.pid, i, kPartyUpdatePacket.affects[i]);
  2969. }
  2970.  
  2971. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UpdatePartyMemberInfo", Py_BuildValue("(i)", kPartyUpdatePacket.pid));
  2972.  
  2973. // 만약 리더가 바뀌었다면, TargetBoard 의 버튼을 업데이트 한다.
  2974. DWORD dwVID;
  2975. if (CPythonPlayer::Instance().PartyMemberPIDToVID(kPartyUpdatePacket.pid, &dwVID))
  2976. if (byOldState != kPartyUpdatePacket.state)
  2977. {
  2978. __RefreshTargetBoardByVID(dwVID);
  2979. }
  2980.  
  2981. // Tracef(" >> RecvPartyUpdate : %d, %d, %d\n", kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
  2982.  
  2983. return true;
  2984. }
  2985.  
  2986. bool CPythonNetworkStream::RecvPartyRemove()
  2987. {
  2988. TPacketGCPartyRemove kPartyRemovePacket;
  2989. if (!Recv(sizeof(kPartyRemovePacket), &kPartyRemovePacket))
  2990. return false;
  2991.  
  2992. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RemovePartyMember", Py_BuildValue("(i)", kPartyRemovePacket.pid));
  2993. Tracef(" >> RecvPartyRemove : %d\n", kPartyRemovePacket.pid);
  2994.  
  2995. return true;
  2996. }
  2997.  
  2998. bool CPythonNetworkStream::RecvPartyLink()
  2999. {
  3000. TPacketGCPartyLink kPartyLinkPacket;
  3001. if (!Recv(sizeof(kPartyLinkPacket), &kPartyLinkPacket))
  3002. return false;
  3003.  
  3004. CPythonPlayer::Instance().LinkPartyMember(kPartyLinkPacket.pid, kPartyLinkPacket.vid);
  3005. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "LinkPartyMember", Py_BuildValue("(ii)", kPartyLinkPacket.pid, kPartyLinkPacket.vid));
  3006. Tracef(" >> RecvPartyLink : %d, %d\n", kPartyLinkPacket.pid, kPartyLinkPacket.vid);
  3007.  
  3008. return true;
  3009. }
  3010.  
  3011. bool CPythonNetworkStream::RecvPartyUnlink()
  3012. {
  3013. TPacketGCPartyUnlink kPartyUnlinkPacket;
  3014. if (!Recv(sizeof(kPartyUnlinkPacket), &kPartyUnlinkPacket))
  3015. return false;
  3016.  
  3017. CPythonPlayer::Instance().UnlinkPartyMember(kPartyUnlinkPacket.pid);
  3018.  
  3019. if (CPythonPlayer::Instance().IsMainCharacterIndex(kPartyUnlinkPacket.vid))
  3020. {
  3021. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkAllPartyMember", Py_BuildValue("()"));
  3022. }
  3023. else
  3024. {
  3025. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkPartyMember", Py_BuildValue("(i)", kPartyUnlinkPacket.pid));
  3026. }
  3027.  
  3028. Tracef(" >> RecvPartyUnlink : %d, %d\n", kPartyUnlinkPacket.pid, kPartyUnlinkPacket.vid);
  3029.  
  3030. return true;
  3031. }
  3032.  
  3033. bool CPythonNetworkStream::RecvPartyParameter()
  3034. {
  3035. TPacketGCPartyParameter kPartyParameterPacket;
  3036. if (!Recv(sizeof(kPartyParameterPacket), &kPartyParameterPacket))
  3037. return false;
  3038.  
  3039. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ChangePartyParameter", Py_BuildValue("(i)", kPartyParameterPacket.bDistributeMode));
  3040. Tracef(" >> RecvPartyParameter : %d\n", kPartyParameterPacket.bDistributeMode);
  3041.  
  3042. return true;
  3043. }
  3044.  
  3045. // Party
  3046. //////////////////////////////////////////////////////////////////////////
  3047.  
  3048.  
  3049. //////////////////////////////////////////////////////////////////////////
  3050. // Guild
  3051.  
  3052. bool CPythonNetworkStream::SendGuildAddMemberPacket(DWORD dwVID)
  3053. {
  3054. TPacketCGGuild GuildPacket;
  3055. GuildPacket.byHeader = HEADER_CG_GUILD;
  3056. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_ADD_MEMBER;
  3057. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3058. return false;
  3059. if (!Send(sizeof(dwVID), &dwVID))
  3060. return false;
  3061.  
  3062. Tracef(" SendGuildAddMemberPacket\n", dwVID);
  3063. return SendSequence();
  3064. }
  3065.  
  3066. bool CPythonNetworkStream::SendGuildRemoveMemberPacket(DWORD dwPID)
  3067. {
  3068. TPacketCGGuild GuildPacket;
  3069. GuildPacket.byHeader = HEADER_CG_GUILD;
  3070. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REMOVE_MEMBER;
  3071. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3072. return false;
  3073. if (!Send(sizeof(dwPID), &dwPID))
  3074. return false;
  3075.  
  3076. Tracef(" SendGuildRemoveMemberPacket %d\n", dwPID);
  3077. return SendSequence();
  3078. }
  3079.  
  3080. bool CPythonNetworkStream::SendGuildChangeGradeNamePacket(BYTE byGradeNumber, const char * c_szName)
  3081. {
  3082. TPacketCGGuild GuildPacket;
  3083. GuildPacket.byHeader = HEADER_CG_GUILD;
  3084. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME;
  3085. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3086. return false;
  3087. if (!Send(sizeof(byGradeNumber), &byGradeNumber))
  3088. return false;
  3089.  
  3090. char szName[GUILD_GRADE_NAME_MAX_LEN+1];
  3091. strncpy(szName, c_szName, GUILD_GRADE_NAME_MAX_LEN);
  3092. szName[GUILD_GRADE_NAME_MAX_LEN] = '\0';
  3093.  
  3094. if (!Send(sizeof(szName), &szName))
  3095. return false;
  3096.  
  3097. Tracef(" SendGuildChangeGradeNamePacket %d, %s\n", byGradeNumber, c_szName);
  3098. return SendSequence();
  3099. }
  3100.  
  3101. bool CPythonNetworkStream::SendGuildChangeGradeAuthorityPacket(BYTE byGradeNumber, BYTE byAuthority)
  3102. {
  3103. TPacketCGGuild GuildPacket;
  3104. GuildPacket.byHeader = HEADER_CG_GUILD;
  3105. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY;
  3106. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3107. return false;
  3108. if (!Send(sizeof(byGradeNumber), &byGradeNumber))
  3109. return false;
  3110. if (!Send(sizeof(byAuthority), &byAuthority))
  3111. return false;
  3112.  
  3113. Tracef(" SendGuildChangeGradeAuthorityPacket %d, %d\n", byGradeNumber, byAuthority);
  3114. return SendSequence();
  3115. }
  3116.  
  3117. bool CPythonNetworkStream::SendGuildOfferPacket(DWORD dwExperience)
  3118. {
  3119. TPacketCGGuild GuildPacket;
  3120. GuildPacket.byHeader = HEADER_CG_GUILD;
  3121. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_OFFER;
  3122. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3123. return false;
  3124. if (!Send(sizeof(dwExperience), &dwExperience))
  3125. return false;
  3126.  
  3127. Tracef(" SendGuildOfferPacket %d\n", dwExperience);
  3128. return SendSequence();
  3129. }
  3130.  
  3131. bool CPythonNetworkStream::SendGuildPostCommentPacket(const char * c_szMessage)
  3132. {
  3133. TPacketCGGuild GuildPacket;
  3134. GuildPacket.byHeader = HEADER_CG_GUILD;
  3135. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_POST_COMMENT;
  3136. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3137. return false;
  3138.  
  3139. BYTE bySize = BYTE(strlen(c_szMessage)) + 1;
  3140. if (!Send(sizeof(bySize), &bySize))
  3141. return false;
  3142. if (!Send(bySize, c_szMessage))
  3143. return false;
  3144.  
  3145. Tracef(" SendGuildPostCommentPacket %d, %s\n", bySize, c_szMessage);
  3146. return SendSequence();
  3147. }
  3148.  
  3149. bool CPythonNetworkStream::SendGuildDeleteCommentPacket(DWORD dwIndex)
  3150. {
  3151. TPacketCGGuild GuildPacket;
  3152. GuildPacket.byHeader = HEADER_CG_GUILD;
  3153. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DELETE_COMMENT;
  3154. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3155. return false;
  3156.  
  3157. if (!Send(sizeof(dwIndex), &dwIndex))
  3158. return false;
  3159.  
  3160. Tracef(" SendGuildDeleteCommentPacket %d\n", dwIndex);
  3161. return SendSequence();
  3162. }
  3163.  
  3164. bool CPythonNetworkStream::SendGuildRefreshCommentsPacket(DWORD dwHighestIndex)
  3165. {
  3166. static DWORD s_LastTime = timeGetTime() - 1001;
  3167.  
  3168. if (timeGetTime() - s_LastTime < 1000)
  3169. return true;
  3170. s_LastTime = timeGetTime();
  3171.  
  3172. TPacketCGGuild GuildPacket;
  3173. GuildPacket.byHeader = HEADER_CG_GUILD;
  3174. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REFRESH_COMMENT;
  3175. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3176. return false;
  3177.  
  3178. Tracef(" SendGuildRefreshCommentPacket %d\n", dwHighestIndex);
  3179. return SendSequence();
  3180. }
  3181.  
  3182. bool CPythonNetworkStream::SendGuildChangeMemberGradePacket(DWORD dwPID, BYTE byGrade)
  3183. {
  3184. TPacketCGGuild GuildPacket;
  3185. GuildPacket.byHeader = HEADER_CG_GUILD;
  3186. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE;
  3187. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3188. return false;
  3189.  
  3190. if (!Send(sizeof(dwPID), &dwPID))
  3191. return false;
  3192. if (!Send(sizeof(byGrade), &byGrade))
  3193. return false;
  3194.  
  3195. Tracef(" SendGuildChangeMemberGradePacket %d, %d\n", dwPID, byGrade);
  3196. return SendSequence();
  3197. }
  3198.  
  3199. bool CPythonNetworkStream::SendGuildUseSkillPacket(DWORD dwSkillID, DWORD dwTargetVID)
  3200. {
  3201. TPacketCGGuild GuildPacket;
  3202. GuildPacket.byHeader = HEADER_CG_GUILD;
  3203. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_USE_SKILL;
  3204. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3205. return false;
  3206.  
  3207. if (!Send(sizeof(dwSkillID), &dwSkillID))
  3208. return false;
  3209. if (!Send(sizeof(dwTargetVID), &dwTargetVID))
  3210. return false;
  3211.  
  3212. Tracef(" SendGuildUseSkillPacket %d, %d\n", dwSkillID, dwTargetVID);
  3213. return SendSequence();
  3214. }
  3215.  
  3216. bool CPythonNetworkStream::SendGuildChangeMemberGeneralPacket(DWORD dwPID, BYTE byFlag)
  3217. {
  3218. TPacketCGGuild GuildPacket;
  3219. GuildPacket.byHeader = HEADER_CG_GUILD;
  3220. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL;
  3221. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3222. return false;
  3223.  
  3224. if (!Send(sizeof(dwPID), &dwPID))
  3225. return false;
  3226. if (!Send(sizeof(byFlag), &byFlag))
  3227. return false;
  3228.  
  3229. Tracef(" SendGuildChangeMemberGeneralFlagPacket %d, %d\n", dwPID, byFlag);
  3230. return SendSequence();
  3231. }
  3232.  
  3233. bool CPythonNetworkStream::SendGuildInviteAnswerPacket(DWORD dwGuildID, BYTE byAnswer)
  3234. {
  3235. TPacketCGGuild GuildPacket;
  3236. GuildPacket.byHeader = HEADER_CG_GUILD;
  3237. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER;
  3238. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3239. return false;
  3240.  
  3241. if (!Send(sizeof(dwGuildID), &dwGuildID))
  3242. return false;
  3243. if (!Send(sizeof(byAnswer), &byAnswer))
  3244. return false;
  3245.  
  3246. Tracef(" SendGuildInviteAnswerPacket %d, %d\n", dwGuildID, byAnswer);
  3247. return SendSequence();
  3248. }
  3249.  
  3250. bool CPythonNetworkStream::SendGuildChargeGSPPacket(DWORD dwMoney)
  3251. {
  3252. TPacketCGGuild GuildPacket;
  3253. GuildPacket.byHeader = HEADER_CG_GUILD;
  3254. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHARGE_GSP;
  3255. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3256. return false;
  3257.  
  3258. if (!Send(sizeof(dwMoney), &dwMoney))
  3259. return false;
  3260.  
  3261. Tracef(" SendGuildChargeGSPPacket %d\n", dwMoney);
  3262. return SendSequence();
  3263. }
  3264.  
  3265. bool CPythonNetworkStream::SendGuildDepositMoneyPacket(DWORD dwMoney)
  3266. {
  3267. TPacketCGGuild GuildPacket;
  3268. GuildPacket.byHeader = HEADER_CG_GUILD;
  3269. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DEPOSIT_MONEY;
  3270. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3271. return false;
  3272. if (!Send(sizeof(dwMoney), &dwMoney))
  3273. return false;
  3274.  
  3275. Tracef(" SendGuildDepositMoneyPacket %d\n", dwMoney);
  3276. return SendSequence();
  3277. }
  3278.  
  3279. bool CPythonNetworkStream::SendGuildWithdrawMoneyPacket(DWORD dwMoney)
  3280. {
  3281. TPacketCGGuild GuildPacket;
  3282. GuildPacket.byHeader = HEADER_CG_GUILD;
  3283. GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_WITHDRAW_MONEY;
  3284. if (!Send(sizeof(GuildPacket), &GuildPacket))
  3285. return false;
  3286. if (!Send(sizeof(dwMoney), &dwMoney))
  3287. return false;
  3288.  
  3289. Tracef(" SendGuildWithdrawMoneyPacket %d\n", dwMoney);
  3290. return SendSequence();
  3291. }
  3292.  
  3293. bool CPythonNetworkStream::RecvGuild()
  3294. {
  3295. TPacketGCGuild GuildPacket;
  3296. if (!Recv(sizeof(GuildPacket), &GuildPacket))
  3297. return false;
  3298.  
  3299. switch(GuildPacket.subheader)
  3300. {
  3301. case GUILD_SUBHEADER_GC_LOGIN:
  3302. {
  3303. DWORD dwPID;
  3304. if (!Recv(sizeof(DWORD), &dwPID))
  3305. return false;
  3306.  
  3307. // Messenger
  3308. CPythonGuild::TGuildMemberData * pGuildMemberData;
  3309. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
  3310. if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
  3311. CPythonMessenger::Instance().LoginGuildMember(pGuildMemberData->strName.c_str());
  3312.  
  3313. //Tracef(" <Login> %d\n", dwPID);
  3314. break;
  3315. }
  3316. case GUILD_SUBHEADER_GC_LOGOUT:
  3317. {
  3318. DWORD dwPID;
  3319. if (!Recv(sizeof(DWORD), &dwPID))
  3320. return false;
  3321.  
  3322. // Messenger
  3323. CPythonGuild::TGuildMemberData * pGuildMemberData;
  3324. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
  3325. if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
  3326. CPythonMessenger::Instance().LogoutGuildMember(pGuildMemberData->strName.c_str());
  3327.  
  3328. //Tracef(" <Logout> %d\n", dwPID);
  3329. break;
  3330. }
  3331. case GUILD_SUBHEADER_GC_REMOVE:
  3332. {
  3333. DWORD dwPID;
  3334. if (!Recv(sizeof(dwPID), &dwPID))
  3335. return false;
  3336.  
  3337. // Main Player 일 경우 DeleteGuild
  3338. if (CPythonGuild::Instance().IsMainPlayer(dwPID))
  3339. {
  3340. CPythonGuild::Instance().Destroy();
  3341. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "DeleteGuild", Py_BuildValue("()"));
  3342. CPythonMessenger::Instance().RemoveAllGuildMember();
  3343. __SetGuildID(0);
  3344. __RefreshMessengerWindow();
  3345. __RefreshTargetBoard();
  3346. __RefreshCharacterWindow();
  3347. }
  3348. else
  3349. {
  3350. // Get Member Name
  3351. std::string strMemberName = "";
  3352. CPythonGuild::TGuildMemberData * pData;
  3353. if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pData))
  3354. {
  3355. strMemberName = pData->strName;
  3356. CPythonMessenger::Instance().RemoveGuildMember(pData->strName.c_str());
  3357. }
  3358.  
  3359. CPythonGuild::Instance().RemoveMember(dwPID);
  3360.  
  3361. // Refresh
  3362. __RefreshTargetBoardByName(strMemberName.c_str());
  3363. __RefreshGuildWindowMemberPage();
  3364. }
  3365.  
  3366. Tracef(" <Remove> %d\n", dwPID);
  3367. break;
  3368. }
  3369. case GUILD_SUBHEADER_GC_LIST:
  3370. {
  3371. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3372.  
  3373. for (; iPacketSize > 0;)
  3374. {
  3375. TPacketGCGuildSubMember memberPacket;
  3376. if (!Recv(sizeof(memberPacket), &memberPacket))
  3377. return false;
  3378.  
  3379. char szName[CHARACTER_NAME_MAX_LEN+1] = "";
  3380. if (memberPacket.byNameFlag)
  3381. {
  3382. if (!Recv(sizeof(szName), &szName))
  3383. return false;
  3384.  
  3385. iPacketSize -= CHARACTER_NAME_MAX_LEN+1;
  3386. }
  3387. else
  3388. {
  3389. CPythonGuild::TGuildMemberData * pMemberData;
  3390. if (CPythonGuild::Instance().GetMemberDataPtrByPID(memberPacket.pid, &pMemberData))
  3391. {
  3392. strncpy(szName, pMemberData->strName.c_str(), CHARACTER_NAME_MAX_LEN);
  3393. }
  3394. }
  3395.  
  3396. //Tracef(" <List> %d : %s, %d (%d, %d, %d)\n", memberPacket.pid, szName, memberPacket.byGrade, memberPacket.byJob, memberPacket.byLevel, memberPacket.dwOffer);
  3397.  
  3398. CPythonGuild::SGuildMemberData GuildMemberData;
  3399. GuildMemberData.dwPID = memberPacket.pid;
  3400. GuildMemberData.byGrade = memberPacket.byGrade;
  3401. GuildMemberData.strName = szName;
  3402. GuildMemberData.byJob = memberPacket.byJob;
  3403. GuildMemberData.byLevel = memberPacket.byLevel;
  3404. GuildMemberData.dwOffer = memberPacket.dwOffer;
  3405. GuildMemberData.byGeneralFlag = memberPacket.byIsGeneral;
  3406. CPythonGuild::Instance().RegisterMember(GuildMemberData);
  3407.  
  3408. // Messenger
  3409. if (strcmp(szName, CPythonPlayer::Instance().GetName()))
  3410. CPythonMessenger::Instance().AppendGuildMember(szName);
  3411.  
  3412. __RefreshTargetBoardByName(szName);
  3413.  
  3414. iPacketSize -= sizeof(memberPacket);
  3415. }
  3416.  
  3417. __RefreshGuildWindowInfoPage();
  3418. __RefreshGuildWindowMemberPage();
  3419. __RefreshMessengerWindow();
  3420. __RefreshCharacterWindow();
  3421. break;
  3422. }
  3423. case GUILD_SUBHEADER_GC_GRADE:
  3424. {
  3425. BYTE byCount;
  3426. if (!Recv(sizeof(byCount), &byCount))
  3427. return false;
  3428.  
  3429. for (BYTE i = 0; i < byCount; ++ i)
  3430. {
  3431. BYTE byIndex;
  3432. if (!Recv(sizeof(byCount), &byIndex))
  3433. return false;
  3434. TPacketGCGuildSubGrade GradePacket;
  3435. if (!Recv(sizeof(GradePacket), &GradePacket))
  3436. return false;
  3437.  
  3438. CPythonGuild::Instance().SetGradeData(byIndex, CPythonGuild::SGuildGradeData(GradePacket.auth_flag, GradePacket.grade_name));
  3439. //Tracef(" <Grade> [%d/%d] : %s, %d\n", byIndex, byCount, GradePacket.grade_name, GradePacket.auth_flag);
  3440. }
  3441. __RefreshGuildWindowGradePage();
  3442. __RefreshGuildWindowMemberPageGradeComboBox();
  3443. break;
  3444. }
  3445. case GUILD_SUBHEADER_GC_GRADE_NAME:
  3446. {
  3447. BYTE byGradeNumber;
  3448. if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
  3449. return false;
  3450.  
  3451. char szGradeName[GUILD_GRADE_NAME_MAX_LEN+1] = "";
  3452. if (!Recv(sizeof(szGradeName), &szGradeName))
  3453. return false;
  3454.  
  3455. CPythonGuild::Instance().SetGradeName(byGradeNumber, szGradeName);
  3456. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
  3457.  
  3458. Tracef(" <Change Grade Name> %d, %s\n", byGradeNumber, szGradeName);
  3459. __RefreshGuildWindowGradePage();
  3460. __RefreshGuildWindowMemberPageGradeComboBox();
  3461. break;
  3462. }
  3463. case GUILD_SUBHEADER_GC_GRADE_AUTH:
  3464. {
  3465. BYTE byGradeNumber;
  3466. if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
  3467. return false;
  3468. BYTE byAuthorityFlag;
  3469. if (!Recv(sizeof(byAuthorityFlag), &byAuthorityFlag))
  3470. return false;
  3471.  
  3472. CPythonGuild::Instance().SetGradeAuthority(byGradeNumber, byAuthorityFlag);
  3473. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
  3474.  
  3475. Tracef(" <Change Grade Authority> %d, %d\n", byGradeNumber, byAuthorityFlag);
  3476. __RefreshGuildWindowGradePage();
  3477. break;
  3478. }
  3479. case GUILD_SUBHEADER_GC_INFO:
  3480. {
  3481. TPacketGCGuildInfo GuildInfo;
  3482. if (!Recv(sizeof(GuildInfo), &GuildInfo))
  3483. return false;
  3484.  
  3485. CPythonGuild::Instance().EnableGuild();
  3486. CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
  3487. strncpy(rGuildInfo.szGuildName, GuildInfo.name, GUILD_NAME_MAX_LEN);
  3488. rGuildInfo.szGuildName[GUILD_NAME_MAX_LEN] = '\0';
  3489.  
  3490. rGuildInfo.dwGuildID = GuildInfo.guild_id;
  3491. rGuildInfo.dwMasterPID = GuildInfo.master_pid;
  3492. rGuildInfo.dwGuildLevel = GuildInfo.level;
  3493. rGuildInfo.dwCurrentExperience = GuildInfo.exp;
  3494. rGuildInfo.dwCurrentMemberCount = GuildInfo.member_count;
  3495. rGuildInfo.dwMaxMemberCount = GuildInfo.max_member_count;
  3496. rGuildInfo.dwGuildMoney = GuildInfo.gold;
  3497. rGuildInfo.bHasLand = GuildInfo.hasLand;
  3498.  
  3499. //Tracef(" <Info> %s, %d, %d : %d\n", GuildInfo.name, GuildInfo.master_pid, GuildInfo.level, rGuildInfo.bHasLand);
  3500. __RefreshGuildWindowInfoPage();
  3501. break;
  3502. }
  3503. case GUILD_SUBHEADER_GC_COMMENTS:
  3504. {
  3505. BYTE byCount;
  3506. if (!Recv(sizeof(byCount), &byCount))
  3507. return false;
  3508.  
  3509. CPythonGuild::Instance().ClearComment();
  3510. //Tracef(" >>> Comments Count : %d\n", byCount);
  3511.  
  3512. for (BYTE i = 0; i < byCount; ++i)
  3513. {
  3514. DWORD dwCommentID;
  3515. if (!Recv(sizeof(dwCommentID), &dwCommentID))
  3516. return false;
  3517.  
  3518. char szName[CHARACTER_NAME_MAX_LEN+1] = "";
  3519. if (!Recv(sizeof(szName), &szName))
  3520. return false;
  3521.  
  3522. char szComment[GULID_COMMENT_MAX_LEN+1] = "";
  3523. if (!Recv(sizeof(szComment), &szComment))
  3524. return false;
  3525.  
  3526. //Tracef(" [Comment-%d] : %s, %s\n", dwCommentID, szName, szComment);
  3527. CPythonGuild::Instance().RegisterComment(dwCommentID, szName, szComment);
  3528. }
  3529.  
  3530. __RefreshGuildWindowBoardPage();
  3531. break;
  3532. }
  3533. case GUILD_SUBHEADER_GC_CHANGE_EXP:
  3534. {
  3535. BYTE byLevel;
  3536. if (!Recv(sizeof(byLevel), &byLevel))
  3537. return false;
  3538. DWORD dwEXP;
  3539. if (!Recv(sizeof(dwEXP), &dwEXP))
  3540. return false;
  3541. CPythonGuild::Instance().SetGuildEXP(byLevel, dwEXP);
  3542. Tracef(" <ChangeEXP> %d, %d\n", byLevel, dwEXP);
  3543. __RefreshGuildWindowInfoPage();
  3544. break;
  3545. }
  3546. case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE:
  3547. {
  3548. DWORD dwPID;
  3549. if (!Recv(sizeof(dwPID), &dwPID))
  3550. return false;
  3551. BYTE byGrade;
  3552. if (!Recv(sizeof(byGrade), &byGrade))
  3553. return false;
  3554. CPythonGuild::Instance().ChangeGuildMemberGrade(dwPID, byGrade);
  3555. Tracef(" <ChangeMemberGrade> %d, %d\n", dwPID, byGrade);
  3556. __RefreshGuildWindowMemberPage();
  3557. break;
  3558. }
  3559. case GUILD_SUBHEADER_GC_SKILL_INFO:
  3560. {
  3561. CPythonGuild::TGuildSkillData & rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
  3562. if (!Recv(sizeof(rSkillData.bySkillPoint), &rSkillData.bySkillPoint))
  3563. return false;
  3564. if (!Recv(sizeof(rSkillData.bySkillLevel), rSkillData.bySkillLevel))
  3565. return false;
  3566. if (!Recv(sizeof(rSkillData.wGuildPoint), &rSkillData.wGuildPoint))
  3567. return false;
  3568. if (!Recv(sizeof(rSkillData.wMaxGuildPoint), &rSkillData.wMaxGuildPoint))
  3569. return false;
  3570.  
  3571. Tracef(" <SkillInfo> %d / %d, %d\n", rSkillData.bySkillPoint, rSkillData.wGuildPoint, rSkillData.wMaxGuildPoint);
  3572. __RefreshGuildWindowSkillPage();
  3573. break;
  3574. }
  3575. case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL:
  3576. {
  3577. DWORD dwPID;
  3578. if (!Recv(sizeof(dwPID), &dwPID))
  3579. return false;
  3580. BYTE byFlag;
  3581. if (!Recv(sizeof(byFlag), &byFlag))
  3582. return false;
  3583.  
  3584. CPythonGuild::Instance().ChangeGuildMemberGeneralFlag(dwPID, byFlag);
  3585. Tracef(" <ChangeMemberGeneralFlag> %d, %d\n", dwPID, byFlag);
  3586. __RefreshGuildWindowMemberPage();
  3587. break;
  3588. }
  3589. case GUILD_SUBHEADER_GC_GUILD_INVITE:
  3590. {
  3591. DWORD dwGuildID;
  3592. if (!Recv(sizeof(dwGuildID), &dwGuildID))
  3593. return false;
  3594. char szGuildName[GUILD_NAME_MAX_LEN+1];
  3595. if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
  3596. return false;
  3597.  
  3598. szGuildName[GUILD_NAME_MAX_LEN] = 0;
  3599.  
  3600. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvGuildInviteQuestion", Py_BuildValue("(is)", dwGuildID, szGuildName));
  3601. Tracef(" <Guild Invite> %d, %s\n", dwGuildID, szGuildName);
  3602. break;
  3603. }
  3604. case GUILD_SUBHEADER_GC_WAR:
  3605. {
  3606. TPacketGCGuildWar kGuildWar;
  3607. if (!Recv(sizeof(kGuildWar), &kGuildWar))
  3608. return false;
  3609.  
  3610. switch (kGuildWar.bWarState)
  3611. {
  3612. case GUILD_WAR_SEND_DECLARE:
  3613. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_SEND_DECLARE\n");
  3614. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3615. "BINARY_GuildWar_OnSendDeclare",
  3616. Py_BuildValue("(i)", kGuildWar.dwGuildOpp)
  3617. );
  3618. break;
  3619. case GUILD_WAR_RECV_DECLARE:
  3620. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_RECV_DECLARE\n");
  3621. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3622. "BINARY_GuildWar_OnRecvDeclare",
  3623. Py_BuildValue("(ii)", kGuildWar.dwGuildOpp, kGuildWar.bType)
  3624. );
  3625. break;
  3626. case GUILD_WAR_ON_WAR:
  3627. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_ON_WAR : %d, %d\n", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp);
  3628. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3629. "BINARY_GuildWar_OnStart",
  3630. Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
  3631. );
  3632. CPythonGuild::Instance().StartGuildWar(kGuildWar.dwGuildOpp);
  3633. break;
  3634. case GUILD_WAR_END:
  3635. Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_END\n");
  3636. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3637. "BINARY_GuildWar_OnEnd",
  3638. Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
  3639. );
  3640. CPythonGuild::Instance().EndGuildWar(kGuildWar.dwGuildOpp);
  3641. break;
  3642. }
  3643. break;
  3644. }
  3645. case GUILD_SUBHEADER_GC_GUILD_NAME:
  3646. {
  3647. DWORD dwID;
  3648. char szGuildName[GUILD_NAME_MAX_LEN+1];
  3649.  
  3650. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3651.  
  3652. int nItemSize = sizeof(dwID) + GUILD_NAME_MAX_LEN;
  3653.  
  3654. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_NAME");
  3655.  
  3656. for (; iPacketSize > 0;)
  3657. {
  3658. if (!Recv(sizeof(dwID), &dwID))
  3659. return false;
  3660.  
  3661. if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
  3662. return false;
  3663.  
  3664. szGuildName[GUILD_NAME_MAX_LEN] = 0;
  3665.  
  3666. //Tracef(" >> GulidName [%d : %s]\n", dwID, szGuildName);
  3667. CPythonGuild::Instance().RegisterGuildName(dwID, szGuildName);
  3668. iPacketSize -= nItemSize;
  3669. }
  3670. break;
  3671. }
  3672. case GUILD_SUBHEADER_GC_GUILD_WAR_LIST:
  3673. {
  3674. DWORD dwSrcGuildID;
  3675. DWORD dwDstGuildID;
  3676.  
  3677. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3678. int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
  3679.  
  3680. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_LIST");
  3681.  
  3682. for (; iPacketSize > 0;)
  3683. {
  3684. if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
  3685. return false;
  3686.  
  3687. if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
  3688. return false;
  3689.  
  3690. Tracef(" >> GulidWarList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
  3691. CInstanceBase::InsertGVGKey(dwSrcGuildID, dwDstGuildID);
  3692. CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
  3693. iPacketSize -= nItemSize;
  3694. }
  3695. break;
  3696. }
  3697. case GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST:
  3698. {
  3699. DWORD dwSrcGuildID;
  3700. DWORD dwDstGuildID;
  3701.  
  3702. int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
  3703. int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
  3704.  
  3705. assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST");
  3706.  
  3707. for (; iPacketSize > 0;)
  3708. {
  3709.  
  3710. if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
  3711. return false;
  3712.  
  3713. if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
  3714. return false;
  3715.  
  3716. Tracef(" >> GulidWarEndList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
  3717. CInstanceBase::RemoveGVGKey(dwSrcGuildID, dwDstGuildID);
  3718. CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
  3719. iPacketSize -= nItemSize;
  3720. }
  3721. break;
  3722. }
  3723. case GUILD_SUBHEADER_GC_WAR_POINT:
  3724. {
  3725. TPacketGuildWarPoint GuildWarPoint;
  3726. if (!Recv(sizeof(GuildWarPoint), &GuildWarPoint))
  3727. return false;
  3728.  
  3729. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3730. "BINARY_GuildWar_OnRecvPoint",
  3731. Py_BuildValue("(iii)", GuildWarPoint.dwGainGuildID, GuildWarPoint.dwOpponentGuildID, GuildWarPoint.lPoint)
  3732. );
  3733. break;
  3734. }
  3735. case GUILD_SUBHEADER_GC_MONEY_CHANGE:
  3736. {
  3737. DWORD dwMoney;
  3738. if (!Recv(sizeof(dwMoney), &dwMoney))
  3739. return false;
  3740.  
  3741. CPythonGuild::Instance().SetGuildMoney(dwMoney);
  3742.  
  3743. __RefreshGuildWindowInfoPage();
  3744. Tracef(" >> Guild Money Change : %d\n", dwMoney);
  3745. break;
  3746. }
  3747. }
  3748.  
  3749. return true;
  3750. }
  3751.  
  3752. // Guild
  3753. //////////////////////////////////////////////////////////////////////////
  3754.  
  3755.  
  3756. /////////////////////////////////////////////////////////////////////////
  3757. // Fishing
  3758.  
  3759. bool CPythonNetworkStream::SendFishingPacket(int iRotation)
  3760. {
  3761. BYTE byHeader = HEADER_CG_FISHING;
  3762. if (!Send(sizeof(byHeader), &byHeader))
  3763. return false;
  3764. BYTE byPacketRotation = iRotation / 5;
  3765. if (!Send(sizeof(BYTE), &byPacketRotation))
  3766. return false;
  3767.  
  3768. return SendSequence();
  3769. }
  3770.  
  3771. bool CPythonNetworkStream::SendGiveItemPacket(DWORD dwTargetVID, TItemPos ItemPos, int iItemCount)
  3772. {
  3773. TPacketCGGiveItem GiveItemPacket;
  3774. GiveItemPacket.byHeader = HEADER_CG_GIVE_ITEM;
  3775. GiveItemPacket.dwTargetVID = dwTargetVID;
  3776. GiveItemPacket.ItemPos = ItemPos;
  3777. GiveItemPacket.byItemCount = iItemCount;
  3778.  
  3779. if (!Send(sizeof(GiveItemPacket), &GiveItemPacket))
  3780. return false;
  3781.  
  3782. return SendSequence();
  3783. }
  3784.  
  3785. bool CPythonNetworkStream::RecvFishing()
  3786. {
  3787. TPacketGCFishing FishingPacket;
  3788. if (!Recv(sizeof(FishingPacket), &FishingPacket))
  3789. return false;
  3790.  
  3791. CInstanceBase * pFishingInstance = NULL;
  3792. if (FISHING_SUBHEADER_GC_FISH != FishingPacket.subheader)
  3793. {
  3794. pFishingInstance = CPythonCharacterManager::Instance().GetInstancePtr(FishingPacket.info);
  3795. if (!pFishingInstance)
  3796. return true;
  3797. }
  3798.  
  3799. switch (FishingPacket.subheader)
  3800. {
  3801. case FISHING_SUBHEADER_GC_START:
  3802. pFishingInstance->StartFishing(float(FishingPacket.dir) * 5.0f);
  3803. break;
  3804. case FISHING_SUBHEADER_GC_STOP:
  3805. if (pFishingInstance->IsFishing())
  3806. pFishingInstance->StopFishing();
  3807. break;
  3808. case FISHING_SUBHEADER_GC_REACT:
  3809. if (pFishingInstance->IsFishing())
  3810. {
  3811. pFishingInstance->SetFishEmoticon(); // Fish Emoticon
  3812. pFishingInstance->ReactFishing();
  3813. }
  3814. break;
  3815. case FISHING_SUBHEADER_GC_SUCCESS:
  3816. pFishingInstance->CatchSuccess();
  3817. break;
  3818. case FISHING_SUBHEADER_GC_FAIL:
  3819. pFishingInstance->CatchFail();
  3820. if (pFishingInstance == CPythonCharacterManager::Instance().GetMainInstancePtr())
  3821. {
  3822. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingFailure", Py_BuildValue("()"));
  3823. }
  3824. break;
  3825. case FISHING_SUBHEADER_GC_FISH:
  3826. {
  3827. DWORD dwFishID = FishingPacket.info;
  3828.  
  3829. if (0 == FishingPacket.info)
  3830. {
  3831. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotifyUnknown", Py_BuildValue("()"));
  3832. return true;
  3833. }
  3834.  
  3835. CItemData * pItemData;
  3836. if (!CItemManager::Instance().GetItemDataPointer(dwFishID, &pItemData))
  3837. return true;
  3838.  
  3839. CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
  3840. if (!pMainInstance)
  3841. return true;
  3842.  
  3843. if (pMainInstance->IsFishing())
  3844. {
  3845. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotify", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
  3846. }
  3847. else
  3848. {
  3849. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingSuccess", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
  3850. }
  3851. break;
  3852. }
  3853. }
  3854.  
  3855. return true;
  3856. }
  3857. // Fishing
  3858. /////////////////////////////////////////////////////////////////////////
  3859.  
  3860. /////////////////////////////////////////////////////////////////////////
  3861. // Dungeon
  3862. bool CPythonNetworkStream::RecvDungeon()
  3863. {
  3864. TPacketGCDungeon DungeonPacket;
  3865. if (!Recv(sizeof(DungeonPacket), &DungeonPacket))
  3866. return false;
  3867.  
  3868. switch (DungeonPacket.subheader)
  3869. {
  3870. case DUNGEON_SUBHEADER_GC_TIME_ATTACK_START:
  3871. {
  3872. break;
  3873. }
  3874. case DUNGEON_SUBHEADER_GC_DESTINATION_POSITION:
  3875. {
  3876. unsigned long ulx, uly;
  3877. if (!Recv(sizeof(ulx), &ulx))
  3878. return false;
  3879. if (!Recv(sizeof(uly), &uly))
  3880. return false;
  3881.  
  3882. CPythonPlayer::Instance().SetDungeonDestinationPosition(ulx, uly);
  3883. break;
  3884. }
  3885. }
  3886.  
  3887. return true;
  3888. }
  3889. // Dungeon
  3890. /////////////////////////////////////////////////////////////////////////
  3891.  
  3892. /////////////////////////////////////////////////////////////////////////
  3893. // MyShop
  3894. bool CPythonNetworkStream::SendBuildPrivateShopPacket(const char * c_szName, const std::vector<TShopItemTable> & c_rSellingItemStock)
  3895. {
  3896. TPacketCGMyShop packet;
  3897. packet.bHeader = HEADER_CG_MYSHOP;
  3898. strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN);
  3899. packet.bCount = c_rSellingItemStock.size();
  3900. if (!Send(sizeof(packet), &packet))
  3901. return false;
  3902.  
  3903. for (std::vector<TShopItemTable>::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor)
  3904. {
  3905. const TShopItemTable & c_rItem = *itor;
  3906. if (!Send(sizeof(c_rItem), &c_rItem))
  3907. return false;
  3908. }
  3909.  
  3910. return SendSequence();
  3911. }
  3912.  
  3913. bool CPythonNetworkStream::RecvShopSignPacket()
  3914. {
  3915. TPacketGCShopSign p;
  3916. if (!Recv(sizeof(TPacketGCShopSign), &p))
  3917. return false;
  3918.  
  3919. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  3920.  
  3921. if (0 == strlen(p.szSign))
  3922. {
  3923. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3924. "BINARY_PrivateShop_Disappear",
  3925. Py_BuildValue("(i)", p.dwVID)
  3926. );
  3927.  
  3928. if (rkPlayer.IsMainCharacterIndex(p.dwVID))
  3929. rkPlayer.ClosePrivateShop();
  3930. }
  3931. else
  3932. {
  3933. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  3934. "BINARY_PrivateShop_Appear",
  3935. Py_BuildValue("(is)", p.dwVID, p.szSign)
  3936. );
  3937.  
  3938. if (rkPlayer.IsMainCharacterIndex(p.dwVID))
  3939. rkPlayer.OpenPrivateShop();
  3940. }
  3941.  
  3942. return true;
  3943. }
  3944. /////////////////////////////////////////////////////////////////////////
  3945.  
  3946. bool CPythonNetworkStream::RecvTimePacket()
  3947. {
  3948. TPacketGCTime TimePacket;
  3949. if (!Recv(sizeof(TimePacket), &TimePacket))
  3950. return false;
  3951.  
  3952. IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
  3953. rkApp.SetServerTime(TimePacket.time);
  3954.  
  3955. return true;
  3956. }
  3957.  
  3958. bool CPythonNetworkStream::RecvWalkModePacket()
  3959. {
  3960. TPacketGCWalkMode WalkModePacket;
  3961. if (!Recv(sizeof(WalkModePacket), &WalkModePacket))
  3962. return false;
  3963.  
  3964. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(WalkModePacket.vid);
  3965. if (pInstance)
  3966. {
  3967. if (WALKMODE_RUN == WalkModePacket.mode)
  3968. {
  3969. pInstance->SetRunMode();
  3970. }
  3971. else
  3972. {
  3973. pInstance->SetWalkMode();
  3974. }
  3975. }
  3976.  
  3977. return true;
  3978. }
  3979.  
  3980. bool CPythonNetworkStream::RecvChangeSkillGroupPacket()
  3981. {
  3982. TPacketGCChangeSkillGroup ChangeSkillGroup;
  3983. if (!Recv(sizeof(ChangeSkillGroup), &ChangeSkillGroup))
  3984. return false;
  3985.  
  3986. m_dwMainActorSkillGroup = ChangeSkillGroup.skill_group;
  3987.  
  3988. CPythonPlayer::Instance().NEW_ClearSkillData();
  3989. __RefreshCharacterWindow();
  3990. return true;
  3991. }
  3992.  
  3993. void CPythonNetworkStream::__TEST_SetSkillGroupFake(int iIndex)
  3994. {
  3995. m_dwMainActorSkillGroup = DWORD(iIndex);
  3996.  
  3997. CPythonPlayer::Instance().NEW_ClearSkillData();
  3998. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
  3999. }
  4000.  
  4001. bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType)
  4002. {
  4003. TPacketCGRefine kRefinePacket;
  4004. kRefinePacket.header = HEADER_CG_REFINE;
  4005. kRefinePacket.pos = byPos;
  4006. kRefinePacket.type = byType;
  4007.  
  4008. if (!Send(sizeof(kRefinePacket), &kRefinePacket))
  4009. return false;
  4010.  
  4011. return SendSequence();
  4012. }
  4013.  
  4014. bool CPythonNetworkStream::SendSelectItemPacket(DWORD dwItemPos)
  4015. {
  4016. TPacketCGScriptSelectItem kScriptSelectItem;
  4017. kScriptSelectItem.header = HEADER_CG_SCRIPT_SELECT_ITEM;
  4018. kScriptSelectItem.selection = dwItemPos;
  4019.  
  4020. if (!Send(sizeof(kScriptSelectItem), &kScriptSelectItem))
  4021. return false;
  4022.  
  4023. return SendSequence();
  4024. }
  4025.  
  4026. bool CPythonNetworkStream::RecvRefineInformationPacket()
  4027. {
  4028. TPacketGCRefineInformation kRefineInfoPacket;
  4029. if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
  4030. return false;
  4031.  
  4032. TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
  4033. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  4034. "OpenRefineDialog",
  4035. Py_BuildValue("(iiii)",
  4036. kRefineInfoPacket.pos,
  4037. kRefineInfoPacket.refine_table.result_vnum,
  4038. rkRefineTable.cost,
  4039. rkRefineTable.prob));
  4040.  
  4041. for (int i = 0; i < rkRefineTable.material_count; ++i)
  4042. {
  4043. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
  4044. }
  4045.  
  4046. #ifdef _DEBUG
  4047. Tracef(" >> RecvRefineInformationPacket(pos=%d, result_vnum=%d, cost=%d, prob=%d)\n",
  4048. kRefineInfoPacket.pos,
  4049. kRefineInfoPacket.refine_table.result_vnum,
  4050. rkRefineTable.cost,
  4051. rkRefineTable.prob);
  4052. #endif
  4053.  
  4054. return true;
  4055. }
  4056.  
  4057. bool CPythonNetworkStream::RecvRefineInformationPacketNew()
  4058. {
  4059. TPacketGCRefineInformationNew kRefineInfoPacket;
  4060. if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
  4061. return false;
  4062.  
  4063. TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
  4064. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
  4065. "OpenRefineDialog",
  4066. Py_BuildValue("(iiiii)",
  4067. kRefineInfoPacket.pos,
  4068. kRefineInfoPacket.refine_table.result_vnum,
  4069. rkRefineTable.cost,
  4070. rkRefineTable.prob,
  4071. kRefineInfoPacket.type)
  4072. );
  4073.  
  4074. for (int i = 0; i < rkRefineTable.material_count; ++i)
  4075. {
  4076. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
  4077. }
  4078.  
  4079. #ifdef _DEBUG
  4080. Tracef(" >> RecvRefineInformationPacketNew(pos=%d, result_vnum=%d, cost=%d, prob=%d, type=%d)\n",
  4081. kRefineInfoPacket.pos,
  4082. kRefineInfoPacket.refine_table.result_vnum,
  4083. rkRefineTable.cost,
  4084. rkRefineTable.prob,
  4085. kRefineInfoPacket.type);
  4086. #endif
  4087.  
  4088. return true;
  4089. }
  4090.  
  4091. bool CPythonNetworkStream::RecvNPCList()
  4092. {
  4093. TPacketGCNPCPosition kNPCPosition;
  4094. if (!Recv(sizeof(kNPCPosition), &kNPCPosition))
  4095. return false;
  4096.  
  4097. assert(int(kNPCPosition.size)-sizeof(kNPCPosition) == kNPCPosition.count*sizeof(TNPCPosition) && "HEADER_GC_NPC_POSITION");
  4098.  
  4099. CPythonMiniMap::Instance().ClearAtlasMarkInfo();
  4100.  
  4101. for (int i = 0; i < kNPCPosition.count; ++i)
  4102. {
  4103. TNPCPosition NPCPosition;
  4104. if (!Recv(sizeof(TNPCPosition), &NPCPosition))
  4105. return false;
  4106.  
  4107. CPythonMiniMap::Instance().RegisterAtlasMark(NPCPosition.bType, NPCPosition.name, NPCPosition.x, NPCPosition.y);
  4108. }
  4109.  
  4110. return true;
  4111. }
  4112.  
  4113. bool CPythonNetworkStream::__SendCRCReportPacket()
  4114. {
  4115. /*
  4116. DWORD dwProcessCRC = 0;
  4117. DWORD dwFileCRC = 0;
  4118. CFilename exeFileName;
  4119. //LPCVOID c_pvBaseAddress = NULL;
  4120.  
  4121. GetExeCRC(dwProcessCRC, dwFileCRC);
  4122.  
  4123. CFilename strRootPackFileName = CEterPackManager::Instance().GetRootPacketFileName();
  4124. strRootPackFileName.ChangeDosPath();
  4125.  
  4126. TPacketCGCRCReport kReportPacket;
  4127.  
  4128. kReportPacket.header = HEADER_CG_CRC_REPORT;
  4129. kReportPacket.byPackMode = CEterPackManager::Instance().GetSearchMode();
  4130. kReportPacket.dwBinaryCRC32 = dwFileCRC;
  4131. kReportPacket.dwProcessCRC32 = dwProcessCRC;
  4132. kReportPacket.dwRootPackCRC32 = GetFileCRC32(strRootPackFileName.c_str());
  4133.  
  4134. if (!Send(sizeof(kReportPacket), &kReportPacket))
  4135. Tracef("SendClientReportPacket Error");
  4136.  
  4137. return SendSequence();
  4138. */
  4139. return true;
  4140. }
  4141.  
  4142. bool CPythonNetworkStream::SendClientVersionPacket()
  4143. {
  4144. std::string filename;
  4145.  
  4146. GetExcutedFileName(filename);
  4147.  
  4148. filename = CFileNameHelper::NoPath(filename);
  4149. CFileNameHelper::ChangeDosPath(filename);
  4150.  
  4151. if (LocaleService_IsEUROPE() && false == LocaleService_IsYMIR())
  4152. {
  4153. TPacketCGClientVersion2 kVersionPacket;
  4154. kVersionPacket.header = HEADER_CG_CLIENT_VERSION2;
  4155. strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
  4156. strncpy(kVersionPacket.timestamp, "1215955205", sizeof(kVersionPacket.timestamp)-1); // # python time.time 앞자리
  4157. //strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1); // old_string_ver
  4158. //strncpy(kVersionPacket.timestamp, "1218055205", sizeof(kVersionPacket.timestamp)-1); // new_future
  4159. //strncpy(kVersionPacket.timestamp, "1214055205", sizeof(kVersionPacket.timestamp)-1); // old_past
  4160.  
  4161. if (!Send(sizeof(kVersionPacket), &kVersionPacket))
  4162. Tracef("SendClientReportPacket Error");
  4163. }
  4164. else
  4165. {
  4166. TPacketCGClientVersion kVersionPacket;
  4167. kVersionPacket.header = HEADER_CG_CLIENT_VERSION;
  4168. strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
  4169. strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1);
  4170.  
  4171. if (!Send(sizeof(kVersionPacket), &kVersionPacket))
  4172. Tracef("SendClientReportPacket Error");
  4173. }
  4174. return SendSequence();
  4175. }
  4176.  
  4177. bool CPythonNetworkStream::RecvAffectAddPacket()
  4178. {
  4179. TPacketGCAffectAdd kAffectAdd;
  4180. if (!Recv(sizeof(kAffectAdd), &kAffectAdd))
  4181. return false;
  4182.  
  4183. TPacketAffectElement & rkElement = kAffectAdd.elem;
  4184. if (rkElement.bPointIdxApplyOn == POINT_ENERGY)
  4185. {
  4186. CPythonPlayer::instance().SetStatus (POINT_ENERGY_END_TIME, CPythonApplication::Instance().GetServerTimeStamp() + rkElement.lDuration);
  4187. __RefreshStatus();
  4188. }
  4189. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_AddAffect", Py_BuildValue("(iiii)", rkElement.dwType, rkElement.bPointIdxApplyOn, rkElement.lApplyValue, rkElement.lDuration));
  4190.  
  4191. return true;
  4192. }
  4193.  
  4194. bool CPythonNetworkStream::RecvAffectRemovePacket()
  4195. {
  4196. TPacketGCAffectRemove kAffectRemove;
  4197. if (!Recv(sizeof(kAffectRemove), &kAffectRemove))
  4198. return false;
  4199.  
  4200. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_RemoveAffect", Py_BuildValue("(ii)", kAffectRemove.dwType, kAffectRemove.bApplyOn));
  4201.  
  4202. return true;
  4203. }
  4204.  
  4205. bool CPythonNetworkStream::RecvChannelPacket()
  4206. {
  4207. TPacketGCChannel kChannelPacket;
  4208. if (!Recv(sizeof(kChannelPacket), &kChannelPacket))
  4209. return false;
  4210.  
  4211. //Tracef(" >> CPythonNetworkStream::RecvChannelPacket(channel=%d)\n", kChannelPacket.channel);
  4212.  
  4213. return true;
  4214. }
  4215.  
  4216. bool CPythonNetworkStream::RecvViewEquipPacket()
  4217. {
  4218. TPacketGCViewEquip kViewEquipPacket;
  4219. if (!Recv(sizeof(kViewEquipPacket), &kViewEquipPacket))
  4220. return false;
  4221.  
  4222. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenEquipmentDialog", Py_BuildValue("(i)", kViewEquipPacket.dwVID));
  4223.  
  4224. for (int i = 0; i < WEAR_MAX_NUM; ++i)
  4225. {
  4226. TEquipmentItemSet & rItemSet = kViewEquipPacket.equips[i];
  4227. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogItem", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, rItemSet.vnum, rItemSet.count));
  4228.  
  4229. for (int j = 0; j < ITEM_SOCKET_SLOT_MAX_NUM; ++j)
  4230. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogSocket", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, j, rItemSet.alSockets[j]));
  4231.  
  4232. for (int k = 0; k < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++k)
  4233. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogAttr", Py_BuildValue("(iiiii)", kViewEquipPacket.dwVID, i, k, rItemSet.aAttr[k].bType, rItemSet.aAttr[k].sValue));
  4234. }
  4235.  
  4236. return true;
  4237. }
  4238.  
  4239. bool CPythonNetworkStream::RecvLandPacket()
  4240. {
  4241. TPacketGCLandList kLandList;
  4242. if (!Recv(sizeof(kLandList), &kLandList))
  4243. return false;
  4244.  
  4245. std::vector<DWORD> kVec_dwGuildID;
  4246.  
  4247. CPythonMiniMap & rkMiniMap = CPythonMiniMap::Instance();
  4248. CPythonBackground & rkBG = CPythonBackground::Instance();
  4249. CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
  4250.  
  4251. rkMiniMap.ClearGuildArea();
  4252. rkBG.ClearGuildArea();
  4253.  
  4254. int iPacketSize = (kLandList.size - sizeof(TPacketGCLandList));
  4255. for (; iPacketSize > 0; iPacketSize-=sizeof(TLandPacketElement))
  4256. {
  4257. TLandPacketElement kElement;
  4258. if (!Recv(sizeof(TLandPacketElement), &kElement))
  4259. return false;
  4260.  
  4261. rkMiniMap.RegisterGuildArea(kElement.dwID,
  4262. kElement.dwGuildID,
  4263. kElement.x,
  4264. kElement.y,
  4265. kElement.width,
  4266. kElement.height);
  4267.  
  4268. if (pMainInstance)
  4269. if (kElement.dwGuildID == pMainInstance->GetGuildID())
  4270. {
  4271. rkBG.RegisterGuildArea(kElement.x,
  4272. kElement.y,
  4273. kElement.x+kElement.width,
  4274. kElement.y+kElement.height);
  4275. }
  4276.  
  4277. if (0 != kElement.dwGuildID)
  4278. kVec_dwGuildID.push_back(kElement.dwGuildID);
  4279. }
  4280.  
  4281. __DownloadSymbol(kVec_dwGuildID);
  4282.  
  4283. return true;
  4284. }
  4285.  
  4286. bool CPythonNetworkStream::RecvTargetCreatePacket()
  4287. {
  4288. TPacketGCTargetCreate kTargetCreate;
  4289. if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
  4290. return false;
  4291.  
  4292. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4293. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
  4294.  
  4295. //#ifdef _DEBUG
  4296. // char szBuf[256+1];
  4297. // _snprintf(szBuf, sizeof(szBuf), "타겟이 생성 되었습니다 [%d:%s]", kTargetCreate.lID, kTargetCreate.szTargetName);
  4298. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4299. // Tracef(" >> RecvTargetCreatePacket %d : %s\n", kTargetCreate.lID, kTargetCreate.szTargetName);
  4300. //#endif
  4301.  
  4302. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
  4303. return true;
  4304. }
  4305.  
  4306. bool CPythonNetworkStream::RecvTargetCreatePacketNew()
  4307. {
  4308. TPacketGCTargetCreateNew kTargetCreate;
  4309. if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
  4310. return false;
  4311.  
  4312. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4313. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4314. if (CREATE_TARGET_TYPE_LOCATION == kTargetCreate.byType)
  4315. {
  4316. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
  4317. }
  4318. else
  4319. {
  4320. rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
  4321. rkpyBG.CreateTargetEffect(kTargetCreate.lID, kTargetCreate.dwVID);
  4322. }
  4323.  
  4324. //#ifdef _DEBUG
  4325. // char szBuf[256+1];
  4326. // _snprintf(szBuf, sizeof(szBuf), "캐릭터 타겟이 생성 되었습니다 [%d:%s:%d]", kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
  4327. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4328. // Tracef(" >> RecvTargetCreatePacketNew %d : %d/%d\n", kTargetCreate.lID, kTargetCreate.byType, kTargetCreate.dwVID);
  4329. //#endif
  4330.  
  4331. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
  4332. return true;
  4333. }
  4334.  
  4335. bool CPythonNetworkStream::RecvTargetUpdatePacket()
  4336. {
  4337. TPacketGCTargetUpdate kTargetUpdate;
  4338. if (!Recv(sizeof(kTargetUpdate), &kTargetUpdate))
  4339. return false;
  4340.  
  4341. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4342. rkpyMiniMap.UpdateTarget(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4343.  
  4344. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4345. rkpyBG.CreateTargetEffect(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4346.  
  4347. //#ifdef _DEBUG
  4348. // char szBuf[256+1];
  4349. // _snprintf(szBuf, sizeof(szBuf), "타겟의 위치가 갱신 되었습니다 [%d:%d/%d]", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4350. // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
  4351. // Tracef(" >> RecvTargetUpdatePacket %d : %d, %d\n", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
  4352. //#endif
  4353.  
  4354. return true;
  4355. }
  4356.  
  4357. bool CPythonNetworkStream::RecvTargetDeletePacket()
  4358. {
  4359. TPacketGCTargetDelete kTargetDelete;
  4360. if (!Recv(sizeof(kTargetDelete), &kTargetDelete))
  4361. return false;
  4362.  
  4363. CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
  4364. rkpyMiniMap.DeleteTarget(kTargetDelete.lID);
  4365.  
  4366. CPythonBackground & rkpyBG = CPythonBackground::Instance();
  4367. rkpyBG.DeleteTargetEffect(kTargetDelete.lID);
  4368.  
  4369. //#ifdef _DEBUG
  4370. // Tracef(" >> RecvTargetDeletePacket %d\n", kTargetDelete.lID);
  4371. //#endif
  4372.  
  4373. return true;
  4374. }
  4375.  
  4376. bool CPythonNetworkStream::RecvLoverInfoPacket()
  4377. {
  4378. TPacketGCLoverInfo kLoverInfo;
  4379. if (!Recv(sizeof(kLoverInfo), &kLoverInfo))
  4380. return false;
  4381.  
  4382. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_LoverInfo", Py_BuildValue("(si)", kLoverInfo.szName, kLoverInfo.byLovePoint));
  4383. #ifdef _DEBUG
  4384. Tracef("RECV LOVER INFO : %s, %d\n", kLoverInfo.szName, kLoverInfo.byLovePoint);
  4385. #endif
  4386. return true;
  4387. }
  4388.  
  4389. bool CPythonNetworkStream::RecvLovePointUpdatePacket()
  4390. {
  4391. TPacketGCLovePointUpdate kLovePointUpdate;
  4392. if (!Recv(sizeof(kLovePointUpdate), &kLovePointUpdate))
  4393. return false;
  4394.  
  4395. PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_UpdateLovePoint", Py_BuildValue("(i)", kLovePointUpdate.byLovePoint));
  4396. #ifdef _DEBUG
  4397. Tracef("RECV LOVE POINT UPDATE : %d\n", kLovePointUpdate.byLovePoint);
  4398. #endif
  4399. return true;
  4400. }
  4401.  
  4402. bool CPythonNetworkStream::RecvDigMotionPacket()
  4403. {
  4404. TPacketGCDigMotion kDigMotion;
  4405. if (!Recv(sizeof(kDigMotion), &kDigMotion))
  4406. return false;
  4407.  
  4408. #ifdef _DEBUG
  4409. Tracef(" Dig Motion [%d/%d]\n", kDigMotion.vid, kDigMotion.count);
  4410. #endif
  4411.  
  4412. IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
  4413. CInstanceBase * pkInstMain = rkChrMgr.GetInstancePtr(kDigMotion.vid);
  4414. CInstanceBase * pkInstTarget = rkChrMgr.GetInstancePtr(kDigMotion.target_vid);
  4415. if (NULL == pkInstMain)
  4416. return true;
  4417.  
  4418. if (pkInstTarget)
  4419. pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
  4420.  
  4421. for (int i = 0; i < kDigMotion.count; ++i)
  4422. pkInstMain->PushOnceMotion(CRaceMotionData::NAME_DIG);
  4423.  
  4424. return true;
  4425. }
  4426.  
  4427.  
  4428. // 용혼석 강화
  4429. bool CPythonNetworkStream::SendDragonSoulRefinePacket(BYTE bRefineType, TItemPos* pos)
  4430. {
  4431. TPacketCGDragonSoulRefine pk;
  4432. pk.header = HEADER_CG_DRAGON_SOUL_REFINE;
  4433. pk.bSubType = bRefineType;
  4434. memcpy (pk.ItemGrid, pos, sizeof (TItemPos) * DS_REFINE_WINDOW_MAX_NUM);
  4435. if (!Send(sizeof (pk), &pk))
  4436. {
  4437. return false;
  4438. }
  4439. return true;
  4440. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!