API tools faq
paste
Advertisement
Guest User

Untitled

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