API tools faq
paste
Guest User

PythonStreamPhaseGame.cpp

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