#include "StdAfx.h" #include "PythonNetworkStream.h" #include "Packet.h" #include "PythonGuild.h" #include "PythonCharacterManager.h" #include "PythonPlayer.h" #include "PythonBackground.h" #include "PythonMiniMap.h" #include "PythonTextTail.h" #include "PythonItem.h" #include "PythonChat.h" #include "PythonShop.h" #include "PythonExchange.h" #include "PythonQuest.h" #include "PythonEventManager.h" #include "PythonMessenger.h" #include "PythonApplication.h" #ifdef BATTLEPASS_WORLDARD #include "PythonBattlePass.h" #endif #ifdef ENABLE_DUNGEON_INFO #include "PythonDungeonInfo.h" #endif #include "../EterPack/EterPackManager.h" #include "../gamelib/ItemManager.h" #include "AbstractApplication.h" #include "AbstractCharacterManager.h" #include "InstanceBase.h" #ifdef ENABLE_MANAGER_BANK_SYSTEM #include "PythonManagerBank.h" #endif #include "ProcessCRC.h" #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) #include "CShield.h" #include "CShieldCheckIntegrity.h" #endif #if defined(WJ_COMBAT_ZONE) #include "PythonCombatZone.h" #endif #include #ifdef ENABLE_DROP_ITEM_WORLDARD #include "PythonDropItem.h" #endif #ifdef ENABLE_CUBE_RENEWAL_WORLDARD #include "PythonCubeRenewal.h" #endif #include #include BOOL gs_bEmpireLanuageEnable = TRUE; static std::vector vWhiteList = //Lista de la carpeta raiz { "Protect.dll", "arrancarstart.bat", "artpclnt.dll", "Jugar.exe", "bdvid32.dll", "BETA-SERVER.bat", "BGM", "channel.inf", "config.exe", "config.ini", "devil.dll", "DSETUP.dll", "errorlog.exe", "ErrorLog.txt", "FileArchiver.exe", "granny2.dll", "ijl15.dll", "ilu.dll", "is_dev.txt", "lib", "locale.cfg", "log.txt", "logininfo.xml", "mark", "metin2.cfg", "metin2.ico", "metin2client.exe", "Metin2EU.ini", "Microsoft.WindowsAPICodePack.dll", "Microsoft.WindowsAPICodePack.Shell.dll", "miles", "mouse.cfg", "mscoree.dll", "MSS32.DLL", "msvcp120.dll", "msvcp60.dll", "MSVCRTD.DLL", "Options.txt", "pack", "Modulo1", "pack_maker", "patchw32.dll", "PropertyGen.exe", "prueba.bat", "python22.dll", "python27.dll", "resource.dll", "screenshot", "shop.cfg", "shops", "SpeedTreeRT.dll", "syserr.txt", "tbb.dll", "unicows.dll", "start.py1", "upload", "font.cfg", "switchbot.pkl" }; static std::vector vWhiteListPack = // Lista de la carpeta pack { "BGM", "Effect", "ETC", "Green_dragon_valley", "guild", "icon", "Index", "indoordeviltower1", "indoormonkeydungeon1", "indoormonkeydungeon2", "indoormonkeydungeon3", "indoorspiderdungeon1", "inventory_locked", "item", "mt2_patch_pascua", "locale", "metin2_map_devilscatacomb", "metin2_patch_10th", "metin2_patch_5th_armor", "metin2_patch_acce", "metin2_patch_acce_w", "metin2_patch_attendance", "metin2_patch_battlefied", "metin2_patch_calendar", "metin2_patch_common", "metin2_patch_costume_soccer", "metin2_patch_dance", "metin2_patch_dawnmist_dungeon", "metin2_patch_dawnmist_dungeon_mob", "metin2_patch_discord", "metin2_patch_dragon_rock", "metin2_patch_dragon_rock_mobs", "metin2_patch_dragon_rock_mobs_texcache", "metin2_patch_dragon_rock_texcache", "metin2_patch_ds", "metin2_patch_dss_box", "metin2_patch_dungeon_info", "metin2_patch_e1", "metin2_patch_easter1", "metin2_patch_easter2016", "metin2_patch_etc", "metin2_patch_etc_costume1", "metin2_patch_eu2", "metin2_patch_eu3", "metin2_patch_eu4", "metin2_patch_event", "metin2_patch_flame", "metin2_patch_flame_dragonlair", "metin2_patch_flame_dungeon", "metin2_patch_guildrenewal", "metin2_patch_guildwar", "metin2_patch_guildwar_object", "metin2_patch_halloween", "metin2_patch_halloween_2018", "metin2_patch_hide_costume", "metin2_patch_kingdoomswar", "metin2_patch_mineral", "metin2_patch_minigame_okey", "metin2_patch_monster_card", "metin2_patch_mundi", "metin2_patch_myshop_deco", "metin2_patch_new_halloween", "metin2_patch_new_halloween_weapon", "metin2_patch_new_pet", "metin2_patch_new_select_ui", "metin2_patch_party", "metin2_patch_pc3", "metin2_patch_pc3_m", "metin2_patch_pepsi", "metin2_patch_pet1", "metin2_patch_pet2", "metin2_patch_privateshop", "metin2_patch_public", "metin2_patch_ramadan", "metin2_patch_ramadan_costume", "metin2_patch_sd", "metin2_patch_search", "metin2_patch_second_guildrenewal", "metin2_patch_snow", "metin2_patch_snow_dungeon", "metin2_patch_summer", "metin2_patch_user_situation", "metin2_patch_valentine_pet", "metin2_patch_w20_etc", "metin2_patch_w20_sound", "metin2_patch_w21_etc", "metin2_patch_w21_mobs", "metin2_patch_w21_mobs_m", "metin2_patch_xmas", "miki_p", "Monster", "monster2", "new_petsystem", "NPC", "npc2", "Outdoor", "OutdoorA1", "OutdoorA2", "OutdoorA3", "OutdoorB1", "OutdoorB3", "OutdoorC1", "OutdoorC3", "outdoordesert1", "outdoorduel", "outdoorempirebattle1", "outdoorfielddungeon1", "outdoorflame1", "outdoorgmguildbuild", "outdoorguild1", "outdoorguild2", "outdoorguild3", "outdoormilgyo1", "OutdoorSnow1", "outdoort1", "outdoort2", "outdoort3", "outdoort4", "outdoortrent", "outdoortrent02", "outdoorwedding", "patch1", "PC", "pc2", "property", "root", "season1", "season2", "season3_eu", "select_create", "skipia_1", "Sound", "sound2", "sound_m", "Terrain", "textureset", "Tree", "uiloading", "uiscript", "WeaponSkin", "w_m_g", "zone2", "patch_arboreal", "metin2_patch_drop_item", "Zone", "metin2_patch_cube_renewal", "metin2_patch_guias", "patch_dungeon_new", "metin2_patch_multi_evolution", "pack2019", "pack_2020", "metin2_patch_ranking_guild", "metin2_patch_elements", "metin2_patch_new_maps", "metin2_patch_d_rework", "patch_design_wa", "metin2_patch_01", "metin2_patch_carcaj", "patch_desafio", "metin2_patch_shining", "metin2_patch_battlepass" }; static std::vector vWhiteListlib = // Lista de la carpeta lib { "abc.pyc", "account_1.cfg", "account_2.cfg", "account_3.cfg", "account_4.cfg", "bisect.pyc", "calendar.pyc", "codecs.pyc", "collections.pyc", "copy.pyc", "copy_reg.pyc", "encodings", "fnmatch.pyc", "font.pyc", "functools.pyc", "genericpath.pyc", "heapq.pyc", "keyword.pyc", "linecache.pyc", "locale.pyc", "ntpath.pyc", "os.pyc", "pyexpat.pyd", "pyexpat_d.pdb", "pyexpat_d.pyd", "re.pyc", "shutil.pyc", "site.pyc", "socket.pyc", "sre_compile.pyc", "sre_constants.pyc", "sre_parse.pyc", "stat.pyc", "string.pyc", "sysconfig.pyc", "traceback.pyc", "types.pyc", "UserDict.pyc", "warnings.pyc", "weakref.pyc", "xml", "_abcoll.pyc", "_locale.pyc", "_socket.pyd", "_strptime.pyc", "_weakrefset.pyc", "__future__.pyc", "wa_ac.py", "base64.pyc", "struct.pyc", }; static std::string GetRootPath() { char szBuffer[MAX_PATH]; if (GetModuleFileNameA(NULL, szBuffer, MAX_PATH)) { std::string szPath = std::string(szBuffer); size_t nPos = szPath.find_last_of("\\/"); szPath = szPath.substr(0, nPos); DWORD dwAttrib = GetFileAttributesA(szPath.c_str()); if (szPath.empty() == false && dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) { return szPath; } } return std::string(""); } static void FileChecks() { std::string szRootPath = GetRootPath(); if (szRootPath.empty()) { // printf("Root path not found! Error: %u\n", GetLastError()); return; } std::string szSearchPath = szRootPath + "/lib/*.*"; WIN32_FIND_DATAA w32fd; HANDLE hFind = FindFirstFileA(szSearchPath.c_str(), &w32fd); if (hFind != INVALID_HANDLE_VALUE) { do { std::string szCurrentItem = w32fd.cFileName; if (szCurrentItem != "." && szCurrentItem != "..") { // printf("\tCurrent %s\n", szCurrentItem.c_str()); if (std::find(vWhiteListlib.begin(), vWhiteListlib.end(), szCurrentItem) == vWhiteListlib.end()) // not whitelisted item { // printf("\tUnknown file: %s\n", szCurrentItem.c_str()); if (DeleteFileA(szCurrentItem.c_str()) == FALSE /* can not removed */ || _access(szCurrentItem.c_str(), 0) == 0 /* removed but still exist */) { std::string szWarn = "Unknown file detected: " + szCurrentItem + ", Delete this file."; MessageBoxA(0,szWarn.c_str(),0,0); PostQuitMessage(0); } } } } while (FindNextFileA(hFind, &w32fd)); FindClose(hFind); } } static void FileCheckPack() { std::string szRootPath = GetRootPath(); if (szRootPath.empty()) { // printf("Root path not found! Error: %u\n", GetLastError()); return; } std::string szSearchPath = szRootPath + "/pack/*.*"; WIN32_FIND_DATAA w32fd; HANDLE hFind = FindFirstFileA(szSearchPath.c_str(), &w32fd); if (hFind != INVALID_HANDLE_VALUE) { do { std::string szCurrentItem = w32fd.cFileName; if (szCurrentItem != "." && szCurrentItem != "..") { // printf("\tCurrent %s\n", szCurrentItem.c_str()); if (std::find(vWhiteListPack.begin(), vWhiteListPack.end(), szCurrentItem) == vWhiteListPack.end()) // not whitelisted item { // printf("\tUnknown file: %s\n", szCurrentItem.c_str()); if (DeleteFileA(szCurrentItem.c_str()) == FALSE /* can not removed */ || _access(szCurrentItem.c_str(), 0) == 0 /* removed but still exist */) { std::string szWarn = "Unknown file detected: " + szCurrentItem + ", Delete this file."; MessageBoxA(0,szWarn.c_str(),0,0); PostQuitMessage(0); } } } } while (FindNextFileA(hFind, &w32fd)); FindClose(hFind); } } static void FileCheckRoutine() { std::string szRootPath = GetRootPath(); if (szRootPath.empty()) { // printf("Root path not found! Error: %u\n", GetLastError()); return; } // printf("Root: %s\n", szRootPath.c_str()); std::string szSearchPath = szRootPath + "/*.*"; WIN32_FIND_DATAA w32fd; HANDLE hFind = FindFirstFileA(szSearchPath.c_str(), &w32fd); if (hFind != INVALID_HANDLE_VALUE) { do { std::string szCurrentItem = w32fd.cFileName; if (szCurrentItem != "." && szCurrentItem != "..") { // printf("\tCurrent %s\n", szCurrentItem.c_str()); if (std::find(vWhiteList.begin(), vWhiteList.end(), szCurrentItem) == vWhiteList.end()) // not whitelisted item { // printf("\tUnknown file: %s\n", szCurrentItem.c_str()); if (DeleteFileA(szCurrentItem.c_str()) == FALSE /* can not removed */ || _access(szCurrentItem.c_str(), 0) == 0 /* removed but still exist */) { std::string szWarn = "Unknown file detected: " + szCurrentItem + ", Delete this file."; MessageBoxA(0,szWarn.c_str(),0,0); PostQuitMessage(0); } } } } while (FindNextFileA(hFind, &w32fd)); FindClose(hFind); } } void CPythonNetworkStream::__RefreshAlignmentWindow() { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshAlignment", Py_BuildValue("()")); } void CPythonNetworkStream::__RefreshTargetBoardByVID(DWORD dwVID) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByVID", Py_BuildValue("(i)", dwVID)); } void CPythonNetworkStream::__RefreshTargetBoardByName(const char * c_szName) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByName", Py_BuildValue("(s)", c_szName)); } void CPythonNetworkStream::__RefreshTargetBoard() { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoard", Py_BuildValue("()")); } void CPythonNetworkStream::__RefreshGuildWindowGradePage() { m_isRefreshGuildWndGradePage=true; } void CPythonNetworkStream::__RefreshGuildWindowSkillPage() { m_isRefreshGuildWndSkillPage=true; } void CPythonNetworkStream::__RefreshGuildWindowMemberPageGradeComboBox() { m_isRefreshGuildWndMemberPageGradeComboBox=true; } void CPythonNetworkStream::__RefreshGuildWindowMemberPage() { m_isRefreshGuildWndMemberPage=true; } void CPythonNetworkStream::__RefreshGuildWindowBoardPage() { m_isRefreshGuildWndBoardPage=true; } void CPythonNetworkStream::__RefreshGuildWindowInfoPage() { m_isRefreshGuildWndInfoPage=true; } void CPythonNetworkStream::__RefreshMessengerWindow() { m_isRefreshMessengerWnd=true; } void CPythonNetworkStream::__RefreshSafeboxWindow() { m_isRefreshSafeboxWnd=true; } void CPythonNetworkStream::__RefreshMallWindow() { m_isRefreshMallWnd=true; } void CPythonNetworkStream::__RefreshSkillWindow() { m_isRefreshSkillWnd=true; } void CPythonNetworkStream::__RefreshExchangeWindow() { m_isRefreshExchangeWnd=true; } void CPythonNetworkStream::__RefreshStatus() { m_isRefreshStatus=true; } void CPythonNetworkStream::__RefreshCharacterWindow() { m_isRefreshCharacterWnd=true; } void CPythonNetworkStream::__RefreshInventoryWindow() { m_isRefreshInventoryWnd=true; } void CPythonNetworkStream::__RefreshEquipmentWindow() { m_isRefreshEquipmentWnd=true; } #ifdef ENABLE_SHOP_SEARCH_SYSTEM void CPythonNetworkStream::__RefreshShopSearchWindow() { m_isRefreshShopSearchWnd = true; } #endif void CPythonNetworkStream::__SetGuildID(DWORD id) { if (m_dwGuildID != id) { m_dwGuildID = id; IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton(); for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i) if (!strncmp(m_akSimplePlayerInfo[i].szName, rkPlayer.GetName(), CHARACTER_NAME_MAX_LEN)) { m_adwGuildID[i] = id; std::string guildName; if (CPythonGuild::Instance().GetGuildName(id, &guildName)) { m_astrGuildName[i] = guildName; } else { m_astrGuildName[i] = ""; } } } } struct PERF_PacketInfo { DWORD dwCount; DWORD dwTime; PERF_PacketInfo() { dwCount=0; dwTime=0; } }; #ifdef __PERFORMANCE_CHECK__ class PERF_PacketTimeAnalyzer { public: ~PERF_PacketTimeAnalyzer() { FILE* fp=fopen("perf_dispatch_packet_result.txt", "w"); for (std::map::iterator i=m_kMap_kPacketInfo.begin(); i!=m_kMap_kPacketInfo.end(); ++i) { if (i->second.dwTime>0) 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); } fclose(fp); } public: std::map m_kMap_kPacketInfo; }; PERF_PacketTimeAnalyzer gs_kPacketTimeAnalyzer; #endif // Game Phase --------------------------------------------------------------------------- void CPythonNetworkStream::GamePhase() { #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) if (clientCode != 0) { std::string message = "CShield-ClientSide-ErrorCode: " + std::to_string(clientCode); NotifyHack(message.c_str()); clientCode = 0; } #endif if (!m_kQue_stHack.empty()) { __SendHack(m_kQue_stHack.front().c_str()); m_kQue_stHack.pop_front(); } TPacketHeader header = 0; bool ret = true; #ifdef __PERFORMANCE_CHECK__ DWORD timeBeginDispatch=timeGetTime(); static std::map kMap_kPacketInfo; kMap_kPacketInfo.clear(); #endif const DWORD MAX_RECV_COUNT = 4; const DWORD SAFE_RECV_BUFSIZE = 8192; DWORD dwRecvCount = 0; while (ret) { if(dwRecvCount++ >= MAX_RECV_COUNT-1 && GetRecvBufferSize() < SAFE_RECV_BUFSIZE && m_strPhase == "Game") //phase_game 이 아니어도 여기로 들어오는 경우가 있다. break; if (!CheckPacket(&header)) break; #ifdef __PERFORMANCE_CHECK__ DWORD timeBeginPacket=timeGetTime(); #endif switch (header) { case HEADER_GC_OBSERVER_ADD: ret = RecvObserverAddPacket(); break; case HEADER_GC_OBSERVER_REMOVE: ret = RecvObserverRemovePacket(); break; case HEADER_GC_OBSERVER_MOVE: ret = RecvObserverMovePacket(); break; case HEADER_GC_WARP: ret = RecvWarpPacket(); break; case HEADER_GC_PHASE: ret = RecvPhasePacket(); return; // 도중에 Phase 가 바뀌면 일단 무조건 GamePhase 탈출 - [levites] break; case HEADER_GC_CHEAT_BLACKLIST: ret = RecvCheatBlacklist(); break; case HEADER_GC_PVP: ret = RecvPVPPacket(); break; case HEADER_GC_DUEL_START: ret = RecvDuelStartPacket(); break; case HEADER_GC_CHARACTER_ADD: ret = RecvCharacterAppendPacket(); break; case HEADER_GC_CHAR_ADDITIONAL_INFO: ret = RecvCharacterAdditionalInfo(); break; case HEADER_GC_CHARACTER_ADD2: ret = RecvCharacterAppendPacketNew(); break; case HEADER_GC_CHARACTER_UPDATE: ret = RecvCharacterUpdatePacket(); break; case HEADER_GC_CHARACTER_UPDATE2: ret = RecvCharacterUpdatePacketNew(); break; case HEADER_GC_CHARACTER_DEL: ret = RecvCharacterDeletePacket(); break; case HEADER_GC_CHAT: ret = RecvChatPacket(); break; case HEADER_GC_SYNC_POSITION: ret = RecvSyncPositionPacket(); break; case HEADER_GC_OWNERSHIP: ret = RecvOwnerShipPacket(); break; case HEADER_GC_WHISPER: ret = RecvWhisperPacket(); break; #ifdef ENABLE_SUPPORT_SYSTEM case HEADER_GC_SUPPORT_SKILL: ret = RecvSupportUseSkill(); break; #endif case HEADER_GC_CHARACTER_MOVE: ret = RecvCharacterMovePacket(); break; // Position case HEADER_GC_CHARACTER_POSITION: ret = RecvCharacterPositionPacket(); break; // Battle Packet case HEADER_GC_STUN: ret = RecvStunPacket(); break; case HEADER_GC_DEAD: ret = RecvDeadPacket(); break; case HEADER_GC_PLAYER_POINT_CHANGE: ret = RecvPointChange(); break; // item packet. case HEADER_GC_ITEM_SET: ret = RecvItemSetPacket(); break; case HEADER_GC_ITEM_SET2: ret = RecvItemSetPacket2(); break; case HEADER_GC_ITEM_USE: ret = RecvItemUsePacket(); break; case HEADER_GC_ITEM_UPDATE: ret = RecvItemUpdatePacket(); break; case HEADER_GC_ITEM_GROUND_ADD: ret = RecvItemGroundAddPacket(); break; case HEADER_GC_ITEM_GROUND_DEL: ret = RecvItemGroundDelPacket(); break; case HEADER_GC_ITEM_OWNERSHIP: ret = RecvItemOwnership(); break; case HEADER_GC_QUICKSLOT_ADD: ret = RecvQuickSlotAddPacket(); break; case HEADER_GC_QUICKSLOT_DEL: ret = RecvQuickSlotDelPacket(); break; case HEADER_GC_QUICKSLOT_SWAP: ret = RecvQuickSlotMovePacket(); break; case HEADER_GC_MOTION: ret = RecvMotionPacket(); break; #if defined(__BL_67_ATTR__) case HEADER_GC_OPEN_67_ATTR: ret = Recv67AttrOpenPacket(); break; #endif case HEADER_GC_SHOP: ret = RecvShopPacket(); break; case HEADER_GC_EXCHANGE: ret = RecvExchangePacket(); break; case HEADER_GC_QUEST_INFO: ret = RecvQuestInfoPacket(); break; case HEADER_GC_REQUEST_MAKE_GUILD: ret = RecvRequestMakeGuild(); break; case HEADER_GC_PING: ret = RecvPingPacket(); break; case HEADER_GC_SCRIPT: ret = RecvScriptPacket(); break; case HEADER_GC_QUEST_CONFIRM: ret = RecvQuestConfirmPacket(); break; case HEADER_GC_TARGET: ret = RecvTargetPacket(); break; #ifdef ENABLE_SEND_TARGET_INFO case HEADER_GC_TARGET_INFO: ret = RecvTargetInfoPacket(); break; #endif case HEADER_GC_DAMAGE_INFO: ret = RecvDamageInfoPacket(); break; #if defined(WJ_COMBAT_ZONE) case HEADER_GC_RANKING_COMBAT_ZONE: ret = __RecvCombatZoneRankingPacket(); break; case HEADER_GC_SEND_COMBAT_ZONE: ret = __RecvCombatZonePacket(); break; #endif case HEADER_GC_MOUNT: ret = RecvMountPacket(); break; #ifdef ENABLE_MANAGER_BANK_SYSTEM case HEADER_GC_BANK: ret = RecvAccountBankPacket(); break; #endif case HEADER_GC_CHANGE_SPEED: ret = RecvChangeSpeedPacket(); break; #ifdef ENABLE_SHOW_CHEST_DROP case HEADER_GC_CHESTDROP: ret = RecvChestDrop(); break; #endif case HEADER_GC_PLAYER_POINTS: ret = __RecvPlayerPoints(); break; case HEADER_GC_CREATE_FLY: ret = RecvCreateFlyPacket(); break; case HEADER_GC_FLY_TARGETING: ret = RecvFlyTargetingPacket(); break; case HEADER_GC_ADD_FLY_TARGETING: ret = RecvAddFlyTargetingPacket(); break; case HEADER_GC_SKILL_LEVEL: ret = RecvSkillLevel(); break; case HEADER_GC_SKILL_LEVEL_NEW: ret = RecvSkillLevelNew(); break; case HEADER_GC_MESSENGER: ret = RecvMessenger(); break; case HEADER_GC_GUILD: ret = RecvGuild(); break; case HEADER_GC_PARTY_INVITE: ret = RecvPartyInvite(); break; case HEADER_GC_PARTY_ADD: ret = RecvPartyAdd(); break; case HEADER_GC_PARTY_UPDATE: ret = RecvPartyUpdate(); break; case HEADER_GC_PARTY_REMOVE: ret = RecvPartyRemove(); break; case HEADER_GC_PARTY_LINK: ret = RecvPartyLink(); break; case HEADER_GC_PARTY_UNLINK: ret = RecvPartyUnlink(); break; case HEADER_GC_PARTY_PARAMETER: ret = RecvPartyParameter(); break; case HEADER_GC_SAFEBOX_SET: ret = RecvSafeBoxSetPacket(); break; case HEADER_GC_SAFEBOX_DEL: ret = RecvSafeBoxDelPacket(); break; case HEADER_GC_SAFEBOX_WRONG_PASSWORD: ret = RecvSafeBoxWrongPasswordPacket(); break; case HEADER_GC_SAFEBOX_SIZE: ret = RecvSafeBoxSizePacket(); break; case HEADER_GC_SAFEBOX_MONEY_CHANGE: ret = RecvSafeBoxMoneyChangePacket(); break; case HEADER_GC_FISHING: ret = RecvFishing(); break; case HEADER_GC_DUNGEON: ret = RecvDungeon(); break; case HEADER_GC_TIME: ret = RecvTimePacket(); break; case HEADER_GC_WALK_MODE: ret = RecvWalkModePacket(); break; case HEADER_GC_CHANGE_SKILL_GROUP: ret = RecvChangeSkillGroupPacket(); break; case HEADER_GC_REFINE_INFORMATION: ret = RecvRefineInformationPacket(); break; case HEADER_GC_REFINE_INFORMATION_NEW: ret = RecvRefineInformationPacketNew(); break; case HEADER_GC_SEPCIAL_EFFECT: ret = RecvSpecialEffect(); break; case HEADER_GC_NPC_POSITION: ret = RecvNPCList(); break; case HEADER_GC_CHANNEL: ret = RecvChannelPacket(); break; case HEADER_GC_VIEW_EQUIP: ret = RecvViewEquipPacket(); break; case HEADER_GC_LAND_LIST: ret = RecvLandPacket(); break; //case HEADER_GC_TARGET_CREATE: // ret = RecvTargetCreatePacket(); // break; case HEADER_GC_TARGET_CREATE_NEW: ret = RecvTargetCreatePacketNew(); break; case HEADER_GC_TARGET_UPDATE: ret = RecvTargetUpdatePacket(); break; case HEADER_GC_TARGET_DELETE: ret = RecvTargetDeletePacket(); break; case HEADER_GC_AFFECT_ADD: ret = RecvAffectAddPacket(); break; case HEADER_GC_AFFECT_REMOVE: ret = RecvAffectRemovePacket(); break; case HEADER_GC_MALL_OPEN: ret = RecvMallOpenPacket(); break; case HEADER_GC_MALL_SET: ret = RecvMallItemSetPacket(); break; case HEADER_GC_MALL_DEL: ret = RecvMallItemDelPacket(); break; #ifdef ENABLE_CONQUEROR_LEVEL case HEADER_GC_SUNGMA_ATTR_UPDATE: ret = RecvSungmaAttrUpdatePacket(); break; #endif case HEADER_GC_LOVER_INFO: ret = RecvLoverInfoPacket(); break; case HEADER_GC_LOVE_POINT_UPDATE: ret = RecvLovePointUpdatePacket(); break; case HEADER_GC_DIG_MOTION: ret = RecvDigMotionPacket(); break; case HEADER_GC_HANDSHAKE: RecvHandshakePacket(); return; break; case HEADER_GC_HANDSHAKE_OK: RecvHandshakeOKPacket(); return; break; #ifdef ENABLE_ITEMSHOP case HEADER_GC_ITEMSHOP: ret = RecvItemShop(); break; #endif case HEADER_GC_HYBRIDCRYPT_KEYS: RecvHybridCryptKeyPacket(); return; break; case HEADER_GC_HYBRIDCRYPT_SDB: RecvHybridCryptSDBPacket(); return; break; #ifdef ENABLE_NEW_DETAILS_GUI case HEADER_GC_KILL_LOG: ret = RecvKillLOG(); break; #endif #ifdef _IMPROVED_PACKET_ENCRYPTION_ case HEADER_GC_KEY_AGREEMENT: RecvKeyAgreementPacket(); return; break; case HEADER_GC_KEY_AGREEMENT_COMPLETED: RecvKeyAgreementCompletedPacket(); return; break; #endif case HEADER_GC_HS_REQUEST: ret = RecvHSCheckRequest(); break; case HEADER_GC_XTRAP_CS1_REQUEST: ret = RecvXTrapVerifyRequest(); break; case HEADER_GC_SPECIFIC_EFFECT: ret = RecvSpecificEffect(); break; case HEADER_GC_DRAGON_SOUL_REFINE: ret = RecvDragonSoulRefine(); break; #ifdef ENABLE_SHOP_SEARCH_SYSTEM case HEADER_GC_SHOPSEARCH_SET: ret = RecvShopSearchSet(); break; #endif #ifdef ENABLE_OFFLINESHOP_SYSTEM case HEADER_GC_OFFLINE_SHOP: ret = RecvOfflineShopPacket(); break; case HEADER_GC_OFFLINE_SHOP_SIGN: ret = RecvOfflineShopSignPacket(); break; #endif #ifdef ENABLE_SWITCHBOT case HEADER_GC_SWITCHBOT: ret = RecvSwitchbotPacket(); break; #endif case HEADER_GC_UNK_213: // @fixme007 ret = RecvUnk213(); break; #ifdef ENABLE_SASH_SYSTEM case HEADER_GC_SASH: ret = RecvSashPacket(); break; #endif #ifdef ENABLE_CALENDAR_SYSTEM case HEADER_GC_CALENDAR_SYSTEM: ret = RecvCalendarSystem(); break; case HEADER_GC_CALENDAR_SYSTEM_ADM: ret = RecvCalendarSystemADM(); break; #endif #ifdef ENABLE_DUNGEON_INFO case HEADER_GC_DUNGEON_INFO_SYSTEM: ret = RecvDungeonInfoPacket(); break; #endif #ifdef ENABLE_KINGDOMS_WAR case HEADER_GC_KINGDOMSWAR: ret = RecvKingdomsWarPacket(); break; #endif #ifdef ENABLE_DROP_ITEM_WORLDARD case HEADER_GC_DROP_ITEM_SYSTEM: ret = RecvDropItemPacket(); break; #endif #ifdef ENABLE_CUBE_RENEWAL_WORLDARD case HEADER_GC_CUBE_RENEWAL: ret = RecvCubeRenewalPacket(); break; #endif #ifdef ELEMENT_SPELL_WORLDARD case HEADER_GC_ELEMENTS_SPELL: ret = RecvElementsSpellPacket(); break; #endif #ifdef BATTLEPASS_WORLDARD case HEADER_GC_BATTLEPASS: ret = RecvBattlePassPacket(); break; #endif #ifdef TOURNAMENT_PVP_SYSTEM case HEADER_GC_TOURNAMENT_ADD: ret = RecvTournamentAdd(); break; #endif #ifdef ENABLE_EVENT_MANAGER case HEADER_GC_EVENT_MANAGER: ret = RecvEventManager(); break; #endif #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) case HEADER_GC_CSHIELD: ret = RecvCShieldPacket(); break; #endif #ifdef ENABLE_EXCHANGE_LOG case HEADER_GC_EXCHANGE_LOG: ret = RecvExchangeLog(); break; #endif #ifdef ENABLE_MINI_GAME_CATCH_KING case HEADER_GC_MINI_GAME_CATCH_KING: ret = RecvMiniGameCatchKingPacket(); break; #endif default: ret = RecvDefaultPacket(header); break; } #ifdef __PERFORMANCE_CHECK__ DWORD timeEndPacket=timeGetTime(); { PERF_PacketInfo& rkPacketInfo=kMap_kPacketInfo[header]; rkPacketInfo.dwCount++; rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket; } { PERF_PacketInfo& rkPacketInfo=gs_kPacketTimeAnalyzer.m_kMap_kPacketInfo[header]; rkPacketInfo.dwCount++; rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket; } #endif } #ifdef __PERFORMANCE_CHECK__ DWORD timeEndDispatch=timeGetTime(); if (timeEndDispatch-timeBeginDispatch>2) { static FILE* fp=fopen("perf_dispatch_packet.txt", "w"); fprintf(fp, "delay %d\n", timeEndDispatch-timeBeginDispatch); for (std::map::iterator i=kMap_kPacketInfo.begin(); i!=kMap_kPacketInfo.end(); ++i) { if (i->second.dwTime>0) fprintf(fp, "header %d: count %d, time %d\n", i->first, i->second.dwCount, i->second.dwTime); } fputs("=====================================================\n", fp); fflush(fp); } #endif if (!ret) RecvErrorPacket(header); static DWORD s_nextRefreshTime = ELTimer_GetMSec(); static DWORD s_nextFileCheckTime = ELTimer_GetMSec(); DWORD curTime = ELTimer_GetMSec(); //if (s_nextRefreshTime > curTime) // return; if (s_nextFileCheckTime <= curTime) { // FileCheckRoutine(); // FileCheckPack(); // FileChecks(); s_nextFileCheckTime = curTime + 800; } if (m_isRefreshCharacterWnd) { m_isRefreshCharacterWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshEquipmentWnd) { m_isRefreshEquipmentWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEquipment", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshInventoryWnd) { m_isRefreshInventoryWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshInventory", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshExchangeWnd) { m_isRefreshExchangeWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshExchange", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshSkillWnd) { m_isRefreshSkillWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSkill", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshSafeboxWnd) { m_isRefreshSafeboxWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafebox", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshMallWnd) { m_isRefreshMallWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMall", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshStatus) { m_isRefreshStatus=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshMessengerWnd) { m_isRefreshMessengerWnd=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMessenger", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndInfoPage) { m_isRefreshGuildWndInfoPage=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildInfoPage", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndBoardPage) { m_isRefreshGuildWndBoardPage=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildBoardPage", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndMemberPage) { m_isRefreshGuildWndMemberPage=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPage", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndMemberPageGradeComboBox) { m_isRefreshGuildWndMemberPageGradeComboBox=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPageGradeComboBox", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndSkillPage) { m_isRefreshGuildWndSkillPage=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildSkillPage", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } if (m_isRefreshGuildWndGradePage) { m_isRefreshGuildWndGradePage=false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGradePage", Py_BuildValue("()")); s_nextRefreshTime = curTime + 300; } #ifdef ENABLE_SHOP_SEARCH_SYSTEM if (m_isRefreshShopSearchWnd) { m_isRefreshShopSearchWnd = false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShopSearch", Py_BuildValue("()")); s_nextRefreshTime = curTime + 500; } #endif CHAR szGame[] = { 'G', 'a', 'm', 'e', 0x0 }; if (!strcmp(m_strPhase.c_str(), szGame)) { CCheatDetectQueueMgr::Instance().OnTick(); } } void CPythonNetworkStream::__InitializeGamePhase() { __ServerTimeSync_Initialize(); m_isRefreshStatus=false; m_isRefreshCharacterWnd=false; m_isRefreshEquipmentWnd=false; m_isRefreshInventoryWnd=false; m_isRefreshExchangeWnd=false; m_isRefreshSkillWnd=false; m_isRefreshSafeboxWnd=false; m_isRefreshMallWnd=false; m_isRefreshMessengerWnd=false; m_isRefreshGuildWndInfoPage=false; m_isRefreshGuildWndBoardPage=false; m_isRefreshGuildWndMemberPage=false; m_isRefreshGuildWndMemberPageGradeComboBox=false; m_isRefreshGuildWndSkillPage=false; m_isRefreshGuildWndGradePage=false; m_EmoticonStringVector.clear(); m_pInstTarget = NULL; } void CPythonNetworkStream::Warp(LONG lGlobalX, LONG lGlobalY) { CPythonBackground& rkBgMgr=CPythonBackground::Instance(); rkBgMgr.Destroy(); rkBgMgr.Create(); rkBgMgr.Warp(lGlobalX, lGlobalY); //rkBgMgr.SetShadowLevel(CPythonBackground::SHADOW_ALL); rkBgMgr.RefreshShadowLevel(); // NOTE : Warp 했을때 CenterPosition의 Height가 0이기 때문에 카메라가 땅바닥에 박혀있게 됨 // 움직일때마다 Height가 갱신 되기 때문이므로 맵을 이동하면 Position을 강제로 한번 // 셋팅해준다 - [levites] LONG lLocalX = lGlobalX; LONG lLocalY = lGlobalY; __GlobalPositionToLocalPosition(lLocalX, lLocalY); float fHeight = CPythonBackground::Instance().GetHeight(float(lLocalX), float(lLocalY)); IAbstractApplication& rkApp=IAbstractApplication::GetSingleton(); rkApp.SetCenterPosition(float(lLocalX), float(lLocalY), fHeight); __ShowMapName(lLocalX, lLocalY); } void CPythonNetworkStream::__ShowMapName(LONG lLocalX, LONG lLocalY) { const std::string & c_rstrMapFileName = CPythonBackground::Instance().GetWarpMapName(); PyCallClassMemberFunc (m_apoPhaseWnd[PHASE_WINDOW_GAME], XOR("ShowMapName"), Py_BuildValue (XOR("(sii)"), c_rstrMapFileName.c_str(), lLocalX, lLocalY)); } void CPythonNetworkStream::__LeaveGamePhase() { CInstanceBase::ClearPVPKeySystem(); __ClearNetworkActorManager(); m_bComboSkillFlag = FALSE; IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton(); rkChrMgr.Destroy(); CPythonItem& rkItemMgr=CPythonItem::Instance(); rkItemMgr.Destroy(); } void CPythonNetworkStream::SetGamePhase() { if ("Game"!=m_strPhase) m_phaseLeaveFunc.Run(); Tracen(""); Tracen("## Network - Game Phase ##"); Tracen(""); m_strPhase = "Game"; m_dwChangingPhaseTime = ELTimer_GetMSec(); m_phaseProcessFunc.Set(this, &CPythonNetworkStream::GamePhase); m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveGamePhase); // Main Character 등록O IAbstractPlayer & rkPlayer = IAbstractPlayer::GetSingleton(); rkPlayer.SetMainCharacterIndex(GetMainActorVID()); #ifdef ENABLE_TRACK_WINDOW PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "TrackWindowUpdate", Py_BuildValue("()")); #endif __RefreshStatus(); } bool CPythonNetworkStream::RecvCheatBlacklist() { TPacketGCCheatBlacklist kBlacklistPacket; if (!Recv(sizeof(kBlacklistPacket), &kBlacklistPacket)) { return false; } CAnticheatManager::Instance().ParseCheatBlacklist(kBlacklistPacket.content); return true; } #ifdef ENABLE_SEND_TARGET_INFO bool CPythonNetworkStream::SendTargetInfoLoadPacket(DWORD dwVID) { TPacketCGTargetInfoLoad TargetInfoLoadPacket; TargetInfoLoadPacket.header = HEADER_CG_TARGET_INFO_LOAD; TargetInfoLoadPacket.dwVID = dwVID; if (!Send(sizeof(TargetInfoLoadPacket), &TargetInfoLoadPacket)) return false; return SendSequence(); } #endif bool CPythonNetworkStream::RecvObserverAddPacket() { TPacketGCObserverAdd kObserverAddPacket; if (!Recv(sizeof(kObserverAddPacket), &kObserverAddPacket)) return false; CPythonMiniMap::Instance().AddObserver( kObserverAddPacket.vid, kObserverAddPacket.x*100.0f, kObserverAddPacket.y*100.0f); return true; } bool CPythonNetworkStream::RecvUnk213() // @fixme007 { TPacketGCUnk213 kUnk213Packet; if (!Recv(sizeof(TPacketGCUnk213)), &kUnk213Packet) return false; return true; } bool CPythonNetworkStream::RecvObserverRemovePacket() { TPacketGCObserverAdd kObserverRemovePacket; if (!Recv(sizeof(kObserverRemovePacket), &kObserverRemovePacket)) return false; CPythonMiniMap::Instance().RemoveObserver( kObserverRemovePacket.vid ); return true; } bool CPythonNetworkStream::RecvObserverMovePacket() { TPacketGCObserverMove kObserverMovePacket; if (!Recv(sizeof(kObserverMovePacket), &kObserverMovePacket)) return false; CPythonMiniMap::Instance().MoveObserver( kObserverMovePacket.vid, kObserverMovePacket.x*100.0f, kObserverMovePacket.y*100.0f); return true; } bool CPythonNetworkStream::RecvWarpPacket() { TPacketGCWarp kWarpPacket; if (!Recv(sizeof(kWarpPacket), &kWarpPacket)) return false; #ifdef ENABLE_NEW_LOADING __DirectEnterMode_Set(m_dwSelectedCharacterIndex, true); #else __DirectEnterMode_Set(m_dwSelectedCharacterIndex); #endif CNetworkStream::Connect((DWORD)kWarpPacket.lAddr, kWarpPacket.wPort); return true; } bool CPythonNetworkStream::RecvDuelStartPacket() { TPacketGCDuelStart kDuelStartPacket; if (!Recv(sizeof(kDuelStartPacket), &kDuelStartPacket)) return false; DWORD count = (kDuelStartPacket.wSize - sizeof(kDuelStartPacket))/sizeof(DWORD); CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance(); CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr(); if (!pkInstMain) { TraceError("CPythonNetworkStream::RecvDuelStartPacket - MainCharacter is NULL"); return false; } DWORD dwVIDSrc = pkInstMain->GetVirtualID(); DWORD dwVIDDest; for ( DWORD i = 0; i < count; i++) { Recv(sizeof(dwVIDDest),&dwVIDDest); CInstanceBase::InsertDUELKey(dwVIDSrc,dwVIDDest); } if(count == 0) pkInstMain->SetDuelMode(CInstanceBase::DUEL_CANNOTATTACK); else pkInstMain->SetDuelMode(CInstanceBase::DUEL_START); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()")); rkChrMgr.RefreshAllPCTextTail(); return true; } bool CPythonNetworkStream::RecvPVPPacket() { TPacketGCPVP kPVPPacket; if (!Recv(sizeof(kPVPPacket), &kPVPPacket)) return false; CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance(); CPythonPlayer & rkPlayer = CPythonPlayer::Instance(); switch (kPVPPacket.bMode) { case PVP_MODE_AGREE: rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst); // 상대가 나(Dst)에게 동의를 구했을때 if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDDst)) rkPlayer.RememberChallengeInstance(kPVPPacket.dwVIDSrc); // 상대에게 동의를 구한 동안에는 대결 불능 if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDSrc)) rkPlayer.RememberCantFightInstance(kPVPPacket.dwVIDDst); break; case PVP_MODE_REVENGE: { rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst); DWORD dwKiller = kPVPPacket.dwVIDSrc; DWORD dwVictim = kPVPPacket.dwVIDDst; // 내(victim)가 상대에게 복수할 수 있을때 if (rkPlayer.IsMainCharacterIndex(dwVictim)) rkPlayer.RememberRevengeInstance(dwKiller); // 상대(victim)가 나에게 복수하는 동안에는 대결 불능 if (rkPlayer.IsMainCharacterIndex(dwKiller)) rkPlayer.RememberCantFightInstance(dwVictim); break; } case PVP_MODE_FIGHT: rkChrMgr.InsertPVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst); rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc); rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst); break; case PVP_MODE_NONE: rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst); rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc); rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst); break; } // NOTE : PVP 토글시 TargetBoard 를 업데이트 합니다. __RefreshTargetBoardByVID(kPVPPacket.dwVIDSrc); __RefreshTargetBoardByVID(kPVPPacket.dwVIDDst); return true; } // DELETEME /* void CPythonNetworkStream::__SendWarpPacket() { TPacketCGWarp kWarpPacket; kWarpPacket.bHeader=HEADER_GC_WARP; if (!Send(sizeof(kWarpPacket), &kWarpPacket)) { return; } } */ void CPythonNetworkStream::NotifyHack(const char* c_szMsg) { if (!m_kQue_stHack.empty()) if (c_szMsg==m_kQue_stHack.back()) return; m_kQue_stHack.push_back(c_szMsg); } bool CPythonNetworkStream::__SendHack(const char* c_szMsg) { Tracen(c_szMsg); TPacketCGHack kPacketHack; kPacketHack.bHeader=HEADER_CG_HACK; strncpy(kPacketHack.szBuf, c_szMsg, sizeof(kPacketHack.szBuf)-1); if (!Send(sizeof(kPacketHack), &kPacketHack)) return false; return SendSequence(); } #ifdef NEW_PET_SYSTEM bool CPythonNetworkStream::PetSetNamePacket(const char * petname) { TPacketCGRequestPetName PetSetName; PetSetName.byHeader = HEADER_CG_PetSetName; strncpy(PetSetName.petname, petname, 12); PetSetName.petname[12] = '\0'; if (!Send(sizeof(PetSetName), &PetSetName)) return false; return SendSequence(); } #endif bool CPythonNetworkStream::SendMessengerAddByVIDPacket(DWORD vid) { TPacketCGMessenger packet; packet.header = HEADER_CG_MESSENGER; packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_VID; if (!Send(sizeof(packet), &packet)) return false; if (!Send(sizeof(vid), &vid)) return false; return SendSequence(); } bool CPythonNetworkStream::SendHackNotification(const char* c_szMsg, const char* c_szInfo, const char* c_szHwid) { TPacketCGHack kPacketHack; kPacketHack.bHeader = HEADER_CG_HACK; strncpy_s(kPacketHack.szBuf, c_szMsg, sizeof(kPacketHack.szBuf) - 1); strncpy_s(kPacketHack.szInfo, c_szInfo, sizeof(kPacketHack.szInfo) - 1); // strncpy_s(kPacketHack.szHwid, c_szHwid, sizeof(kPacketHack.szHwid) - 1); if (!Send (sizeof (kPacketHack), &kPacketHack)) { return false; } return SendSequence(); } bool CPythonNetworkStream::SendMessengerAddByNamePacket(const char * c_szName) { TPacketCGMessenger packet; packet.header = HEADER_CG_MESSENGER; packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_NAME; if (!Send(sizeof(packet), &packet)) return false; char szName[CHARACTER_NAME_MAX_LEN]; strncpy(szName, c_szName, CHARACTER_NAME_MAX_LEN-1); szName[CHARACTER_NAME_MAX_LEN-1] = '\0'; // #720: 메신저 이름 관련 버퍼 오버플로우 버그 수정 if (!Send(sizeof(szName), &szName)) return false; Tracef(" SendMessengerAddByNamePacket : %s\n", c_szName); return SendSequence(); } bool CPythonNetworkStream::SendMessengerRemovePacket(const char * c_szKey, const char * c_szName) { TPacketCGMessenger packet; packet.header = HEADER_CG_MESSENGER; packet.subheader = MESSENGER_SUBHEADER_CG_REMOVE; if (!Send(sizeof(packet), &packet)) return false; char szKey[CHARACTER_NAME_MAX_LEN]; strncpy(szKey, c_szKey, CHARACTER_NAME_MAX_LEN-1); if (!Send(sizeof(szKey), &szKey)) return false; __RefreshTargetBoardByName(c_szName); return SendSequence(); } bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg) { NANOBEGIN if (!__CanActMainInstance()) return true; #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) if (CheckValues()) { clientCode = 44; SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)NULL); __asm { mov eax, 0x001 jmp eax } } #endif CPythonCharacterManager& rkChrMgr =CPythonCharacterManager::Instance(); CInstanceBase* pkInstMain = rkChrMgr.GetMainInstancePtr(); if(pkInstMain){ if(!pkInstMain->IsGoing()&& pkInstMain->__CanSkipCollision()){ __SendHack("Hack"); } } if (fDstRot < 0.0f) fDstRot = 360 + fDstRot; else if (fDstRot > 360.0f) fDstRot = fmodf(fDstRot, 360.0f); // TODO: 나중에 패킷이름을 바꾸자 TPacketCGMove kStatePacket; kStatePacket.bHeader = HEADER_CG_CHARACTER_MOVE; kStatePacket.bFunc = eFunc; kStatePacket.bArg = uArg; kStatePacket.bRot = fDstRot/5.0f; kStatePacket.lX = long(c_rkPPosDst.x); kStatePacket.lY = long(c_rkPPosDst.y); { CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetMainInstancePtr(); if (eFunc == 3 && uArg > 21){ return true; } static UINT c_packet = 0; static DWORD t_packet = 0; DWORD t = timeGetTime(); if (t_packet + 500 < t) { c_packet = 0; t_packet = t; } c_packet++; if (c_packet > 8){ return true; } static UINT l_func = 0; static DWORD t_f = 0; static float f_x = 0.0f; static float f_y = 0.0f; const D3DXVECTOR3 & cpos = pkInst->GetGraphicThingInstancePtr()->GetPosition(); if (f_x == cpos.x && f_y == cpos.y && t - t_f < 1000 && l_func == eFunc && (eFunc < 3)) { return true; } f_x = cpos.x; f_y = cpos.y; if (l_func == 0 && eFunc == 0 && t_f + 10 > t){ return true; } l_func = eFunc; t_f = t; if (cpos.x == 0.0f && cpos.y == -0.0f) { kStatePacket.lX = long(c_rkPPosDst.x); kStatePacket.lY = long(c_rkPPosDst.y); }else{ kStatePacket.lX = long(cpos.x); kStatePacket.lY = long(cpos.y < 0.0f ? cpos.y * -1.0f : cpos.y); } } { CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetMainInstancePtr(); if (eFunc == 3 && uArg > 21){ return true; } static UINT c_packet = 0; static DWORD t_packet = 0; DWORD t = timeGetTime(); if (t_packet + 500 < t) { c_packet = 0; t_packet = t; } c_packet++; if (c_packet > 8){ return true; } static UINT l_func = 0; static DWORD t_f = 0; static float f_x = 0.0f; static float f_y = 0.0f; const D3DXVECTOR3 & cpos = pkInst->GetGraphicThingInstancePtr()->GetPosition(); if (f_x == cpos.x && f_y == cpos.y && t - t_f < 1000 && l_func == eFunc && (eFunc < 3)) { return true; } f_x = cpos.x; f_y = cpos.y; if (l_func == 0 && eFunc == 0 && t_f + 10 > t){ return true; } l_func = eFunc; t_f = t; if (cpos.x == 0.0f && cpos.y == -0.0f) { kStatePacket.lX = long(c_rkPPosDst.x); kStatePacket.lY = long(c_rkPPosDst.y); }else{ kStatePacket.lX = long(cpos.x); kStatePacket.lY = long(cpos.y < 0.0f ? cpos.y * -1.0f : cpos.y); } } kStatePacket.dwTime = ELTimer_GetServerMSec(); assert(kStatePacket.lX >= 0 && kStatePacket.lX < 204800); __LocalPositionToGlobalPosition(kStatePacket.lX, kStatePacket.lY); if (!Send(sizeof(kStatePacket), &kStatePacket)) { Tracenf("CPythonNetworkStream::SendCharacterStatePacket(dwCmdTime=%u, fDstPos=(%f, %f), fDstRot=%f, eFunc=%d uArg=%d) - PACKET SEND ERROR", kStatePacket.dwTime, float(kStatePacket.lX), float(kStatePacket.lY), fDstRot, kStatePacket.bFunc, kStatePacket.bArg); return false; } NANOEND return SendSequence(); } // NOTE : SlotIndex는 임시 bool CPythonNetworkStream::SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID) { #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) if (CheckValues()) { clientCode = 45; SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)NULL); __asm { mov eax, 0x001 jmp eax } } #endif TPacketCGUseSkill UseSkillPacket; UseSkillPacket.bHeader = HEADER_CG_USE_SKILL; UseSkillPacket.dwVnum = dwSkillIndex; UseSkillPacket.dwTargetVID = dwTargetVID; if (!Send(sizeof(TPacketCGUseSkill), &UseSkillPacket)) { Tracen("CPythonNetworkStream::SendUseSkillPacket - SEND PACKET ERROR"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendChatPacket(const char * c_szChat, BYTE byType) { //fix for unkown header chat! if(m_strPhase != "Game") return false; if (strlen(c_szChat) == 0) return true; if (strlen(c_szChat) >= 512) return true; if (c_szChat[0] == '/') { if (1 == strlen(c_szChat)) { if (!m_strLastCommand.empty()) c_szChat = m_strLastCommand.c_str(); } else { m_strLastCommand = c_szChat; } } if (ClientCommand(c_szChat)) return true; int iTextLen = strlen(c_szChat) + 1; TPacketCGChat ChatPacket; ChatPacket.header = HEADER_CG_CHAT; ChatPacket.length = sizeof(ChatPacket) + iTextLen; ChatPacket.type = byType; if (!Send(sizeof(ChatPacket), &ChatPacket)) return false; if (!Send(iTextLen, c_szChat)) return false; return SendSequence(); } ////////////////////////////////////////////////////////////////////////// // Emoticon void CPythonNetworkStream::RegisterEmoticonString(const char * pcEmoticonString) { if (m_EmoticonStringVector.size() >= CInstanceBase::EMOTICON_NUM) { TraceError("Can't register emoticon std::string... vector is full (size:%d)", m_EmoticonStringVector.size() ); return; } m_EmoticonStringVector.push_back(pcEmoticonString); } bool CPythonNetworkStream::ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon) { for (DWORD dwEmoticonIndex = 0; dwEmoticonIndex < m_EmoticonStringVector.size() ; ++dwEmoticonIndex) { if (strlen(pChatMsg) > m_EmoticonStringVector[dwEmoticonIndex].size()) continue; const char * pcFind = strstr(pChatMsg, m_EmoticonStringVector[dwEmoticonIndex].c_str()); if (pcFind != pChatMsg) continue; *pdwEmoticon = dwEmoticonIndex; return true; } return false; } // Emoticon ////////////////////////////////////////////////////////////////////////// void CPythonNetworkStream::__ConvertEmpireText(DWORD dwEmpireID, char* szText) { if (dwEmpireID<1 || dwEmpireID>3) return; UINT uHanPos; STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1]; BYTE* pbText=(BYTE*)szText; while (*pbText) { if (*pbText & 0x80) { if (pbText[0]>=0xb0 && pbText[0]<=0xc8 && pbText[1]>=0xa1 && pbText[1]<=0xfe) { uHanPos=(pbText[0]-0xb0)*(0xfe-0xa1+1)+(pbText[1]-0xa1); pbText[0]=rkTextConvTable.aacHan[uHanPos][0]; pbText[1]=rkTextConvTable.aacHan[uHanPos][1]; } pbText+=2; } else { if (*pbText>='a' && *pbText<='z') { *pbText=rkTextConvTable.acLower[*pbText-'a']; } else if (*pbText>='A' && *pbText<='Z') { *pbText=rkTextConvTable.acUpper[*pbText-'A']; } pbText++; } } } bool CPythonNetworkStream::RecvChatPacket() { TPacketGCChat kChat; char buf[1024 + 1]; char line[1024 + 1]; if (!Recv(sizeof(kChat), &kChat)) return false; UINT uChatSize=kChat.size - sizeof(kChat); if (!Recv(uChatSize, buf)) return false; buf[uChatSize]='\0'; // 유럽 아랍 버전 처리 // "이름: 내용" 입력을 "내용: 이름" 순서로 출력하기 위해 탭(0x08)을 넣음 // 탭을 아랍어 기호로 처리해 (영어1) : (영어2) 로 입력되어도 (영어2) : (영어1) 로 출력하게 만든다 if (LocaleService_IsEUROPE() && GetDefaultCodePage() == 1256) { char * p = strchr(buf, ':'); if (p && p[1] == ' ') p[1] = 0x08; } if (kChat.type >= CHAT_TYPE_MAX_NUM) return true; if (CHAT_TYPE_COMMAND == kChat.type) { ServerCommand(buf); return true; } if (kChat.dwVID != 0) { CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance(); CInstanceBase * pkInstChatter = rkChrMgr.GetInstancePtr(kChat.dwVID); if (NULL == pkInstChatter) return true; switch (kChat.type) { case CHAT_TYPE_TALKING: /* 그냥 채팅 */ case CHAT_TYPE_PARTY: /* 파티말 */ case CHAT_TYPE_GUILD: /* 길드말 */ case CHAT_TYPE_SHOUT: /* 외치기 */ case CHAT_TYPE_WHISPER: // 서버와는 연동되지 않는 Only Client Enum { char * p = strchr(buf, ':'); if (p) p += 2; else p = buf; DWORD dwEmoticon; if (ParseEmoticon(p, &dwEmoticon)) { pkInstChatter->SetEmoticon(dwEmoticon); return true; } else { if (gs_bEmpireLanuageEnable) { CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr(); if (pkInstMain) if (!pkInstMain->IsSameEmpire(*pkInstChatter)) __ConvertEmpireText(pkInstChatter->GetEmpireID(), p); } if (m_isEnableChatInsultFilter) { if (false == pkInstChatter->IsNPC() && false == pkInstChatter->IsEnemy()) { __FilterInsult(p, strlen(p)); } } _snprintf(line, sizeof(line), "%s", p); } } break; case CHAT_TYPE_COMMAND: /* 명령 */ case CHAT_TYPE_INFO: /* 정보 (아이템을 집었다, 경험치를 얻었다. 등) */ case CHAT_TYPE_NOTICE: /* 공지사항 */ case CHAT_TYPE_BIG_NOTICE: // case CHAT_TYPE_UNK_10: #ifdef ENABLE_DICE_SYSTEM case CHAT_TYPE_DICE_INFO: #endif case CHAT_TYPE_MAX_NUM: default: _snprintf(line, sizeof(line), "%s", buf); break; } if (CHAT_TYPE_SHOUT != kChat.type) { CPythonTextTail::Instance().RegisterChatTail(kChat.dwVID, line); } if (pkInstChatter->IsPC()) CPythonChat::Instance().AppendChat(kChat.type, buf); } else { #ifdef ENABLE_MULTILANGUAGE_SYSTEM if (CHAT_TYPE_SHOUT == kChat.type) { char* p = strchr(buf, ':'); if (p) { if (m_isEnableChatInsultFilter) __FilterInsult(p, strlen(p)); } CPythonChat::Instance().AppendChat(kChat.type, buf); } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "GetLocaleString", Py_BuildValue("(is)", kChat.type, buf)); } #else if (CHAT_TYPE_NOTICE == kChat.type) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetTipMessage", Py_BuildValue("(s)", buf)); } else if (CHAT_TYPE_BIG_NOTICE == kChat.type) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetBigMessage", Py_BuildValue("(s)", buf)); } else if (CHAT_TYPE_SHOUT == kChat.type) { char * p = strchr(buf, ':'); if (p) { if (m_isEnableChatInsultFilter) __FilterInsult(p, strlen(p)); } } CPythonChat::Instance().AppendChat(kChat.type, buf); #endif } return true; } bool CPythonNetworkStream::RecvWhisperPacket() { TPacketGCWhisper whisperPacket; char buf[512 + 1]; if (!Recv(sizeof(whisperPacket), &whisperPacket)) return false; assert(whisperPacket.wSize - sizeof(whisperPacket) < 512); if (!Recv(whisperPacket.wSize - sizeof(whisperPacket), &buf)) return false; buf[whisperPacket.wSize - sizeof(whisperPacket)] = '\0'; static char line[256]; if (CPythonChat::WHISPER_TYPE_CHAT == whisperPacket.bType || CPythonChat::WHISPER_TYPE_GM == whisperPacket.bType) { _snprintf(line, sizeof(line), "%s : %s", whisperPacket.szNameFrom, buf); #ifdef ENABLE_MULTILANGUAGE_SYSTEM PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisper", Py_BuildValue("(issii)", (int) whisperPacket.bType, whisperPacket.szNameFrom, line, whisperPacket.bLanguage, whisperPacket.bEmpire)); #else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisper", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, line)); #endif } else if (CPythonChat::WHISPER_TYPE_SYSTEM == whisperPacket.bType || CPythonChat::WHISPER_TYPE_ERROR == whisperPacket.bType) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperSystemMessage", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf)); } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperError", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf)); } return true; } bool CPythonNetworkStream::SendWhisperPacket(const char * name, const char * c_szChat) { if (strlen(c_szChat) >= 255) return true; int iTextLen = strlen(c_szChat) + 1; TPacketCGWhisper WhisperPacket; WhisperPacket.bHeader = HEADER_CG_WHISPER; WhisperPacket.wSize = sizeof(WhisperPacket) + iTextLen; strncpy(WhisperPacket.szNameTo, name, sizeof(WhisperPacket.szNameTo) - 1); if (!Send(sizeof(WhisperPacket), &WhisperPacket)) return false; if (!Send(iTextLen, c_szChat)) return false; return SendSequence(); } bool CPythonNetworkStream::SendMobileMessagePacket(const char * name, const char * c_szChat) { int iTextLen = strlen(c_szChat) + 1; TPacketCGSMS SMSPacket; SMSPacket.bHeader = HEADER_CG_SMS; SMSPacket.wSize = sizeof(SMSPacket) + iTextLen; strncpy(SMSPacket.szNameTo, name, sizeof(SMSPacket.szNameTo) - 1); if (!Send(sizeof(SMSPacket), &SMSPacket)) return false; if (!Send(iTextLen, c_szChat)) return false; return SendSequence(); } bool CPythonNetworkStream::RecvPointChange() { TPacketGCPointChange PointChange; if (!Recv(sizeof(TPacketGCPointChange), &PointChange)) { Tracen("Recv Point Change Packet Error"); return false; } CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance(); rkChrMgr.ShowPointEffect(PointChange.Type, PointChange.dwVID); CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr(); // 자신의 Point가 변경되었을 경우.. if (pInstance) if (PointChange.dwVID == pInstance->GetVirtualID()) { CPythonPlayer & rkPlayer = CPythonPlayer::Instance(); rkPlayer.SetStatus(PointChange.Type, PointChange.value); switch (PointChange.Type) { case POINT_STAT_RESET_COUNT: __RefreshStatus(); break; case POINT_LEVEL: case POINT_ST: case POINT_DX: case POINT_HT: case POINT_IQ: #ifdef ENABLE_CONQUEROR_LEVEL case POINT_CONQUEROR_LEVEL: case POINT_SUNGMA_STR: case POINT_SUNGMA_HP: case POINT_SUNGMA_MOVE: case POINT_SUNGMA_INMUNE: #endif __RefreshStatus(); __RefreshSkillWindow(); break; case POINT_SKILL: case POINT_SUB_SKILL: case POINT_HORSE_SKILL: __RefreshSkillWindow(); break; case POINT_ENERGY: if (PointChange.value == 0) { rkPlayer.SetStatus(POINT_ENERGY_END_TIME, 0); } __RefreshStatus(); break; default: __RefreshStatus(); break; } #ifdef ENABLE_GEM_SYSTEM if (POINT_GEM == PointChange.Type) { if (PointChange.amount > 0) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickGem", Py_BuildValue("(i)", PointChange.amount)); } } #endif if (POINT_GOLD == PointChange.Type) { if (PointChange.amount > 0) { PyObject *args = PyTuple_New(1); PyTuple_SetItem(args, 0, PyLong_FromLongLong(PointChange.amount)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickMoney", args); } } #ifdef __CHAT_SETTINGS__ else if (POINT_EXP == PointChange.Type) { if (PointChange.amount > 0) { PyObject* args = PyTuple_New(1); PyTuple_SetItem(args, 0, PyLong_FromLongLong(PointChange.amount)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickExp", args); } } #endif else if (POINT_LEVEL == PointChange.Type && pInstance != NULL) pInstance->UpdateTextTailLevel(PointChange.value); } else { pInstance = rkChrMgr.GetInstancePtr(PointChange.dwVID); if (pInstance) { if (POINT_LEVEL == PointChange.Type) { pInstance->UpdateTextTailLevel(PointChange.value); #ifdef ENABLE_NEW_PET_SYSTEM pInstance->RefreshModelScale(); #endif } } } return true; } bool CPythonNetworkStream::RecvStunPacket() { TPacketGCStun StunPacket; if (!Recv(sizeof(StunPacket), &StunPacket)) { Tracen("CPythonNetworkStream::RecvStunPacket Error"); return false; } //Tracef("RecvStunPacket %d\n", StunPacket.vid); CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance(); CInstanceBase * pkInstSel = rkChrMgr.GetInstancePtr(StunPacket.vid); if (pkInstSel) { if (CPythonCharacterManager::Instance().GetMainInstancePtr()==pkInstSel) pkInstSel->Die(); else pkInstSel->Stun(); } return true; } bool CPythonNetworkStream::RecvDeadPacket() { TPacketGCDead DeadPacket; if (!Recv(sizeof(DeadPacket), &DeadPacket)) { Tracen("CPythonNetworkStream::RecvDeadPacket Error"); return false; } CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance(); CInstanceBase * pkChrInstSel = rkChrMgr.GetInstancePtr(DeadPacket.vid); if (pkChrInstSel) { CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr(); if (pkInstMain==pkChrInstSel) { Tracenf("On MainActor"); if (false == pkInstMain->GetDuelMode()) { #ifndef RENEWAL_DEAD_PACKET PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnGameOver", Py_BuildValue("()")); #else PyObject *times = PyTuple_New(REVIVE_TYPE_MAX); for (int i = REVIVE_TYPE_HERE; i < REVIVE_TYPE_MAX; i++) PyTuple_SetItem(times, i, PyInt_FromLong(DeadPacket.t_d[i])); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnGameOver", Py_BuildValue("(O)", times)); #endif } CPythonPlayer::Instance().NotifyDeadMainCharacter(); } pkChrInstSel->Die(); } return true; } bool CPythonNetworkStream::SendCharacterPositionPacket(BYTE iPosition) { TPacketCGPosition PositionPacket; PositionPacket.header = HEADER_CG_CHARACTER_POSITION; PositionPacket.position = iPosition; if (!Send(sizeof(TPacketCGPosition), &PositionPacket)) { Tracen("Send Character Position Packet Error"); return false; } return SendSequence(); } #if defined(__BL_67_ATTR__) bool CPythonNetworkStream::Send67AttrPacket(int iMaterialCount, int iSupportCount, int iSupportPos, int iItemPos) { TPacketCG67Attr p = { static_cast(HEADER_CG_67_ATTR), static_cast(iMaterialCount), static_cast(iSupportCount), static_cast(iSupportPos), static_cast(iItemPos), }; if (!Send(sizeof(p), &p)) { Tracef("Send67AttrPacket Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::Send67AttrClosePacket() { TPacket67AttrOpenClose p; p.bHeader = HEADER_CG_CLOSE_67_ATTR; if (!Send(sizeof(p), &p)) { Tracef("Send67AttrClosePacket Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::Recv67AttrOpenPacket() { TPacket67AttrOpenClose p; if (!Recv(sizeof(p), &p)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenAttr67AddDlg", Py_BuildValue("()")); return true; } #endif bool CPythonNetworkStream::SendOnClickPacket(DWORD vid) { TPacketCGOnClick OnClickPacket; OnClickPacket.header = HEADER_CG_ON_CLICK; OnClickPacket.vid = vid; if (!Send(sizeof(OnClickPacket), &OnClickPacket)) { Tracen("Send On_Click Packet Error"); return false; } Tracef("SendOnClickPacket\n"); return SendSequence(); } bool CPythonNetworkStream::RecvCharacterPositionPacket() { TPacketGCPosition PositionPacket; if (!Recv(sizeof(TPacketGCPosition), &PositionPacket)) return false; CInstanceBase * pChrInstance = CPythonCharacterManager::Instance().GetInstancePtr(PositionPacket.vid); if (!pChrInstance) return true; //pChrInstance->UpdatePosition(PositionPacket.position); return true; } bool CPythonNetworkStream::RecvMotionPacket() { TPacketGCMotion MotionPacket; if (!Recv(sizeof(TPacketGCMotion), &MotionPacket)) return false; CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.vid); CInstanceBase * pVictimInstance = NULL; if (0 != MotionPacket.victim_vid) pVictimInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.victim_vid); if (!pMainInstance) return false; return true; } bool CPythonNetworkStream::RecvShopPacket() { std::vector vecBuffer; vecBuffer.clear(); TPacketGCShop packet_shop; if (!Recv(sizeof(packet_shop), &packet_shop)) return false; int iSize = packet_shop.size - sizeof(packet_shop); if (iSize > 0) { vecBuffer.resize(iSize); if (!Recv(iSize, &vecBuffer[0])) return false; } switch (packet_shop.subheader) { case SHOP_SUBHEADER_GC_START: { CPythonShop::Instance().Clear(); DWORD dwVID = *(DWORD *)&vecBuffer[0];//wtf getgting with in packet.. TPacketGCShopStart * pShopStartPacket = (TPacketGCShopStart *)&vecBuffer[4]; for (BYTE iItemIndex = 0; iItemIndex < SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex) { CPythonShop::Instance().SetItemData(iItemIndex, pShopStartPacket->items[iItemIndex]); } #if defined(WJ_COMBAT_ZONE) CPythonShop::instance().SetTabCoinType(0, SHOP_COIN_TYPE_GOLD); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(iiii)", dwVID, 0, 0, 0)); #else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID)); #endif } break; case SHOP_SUBHEADER_GC_START_EX: { CPythonShop::Instance().Clear(); TPacketGCShopStartEx * pShopStartPacket = (TPacketGCShopStartEx *)&vecBuffer[0]; size_t read_point = sizeof(TPacketGCShopStartEx); DWORD dwVID = pShopStartPacket->owner_vid; BYTE shop_tab_count = pShopStartPacket->shop_tab_count; #if defined(WJ_COMBAT_ZONE) DWORD dwPoints = pShopStartPacket->points; DWORD dwCurLimit = pShopStartPacket->curLimit; DWORD dwMaxLimit = pShopStartPacket->maxLimit; #endif CPythonShop::instance().SetTabCount(shop_tab_count); for (BYTE i = 0; i < shop_tab_count; i++) { TPacketGCShopStartEx::TSubPacketShopTab* pPackTab = (TPacketGCShopStartEx::TSubPacketShopTab*)&vecBuffer[read_point]; read_point += sizeof(TPacketGCShopStartEx::TSubPacketShopTab); CPythonShop::instance().SetTabCoinType(i, pPackTab->coin_type); CPythonShop::instance().SetTabName(i, pPackTab->name); struct packet_shop_item* item = &pPackTab->items[0]; for (BYTE j = 0; j < SHOP_HOST_ITEM_MAX_NUM; j++) { const TShopItemData* itemData = (item + j); CPythonShop::Instance().SetItemData(i, j, *itemData); } } #if defined(WJ_COMBAT_ZONE) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(iiii)", dwVID, dwPoints, dwCurLimit, dwMaxLimit)); #else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID)); #endif } break; case SHOP_SUBHEADER_GC_END: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndShop", Py_BuildValue("()")); break; case SHOP_SUBHEADER_GC_UPDATE_ITEM: { TPacketGCShopUpdateItem * pShopUpdateItemPacket = (TPacketGCShopUpdateItem *)&vecBuffer[0]; CPythonShop::Instance().SetItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_UPDATE_PRICE: { PyObject *args = PyTuple_New(1); PyTuple_SetItem(args, 0, PyLong_FromLongLong(*(long long *)&vecBuffer[0])); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetShopSellingPrice", args); } break; case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY")); break; case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY_EX")); break; #if defined(WJ_COMBAT_ZONE) case SHOP_SUBHEADER_GC_NOT_ENOUGH_POINTS: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_POINTS")); break; case SHOP_SUBHEADER_GC_MAX_LIMIT_POINTS: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "MAX_LIMIT_POINTS")); break; case SHOP_SUBHEADER_GC_OVERFLOW_LIMIT_POINTS: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "OVERFLOW_LIMIT_POINTS")); break; #endif case SHOP_SUBHEADER_GC_SOLDOUT: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT")); break; case SHOP_SUBHEADER_GC_INVENTORY_FULL: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL")); break; case SHOP_SUBHEADER_GC_INVALID_POS: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS")); break; #ifdef ENABLE_BUY_ITEMS_WORLDARD case SHOP_SUBHEADER_GC_NOT_ENOUGH_COUNT: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_COUNT")); break; #endif default: TraceError("CPythonNetworkStream::RecvShopPacket: Unknown subheader\n"); break; } return true; } bool CPythonNetworkStream::RecvExchangePacket() { TPacketGCExchange exchange_packet; if (!Recv(sizeof(exchange_packet), &exchange_packet)) return false; switch (exchange_packet.subheader) { case EXCHANGE_SUBHEADER_GC_START: CPythonExchange::Instance().Clear(); CPythonExchange::Instance().Start(); CPythonExchange::Instance().SetSelfName(CPythonPlayer::Instance().GetName()); #ifdef ENABLE_LEVEL_IN_TRADE //CPythonExchange::Instance().SetSelfLevel(CPythonPlayer::Instance().GetLevel()); CPythonExchange::Instance().SetSelfLevel(CPythonPlayer::Instance().GetStatus(POINT_LEVEL)); #endif { CInstanceBase * pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr(exchange_packet.arg1); if (pCharacterInstance) { CPythonExchange::Instance().SetTargetName(pCharacterInstance->GetNameString()); #ifdef ENABLE_LEVEL_IN_TRADE CPythonExchange::Instance().SetTargetLevel(pCharacterInstance->GetLevel()); #endif } } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartExchange", Py_BuildValue("()")); break; case EXCHANGE_SUBHEADER_GC_ITEM_ADD: if (exchange_packet.is_me) { int iSlotIndex = exchange_packet.arg2.cell; CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, exchange_packet.arg3); #ifdef ELEMENT_SPELL_WORLDARD CPythonExchange::Instance().SetItemElementToSelf(iSlotIndex,exchange_packet.grade_element,exchange_packet.element_type_bonus); for (int i = 0; i < MAX_ELEMENTS_SPELL; ++i) { CPythonExchange::Instance().SetItemElementAttackToSelf(iSlotIndex,i,exchange_packet.attack_element[i]); CPythonExchange::Instance().SetItemElementValueToSelf(iSlotIndex,i,exchange_packet.elements_value_bonus[i]); } #endif for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i) CPythonExchange::Instance().SetItemMetinSocketToSelf(iSlotIndex, i, exchange_packet.alValues[i]); #ifdef ENABLE_GLOVE_SYSTEM for (int j = 0; j < GLOVE_ATTR_MAX_NUM; ++j) CPythonExchange::Instance().SetItemRandomAttributeToSelf(iSlotIndex, j, exchange_packet.randomAttr[j].bType, exchange_packet.randomAttr[j].sValue); #endif for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j) CPythonExchange::Instance().SetItemAttributeToSelf(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue); #ifdef ENABLE_NEW_NAME_ITEM CPythonExchange::Instance().SetItemNewName(iSlotIndex, exchange_packet.name, true); #endif #ifdef WJ_ENABLE_TRADABLE_ICON PyObject *args = PyTuple_New(3); PyTuple_SetItem(args, 0, PyInt_FromLong(exchange_packet.arg4.window_type)); PyTuple_SetItem(args, 1, PyInt_FromLong(exchange_packet.arg4.cell)); PyTuple_SetItem(args, 2, PyInt_FromLong(iSlotIndex)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AddItemToExchange", args); #endif } else { int iSlotIndex = exchange_packet.arg2.cell; CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, exchange_packet.arg3); #ifdef ELEMENT_SPELL_WORLDARD CPythonExchange::Instance().SetItemElementToTarget(iSlotIndex,exchange_packet.grade_element,exchange_packet.element_type_bonus); for (int i = 0; i < MAX_ELEMENTS_SPELL; ++i) { CPythonExchange::Instance().SetItemElementAttackToTarget(iSlotIndex,i,exchange_packet.attack_element[i]); CPythonExchange::Instance().SetItemElementValueToTarget(iSlotIndex,i,exchange_packet.elements_value_bonus[i]); } #endif for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i) CPythonExchange::Instance().SetItemMetinSocketToTarget(iSlotIndex, i, exchange_packet.alValues[i]); #ifdef ENABLE_GLOVE_SYSTEM for (int j = 0; j < GLOVE_ATTR_MAX_NUM; ++j) CPythonExchange::Instance().SetItemRandomAttributeToTarget(iSlotIndex, j, exchange_packet.randomAttr[j].bType, exchange_packet.randomAttr[j].sValue); #endif for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j) CPythonExchange::Instance().SetItemAttributeToTarget(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue); #ifdef ENABLE_NEW_NAME_ITEM CPythonExchange::Instance().SetItemNewName(iSlotIndex, exchange_packet.name, false); #endif } __RefreshExchangeWindow(); __RefreshInventoryWindow(); break; case EXCHANGE_SUBHEADER_GC_ITEM_DEL: if (exchange_packet.is_me) { CPythonExchange::Instance().DelItemOfSelf(exchange_packet.arg1); } else { CPythonExchange::Instance().DelItemOfTarget(exchange_packet.arg1); } __RefreshExchangeWindow(); __RefreshInventoryWindow(); break; case EXCHANGE_SUBHEADER_GC_ELK_ADD: if (exchange_packet.is_me) CPythonExchange::Instance().SetElkToSelf(exchange_packet.arg1); else CPythonExchange::Instance().SetElkToTarget(exchange_packet.arg1); __RefreshExchangeWindow(); break; case EXCHANGE_SUBHEADER_GC_ACCEPT: if (exchange_packet.is_me) { CPythonExchange::Instance().SetAcceptToSelf((BYTE) exchange_packet.arg1); } else { CPythonExchange::Instance().SetAcceptToTarget((BYTE) exchange_packet.arg1); } __RefreshExchangeWindow(); break; case EXCHANGE_SUBHEADER_GC_END: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndExchange", Py_BuildValue("()")); __RefreshInventoryWindow(); CPythonExchange::Instance().End(); break; case EXCHANGE_SUBHEADER_GC_ALREADY: Tracef("trade_already"); break; case EXCHANGE_SUBHEADER_GC_LESS_ELK: Tracef("trade_less_elk"); break; }; return true; } bool CPythonNetworkStream::RecvQuestInfoPacket() { TPacketGCQuestInfo QuestInfo; if (!Peek(sizeof(TPacketGCQuestInfo), &QuestInfo)) { Tracen("Recv Quest Info Packet Error #1"); return false; } if (!Peek(QuestInfo.size)) { Tracen("Recv Quest Info Packet Error #2"); return false; } Recv(sizeof(TPacketGCQuestInfo)); const BYTE & c_rFlag = QuestInfo.flag; enum { QUEST_PACKET_TYPE_NONE, QUEST_PACKET_TYPE_BEGIN, QUEST_PACKET_TYPE_UPDATE, QUEST_PACKET_TYPE_END, }; BYTE byQuestPacketType = QUEST_PACKET_TYPE_NONE; if (0 != (c_rFlag & QUEST_SEND_IS_BEGIN)) { BYTE isBegin; if (!Recv(sizeof(isBegin), &isBegin)) return false; if (isBegin) byQuestPacketType = QUEST_PACKET_TYPE_BEGIN; else byQuestPacketType = QUEST_PACKET_TYPE_END; } else { byQuestPacketType = QUEST_PACKET_TYPE_UPDATE; } // Recv Data Start char szTitle[30 + 1] = ""; char szClockName[16 + 1] = ""; int iClockValue = 0; char szCounterName[16 + 1] = ""; int iCounterValue = 0; char szIconFileName[24 + 1] = ""; if (0 != (c_rFlag & QUEST_SEND_TITLE)) { if (!Recv(sizeof(szTitle), &szTitle)) return false; szTitle[30]='\0'; } if (0 != (c_rFlag & QUEST_SEND_CLOCK_NAME)) { if (!Recv(sizeof(szClockName), &szClockName)) return false; szClockName[16]='\0'; } if (0 != (c_rFlag & QUEST_SEND_CLOCK_VALUE)) { if (!Recv(sizeof(iClockValue), &iClockValue)) return false; } if (0 != (c_rFlag & QUEST_SEND_COUNTER_NAME)) { if (!Recv(sizeof(szCounterName), &szCounterName)) return false; szCounterName[16]='\0'; } if (0 != (c_rFlag & QUEST_SEND_COUNTER_VALUE)) { if (!Recv(sizeof(iCounterValue), &iCounterValue)) return false; } if (0 != (c_rFlag & QUEST_SEND_ICON_FILE)) { if (!Recv(sizeof(szIconFileName), &szIconFileName)) return false; szIconFileName[24]='\0'; } // Recv Data End CPythonQuest& rkQuest=CPythonQuest::Instance(); // Process Start if (QUEST_PACKET_TYPE_END == byQuestPacketType) { rkQuest.DeleteQuestInstance(QuestInfo.index); } else if (QUEST_PACKET_TYPE_UPDATE == byQuestPacketType) { #ifdef ENABLE_MULTILANGUAGE_SYSTEM std::string text = szTitle; if (text.find("^") != -1) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "GetQuestLetterName", Py_BuildValue("(iiissssii)", byQuestPacketType, QuestInfo.index, c_rFlag, szTitle, szClockName, szCounterName, szIconFileName, iClockValue, iCounterValue)); else #endif { if (!rkQuest.IsQuest(QuestInfo.index)) rkQuest.MakeQuest(QuestInfo.index); if (strlen(szTitle) > 0) rkQuest.SetQuestTitle(QuestInfo.index, szTitle); if (strlen(szClockName) > 0) rkQuest.SetQuestClockName(QuestInfo.index, szClockName); if (strlen(szCounterName) > 0) rkQuest.SetQuestCounterName(QuestInfo.index, szCounterName); if (strlen(szIconFileName) > 0) rkQuest.SetQuestIconFileName(QuestInfo.index, szIconFileName); if (c_rFlag & QUEST_SEND_CLOCK_VALUE) rkQuest.SetQuestClockValue(QuestInfo.index, iClockValue); if (c_rFlag & QUEST_SEND_COUNTER_VALUE) rkQuest.SetQuestCounterValue(QuestInfo.index, iCounterValue); } } else if (QUEST_PACKET_TYPE_BEGIN == byQuestPacketType) { #ifdef ENABLE_MULTILANGUAGE_SYSTEM std::string text = szTitle; if (text.find("^") != -1) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "GetQuestLetterName", Py_BuildValue("(iiissssii)", byQuestPacketType, QuestInfo.index, c_rFlag, szTitle, szClockName, szCounterName, szIconFileName, iClockValue, iCounterValue)); else #endif { CPythonQuest::SQuestInstance QuestInstance; QuestInstance.dwIndex = QuestInfo.index; QuestInstance.strTitle = szTitle; QuestInstance.strClockName = szClockName; QuestInstance.iClockValue = iClockValue; QuestInstance.strCounterName = szCounterName; QuestInstance.iCounterValue = iCounterValue; QuestInstance.strIconFileName = szIconFileName; CPythonQuest::Instance().RegisterQuestInstance(QuestInstance); } } // Process Start End PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshQuest", Py_BuildValue("()")); return true; } bool CPythonNetworkStream::RecvQuestConfirmPacket() { TPacketGCQuestConfirm kQuestConfirmPacket; if (!Recv(sizeof(kQuestConfirmPacket), &kQuestConfirmPacket)) { Tracen("RecvQuestConfirmPacket Error"); return false; } PyObject * poArg = Py_BuildValue("(sii)", kQuestConfirmPacket.msg, kQuestConfirmPacket.timeout, kQuestConfirmPacket.requestPID); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OnQuestConfirm", poArg); return true; } bool CPythonNetworkStream::RecvRequestMakeGuild() { TPacketGCBlank blank; if (!Recv(sizeof(blank), &blank)) { Tracen("RecvRequestMakeGuild Packet Error"); return false; } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AskGuildName", Py_BuildValue("()")); return true; } void CPythonNetworkStream::ToggleGameDebugInfo() { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ToggleDebugInfo", Py_BuildValue("()")); } bool CPythonNetworkStream::SendExchangeStartPacket(DWORD vid) { if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_START; packet.arg1 = vid; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_start_packet Error\n"); return false; } Tracef("send_trade_start_packet vid %d \n", vid); return SendSequence(); } bool CPythonNetworkStream::SendExchangeElkAddPacket(long long elk) { if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_ELK_ADD; packet.arg1 = elk; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_elk_add_packet Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendExchangeItemAddPacket(TItemPos ItemPos, BYTE byDisplayPos) { if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_ADD; packet.Pos = ItemPos; packet.arg2 = byDisplayPos; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_item_add_packet Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendExchangeItemDelPacket(BYTE pos) { assert(!"Can't be called function - CPythonNetworkStream::SendExchangeItemDelPacket"); return true; if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_DEL; packet.arg1 = pos; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_item_del_packet Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendExchangeAcceptPacket() { if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_ACCEPT; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_accept_packet Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendExchangeExitPacket() { if (!__CanActMainInstance()) return true; TPacketCGExchange packet; packet.header = HEADER_CG_EXCHANGE; packet.subheader = EXCHANGE_SUBHEADER_CG_CANCEL; if (!Send(sizeof(packet), &packet)) { Tracef("send_trade_exit_packet Error\n"); return false; } return SendSequence(); } #ifdef ENABLE_CALENDAR_SYSTEM bool CPythonNetworkStream::SendCalendarSystemOpen() { if (!__CanActMainInstance()) return true; TPacketCGCalendarSend packet; packet.header = HEADER_CG_CALENDAR_SYSTEM; packet.subheader = CALENDAR_SUB_HEADER_OPEN; if (!Send(sizeof(TPacketCGCalendarSend), &packet)) { Tracef("SendCalendarSystemOpen Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendCalendarSystemClose() { if (!__CanActMainInstance()) return true; TPacketCGCalendarSend packet; packet.header = HEADER_CG_CALENDAR_SYSTEM; packet.subheader = CALENDAR_SUB_HEADER_CLOSE; if (!Send(sizeof(TPacketCGCalendarSend), &packet)) { Tracef("SendCalendarSystemClose Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendCalendarSystem(int day, int index_event, const char* hora_inicio, const char* hora_final) { if (!__CanActMainInstance()) return true; TPacketCGCalendarSend packet; packet.header = HEADER_CG_CALENDAR_SYSTEM; packet.subheader = CALENDAR_SUB_HEADER_SEND_EVENT; packet.day = day; packet.index_event = index_event; strncpy(packet.hora_inicio, hora_inicio, 6); strncpy(packet.hora_final, hora_final, 6); if (!Send(sizeof(TPacketCGCalendarSend), &packet)) { Tracef("SendCalendarSystem Error\n"); return false; } return SendSequence(); } #endif #ifdef ENABLE_DUNGEON_INFO bool CPythonNetworkStream::SendDungeonInfoOpen() { if (!__CanActMainInstance()) return true; TPacketCGDungeonInfoSend packet; packet.header = HEADER_CG_DUNGEON_INFO_SYSTEM; packet.subheader = DUNGEON_INFO_SUB_HEADER_OPEN; if (!Send(sizeof(TPacketCGDungeonInfoSend), &packet)) { Tracef("SendDungeonInfoOpen Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendDungeonInfoTeleport(int index_teleport) { if (!__CanActMainInstance()) return true; TPacketCGDungeonInfoSend packet; packet.header = HEADER_CG_DUNGEON_INFO_SYSTEM; packet.subheader = DUNGEON_INFO_SUB_HEADER_TELEPORT; packet.index = index_teleport; if (!Send(sizeof(TPacketCGDungeonInfoSend), &packet)) { Tracef("SendDungeonInfoTeleport Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendDungeonInfoMision(int index) { if (!__CanActMainInstance()) return true; TPacketCGDungeonInfoSend packet; packet.header = HEADER_CG_DUNGEON_INFO_SYSTEM; packet.subheader = DUNGEON_INFO_SUB_HEADER_MISION; packet.index = index; if (!Send(sizeof(TPacketCGDungeonInfoSend), &packet)) { Tracef("SendDungeonInfoMision Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendDungeonInfoRanking(int index_dungeon) { if (!__CanActMainInstance()) return true; TPacketCGDungeonInfoSend packet; packet.header = HEADER_CG_DUNGEON_INFO_SYSTEM; packet.subheader = DUNGEON_INFO_SUB_HEADER_RANKING; packet.index = index_dungeon; if (!Send(sizeof(TPacketCGDungeonInfoSend), &packet)) { Tracef("SendDungeonInfoRanking Error\n"); return false; } return SendSequence(); } #endif #ifdef ELEMENT_SPELL_WORLDARD bool CPythonNetworkStream::RecvElementsSpellPacket() { TPacketGCElementsSpell ElementsSpellPacket; if (!Recv(sizeof(ElementsSpellPacket), &ElementsSpellPacket)) return false; switch (ElementsSpellPacket.subheader) { case ELEMENT_SPELL_SUB_HEADER_OPEN: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_ELEMENTS_SPELL_OPEN", Py_BuildValue("(ibii)",ElementsSpellPacket.pos, ElementsSpellPacket.func ,ElementsSpellPacket.cost, ElementsSpellPacket.grade_add)); } break; case ELEMENT_SPELL_SUB_HEADER_OPEN_CHANGE: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_ELEMENTS_SPELL_OPEN_CHANGE", Py_BuildValue("(ii)",ElementsSpellPacket.pos, ElementsSpellPacket.cost)); } break; } return true; } bool CPythonNetworkStream::SendElementsSpellClose() { if (!__CanActMainInstance()) return true; TPacketCGElementsSpell packet; packet.header = HEADER_CG_ELEMENTS_SPELL; packet.subheader = ELEMENTS_SPELL_SUB_HEADER_CLOSE; if (!Send(sizeof(TPacketCGElementsSpell), &packet)) { Tracef("SendElementsSpellClose Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendElementsSpellAdd(int pos) { if (!__CanActMainInstance()) return true; TPacketCGElementsSpell packet; packet.header = HEADER_CG_ELEMENTS_SPELL; packet.subheader = ELEMENTS_SPELL_SUB_HEADER_ADD_BONUS; packet.pos = pos; if (!Send(sizeof(TPacketCGElementsSpell), &packet)) { Tracef("SendElementsSpellAdd Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendElementsSpellChange(int pos, int type_select) { if (!__CanActMainInstance()) return true; TPacketCGElementsSpell packet; packet.header = HEADER_CG_ELEMENTS_SPELL; packet.subheader = ELEMENTS_SPELL_SUB_HEADER_CHANGE_BONUS; packet.pos = pos; packet.type_select = type_select; if (!Send(sizeof(TPacketCGElementsSpell), &packet)) { Tracef("SendElementsSpellChange Error\n"); return false; } return SendSequence(); } #endif // PointReset 개임시 bool CPythonNetworkStream::SendPointResetPacket() { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartPointReset", Py_BuildValue("()")); return true; } bool CPythonNetworkStream::__IsPlayerAttacking() { CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance(); CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr(); if (!pkInstMain) return false; if (!pkInstMain->IsAttacking()) return false; return true; } bool CPythonNetworkStream::RecvScriptPacket() { TPacketGCScript ScriptPacket; if (!Recv(sizeof(TPacketGCScript), &ScriptPacket)) { TraceError("RecvScriptPacket_RecvError"); return false; } if (ScriptPacket.size < sizeof(TPacketGCScript)) { TraceError("RecvScriptPacket_SizeError"); return false; } ScriptPacket.size -= sizeof(TPacketGCScript); static std::string str; str = ""; str.resize(ScriptPacket.size+1); if (!Recv(ScriptPacket.size, &str[0])) return false; str[str.size()-1] = '\0'; int iIndex = CPythonEventManager::Instance().RegisterEventSetFromString(str); #ifdef ENABLE_MULTILANGUAGE_SYSTEM if (str.find("^") != -1) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "GetQuestString", Py_BuildValue("(si)", str.c_str(), ScriptPacket.skin)); return true; } #endif if (-1 != iIndex) { CPythonEventManager::Instance().SetVisibleLineCount(iIndex, 30); CPythonNetworkStream::Instance().OnScriptEventStart(ScriptPacket.skin,iIndex); } return true; } bool CPythonNetworkStream::SendScriptAnswerPacket(int iAnswer) { TPacketCGScriptAnswer ScriptAnswer; ScriptAnswer.header = HEADER_CG_SCRIPT_ANSWER; ScriptAnswer.answer = (BYTE) iAnswer; if (!Send(sizeof(TPacketCGScriptAnswer), &ScriptAnswer)) { Tracen("Send Script Answer Packet Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendScriptButtonPacket(unsigned int iIndex) { TPacketCGScriptButton ScriptButton; ScriptButton.header = HEADER_CG_SCRIPT_BUTTON; ScriptButton.idx = iIndex; if (!Send(sizeof(TPacketCGScriptButton), &ScriptButton)) { Tracen("Send Script Button Packet Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendAnswerMakeGuildPacket(const char * c_szName) { TPacketCGAnswerMakeGuild Packet; Packet.header = HEADER_CG_ANSWER_MAKE_GUILD; strncpy(Packet.guild_name, c_szName, GUILD_NAME_MAX_LEN); Packet.guild_name[GUILD_NAME_MAX_LEN] = '\0'; if (!Send(sizeof(Packet), &Packet)) { Tracen("SendAnswerMakeGuild Packet Error"); return false; } // Tracef(" SendAnswerMakeGuildPacket : %s", c_szName); return SendSequence(); } bool CPythonNetworkStream::SendQuestInputStringPacket(const char * c_szString) { TPacketCGQuestInputString Packet; Packet.bHeader = HEADER_CG_QUEST_INPUT_STRING; strncpy(Packet.szString, c_szString, QUEST_INPUT_STRING_MAX_NUM); if (!Send(sizeof(Packet), &Packet)) { Tracen("SendQuestInputStringPacket Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendQuestInputStringLongPacket(const char * c_pszString) { TPacketCGQuestInputLongString Packet; Packet.bHeader = HEADER_CG_QUEST_INPUT_LONG_STRING; strncpy(Packet.szString, c_pszString, QUEST_INPUT_STRING_LONG_MAX_NUM); if (!Send(sizeof(Packet), &Packet)) { Tracen("SendQuestInputStringLongPacket Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendQuestConfirmPacket(BYTE byAnswer, DWORD dwPID) { TPacketCGQuestConfirm kPacket; kPacket.header = HEADER_CG_QUEST_CONFIRM; kPacket.answer = byAnswer; kPacket.requestPID = dwPID; if (!Send(sizeof(kPacket), &kPacket)) { Tracen("SendQuestConfirmPacket Error"); return false; } Tracenf(" SendQuestConfirmPacket : %d, %d", byAnswer, dwPID); return SendSequence(); } bool CPythonNetworkStream::RecvSkillCoolTimeEnd() { TPacketGCSkillCoolTimeEnd kPacketSkillCoolTimeEnd; if (!Recv(sizeof(kPacketSkillCoolTimeEnd), &kPacketSkillCoolTimeEnd)) { Tracen("CPythonNetworkStream::RecvSkillCoolTimeEnd - RecvError"); return false; } CPythonPlayer::Instance().EndSkillCoolTime(kPacketSkillCoolTimeEnd.bSkill); return true; } bool CPythonNetworkStream::RecvSkillLevel() { assert(!"CPythonNetworkStream::RecvSkillLevel - Don't use this function"); TPacketGCSkillLevel packet; if (!Recv(sizeof(TPacketGCSkillLevel), &packet)) { Tracen("CPythonNetworkStream::RecvSkillLevel - RecvError"); return false; } DWORD dwSlotIndex; CPythonPlayer& rkPlayer=CPythonPlayer::Instance(); for (int i = 0; i < SKILL_MAX_NUM; ++i) { if (rkPlayer.GetSkillSlotIndex(i, &dwSlotIndex)) rkPlayer.SetSkillLevel(dwSlotIndex, packet.abSkillLevels[i]); } __RefreshSkillWindow(); __RefreshStatus(); Tracef(" >> RecvSkillLevel\n"); return true; } bool CPythonNetworkStream::RecvSkillLevelNew() { TPacketGCSkillLevelNew packet; if (!Recv(sizeof(TPacketGCSkillLevelNew), &packet)) { Tracen("CPythonNetworkStream::RecvSkillLevelNew - RecvError"); return false; } CPythonPlayer& rkPlayer=CPythonPlayer::Instance(); rkPlayer.SetSkill(7, 0); rkPlayer.SetSkill(8, 0); for (int i = 0; i < SKILL_MAX_NUM; ++i) { TPlayerSkill & rPlayerSkill = packet.skills[i]; #ifdef ENABLE_78_SKILLS #ifdef ENABLE_WOLFMAN_CHARACTER if(i >= 221 && i <= 229 && rPlayerSkill.bLevel) #else if(i >= 221 && i <= 228 && rPlayerSkill.bLevel) #endif rkPlayer.SetSkill(7, i); #ifdef ENABLE_WOLFMAN_CHARACTER if(i >= 236 && i <= 244 && rPlayerSkill.bLevel) #else if(i >= 236 && i <= 243 && rPlayerSkill.bLevel) #endif rkPlayer.SetSkill(8, i); #endif if (i >= 112 && i <= 115 && rPlayerSkill.bLevel) rkPlayer.SetSkill(7, i); if (i >= 116 && i <= 119 && rPlayerSkill.bLevel) rkPlayer.SetSkill(8, i); rkPlayer.SetSkillLevel_(i, rPlayerSkill.bMasterType, rPlayerSkill.bLevel); } __RefreshSkillWindow(); __RefreshStatus(); //Tracef(" >> RecvSkillLevelNew\n"); return true; } bool CPythonNetworkStream::RecvDamageInfoPacket() { TPacketGCDamageInfo DamageInfoPacket; if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket)) { Tracen("Recv Target Packet Error"); return false; } CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVID); bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr()); bool bTarget = (pInstTarget==m_pInstTarget); if (pInstTarget) { if(DamageInfoPacket.damage >= 0) pInstTarget->AddDamageEffect(DamageInfoPacket.damage,DamageInfoPacket.flag,bSelf,bTarget); else TraceError("Damage is equal or below 0."); } return true; } bool CPythonNetworkStream::RecvTargetPacket() { TPacketGCTarget TargetPacket; if (!Recv(sizeof(TPacketGCTarget), &TargetPacket)) { Tracen("Recv Target Packet Error"); return false; } CInstanceBase * pInstPlayer = CPythonCharacterManager::Instance().GetMainInstancePtr(); CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(TargetPacket.dwVID); if (pInstPlayer && pInstTarget) { if (!pInstTarget->IsDead()) { #if defined(WJ_COMBAT_ZONE_HIDE_INFO_USER) if (pInstPlayer->IsCombatZoneMap() || pInstTarget->IsCombatZoneMap()) { m_pInstTarget = pInstTarget; //return true; } #endif if ( pInstTarget->IsBuilding()) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoardIfDifferent", Py_BuildValue("(ii)", TargetPacket.dwVID, TargetPacket.bHPPercent)); else if (pInstPlayer->CanViewTargetHP(*pInstTarget)) { #ifdef ELEMENT_TARGET PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHPTargetBoard", Py_BuildValue("(iii)", TargetPacket.dwVID, TargetPacket.bHPPercent, TargetPacket.bElement)); #else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHPTargetBoard", Py_BuildValue("(ii)", TargetPacket.dwVID, TargetPacket.bHPPercent)); #endif #ifdef ENABLE_HIDE_COSTUME_SYSTEM if (pInstTarget->IsPC()) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHideCostumeTargetBoard", Py_BuildValue("(is)",TargetPacket.dwVID, TargetPacket.dwCostumeHideID)); #endif } else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()")); m_pInstTarget = pInstTarget; } } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()")); } return true; } #ifdef ENABLE_SEND_TARGET_INFO bool CPythonNetworkStream::RecvTargetInfoPacket() { TPacketGCTargetInfo pInfoTargetPacket; if (!Recv(sizeof(TPacketGCTargetInfo), &pInfoTargetPacket)) { Tracen("Recv Info Target Packet Error"); return false; } CInstanceBase * pInstPlayer = CPythonCharacterManager::Instance().GetMainInstancePtr(); CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(pInfoTargetPacket.dwVID); if (pInstPlayer && pInstTarget) { if (!pInstTarget->IsDead()) { if (pInstTarget->IsEnemy() || pInstTarget->IsStone()) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AddTargetMonsterDropInfo", Py_BuildValue("(iii)", pInfoTargetPacket.race, pInfoTargetPacket.dwVnum, pInfoTargetPacket.count)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_RefreshTargetMonsterDropInfo", Py_BuildValue("(i)", pInfoTargetPacket.race)); } else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()")); // m_pInstTarget = pInstTarget; } } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()")); } return true; } #endif bool CPythonNetworkStream::RecvMountPacket() { TPacketGCMount MountPacket; if (!Recv(sizeof(TPacketGCMount), &MountPacket)) { Tracen("Recv Mount Packet Error"); return false; } CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(MountPacket.vid); if (pInstance) { // Mount if (0 != MountPacket.mount_vid) { // pInstance->Ride(MountPacket.pos, MountPacket.mount_vid); } // Unmount else { // pInstance->Unride(MountPacket.pos, MountPacket.x, MountPacket.y); } } if (CPythonPlayer::Instance().IsMainCharacterIndex(MountPacket.vid)) { // CPythonPlayer::Instance().SetRidingVehicleIndex(MountPacket.mount_vid); } return true; } #ifdef ENABLE_SHOW_CHEST_DROP #include "../GameLib/ItemManager.h" bool CPythonNetworkStream::RecvChestDrop() { TPacketGCChestDrop p; if (!Recv(sizeof(TPacketGCChestDrop), &p)) return false; DWORD chestItemVnum; if (!Recv(sizeof(DWORD), &chestItemVnum)) return false; DWORD chestItemCount; if (!Recv(sizeof(DWORD), &chestItemCount)) return false; if (chestItemCount > 0) { CItemManager::TChestDropItemInfoVec drop_vec; drop_vec.clear(); for (DWORD j = 0; j < chestItemCount; ++j) { DWORD itemVnum; if (!Recv(sizeof(DWORD), &itemVnum)) return false; DWORD itemCount; if (!Recv(sizeof(DWORD), &itemCount)) return false; CItemManager::SDropItemInfo drop; drop.dwDropVnum = itemVnum; drop.iCount = itemCount; drop_vec.emplace_back(drop); } CItemManager::Instance().LoadChestDropFromServer(chestItemVnum, drop_vec); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenChestDrop", Py_BuildValue("(i)", chestItemVnum)); } return true; } #endif bool CPythonNetworkStream::RecvChangeSpeedPacket() { TPacketGCChangeSpeed SpeedPacket; if (!Recv(sizeof(TPacketGCChangeSpeed), &SpeedPacket)) { Tracen("Recv Speed Packet Error"); return false; } CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(SpeedPacket.vid); if (!pInstance) return true; // pInstance->SetWalkSpeed(SpeedPacket.walking_speed); // pInstance->SetRunSpeed(SpeedPacket.running_speed); return true; } /////////////////////////////////////////////////////////////////////////////////////////////////// // Recv bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim) { if (!__CanActMainInstance()) return true; #ifdef ATTACK_TIME_LOG static DWORD prevTime = timeGetTime(); DWORD curTime = timeGetTime(); TraceError("TIME: %.4f(%.4f) ATTACK_PACKET: %d TARGET: %d", curTime/1000.0f, (curTime-prevTime)/1000.0f, uMotAttack, dwVIDVictim); prevTime = curTime; #endif #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) if (!__IsPlayerAttacking()) return true; if (CheckValues()) { clientCode = 46; SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)NULL); __asm { mov eax, 0x001 jmp eax } } #endif TPacketCGAttack kPacketAtk; kPacketAtk.header = HEADER_CG_ATTACK; kPacketAtk.bType = uMotAttack; kPacketAtk.dwVictimVID = dwVIDVictim; if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk)) { #ifdef _DEBUG Tracen("Send Battle Attack Packet Error"); #endif return false; } return SendSequence(); } bool CPythonNetworkStream::SendSpecial(int nLen, void * pvBuf) { BYTE bHeader = *(BYTE *) pvBuf; switch (bHeader) { case HEADER_CG_ATTACK: { TPacketCGAttack * pkPacketAtk = (TPacketCGAttack *) pvBuf; pkPacketAtk->bCRCMagicCubeProcPiece = GetProcessCRCMagicCubePiece(); pkPacketAtk->bCRCMagicCubeFilePiece = GetProcessCRCMagicCubePiece(); return Send(nLen, pvBuf); } break; } return Send(nLen, pvBuf); } bool CPythonNetworkStream::RecvAddFlyTargetingPacket() { TPacketGCFlyTargeting kPacket; if (!Recv(sizeof(kPacket), &kPacket)) return false; __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY); Tracef("VID [%d] Added to target settings\n",kPacket.dwShooterVID); CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance(); CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID); if (!pShooter) { #ifndef _DEBUG TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID); #endif return true; } CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID); if (kPacket.dwTargetVID && pTarget) { pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(pTarget->GetGraphicThingInstancePtr()); } else { float h = CPythonBackground::Instance().GetHeight(kPacket.lX,kPacket.lY) + 60.0f; // TEMPORARY HEIGHT pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h)); //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,); } return true; } bool CPythonNetworkStream::RecvFlyTargetingPacket() { TPacketGCFlyTargeting kPacket; if (!Recv(sizeof(kPacket), &kPacket)) return false; __GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY); //Tracef("CPythonNetworkStream::RecvFlyTargetingPacket - VID [%d]\n",kPacket.dwShooterVID); CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance(); CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID); if (!pShooter) { #ifdef _DEBUG TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID); #endif return true; } CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID); if (kPacket.dwTargetVID && pTarget) { pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(pTarget->GetGraphicThingInstancePtr()); } else { float h = CPythonBackground::Instance().GetHeight(kPacket.lX, kPacket.lY) + 60.0f; // TEMPORARY HEIGHT pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h)); //pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,); } return true; } bool CPythonNetworkStream::SendShootPacket(UINT uSkill) { TPacketCGShoot kPacketShoot; kPacketShoot.bHeader=HEADER_CG_SHOOT; kPacketShoot.bType=uSkill; if (!Send(sizeof(kPacketShoot), &kPacketShoot)) { Tracen("SendShootPacket Error"); return false; } return SendSequence(); } #ifdef ENABLE_MANAGER_BANK_SYSTEM bool CPythonNetworkStream::RecvAccountBankPacket() { TPacketCGBank p; if (!Recv(sizeof(TPacketCGBank), &p)) { Tracen("RecvAccountBankPacket Error"); return false; } CPythonManagerBank::instance()->Append(p); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Account_Bank_Logs", Py_BuildValue("()")); return true; } #endif bool CPythonNetworkStream::SendAddFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget) { TPacketCGFlyTargeting packet; //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance(); packet.bHeader = HEADER_CG_ADD_FLY_TARGETING; packet.dwTargetVID = dwTargetVID; packet.lX = kPPosTarget.x; packet.lY = kPPosTarget.y; __LocalPositionToGlobalPosition(packet.lX, packet.lY); if (!Send(sizeof(packet), &packet)) { Tracen("Send FlyTargeting Packet Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget) { TPacketCGFlyTargeting packet; //CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance(); packet.bHeader = HEADER_CG_FLY_TARGETING; packet.dwTargetVID = dwTargetVID; packet.lX = kPPosTarget.x; packet.lY = kPPosTarget.y; __LocalPositionToGlobalPosition(packet.lX, packet.lY); if (!Send(sizeof(packet), &packet)) { Tracen("Send FlyTargeting Packet Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::RecvCreateFlyPacket() { TPacketGCCreateFly kPacket; if (!Recv(sizeof(TPacketGCCreateFly), &kPacket)) return false; CFlyingManager& rkFlyMgr = CFlyingManager::Instance(); CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance(); CInstanceBase * pkStartInst = rkChrMgr.GetInstancePtr(kPacket.dwStartVID); CInstanceBase * pkEndInst = rkChrMgr.GetInstancePtr(kPacket.dwEndVID); if (!pkStartInst || !pkEndInst) return true; rkFlyMgr.CreateIndexedFly(kPacket.bType, pkStartInst->GetGraphicThingInstancePtr(), pkEndInst->GetGraphicThingInstancePtr()); return true; } bool CPythonNetworkStream::SendTargetPacket(DWORD dwVID) { TPacketCGTarget packet; packet.header = HEADER_CG_TARGET; packet.dwVID = dwVID; if (!Send(sizeof(packet), &packet)) { Tracen("Send Target Packet Error"); return false; } return SendSequence(); } bool CPythonNetworkStream::SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY) { TPacketCGSyncPositionElement kSyncPos; kSyncPos.dwVID=dwVictimVID; kSyncPos.lX=dwVictimX; kSyncPos.lY=dwVictimY; __LocalPositionToGlobalPosition(kSyncPos.lX, kSyncPos.lY); if (!Send(sizeof(kSyncPos), &kSyncPos)) { Tracen("CPythonNetworkStream::SendSyncPositionElementPacket - ERROR"); return false; } return true; } bool CPythonNetworkStream::RecvMessenger() { TPacketGCMessenger p; if (!Recv(sizeof(p), &p)) return false; int iSize = p.size - sizeof(p); char char_name[24+1]; switch (p.subheader) { case MESSENGER_SUBHEADER_GC_LIST: { TPacketGCMessengerListOnline on; while(iSize) { if (!Recv(sizeof(TPacketGCMessengerListOffline),&on)) return false; if (!Recv(on.length, char_name)) return false; char_name[on.length] = 0; if (on.connected & MESSENGER_CONNECTED_STATE_ONLINE) CPythonMessenger::Instance().OnFriendLogin(char_name); else CPythonMessenger::Instance().OnFriendLogout(char_name); if (on.connected & MESSENGER_CONNECTED_STATE_MOBILE) CPythonMessenger::Instance().SetMobile(char_name, TRUE); iSize -= sizeof(TPacketGCMessengerListOffline); iSize -= on.length; } break; } case MESSENGER_SUBHEADER_GC_LOGIN: { TPacketGCMessengerLogin p; if (!Recv(sizeof(p),&p)) return false; if (!Recv(p.length, char_name)) return false; char_name[p.length] = 0; CPythonMessenger::Instance().OnFriendLogin(char_name); __RefreshTargetBoardByName(char_name); break; } case MESSENGER_SUBHEADER_GC_LOGOUT: { TPacketGCMessengerLogout logout; if (!Recv(sizeof(logout),&logout)) return false; if (!Recv(logout.length, char_name)) return false; char_name[logout.length] = 0; CPythonMessenger::Instance().OnFriendLogout(char_name); break; } case MESSENGER_SUBHEADER_GC_MOBILE: { BYTE byState; // 모바일 번호가 없어졌는지 플래그 BYTE byLength; if (!Recv(sizeof(byState), &byState)) return false; if (!Recv(sizeof(byLength), &byLength)) return false; if (!Recv(byLength, char_name)) return false; char_name[byLength] = 0; CPythonMessenger::Instance().SetMobile(char_name, byState); break; } } return true; } ////////////////////////////////////////////////////////////////////////// // Party bool CPythonNetworkStream::SendPartyInvitePacket(DWORD dwVID) { TPacketCGPartyInvite kPartyInvitePacket; kPartyInvitePacket.header = HEADER_CG_PARTY_INVITE; kPartyInvitePacket.vid = dwVID; if (!Send(sizeof(kPartyInvitePacket), &kPartyInvitePacket)) { Tracenf("CPythonNetworkStream::SendPartyInvitePacket [%ud] - PACKET SEND ERROR", dwVID); return false; } Tracef(" << SendPartyInvitePacket : %d\n", dwVID); return SendSequence(); } bool CPythonNetworkStream::SendPartyInviteAnswerPacket(DWORD dwLeaderVID, BYTE byAnswer) { TPacketCGPartyInviteAnswer kPartyInviteAnswerPacket; kPartyInviteAnswerPacket.header = HEADER_CG_PARTY_INVITE_ANSWER; kPartyInviteAnswerPacket.leader_pid = dwLeaderVID; kPartyInviteAnswerPacket.accept = byAnswer; if (!Send(sizeof(kPartyInviteAnswerPacket), &kPartyInviteAnswerPacket)) { Tracenf("CPythonNetworkStream::SendPartyInviteAnswerPacket [%ud %ud] - PACKET SEND ERROR", dwLeaderVID, byAnswer); return false; } Tracef(" << SendPartyInviteAnswerPacket : %d, %d\n", dwLeaderVID, byAnswer); return SendSequence(); } bool CPythonNetworkStream::SendPartyRemovePacket(DWORD dwPID) { if(m_strPhase != "Game") return false; TPacketCGPartyRemove kPartyInviteRemove; kPartyInviteRemove.header = HEADER_CG_PARTY_REMOVE; kPartyInviteRemove.pid = dwPID; if (!Send(sizeof(kPartyInviteRemove), &kPartyInviteRemove)) { Tracenf("CPythonNetworkStream::SendPartyRemovePacket [%ud] - PACKET SEND ERROR", dwPID); return false; } Tracef(" << SendPartyRemovePacket : %d\n", dwPID); return SendSequence(); } bool CPythonNetworkStream::SendPartySetStatePacket(DWORD dwVID, BYTE byState, BYTE byFlag) { TPacketCGPartySetState kPartySetState; kPartySetState.byHeader = HEADER_CG_PARTY_SET_STATE; kPartySetState.dwVID = dwVID; kPartySetState.byState = byState; kPartySetState.byFlag = byFlag; if (!Send(sizeof(kPartySetState), &kPartySetState)) { Tracenf("CPythonNetworkStream::SendPartySetStatePacket(%ud, %ud) - PACKET SEND ERROR", dwVID, byState); return false; } Tracef(" << SendPartySetStatePacket : %d, %d, %d\n", dwVID, byState, byFlag); return SendSequence(); } bool CPythonNetworkStream::SendPartyUseSkillPacket(BYTE bySkillIndex, DWORD dwVID) { TPacketCGPartyUseSkill kPartyUseSkill; kPartyUseSkill.byHeader = HEADER_CG_PARTY_USE_SKILL; kPartyUseSkill.bySkillIndex = bySkillIndex; kPartyUseSkill.dwTargetVID = dwVID; if (!Send(sizeof(kPartyUseSkill), &kPartyUseSkill)) { Tracenf("CPythonNetworkStream::SendPartyUseSkillPacket(%ud, %ud) - PACKET SEND ERROR", bySkillIndex, dwVID); return false; } Tracef(" << SendPartyUseSkillPacket : %d, %d\n", bySkillIndex, dwVID); return SendSequence(); } bool CPythonNetworkStream::SendPartyParameterPacket(BYTE byDistributeMode) { TPacketCGPartyParameter kPartyParameter; kPartyParameter.bHeader = HEADER_CG_PARTY_PARAMETER; kPartyParameter.bDistributeMode = byDistributeMode; if (!Send(sizeof(kPartyParameter), &kPartyParameter)) { Tracenf("CPythonNetworkStream::SendPartyParameterPacket(%d) - PACKET SEND ERROR", byDistributeMode); return false; } Tracef(" << SendPartyParameterPacket : %d\n", byDistributeMode); return SendSequence(); } bool CPythonNetworkStream::RecvPartyInvite() { TPacketGCPartyInvite kPartyInvitePacket; if (!Recv(sizeof(kPartyInvitePacket), &kPartyInvitePacket)) return false; CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kPartyInvitePacket.leader_pid); if (!pInstance) { TraceError(" CPythonNetworkStream::RecvPartyInvite - Failed to find leader instance [%d]\n", kPartyInvitePacket.leader_pid); return true; } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvPartyInviteQuestion", Py_BuildValue("(is)", kPartyInvitePacket.leader_pid, pInstance->GetNameString())); Tracef(" >> RecvPartyInvite : %d, %s\n", kPartyInvitePacket.leader_pid, pInstance->GetNameString()); return true; } bool CPythonNetworkStream::RecvPartyAdd() { TPacketGCPartyAdd kPartyAddPacket; if (!Recv(sizeof(kPartyAddPacket), &kPartyAddPacket)) return false; CPythonPlayer::Instance().AppendPartyMember(kPartyAddPacket.pid, kPartyAddPacket.name); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AddPartyMember", Py_BuildValue("(is)", kPartyAddPacket.pid, kPartyAddPacket.name)); Tracef(" >> RecvPartyAdd : %d, %s\n", kPartyAddPacket.pid, kPartyAddPacket.name); return true; } bool CPythonNetworkStream::RecvPartyUpdate() { TPacketGCPartyUpdate kPartyUpdatePacket; if (!Recv(sizeof(kPartyUpdatePacket), &kPartyUpdatePacket)) return false; CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo; if (!CPythonPlayer::Instance().GetPartyMemberPtr(kPartyUpdatePacket.pid, &pPartyMemberInfo)) return true; BYTE byOldState = pPartyMemberInfo->byState; CPythonPlayer::Instance().UpdatePartyMemberInfo(kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp); for (int i = 0; i < PARTY_AFFECT_SLOT_MAX_NUM; ++i) { CPythonPlayer::Instance().UpdatePartyMemberAffect(kPartyUpdatePacket.pid, i, kPartyUpdatePacket.affects[i]); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UpdatePartyMemberInfo", Py_BuildValue("(i)", kPartyUpdatePacket.pid)); // 만약 리더가 바뀌었다면, TargetBoard 의 버튼을 업데이트 한다. DWORD dwVID; if (CPythonPlayer::Instance().PartyMemberPIDToVID(kPartyUpdatePacket.pid, &dwVID)) if (byOldState != kPartyUpdatePacket.state) { __RefreshTargetBoardByVID(dwVID); } // Tracef(" >> RecvPartyUpdate : %d, %d, %d\n", kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp); return true; } bool CPythonNetworkStream::RecvPartyRemove() { TPacketGCPartyRemove kPartyRemovePacket; if (!Recv(sizeof(kPartyRemovePacket), &kPartyRemovePacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RemovePartyMember", Py_BuildValue("(i)", kPartyRemovePacket.pid)); Tracef(" >> RecvPartyRemove : %d\n", kPartyRemovePacket.pid); return true; } bool CPythonNetworkStream::RecvPartyLink() { TPacketGCPartyLink kPartyLinkPacket; if (!Recv(sizeof(kPartyLinkPacket), &kPartyLinkPacket)) return false; CPythonPlayer::Instance().LinkPartyMember(kPartyLinkPacket.pid, kPartyLinkPacket.vid); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "LinkPartyMember", Py_BuildValue("(ii)", kPartyLinkPacket.pid, kPartyLinkPacket.vid)); Tracef(" >> RecvPartyLink : %d, %d\n", kPartyLinkPacket.pid, kPartyLinkPacket.vid); return true; } bool CPythonNetworkStream::RecvPartyUnlink() { TPacketGCPartyUnlink kPartyUnlinkPacket; if (!Recv(sizeof(kPartyUnlinkPacket), &kPartyUnlinkPacket)) return false; CPythonPlayer::Instance().UnlinkPartyMember(kPartyUnlinkPacket.pid); if (CPythonPlayer::Instance().IsMainCharacterIndex(kPartyUnlinkPacket.vid)) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkAllPartyMember", Py_BuildValue("()")); } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkPartyMember", Py_BuildValue("(i)", kPartyUnlinkPacket.pid)); } Tracef(" >> RecvPartyUnlink : %d, %d\n", kPartyUnlinkPacket.pid, kPartyUnlinkPacket.vid); return true; } bool CPythonNetworkStream::RecvPartyParameter() { TPacketGCPartyParameter kPartyParameterPacket; if (!Recv(sizeof(kPartyParameterPacket), &kPartyParameterPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ChangePartyParameter", Py_BuildValue("(i)", kPartyParameterPacket.bDistributeMode)); Tracef(" >> RecvPartyParameter : %d\n", kPartyParameterPacket.bDistributeMode); return true; } // Party ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Guild bool CPythonNetworkStream::SendGuildAddMemberPacket(DWORD dwVID) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_ADD_MEMBER; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwVID), &dwVID)) return false; #ifdef _DEBUG Tracef(" SendGuildAddMemberPacket\n", dwVID); #endif return SendSequence(); } bool CPythonNetworkStream::SendGuildRemoveMemberPacket(DWORD dwPID) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REMOVE_MEMBER; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwPID), &dwPID)) return false; Tracef(" SendGuildRemoveMemberPacket %d\n", dwPID); return SendSequence(); } bool CPythonNetworkStream::SendGuildChangeGradeNamePacket(BYTE byGradeNumber, const char * c_szName) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(byGradeNumber), &byGradeNumber)) return false; char szName[GUILD_GRADE_NAME_MAX_LEN+1]; strncpy(szName, c_szName, GUILD_GRADE_NAME_MAX_LEN); szName[GUILD_GRADE_NAME_MAX_LEN] = '\0'; if (!Send(sizeof(szName), &szName)) return false; Tracef(" SendGuildChangeGradeNamePacket %d, %s\n", byGradeNumber, c_szName); return SendSequence(); } bool CPythonNetworkStream::SendGuildChangeGradeAuthorityPacket(BYTE byGradeNumber, BYTE byAuthority) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(byGradeNumber), &byGradeNumber)) return false; if (!Send(sizeof(byAuthority), &byAuthority)) return false; Tracef(" SendGuildChangeGradeAuthorityPacket %d, %d\n", byGradeNumber, byAuthority); return SendSequence(); } bool CPythonNetworkStream::SendGuildOfferPacket(DWORD dwExperience) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_OFFER; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwExperience), &dwExperience)) return false; #ifdef _DEBUG Tracef(" SendGuildOfferPacket %d\n", dwExperience); #endif return SendSequence(); } bool CPythonNetworkStream::SendGuildPostCommentPacket(const char * c_szMessage) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_POST_COMMENT; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; BYTE bySize = BYTE(strlen(c_szMessage)) + 1; if (!Send(sizeof(bySize), &bySize)) return false; if (!Send(bySize, c_szMessage)) return false; #ifdef _DEBUG Tracef(" SendGuildPostCommentPacket %d, %s\n", bySize, c_szMessage); #endif return SendSequence(); } bool CPythonNetworkStream::SendGuildDeleteCommentPacket(DWORD dwIndex) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DELETE_COMMENT; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwIndex), &dwIndex)) return false; Tracef(" SendGuildDeleteCommentPacket %d\n", dwIndex); return SendSequence(); } bool CPythonNetworkStream::SendGuildRefreshCommentsPacket(DWORD dwHighestIndex) { static DWORD s_LastTime = timeGetTime() - 1001; if (timeGetTime() - s_LastTime < 1000) return true; s_LastTime = timeGetTime(); TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REFRESH_COMMENT; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; #ifdef _DEBUG Tracef(" SendGuildRefreshCommentPacket %d\n", dwHighestIndex); #endif return SendSequence(); } bool CPythonNetworkStream::SendGuildChangeMemberGradePacket(DWORD dwPID, BYTE byGrade) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwPID), &dwPID)) return false; if (!Send(sizeof(byGrade), &byGrade)) return false; Tracef(" SendGuildChangeMemberGradePacket %d, %d\n", dwPID, byGrade); return SendSequence(); } bool CPythonNetworkStream::SendGuildUseSkillPacket(DWORD dwSkillID, DWORD dwTargetVID) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_USE_SKILL; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwSkillID), &dwSkillID)) return false; if (!Send(sizeof(dwTargetVID), &dwTargetVID)) return false; Tracef(" SendGuildUseSkillPacket %d, %d\n", dwSkillID, dwTargetVID); return SendSequence(); } bool CPythonNetworkStream::SendGuildChangeMemberGeneralPacket(DWORD dwPID, BYTE byFlag) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwPID), &dwPID)) return false; if (!Send(sizeof(byFlag), &byFlag)) return false; Tracef(" SendGuildChangeMemberGeneralFlagPacket %d, %d\n", dwPID, byFlag); return SendSequence(); } bool CPythonNetworkStream::SendGuildInviteAnswerPacket(DWORD dwGuildID, BYTE byAnswer) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwGuildID), &dwGuildID)) return false; if (!Send(sizeof(byAnswer), &byAnswer)) return false; Tracef(" SendGuildInviteAnswerPacket %d, %d\n", dwGuildID, byAnswer); return SendSequence(); } bool CPythonNetworkStream::SendGuildChargeGSPPacket(DWORD dwMoney) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHARGE_GSP; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwMoney), &dwMoney)) return false; Tracef(" SendGuildChargeGSPPacket %d\n", dwMoney); return SendSequence(); } bool CPythonNetworkStream::SendGuildDepositMoneyPacket(DWORD dwMoney) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DEPOSIT_MONEY; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwMoney), &dwMoney)) return false; Tracef(" SendGuildDepositMoneyPacket %d\n", dwMoney); return SendSequence(); } bool CPythonNetworkStream::SendGuildWithdrawMoneyPacket(DWORD dwMoney) { TPacketCGGuild GuildPacket; GuildPacket.byHeader = HEADER_CG_GUILD; GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_WITHDRAW_MONEY; if (!Send(sizeof(GuildPacket), &GuildPacket)) return false; if (!Send(sizeof(dwMoney), &dwMoney)) return false; Tracef(" SendGuildWithdrawMoneyPacket %d\n", dwMoney); return SendSequence(); } bool CPythonNetworkStream::RecvGuild() { TPacketGCGuild GuildPacket; if (!Recv(sizeof(GuildPacket), &GuildPacket)) return false; switch(GuildPacket.subheader) { case GUILD_SUBHEADER_GC_LOGIN: { DWORD dwPID; if (!Recv(sizeof(DWORD), &dwPID)) return false; // Messenger CPythonGuild::TGuildMemberData * pGuildMemberData; if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData)) if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName())) CPythonMessenger::Instance().LoginGuildMember(pGuildMemberData->strName.c_str()); //Tracef(" %d\n", dwPID); break; } case GUILD_SUBHEADER_GC_LOGOUT: { DWORD dwPID; if (!Recv(sizeof(DWORD), &dwPID)) return false; // Messenger CPythonGuild::TGuildMemberData * pGuildMemberData; if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData)) if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName())) CPythonMessenger::Instance().LogoutGuildMember(pGuildMemberData->strName.c_str()); //Tracef(" %d\n", dwPID); break; } case GUILD_SUBHEADER_GC_REMOVE: { DWORD dwPID; if (!Recv(sizeof(dwPID), &dwPID)) return false; // Main Player 일 경우 DeleteGuild if (CPythonGuild::Instance().IsMainPlayer(dwPID)) { CPythonGuild::Instance().Destroy(); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "DeleteGuild", Py_BuildValue("()")); CPythonMessenger::Instance().RemoveAllGuildMember(); __SetGuildID(0); __RefreshMessengerWindow(); __RefreshTargetBoard(); __RefreshCharacterWindow(); } else { // Get Member Name std::string strMemberName = ""; CPythonGuild::TGuildMemberData * pData; if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pData)) { strMemberName = pData->strName; CPythonMessenger::Instance().RemoveGuildMember(pData->strName.c_str()); } CPythonGuild::Instance().RemoveMember(dwPID); // Refresh __RefreshTargetBoardByName(strMemberName.c_str()); __RefreshGuildWindowMemberPage(); } Tracef(" %d\n", dwPID); break; } case GUILD_SUBHEADER_GC_LIST: { int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket); for (; iPacketSize > 0;) { TPacketGCGuildSubMember memberPacket; if (!Recv(sizeof(memberPacket), &memberPacket)) return false; char szName[CHARACTER_NAME_MAX_LEN+1] = ""; if (memberPacket.byNameFlag) { if (!Recv(sizeof(szName), &szName)) return false; iPacketSize -= CHARACTER_NAME_MAX_LEN+1; } else { CPythonGuild::TGuildMemberData * pMemberData; if (CPythonGuild::Instance().GetMemberDataPtrByPID(memberPacket.pid, &pMemberData)) { strncpy(szName, pMemberData->strName.c_str(), CHARACTER_NAME_MAX_LEN); } } //Tracef(" %d : %s, %d (%d, %d, %d)\n", memberPacket.pid, szName, memberPacket.byGrade, memberPacket.byJob, memberPacket.byLevel, memberPacket.dwOffer); CPythonGuild::SGuildMemberData GuildMemberData; GuildMemberData.dwPID = memberPacket.pid; GuildMemberData.byGrade = memberPacket.byGrade; GuildMemberData.strName = szName; GuildMemberData.byJob = memberPacket.byJob; GuildMemberData.byLevel = memberPacket.byLevel; GuildMemberData.dwOffer = memberPacket.dwOffer; GuildMemberData.byGeneralFlag = memberPacket.byIsGeneral; CPythonGuild::Instance().RegisterMember(GuildMemberData); // Messenger if (strcmp(szName, CPythonPlayer::Instance().GetName())) CPythonMessenger::Instance().AppendGuildMember(szName); __RefreshTargetBoardByName(szName); iPacketSize -= sizeof(memberPacket); } __RefreshGuildWindowInfoPage(); __RefreshGuildWindowMemberPage(); __RefreshMessengerWindow(); __RefreshCharacterWindow(); break; } case GUILD_SUBHEADER_GC_GRADE: { BYTE byCount; if (!Recv(sizeof(byCount), &byCount)) return false; for (BYTE i = 0; i < byCount; ++i) { BYTE byIndex; if (!Recv(sizeof(byCount), &byIndex)) return false; TPacketGCGuildSubGrade GradePacket; if (!Recv(sizeof(GradePacket), &GradePacket)) return false; auto data = CPythonGuild::SGuildGradeData(GradePacket.auth_flag, GradePacket.grade_name); CPythonGuild::Instance().SetGradeData(byIndex, data); //Tracef(" [%d/%d] : %s, %d\n", byIndex, byCount, GradePacket.grade_name, GradePacket.auth_flag); } __RefreshGuildWindowGradePage(); __RefreshGuildWindowMemberPageGradeComboBox(); break; } case GUILD_SUBHEADER_GC_GRADE_NAME: { BYTE byGradeNumber; if (!Recv(sizeof(byGradeNumber), &byGradeNumber)) return false; char szGradeName[GUILD_GRADE_NAME_MAX_LEN+1] = ""; if (!Recv(sizeof(szGradeName), &szGradeName)) return false; CPythonGuild::Instance().SetGradeName(byGradeNumber, szGradeName); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()")); Tracef(" %d, %s\n", byGradeNumber, szGradeName); __RefreshGuildWindowGradePage(); __RefreshGuildWindowMemberPageGradeComboBox(); break; } case GUILD_SUBHEADER_GC_GRADE_AUTH: { BYTE byGradeNumber; if (!Recv(sizeof(byGradeNumber), &byGradeNumber)) return false; BYTE byAuthorityFlag; if (!Recv(sizeof(byAuthorityFlag), &byAuthorityFlag)) return false; CPythonGuild::Instance().SetGradeAuthority(byGradeNumber, byAuthorityFlag); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()")); Tracef(" %d, %d\n", byGradeNumber, byAuthorityFlag); __RefreshGuildWindowGradePage(); break; } case GUILD_SUBHEADER_GC_INFO: { TPacketGCGuildInfo GuildInfo; if (!Recv(sizeof(GuildInfo), &GuildInfo)) return false; CPythonGuild::Instance().EnableGuild(); CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef(); strncpy(rGuildInfo.szGuildName, GuildInfo.name, GUILD_NAME_MAX_LEN); rGuildInfo.szGuildName[GUILD_NAME_MAX_LEN] = '\0'; rGuildInfo.dwGuildID = GuildInfo.guild_id; rGuildInfo.dwMasterPID = GuildInfo.master_pid; rGuildInfo.dwGuildLevel = GuildInfo.level; rGuildInfo.dwCurrentExperience = GuildInfo.exp; rGuildInfo.dwCurrentMemberCount = GuildInfo.member_count; rGuildInfo.dwMaxMemberCount = GuildInfo.max_member_count; rGuildInfo.dwGuildMoney = GuildInfo.gold; rGuildInfo.bHasLand = GuildInfo.hasLand; //Tracef(" %s, %d, %d : %d\n", GuildInfo.name, GuildInfo.master_pid, GuildInfo.level, rGuildInfo.bHasLand); __RefreshGuildWindowInfoPage(); break; } case GUILD_SUBHEADER_GC_COMMENTS: { BYTE byCount; if (!Recv(sizeof(byCount), &byCount)) return false; CPythonGuild::Instance().ClearComment(); //Tracef(" >>> Comments Count : %d\n", byCount); for (BYTE i = 0; i < byCount; ++i) { DWORD dwCommentID; if (!Recv(sizeof(dwCommentID), &dwCommentID)) return false; char szName[CHARACTER_NAME_MAX_LEN+1] = ""; if (!Recv(sizeof(szName), &szName)) return false; char szComment[GULID_COMMENT_MAX_LEN+1] = ""; if (!Recv(sizeof(szComment), &szComment)) return false; //Tracef(" [Comment-%d] : %s, %s\n", dwCommentID, szName, szComment); CPythonGuild::Instance().RegisterComment(dwCommentID, szName, szComment); } __RefreshGuildWindowBoardPage(); break; } case GUILD_SUBHEADER_GC_CHANGE_EXP: { BYTE byLevel; if (!Recv(sizeof(byLevel), &byLevel)) return false; DWORD dwEXP; if (!Recv(sizeof(dwEXP), &dwEXP)) return false; CPythonGuild::Instance().SetGuildEXP(byLevel, dwEXP); Tracef(" %d, %d\n", byLevel, dwEXP); __RefreshGuildWindowInfoPage(); break; } case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE: { DWORD dwPID; if (!Recv(sizeof(dwPID), &dwPID)) return false; BYTE byGrade; if (!Recv(sizeof(byGrade), &byGrade)) return false; CPythonGuild::Instance().ChangeGuildMemberGrade(dwPID, byGrade); Tracef(" %d, %d\n", dwPID, byGrade); __RefreshGuildWindowMemberPage(); break; } case GUILD_SUBHEADER_GC_SKILL_INFO: { CPythonGuild::TGuildSkillData & rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef(); if (!Recv(sizeof(rSkillData.bySkillPoint), &rSkillData.bySkillPoint)) return false; if (!Recv(sizeof(rSkillData.bySkillLevel), rSkillData.bySkillLevel)) return false; if (!Recv(sizeof(rSkillData.wGuildPoint), &rSkillData.wGuildPoint)) return false; if (!Recv(sizeof(rSkillData.wMaxGuildPoint), &rSkillData.wMaxGuildPoint)) return false; Tracef(" %d / %d, %d\n", rSkillData.bySkillPoint, rSkillData.wGuildPoint, rSkillData.wMaxGuildPoint); __RefreshGuildWindowSkillPage(); break; } case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL: { DWORD dwPID; if (!Recv(sizeof(dwPID), &dwPID)) return false; BYTE byFlag; if (!Recv(sizeof(byFlag), &byFlag)) return false; CPythonGuild::Instance().ChangeGuildMemberGeneralFlag(dwPID, byFlag); Tracef(" %d, %d\n", dwPID, byFlag); __RefreshGuildWindowMemberPage(); break; } case GUILD_SUBHEADER_GC_GUILD_INVITE: { DWORD dwGuildID; if (!Recv(sizeof(dwGuildID), &dwGuildID)) return false; char szGuildName[GUILD_NAME_MAX_LEN+1]; if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName)) return false; szGuildName[GUILD_NAME_MAX_LEN] = 0; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvGuildInviteQuestion", Py_BuildValue("(is)", dwGuildID, szGuildName)); Tracef(" %d, %s\n", dwGuildID, szGuildName); break; } case GUILD_SUBHEADER_GC_WAR: { TPacketGCGuildWar kGuildWar; if (!Recv(sizeof(kGuildWar), &kGuildWar)) return false; switch (kGuildWar.bWarState) { case GUILD_WAR_SEND_DECLARE: Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_SEND_DECLARE\n"); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_GuildWar_OnSendDeclare", Py_BuildValue("(i)", kGuildWar.dwGuildOpp) ); break; case GUILD_WAR_RECV_DECLARE: Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_RECV_DECLARE\n"); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_GuildWar_OnRecvDeclare", Py_BuildValue("(ii)", kGuildWar.dwGuildOpp, kGuildWar.bType) ); break; case GUILD_WAR_ON_WAR: Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_ON_WAR : %d, %d\n", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_GuildWar_OnStart", Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp) ); CPythonGuild::Instance().StartGuildWar(kGuildWar.dwGuildOpp); break; case GUILD_WAR_END: Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_END\n"); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_GuildWar_OnEnd", Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp) ); CPythonGuild::Instance().EndGuildWar(kGuildWar.dwGuildOpp); break; } break; } case GUILD_SUBHEADER_GC_GUILD_NAME: { DWORD dwID; char szGuildName[GUILD_NAME_MAX_LEN+1]; int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket); int nItemSize = sizeof(dwID) + GUILD_NAME_MAX_LEN; assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_NAME"); for (; iPacketSize > 0;) { if (!Recv(sizeof(dwID), &dwID)) return false; if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName)) return false; szGuildName[GUILD_NAME_MAX_LEN] = 0; //Tracef(" >> GulidName [%d : %s]\n", dwID, szGuildName); CPythonGuild::Instance().RegisterGuildName(dwID, szGuildName); iPacketSize -= nItemSize; } break; } case GUILD_SUBHEADER_GC_GUILD_WAR_LIST: { DWORD dwSrcGuildID; DWORD dwDstGuildID; int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket); int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID); assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_LIST"); for (; iPacketSize > 0;) { if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID)) return false; if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID)) return false; Tracef(" >> GulidWarList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID); CInstanceBase::InsertGVGKey(dwSrcGuildID, dwDstGuildID); CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID); iPacketSize -= nItemSize; } break; } case GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST: { DWORD dwSrcGuildID; DWORD dwDstGuildID; int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket); int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID); assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST"); for (; iPacketSize > 0;) { if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID)) return false; if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID)) return false; Tracef(" >> GulidWarEndList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID); CInstanceBase::RemoveGVGKey(dwSrcGuildID, dwDstGuildID); CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID); iPacketSize -= nItemSize; } break; } case GUILD_SUBHEADER_GC_WAR_POINT: { TPacketGuildWarPoint GuildWarPoint; if (!Recv(sizeof(GuildWarPoint), &GuildWarPoint)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_GuildWar_OnRecvPoint", Py_BuildValue("(iii)", GuildWarPoint.dwGainGuildID, GuildWarPoint.dwOpponentGuildID, GuildWarPoint.lPoint) ); break; } case GUILD_SUBHEADER_GC_MONEY_CHANGE: { DWORD dwMoney; if (!Recv(sizeof(dwMoney), &dwMoney)) return false; CPythonGuild::Instance().SetGuildMoney(dwMoney); __RefreshGuildWindowInfoPage(); Tracef(" >> Guild Money Change : %d\n", dwMoney); break; } } return true; } // Guild ////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// // Fishing bool CPythonNetworkStream::SendFishingPacket(int iRotation) { BYTE byHeader = HEADER_CG_FISHING; if (!Send(sizeof(byHeader), &byHeader)) return false; BYTE byPacketRotation = iRotation / 5; if (!Send(sizeof(BYTE), &byPacketRotation)) return false; return SendSequence(); } bool CPythonNetworkStream::SendGiveItemPacket(DWORD dwTargetVID, TItemPos ItemPos, int iItemCount) { TPacketCGGiveItem GiveItemPacket; GiveItemPacket.byHeader = HEADER_CG_GIVE_ITEM; GiveItemPacket.dwTargetVID = dwTargetVID; GiveItemPacket.ItemPos = ItemPos; GiveItemPacket.byItemCount = iItemCount; if (!Send(sizeof(GiveItemPacket), &GiveItemPacket)) return false; return SendSequence(); } #if defined(WJ_COMBAT_ZONE) bool CPythonNetworkStream::__RecvCombatZoneRankingPacket() { TPacketGCCombatZoneRankingData p; if (!Recv(sizeof(TPacketGCCombatZoneRankingData), &p)) { Tracen("Recv PacketGCCombatZoneRankingData Error"); return false; } CPythonCombatZone::instance()->Initialize(p); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(s)", "RegisterRank")); return true; } bool CPythonNetworkStream::SendCombatZoneRequestActionPacket(int iAction, int iValue) { TPacketCGCombatZoneRequestAction p; p.header = HEADER_CG_COMBAT_ZONE_REQUEST_ACTION; p.action = iAction; p.value = iValue; if (!Send(sizeof(p), &p)) return false; return SendSequence(); } bool CPythonNetworkStream::__RecvCombatZonePacket() { TPacketGCSendCombatZone p; if (!Recv(sizeof(TPacketGCSendCombatZone), &p)) { Tracen("Recv CombatZone Packet Error"); return false; } switch (p.sub_header) { /* case COMBAT_ZONE_SUB_HEADER_ADD_LEAVING_TARGET: CPythonBackground::Instance().CreateCombatZoneTargetsLeaving(p.m_pInfoData[0], p.m_pInfoData[1]); break; case COMBAT_ZONE_SUB_HEADER_REMOVE_LEAVING_TARGET: CPythonBackground::Instance().DeleteCombatZoneTargetsLeaving(0); break; */ case COMBAT_ZONE_SUB_HEADER_BONUS: { DWORD dwBonusType = p.m_pInfoData[0]; DWORD dwBonusValue = p.m_pInfoData[1]; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(sii)", "Bonus", dwBonusType, dwBonusValue)); } break; case COMBAT_ZONE_SUB_HEADER_TIME: { DWORD dwTime = p.m_pInfoData[0]; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(si)", "Time", dwTime)); } break; case COMBAT_ZONE_SUB_HEADER_BONUS_CLEAR: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(s)", "BonusClear")); break; case COMBAT_ZONE_SUB_HEADER_MP: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(s)", "StartMp")); break; case COMBAT_ZONE_SUB_HEADER_FLASH_ON_MINIMAP: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(s)", "StartFlashing")); break; case COMBAT_ZONE_SUB_HEADER_OPEN_RANKING: { DWORD dwPoints = p.m_pInfoData[0]; DWORD dwTimeRemaining = p.m_pInfoData[1]; DWORD dwCurMobsKills = p.m_pInfoData[2]; DWORD dwMaxMobsKills = p.m_pInfoData[3]; CPythonCombatZone::instance()->SendDataDays(p.m_pDataDays, p.m_pDataDaysCheck ,p.isRunning); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(siiii)", "OpenWindow", dwPoints, dwTimeRemaining, dwCurMobsKills, dwMaxMobsKills)); } break; case COMBAT_ZONE_SUB_HEADER_REFRESH_SHOP: { DWORD dwPoints = p.m_pInfoData[0]; DWORD dwCurLimit = p.m_pInfoData[1]; DWORD dwMaxLimit = p.m_pInfoData[2]; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CombatZone_Manager", Py_BuildValue("(siii)", "RefreshShop", dwPoints, dwCurLimit, dwMaxLimit)); } break; default: return false; } return true; } #endif bool CPythonNetworkStream::RecvFishing() { TPacketGCFishing FishingPacket; if (!Recv(sizeof(FishingPacket), &FishingPacket)) return false; CInstanceBase * pFishingInstance = NULL; if (FISHING_SUBHEADER_GC_FISH != FishingPacket.subheader) { pFishingInstance = CPythonCharacterManager::Instance().GetInstancePtr(FishingPacket.info); if (!pFishingInstance) return true; } switch (FishingPacket.subheader) { case FISHING_SUBHEADER_GC_START: pFishingInstance->StartFishing(float(FishingPacket.dir) * 5.0f); break; case FISHING_SUBHEADER_GC_STOP: if (pFishingInstance->IsFishing()) pFishingInstance->StopFishing(); break; case FISHING_SUBHEADER_GC_REACT: if (pFishingInstance->IsFishing()) { pFishingInstance->SetFishEmoticon(); // Fish Emoticon pFishingInstance->ReactFishing(); } break; case FISHING_SUBHEADER_GC_SUCCESS: pFishingInstance->CatchSuccess(); break; case FISHING_SUBHEADER_GC_FAIL: pFishingInstance->CatchFail(); if (pFishingInstance == CPythonCharacterManager::Instance().GetMainInstancePtr()) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingFailure", Py_BuildValue("()")); } break; case FISHING_SUBHEADER_GC_FISH: { DWORD dwFishID = FishingPacket.info; if (0 == FishingPacket.info) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotifyUnknown", Py_BuildValue("()")); return true; } CItemData * pItemData; if (!CItemManager::Instance().GetItemDataPointer(dwFishID, &pItemData)) return true; CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr(); if (!pMainInstance) return true; if (pMainInstance->IsFishing()) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotify", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName())); } else { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingSuccess", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName())); } break; } } return true; } // Fishing ///////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////// // Dungeon bool CPythonNetworkStream::RecvDungeon() { TPacketGCDungeon DungeonPacket; if (!Recv(sizeof(DungeonPacket), &DungeonPacket)) return false; switch (DungeonPacket.subheader) { case DUNGEON_SUBHEADER_GC_TIME_ATTACK_START: { break; } case DUNGEON_SUBHEADER_GC_DESTINATION_POSITION: { unsigned long ulx, uly; if (!Recv(sizeof(ulx), &ulx)) return false; if (!Recv(sizeof(uly), &uly)) return false; CPythonPlayer::Instance().SetDungeonDestinationPosition(ulx, uly); break; } } return true; } // Dungeon ///////////////////////////////////////////////////////////////////////// bool CPythonNetworkStream::RecvTimePacket() { TPacketGCTime TimePacket; if (!Recv(sizeof(TimePacket), &TimePacket)) return false; IAbstractApplication& rkApp=IAbstractApplication::GetSingleton(); rkApp.SetServerTime(TimePacket.time); return true; } bool CPythonNetworkStream::RecvWalkModePacket() { TPacketGCWalkMode WalkModePacket; if (!Recv(sizeof(WalkModePacket), &WalkModePacket)) return false; CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(WalkModePacket.vid); if (pInstance) { if (WALKMODE_RUN == WalkModePacket.mode) { pInstance->SetRunMode(); } else { pInstance->SetWalkMode(); } } return true; } bool CPythonNetworkStream::RecvChangeSkillGroupPacket() { TPacketGCChangeSkillGroup ChangeSkillGroup; if (!Recv(sizeof(ChangeSkillGroup), &ChangeSkillGroup)) return false; m_dwMainActorSkillGroup = ChangeSkillGroup.skill_group; CPythonPlayer::Instance().NEW_ClearSkillData(); __RefreshCharacterWindow(); return true; } #ifdef TOURNAMENT_PVP_SYSTEM bool CPythonNetworkStream::RecvTournamentAdd() { TPacketGCTournamentAdd dwPacket; if (!Recv(sizeof(dwPacket), &dwPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Tournament_OnRecvData", Py_BuildValue("(iiiiii)", dwPacket.dwTimeRemained, dwPacket.membersOnline_A, dwPacket.membersOnline_B, dwPacket.membersDead_A, dwPacket.membersDead_B, dwPacket.memberLives)); return true; } #endif void CPythonNetworkStream::__TEST_SetSkillGroupFake(int iIndex) { m_dwMainActorSkillGroup = DWORD(iIndex); CPythonPlayer::Instance().NEW_ClearSkillData(); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()")); } #ifdef ENABLE_MULTILANGUAGE_SYSTEM bool CPythonNetworkStream::RequestFlag(const char* szName) { TPacketCGRequestFlag kRequestFlagPacket; kRequestFlagPacket.header = HEADER_CG_REQUEST_FLAG; strncpy(kRequestFlagPacket.name, szName, sizeof(kRequestFlagPacket.name)); if (!Send(sizeof(kRequestFlagPacket), &kRequestFlagPacket)) return false; return SendSequence(); } #endif #ifdef ENABLE_FEATURES_REFINE_SYSTEM bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType, BYTE lLow, BYTE lMedium, BYTE lExtra, BYTE lTotal) #else #ifdef ENABLE_MULTI_REFINE_WORLDARD bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType, BYTE bySpecialStorage, BYTE bIndex) #else bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType, BYTE bySpecialStorage) #endif #endif { TPacketCGRefine kRefinePacket; kRefinePacket.header = HEADER_CG_REFINE; kRefinePacket.pos = byPos; kRefinePacket.type = byType; kRefinePacket.special_storage = bySpecialStorage; #ifdef ENABLE_FEATURES_REFINE_SYSTEM kRefinePacket.lLow = lLow; kRefinePacket.lMedium = lMedium; kRefinePacket.lExtra = lExtra; kRefinePacket.lTotal = lTotal; #endif #ifdef ENABLE_MULTI_REFINE_WORLDARD kRefinePacket.index = bIndex; #endif if (!Send(sizeof(kRefinePacket), &kRefinePacket)) return false; return SendSequence(); } bool CPythonNetworkStream::SendSelectItemPacket(DWORD dwItemPos) { TPacketCGScriptSelectItem kScriptSelectItem; kScriptSelectItem.header = HEADER_CG_SCRIPT_SELECT_ITEM; kScriptSelectItem.selection = dwItemPos; if (!Send(sizeof(kScriptSelectItem), &kScriptSelectItem)) return false; return SendSequence(); } #ifdef ENABLE_MULTI_REFINE_WORLDARD bool CPythonNetworkStream::RecvRefineInformationPacket() { TPacketGCRefineInformation kRefineInfoPacket; if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket)) return false; TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table; switch (rkRefineTable.bSubType) { case MULTIREFINE_CLEAR_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_CLEAR_INFO", Py_BuildValue("()")); } break; case MULTIREFINE_ADD_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenRefineDialog", Py_BuildValue("(iiiiii)", rkRefineTable.index, kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.refine_table.special_storage)); for (int i = 0; i < rkRefineTable.material_count; ++i) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(iii)",rkRefineTable.index, rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count)); } } break; case MULTIREFINE_LOAD_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_LOAD_INFO", Py_BuildValue("()")); } break; case MULTIREFINE_OPEN: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_OPEN", Py_BuildValue("()")); } break; case MULTIREFINE_SEND_DATES_CLEAR: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_DATES_CLEAR", Py_BuildValue("()")); } break; case MULTIREFINE_SEND_DATES: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_SEND_DATES", Py_BuildValue("(i)",kRefineInfoPacket.refine_table.src_vnum)); } break; } #ifdef _DEBUG Tracef(" >> RecvRefineInformationPacket(pos=%d, result_vnum=%d, cost=%d, prob=%d)\n", kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob); #endif return true; } #else bool CPythonNetworkStream::RecvRefineInformationPacket() { TPacketGCRefineInformation kRefineInfoPacket; if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket)) return false; TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], XOR("OpenRefineDialog"), Py_BuildValue (XOR("(iiiii)"), kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.refine_table.special_storage) ); for (int i = 0; i < rkRefineTable.material_count; ++i) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], XOR("AppendMaterialToRefineDialog"), Py_BuildValue ("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count)); } #ifdef _DEBUG Tracef(" >> RecvRefineInformationPacket(pos=%d, result_vnum=%d, cost=%d, prob=%d)\n", kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob); #endif return true; } #endif #ifdef ENABLE_MULTI_REFINE_WORLDARD bool CPythonNetworkStream::RecvRefineInformationPacketNew() { TPacketGCRefineInformationNew kRefineInfoPacket; if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket)) return false; TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table; switch (rkRefineTable.bSubType) { case MULTIREFINE_CLEAR_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_CLEAR_INFO", Py_BuildValue("()")); } break; case MULTIREFINE_ADD_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_ADD_INFO", Py_BuildValue("(iiiiiii)", rkRefineTable.index, kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.refine_table.special_storage, kRefineInfoPacket.type) ); for (int i = 0; i < rkRefineTable.material_count; ++i) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_ADD_MATERIAL", Py_BuildValue("(iii)",rkRefineTable.index, rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count)); } } break; case MULTIREFINE_LOAD_INFO: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_LOAD_INFO", Py_BuildValue("()")); } break; case MULTIREFINE_OPEN: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_OPEN", Py_BuildValue("()")); } break; case MULTIREFINE_SEND_DATES_CLEAR: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_DATES_CLEAR", Py_BuildValue("()")); } break; case MULTIREFINE_SEND_DATES: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_MULTI_REFINE_SEND_DATES", Py_BuildValue("(i)",kRefineInfoPacket.refine_table.src_vnum)); } break; } #ifdef _DEBUG Tracef(" >> RecvRefineInformationPacketNew(pos=%d, result_vnum=%d, cost=%d, prob=%d, type=%d)\n", kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.type); #endif return true; } #else bool CPythonNetworkStream::RecvRefineInformationPacketNew() { TPacketGCRefineInformationNew kRefineInfoPacket; if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket)) return false; TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenRefineDialog", Py_BuildValue("(iiiiii)", kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.refine_table.special_storage, kRefineInfoPacket.type) ); for (int i = 0; i < rkRefineTable.material_count; ++i) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], XOR("AppendMaterialToRefineDialog"), Py_BuildValue ("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count)); } #ifdef _DEBUG Tracef(" >> RecvRefineInformationPacketNew(pos=%d, result_vnum=%d, cost=%d, prob=%d, type=%d)\n", kRefineInfoPacket.pos, kRefineInfoPacket.refine_table.result_vnum, rkRefineTable.cost, rkRefineTable.prob, kRefineInfoPacket.type); #endif return true; } #endif bool CPythonNetworkStream::RecvNPCList() { TPacketGCNPCPosition kNPCPosition; if (!Recv(sizeof(kNPCPosition), &kNPCPosition)) return false; assert(int(kNPCPosition.size)-sizeof(kNPCPosition) == kNPCPosition.count*sizeof(TNPCPosition) && "HEADER_GC_NPC_POSITION"); CPythonMiniMap::Instance().ClearAtlasMarkInfo(); for (int i = 0; i < kNPCPosition.count; ++i) { TNPCPosition NPCPosition; if (!Recv(sizeof(TNPCPosition), &NPCPosition)) return false; const char* c_szName; CPythonNonPlayer& rkNonPlayer = CPythonNonPlayer::Instance(); rkNonPlayer.GetName(NPCPosition.mobVnum, &c_szName); CPythonMiniMap::Instance().RegisterAtlasMark(NPCPosition.bType, NPCPosition.mobVnum, c_szName, NPCPosition.x, NPCPosition.y, NPCPosition.regenTime); } return true; } bool CPythonNetworkStream::__SendCRCReportPacket() { /* DWORD dwProcessCRC = 0; DWORD dwFileCRC = 0; CFilename exeFileName; //LPCVOID c_pvBaseAddress = NULL; GetExeCRC(dwProcessCRC, dwFileCRC); CFilename strRootPackFileName = CEterPackManager::Instance().GetRootPacketFileName(); strRootPackFileName.ChangeDosPath(); TPacketCGCRCReport kReportPacket; kReportPacket.header = HEADER_CG_CRC_REPORT; kReportPacket.byPackMode = CEterPackManager::Instance().GetSearchMode(); kReportPacket.dwBinaryCRC32 = dwFileCRC; kReportPacket.dwProcessCRC32 = dwProcessCRC; kReportPacket.dwRootPackCRC32 = GetFileCRC32(strRootPackFileName.c_str()); if (!Send(sizeof(kReportPacket), &kReportPacket)) Tracef("SendClientReportPacket Error"); return SendSequence(); */ return true; } bool CPythonNetworkStream::SendClientVersionPacket() { std::string filename; GetExcutedFileName(filename); filename = CFileNameHelper::NoPath(filename); CFileNameHelper::ChangeDosPath(filename); if (LocaleService_IsEUROPE() && false == LocaleService_IsYMIR()) { TPacketCGClientVersion2 kVersionPacket; kVersionPacket.header = HEADER_CG_CLIENT_VERSION2; strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1); strncpy(kVersionPacket.timestamp, "1215955205", sizeof(kVersionPacket.timestamp)-1); // # python time.time 앞자리 //strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1); // old_string_ver //strncpy(kVersionPacket.timestamp, "1218055205", sizeof(kVersionPacket.timestamp)-1); // new_future //strncpy(kVersionPacket.timestamp, "1214055205", sizeof(kVersionPacket.timestamp)-1); // old_past if (!Send(sizeof(kVersionPacket), &kVersionPacket)) Tracef("SendClientReportPacket Error"); } else { TPacketCGClientVersion kVersionPacket; kVersionPacket.header = HEADER_CG_CLIENT_VERSION; strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1); strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1); if (!Send(sizeof(kVersionPacket), &kVersionPacket)) Tracef("SendClientReportPacket Error"); } return SendSequence(); } bool CPythonNetworkStream::RecvAffectAddPacket() { TPacketGCAffectAdd kAffectAdd; if (!Recv(sizeof(kAffectAdd), &kAffectAdd)) return false; TPacketAffectElement & rkElement = kAffectAdd.elem; if (rkElement.bPointIdxApplyOn == POINT_ENERGY) { CPythonPlayer::instance().SetStatus (POINT_ENERGY_END_TIME, CPythonApplication::Instance().GetServerTimeStamp() + rkElement.lDuration); __RefreshStatus(); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_AddAffect", Py_BuildValue("(iiii)", rkElement.dwType, rkElement.bPointIdxApplyOn, rkElement.lApplyValue, rkElement.lDuration)); return true; } bool CPythonNetworkStream::RecvAffectRemovePacket() { TPacketGCAffectRemove kAffectRemove; if (!Recv(sizeof(kAffectRemove), &kAffectRemove)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_RemoveAffect", Py_BuildValue("(ii)", kAffectRemove.dwType, kAffectRemove.bApplyOn)); return true; } bool CPythonNetworkStream::RecvChannelPacket() { TPacketGCChannel kChannelPacket; if (!Recv(sizeof(kChannelPacket), &kChannelPacket)) return false; #ifdef ENABLE_CHANNEL_CHANGE PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetChannelIndex", Py_BuildValue("(i)", kChannelPacket.channel)); #endif //Tracef(" >> CPythonNetworkStream::RecvChannelPacket(channel=%d)\n", kChannelPacket.channel); #ifdef ENABLE_ANTI_EXP PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetAntiExp", Py_BuildValue("(i)", kChannelPacket.anti_exp)); #endif return true; } bool CPythonNetworkStream::RecvViewEquipPacket() { TPacketGCViewEquip kViewEquipPacket; if (!Recv(sizeof(kViewEquipPacket), &kViewEquipPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenEquipmentDialog", Py_BuildValue("(i)", kViewEquipPacket.dwVID)); for (int i = 0; i < WEAR_MAX_NUM; ++i) { TEquipmentItemSet & rItemSet = kViewEquipPacket.equips[i]; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogItem", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, rItemSet.vnum, rItemSet.count)); for (int j = 0; j < ITEM_SOCKET_SLOT_MAX_NUM; ++j) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogSocket", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, j, rItemSet.alSockets[j])); for (int k = 0; k < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++k) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogAttr", Py_BuildValue("(iiiii)", kViewEquipPacket.dwVID, i, k, rItemSet.aAttr[k].bType, rItemSet.aAttr[k].sValue)); } return true; } bool CPythonNetworkStream::RecvLandPacket() { TPacketGCLandList kLandList; if (!Recv(sizeof(kLandList), &kLandList)) return false; std::vector kVec_dwGuildID; CPythonMiniMap & rkMiniMap = CPythonMiniMap::Instance(); CPythonBackground & rkBG = CPythonBackground::Instance(); CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr(); rkMiniMap.ClearGuildArea(); rkBG.ClearGuildArea(); int iPacketSize = (kLandList.size - sizeof(TPacketGCLandList)); for (; iPacketSize > 0; iPacketSize-=sizeof(TLandPacketElement)) { TLandPacketElement kElement; if (!Recv(sizeof(TLandPacketElement), &kElement)) return false; rkMiniMap.RegisterGuildArea(kElement.dwID, kElement.dwGuildID, kElement.x, kElement.y, kElement.width, kElement.height); if (pMainInstance) if (kElement.dwGuildID == pMainInstance->GetGuildID()) { rkBG.RegisterGuildArea(kElement.x, kElement.y, kElement.x+kElement.width, kElement.y+kElement.height); } if (0 != kElement.dwGuildID) kVec_dwGuildID.push_back(kElement.dwGuildID); } // @fixme006 if (kVec_dwGuildID.size()>0) __DownloadSymbol(kVec_dwGuildID); return true; } bool CPythonNetworkStream::RecvTargetCreatePacket() { TPacketGCTargetCreate kTargetCreate; if (!Recv(sizeof(kTargetCreate), &kTargetCreate)) return false; CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance(); rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName); //#ifdef _DEBUG // char szBuf[256+1]; // _snprintf(szBuf, sizeof(szBuf), "타겟이 생성 되었습니다 [%d:%s]", kTargetCreate.lID, kTargetCreate.szTargetName); // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf); // Tracef(" >> RecvTargetCreatePacket %d : %s\n", kTargetCreate.lID, kTargetCreate.szTargetName); //#endif PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()")); return true; } bool CPythonNetworkStream::RecvTargetCreatePacketNew() { TPacketGCTargetCreateNew kTargetCreate; if (!Recv(sizeof(kTargetCreate), &kTargetCreate)) return false; CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance(); CPythonBackground & rkpyBG = CPythonBackground::Instance(); if (CREATE_TARGET_TYPE_LOCATION == kTargetCreate.byType) { rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName); } #if defined(WJ_COMBAT_ZONE) else if (CREATE_TARGET_TYPE_COMBAT_ZONE == kTargetCreate.byType) { rkpyBG.CreateCombatZoneTargetsLeaving(kTargetCreate.lID, kTargetCreate.dwVID); rkpyMiniMap.CreateTarget(kTargetCreate.lID, #if defined(WJ_COMBAT_ZONE_HIDE_INFO_USER) "" #else kTargetCreate.szTargetName #endif ,kTargetCreate.dwVID); } #endif else { rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID); rkpyBG.CreateTargetEffect(kTargetCreate.lID, kTargetCreate.dwVID); } //#ifdef _DEBUG // char szBuf[256+1]; // _snprintf(szBuf, sizeof(szBuf), "캐릭터 타겟이 생성 되었습니다 [%d:%s:%d]", kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID); // CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf); // Tracef(" >> RecvTargetCreatePacketNew %d : %d/%d\n", kTargetCreate.lID, kTargetCreate.byType, kTargetCreate.dwVID); //#endif PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()")); return true; } //search offline remplace bool CPythonNetworkStream::RecvTargetUpdatePacket() { TPacketGCTargetUpdate kTargetUpdate; if (!Recv(sizeof(kTargetUpdate), &kTargetUpdate)) return false; CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance(); CPythonBackground & rkpyBG = CPythonBackground::Instance(); rkpyMiniMap.UpdateTarget(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY); if (5 == kTargetUpdate.lType){ rkpyBG.CreateTargetEffectShop(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY); } else{ rkpyBG.CreateTargetEffect(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY); } return true; } //search offline end bool CPythonNetworkStream::RecvTargetDeletePacket() { TPacketGCTargetDelete kTargetDelete; if (!Recv(sizeof(kTargetDelete), &kTargetDelete)) return false; CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance(); rkpyMiniMap.DeleteTarget(kTargetDelete.lID); CPythonBackground & rkpyBG = CPythonBackground::Instance(); rkpyBG.DeleteTargetEffect(kTargetDelete.lID); //#ifdef _DEBUG // Tracef(" >> RecvTargetDeletePacket %d\n", kTargetDelete.lID); //#endif return true; } #ifdef ENABLE_CONQUEROR_LEVEL bool CPythonNetworkStream::RecvSungmaAttrUpdatePacket() { TPacketGCSungmaAttrUpdate kSungmaAttrUpdate; if (!Recv(sizeof(kSungmaAttrUpdate), &kSungmaAttrUpdate)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SungMaAttr", Py_BuildValue("(iiii)", kSungmaAttrUpdate.bSTR, kSungmaAttrUpdate.bHP, kSungmaAttrUpdate.bMOVE, kSungmaAttrUpdate.bINMUNE)); #ifdef _DEBUG Tracef("RECV SUNGMA ATTR UPDATE : %d\n", kSungmaAttrUpdate.bSTR, kSungmaAttrUpdate.bHP, kSungmaAttrUpdate.bMOVE, kSungmaAttrUpdate.bINMUNE); #endif return true; } #endif bool CPythonNetworkStream::RecvLoverInfoPacket() { TPacketGCLoverInfo kLoverInfo; if (!Recv(sizeof(kLoverInfo), &kLoverInfo)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_LoverInfo", Py_BuildValue("(si)", kLoverInfo.szName, kLoverInfo.byLovePoint)); #ifdef _DEBUG Tracef("RECV LOVER INFO : %s, %d\n", kLoverInfo.szName, kLoverInfo.byLovePoint); #endif return true; } bool CPythonNetworkStream::RecvLovePointUpdatePacket() { TPacketGCLovePointUpdate kLovePointUpdate; if (!Recv(sizeof(kLovePointUpdate), &kLovePointUpdate)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_UpdateLovePoint", Py_BuildValue("(i)", kLovePointUpdate.byLovePoint)); #ifdef _DEBUG Tracef("RECV LOVE POINT UPDATE : %d\n", kLovePointUpdate.byLovePoint); #endif return true; } bool CPythonNetworkStream::RecvDigMotionPacket() { TPacketGCDigMotion kDigMotion; if (!Recv(sizeof(kDigMotion), &kDigMotion)) return false; #ifdef _DEBUG Tracef(" Dig Motion [%d/%d]\n", kDigMotion.vid, kDigMotion.count); #endif IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton(); CInstanceBase * pkInstMain = rkChrMgr.GetInstancePtr(kDigMotion.vid); CInstanceBase * pkInstTarget = rkChrMgr.GetInstancePtr(kDigMotion.target_vid); if (NULL == pkInstMain) return true; if (pkInstTarget) pkInstMain->NEW_LookAtDestInstance(*pkInstTarget); for (int i = 0; i < kDigMotion.count; ++i) pkInstMain->PushOnceMotion(CRaceMotionData::NAME_DIG); return true; } #ifdef ENABLE_KINGDOMS_WAR bool CPythonNetworkStream::RecvKingdomsWarPacket(bool bReturn) { TPacketKingdomWar sPacket; if (!Recv(sizeof(sPacket), &sPacket)) return bReturn; bReturn = true; switch (sPacket.bSubHeader) { case KINGDOMSWAR_SUBHEADER_GC_OPEN: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActKingdomsWar", Py_BuildValue("(iiiiiiii)", 1, sPacket.iKills[0], sPacket.iKills[1], sPacket.iKills[2], sPacket.iLimitKills, sPacket.iDeads, sPacket.iLimitDeads, sPacket.dwTimeRemained)); } break; case KINGDOMSWAR_SUBHEADER_GC_REFRESH: { if (sPacket.iLimitDeads > 0) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActKingdomsWar", Py_BuildValue("(iiiiiiii)", 3, sPacket.iKills[0], sPacket.iKills[1], sPacket.iKills[2], sPacket.iLimitKills, sPacket.iDeads, sPacket.iLimitDeads, sPacket.dwTimeRemained)); else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActKingdomsWar", Py_BuildValue("(iiiiiiii)", 2, sPacket.iKills[0], sPacket.iKills[1], sPacket.iKills[2], sPacket.iLimitKills, sPacket.iDeads, sPacket.iLimitDeads, sPacket.dwTimeRemained)); } break; default: TraceError("CPythonNetworkStream::RecvKingdomsWarPacket: unknown subheader %d\n.", sPacket.bSubHeader); break; } return bReturn; } #endif // 용혼석 강화 bool CPythonNetworkStream::SendDragonSoulRefinePacket(BYTE bRefineType, TItemPos* pos) { TPacketCGDragonSoulRefine pk; pk.header = HEADER_CG_DRAGON_SOUL_REFINE; pk.bSubType = bRefineType; memcpy (pk.ItemGrid, pos, sizeof (TItemPos) * DS_REFINE_WINDOW_MAX_NUM); if (!Send(sizeof (pk), &pk)) { return false; } return true; } #ifdef ENABLE_SASH_SYSTEM bool CPythonNetworkStream::RecvSashPacket(bool bReturn) { TPacketSash sPacket; if (!Recv(sizeof(sPacket), &sPacket)) return bReturn; bReturn = true; switch (sPacket.subheader) { case SASH_SUBHEADER_GC_OPEN: { CPythonSash::Instance().Clear(); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActSash", Py_BuildValue("(ib)", 1, sPacket.bWindow)); } break; case SASH_SUBHEADER_GC_CLOSE: { CPythonSash::Instance().Clear(); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActSash", Py_BuildValue("(ib)", 2, sPacket.bWindow)); } break; case SASH_SUBHEADER_GC_ADDED: { CPythonSash::Instance().AddMaterial(sPacket.dwPrice, sPacket.bPos, sPacket.tPos); if (sPacket.bPos == 1) { CPythonSash::Instance().AddResult(sPacket.dwItemVnum, sPacket.dwMinAbs, sPacket.dwMaxAbs); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AlertSash", Py_BuildValue("(b)", sPacket.bWindow)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActSash", Py_BuildValue("(ib)", 3, sPacket.bWindow)); } break; case SASH_SUBHEADER_GC_REMOVED: { CPythonSash::Instance().RemoveMaterial(sPacket.dwPrice, sPacket.bPos); if (sPacket.bPos == 0) CPythonSash::Instance().RemoveMaterial(sPacket.dwPrice, 1); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActSash", Py_BuildValue("(ib)", 4, sPacket.bWindow)); } break; case SASH_SUBHEADER_CG_REFINED: { if (sPacket.dwMaxAbs == 0) CPythonSash::Instance().RemoveMaterial(sPacket.dwPrice, 1); else { CPythonSash::Instance().RemoveMaterial(sPacket.dwPrice, 0); CPythonSash::Instance().RemoveMaterial(sPacket.dwPrice, 1); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ActSash", Py_BuildValue("(ib)", 4, sPacket.bWindow)); } break; default: TraceError("CPythonNetworkStream::RecvSashPacket: unknown subheader %d\n.", sPacket.subheader); break; } return bReturn; } bool CPythonNetworkStream::SendSashClosePacket() { if (!__CanActMainInstance()) return true; TItemPos tPos; tPos.window_type = INVENTORY; tPos.cell = 0; TPacketSash sPacket; sPacket.header = HEADER_CG_SASH; sPacket.subheader = SASH_SUBHEADER_CG_CLOSE; sPacket.dwPrice = 0; sPacket.bPos = 0; sPacket.tPos = tPos; sPacket.dwItemVnum = 0; sPacket.dwMinAbs = 0; sPacket.dwMaxAbs = 0; if (!Send(sizeof(sPacket), &sPacket)) return false; return SendSequence(); } bool CPythonNetworkStream::SendSashAddPacket(TItemPos tPos, BYTE bPos) { if (!__CanActMainInstance()) return true; TPacketSash sPacket; sPacket.header = HEADER_CG_SASH; sPacket.subheader = SASH_SUBHEADER_CG_ADD; sPacket.dwPrice = 0; sPacket.bPos = bPos; sPacket.tPos = tPos; sPacket.dwItemVnum = 0; sPacket.dwMinAbs = 0; sPacket.dwMaxAbs = 0; if (!Send(sizeof(sPacket), &sPacket)) return false; return SendSequence(); } bool CPythonNetworkStream::SendSashRemovePacket(BYTE bPos) { if (!__CanActMainInstance()) return true; TItemPos tPos; tPos.window_type = INVENTORY; tPos.cell = 0; TPacketSash sPacket; sPacket.header = HEADER_CG_SASH; sPacket.subheader = SASH_SUBHEADER_CG_REMOVE; sPacket.dwPrice = 0; sPacket.bPos = bPos; sPacket.tPos = tPos; sPacket.dwItemVnum = 0; sPacket.dwMinAbs = 0; sPacket.dwMaxAbs = 0; if (!Send(sizeof(sPacket), &sPacket)) return false; return SendSequence(); } bool CPythonNetworkStream::SendSashRefinePacket() { if (!__CanActMainInstance()) return true; TItemPos tPos; tPos.window_type = INVENTORY; tPos.cell = 0; TPacketSash sPacket; sPacket.header = HEADER_CG_SASH; sPacket.subheader = SASH_SUBHEADER_CG_REFINE; sPacket.dwPrice = 0; sPacket.bPos = 0; sPacket.tPos = tPos; sPacket.dwItemVnum = 0; sPacket.dwMinAbs = 0; sPacket.dwMaxAbs = 0; if (!Send(sizeof(sPacket), &sPacket)) return false; return SendSequence(); } #endif #ifdef ENABLE_DUNGEON_INFO bool CPythonNetworkStream::RecvDungeonInfoPacket() { TPacketGCDungeonInfoReceive KDungeonInfo; if (!Recv(sizeof(KDungeonInfo), &KDungeonInfo)) return false; switch (KDungeonInfo.bSubType) { case DUNGEON_INFO_SUB_HEADER_OPEN_SEND: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_TABLE_DUNGEON_INFO_OPEN", Py_BuildValue("()")); } break; case DUNGEON_INFO_SUB_HEADER_DATES_CLEAR: { CPythonDungeonInfo::Instance().Clear(); } break; case DUNGEON_INFO_SUB_HEADER_DATES_MISION_CLEAR: { CPythonDungeonInfo::Instance().ClearMision(); } break; case DUNGEON_INFO_SUB_HEADER_DATES_SEND: { CPythonDungeonInfo::Instance().DateInfoList(KDungeonInfo.dateinfo); } break; case DUNGEON_INFO_SUB_HEADER_DATES_MISION_SEND: { CPythonDungeonInfo::Instance().DateInfoMisionList(KDungeonInfo.dateinfom); } case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_CLEAR: { CPythonDungeonInfo::Instance().ClearRanking(); } break; case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_SEND: { CPythonDungeonInfo::Instance().DateInfoRankingList(KDungeonInfo.dateinfo_ranking); } break; case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_LOAD: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_TABLE_DUNGEON_RANKING_LOAD", Py_BuildValue("()")); } break; case DUNGEON_INFO_SUB_HEADER_DATES_MISION_LOAD: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_TABLE_DUNGEON_MISION_LOAD", Py_BuildValue("()")); } break; } return true; } #endif #ifdef ENABLE_DROP_ITEM_WORLDARD bool CPythonNetworkStream::SendDropItemOpen() { if (!__CanActMainInstance()) return true; TPacketCGDropItemSend packet; packet.header = HEADER_CG_DROP_ITEM_SYSTEM; packet.subheader = DROP_ITEM_SUB_HEADER_OPEN; if (!Send(sizeof(TPacketCGDropItemSend), &packet)) { Tracef("SendDropItemOpen Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::SearchDropItem(int vnum_item) { if (!__CanActMainInstance()) return true; TPacketCGDropItemSend packet; packet.header = HEADER_CG_DROP_ITEM_SYSTEM; packet.subheader = DROP_ITEM_SUB_HEADER_SEARCH; packet.vnum_item = vnum_item; if (!Send(sizeof(TPacketCGDropItemSend), &packet)) { Tracef("SearchDropItem Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::RecvDropItemPacket() { TPacketGCDropItemReceive WDropItem; if (!Recv(sizeof(WDropItem), &WDropItem)) return false; switch (WDropItem.subheader) { case DROP_ITEM_SUB_HEADER_OPEN_RECEIVE: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DROP_ITEM_OPEN", Py_BuildValue("()")); } break; case DROP_ITEM_SUB_HEADER_DATES_RECEIVE: { CPythonDropItem::Instance().ReceiveList(WDropItem.info_drop); } break; case DROP_ITEM_SUB_HEADER_DATES_LOADING: { CPythonDropItem::Instance().LoadingList(); } break; case DROP_ITEM_SUB_HEADER_DATES_CLEAR_RECEIVE: { CPythonDropItem::Instance().ClearList(); } break; } return true; } #endif #ifdef ENABLE_CUBE_RENEWAL_WORLDARD bool CPythonNetworkStream::CubeRenewalMakeItem(int index_item, int count_item) { if (!__CanActMainInstance()) return true; TPacketCGCubeRenewalSend packet; packet.header = HEADER_CG_CUBE_RENEWAL; packet.subheader = CUBE_RENEWAL_SUB_HEADER_MAKE_ITEM; packet.index_item = index_item; packet.count_item = count_item; if (!Send(sizeof(TPacketCGCubeRenewalSend), &packet)) { Tracef("CPythonNetworkStream::CubeRenewalMakeItem Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::CubeRenewalClose() { if (!__CanActMainInstance()) return true; TPacketCGCubeRenewalSend packet; packet.header = HEADER_CG_CUBE_RENEWAL; packet.subheader = CUBE_RENEWAL_SUB_HEADER_CLOSE; if (!Send(sizeof(TPacketCGCubeRenewalSend), &packet)) { Tracef("CPythonNetworkStream::CubeRenewalClose Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::RecvCubeRenewalPacket() { TPacketGCCubeRenewalReceive CubeRenewalPacket; if (!Recv(sizeof(CubeRenewalPacket), &CubeRenewalPacket)) return false; switch (CubeRenewalPacket.subheader) { case CUBE_RENEWAL_SUB_HEADER_OPEN_RECEIVE: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CUBE_RENEWAL_OPEN", Py_BuildValue("()")); } break; case CUBE_RENEWAL_SUB_HEADER_DATES_RECEIVE: { CPythonCubeRenewal::Instance().ReceiveList(CubeRenewalPacket.date_cube_renewal); } break; case CUBE_RENEWAL_SUB_HEADER_DATES_LOADING: { CPythonCubeRenewal::Instance().LoadingList(); } break; case CUBE_RENEWAL_SUB_HEADER_CLEAR_DATES_RECEIVE: { CPythonCubeRenewal::Instance().ClearList(); } break; } return true; } #endif #ifdef ENABLE_SWITCHBOT bool CPythonNetworkStream::RecvSwitchbotPacket() { TPacketGCSwitchbot pack; if (!Recv(sizeof(pack), &pack)) { return false; } size_t packet_size = int(pack.size) - sizeof(TPacketGCSwitchbot); if (pack.subheader == SUBHEADER_GC_SWITCHBOT_UPDATE) { if (packet_size != sizeof(CPythonSwitchbot::TSwitchbotTable)) { return false; } CPythonSwitchbot::TSwitchbotTable table; if (!Recv(sizeof(table), &table)) { return false; } CPythonSwitchbot::Instance().Update(table); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSwitchbotWindow", Py_BuildValue("()")); } else if (pack.subheader == SUBHEADER_GC_SWITCHBOT_UPDATE_ITEM) { if (packet_size != sizeof(TSwitchbotUpdateItem)) { return false; } TSwitchbotUpdateItem update; if (!Recv(sizeof(update), &update)) { return false; } TItemPos pos(SWITCHBOT, update.slot); IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton(); rkPlayer.SetItemCount(pos, update.count); for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i) { rkPlayer.SetItemMetinSocket(pos, i, update.alSockets[i]); } for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j) { rkPlayer.SetItemAttribute(pos, j, update.aAttr[j].bType, update.aAttr[j].sValue); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSwitchbotItem", Py_BuildValue("(i)", update.slot)); return true; } else if (pack.subheader == SUBHEADER_GC_SWITCHBOT_SEND_ATTRIBUTE_INFORMATION) { CPythonSwitchbot::Instance().ClearAttributeMap(); size_t table_size = sizeof(CPythonSwitchbot::TSwitchbottAttributeTable); while (packet_size >= table_size) { const int test = sizeof(CPythonSwitchbot::TSwitchbottAttributeTable); CPythonSwitchbot::TSwitchbottAttributeTable table; if (!Recv(table_size, &table)) { return false; } CPythonSwitchbot::Instance().AddAttributeToMap(table); packet_size -= table_size; } } return true; } bool CPythonNetworkStream::SendSwitchbotStartPacket(BYTE slot, std::vector alternatives) { TPacketCGSwitchbot pack; pack.header = HEADER_CG_SWITCHBOT; pack.subheader = SUBHEADER_CG_SWITCHBOT_START; pack.size = sizeof(TPacketCGSwitchbot) + sizeof(CPythonSwitchbot::TSwitchbotAttributeAlternativeTable) * SWITCHBOT_ALTERNATIVE_COUNT; pack.slot = slot; if (!Send(sizeof(pack), &pack)) { return false; } for (const auto& it : alternatives) { if (!Send(sizeof(it), &it)) { return false; } } return SendSequence(); } bool CPythonNetworkStream::SendSwitchbotStopPacket(BYTE slot) { TPacketCGSwitchbot pack; pack.header = HEADER_CG_SWITCHBOT; pack.subheader = SUBHEADER_CG_SWITCHBOT_STOP; pack.size = sizeof(TPacketCGSwitchbot); pack.slot = slot; if (!Send(sizeof(pack), &pack)) { return false; } return SendSequence(); } #endif #if defined(ENABLE_DISCORD_RPC) #include "discord_rpc.h" #include "Discord.h" #ifdef _DEBUG #pragma comment(lib, "discord_rpc_d.lib") #else #pragma comment(lib, "discord_rpc_r.lib") #endif static int64_t StartTime; void CPythonNetworkStream::Discord_Start() { StartTime = time(0); DiscordEventHandlers handlers; memset(&handlers, 0, sizeof(handlers)); Discord_Initialize(Discord::DiscordClientID, &handlers, 1, nullptr); Discord_Update(false); } void CPythonNetworkStream::Discord_Update(const bool ingame) { DiscordRichPresence discordPresence; memset(&discordPresence, 0, sizeof(discordPresence)); discordPresence.startTimestamp = StartTime; discordPresence.state = "Ava2.org"; discordPresence.details = "Metin2"; discordPresence.largeImageKey = "dracarwe"; discordPresence.largeImageText = "Ava2"; //discordPresence.partyId = "ae488379-351d-4a4f-ad32-2b9b01c91657"; //discordPresence.joinSecret = "MTI4NzM0OjFpMmhuZToxMjMxMjM= "; if (!ingame) { Discord_UpdatePresence(&discordPresence); return; } /*Name*/ //auto NameData = Discord::GetNameData(); //discordPresence.state = std::get<0>(NameData).c_str(); //discordPresence.details = std::get<1>(NameData).c_str(); /*Race*/ //auto RaceData = Discord::GetRaceData(); //discordPresence.largeImageKey = std::get<0>(RaceData).c_str(); //discordPresence.largeImageText = std::get<1>(RaceData).c_str(); ///*Empire*/ //auto EmpireData = Discord::GetEmpireData(); //discordPresence.smallImageKey = std::get<0>(EmpireData).c_str(); //discordPresence.smallImageText = std::get<1>(EmpireData).c_str(); Discord_UpdatePresence(&discordPresence); } void CPythonNetworkStream::Discord_Close() { Discord_Shutdown(); } #endif #ifdef BATTLEPASS_WORLDARD bool CPythonNetworkStream::BattlePassOpen() { if (!__CanActMainInstance()) return true; TPacketCGBattlePass packet; packet.header = HEADER_CG_BATTLEPASS; packet.subheader = BATTLEPASS_SUB_HEADER_OPEN; if (!Send(sizeof(TPacketCGBattlePass), &packet)) { Tracef("CPythonNetworkStream::BattlePassOpen Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::BattlePassReceiveReward(int index) { if (!__CanActMainInstance()) return true; TPacketCGBattlePass packet; packet.header = HEADER_CG_BATTLEPASS; packet.subheader = BATTLEPASS_SUB_HEADER_REWARD; packet.index = index; if (!Send(sizeof(TPacketCGBattlePass), &packet)) { Tracef("CPythonNetworkStream::BattlePassReceiveReward Error\n"); return false; } return SendSequence(); } bool CPythonNetworkStream::RecvBattlePassPacket() { TPacketGCBattlePass packet; if (!Recv(sizeof(packet), &packet)) return false; switch (packet.subheader) { case BATTLEPASS_SUB_HEADER_OPEN: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_BATTLEPASS_OPEN", Py_BuildValue("()")); } break; case BATTLEPASS_SUB_HEADER_MP: { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_BATTLEPASS_MP", Py_BuildValue("()")); } break; case BATTLEPASS_SUB_HEADER_INFO_EXTRA: { CPythonBattlePass::Instance().ReceiveDataExtra(packet.time); } break; case BATTLEPASS_SUB_HEADER_UPDATE: case BATTLEPASS_SUB_HEADER_INFO: { CPythonBattlePass::Instance().ReceiveData(packet.subheader,packet.data); } break; case BATTLEPASS_SUB_HEADER_UPDATE_LOADING: case BATTLEPASS_SUB_HEADER_LOADING: { CPythonBattlePass::Instance().LoadingData(packet.subheader); } break; case BATTLEPASS_SUB_HEADER_UPDATE_CLEAR: case BATTLEPASS_SUB_HEADER_CLEAR: { CPythonBattlePass::Instance().ClearData(packet.subheader); } break; } return true; } #endif #ifdef ENABLE_OFFLINESHOP_SYSTEM bool CPythonNetworkStream::SendBuildOfflineShopPacket(const char* c_szName, const std::vector& c_rSellingItemStock, DWORD shopVnum, BYTE shopTitle) { TPacketCGMyOfflineShop packet; packet.bHeader = HEADER_CG_MY_OFFLINE_SHOP; strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN); packet.bCount = c_rSellingItemStock.size(); packet.shopVnum = shopVnum; packet.shopTitle = shopTitle; if (!Send(sizeof(packet), &packet)) return false; for (std::vector::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor) { const TOfflineShopItemTable& c_rItem = *itor; if (!Send(sizeof(c_rItem), &c_rItem)) return false; } return SendSequence(); } bool CPythonNetworkStream::RecvOfflineShopSignPacket() { TPacketGCShopSign p; if (!Recv(sizeof(TPacketGCShopSign), &p)) return false; CInstanceBase* pInstance = CPythonCharacterManager::instance().GetInstancePtr(p.dwVID); if (pInstance) { if (pInstance->IsShop()) { if (0 == strlen(p.szSign)) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID)); else PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Appear", Py_BuildValue("(is)", p.dwVID, p.szSign)); } } return true; } bool CPythonNetworkStream::RecvOfflineShopPacket() { TPacketGCShop packet_shop; if (!Recv(sizeof(packet_shop), &packet_shop)) return false; std::vector vecBuffer; vecBuffer.clear(); int iSize = packet_shop.size - sizeof(packet_shop); switch (packet_shop.subheader) { case SHOP_SUBHEADER_GC_REFRESH_MONEY: case SHOP_SUBHEADER_GC_REFRESH_DISPLAY_COUNT: case SHOP_SUBHEADER_GC_CHECK_RESULT: case SHOP_SUBHEADER_GC_REFRESH_COUNT: case SHOP_SUBHEADER_GC_REALWATCHER_COUNT: case SHOP_SUBHEADER_GC_CHANGE_TITLE: break; default: if (iSize > 0) { vecBuffer.resize(iSize); if (!Recv(iSize, &vecBuffer[0])) return false; } } switch (packet_shop.subheader) { case SHOP_SUBHEADER_GC_START: { CPythonShop::Instance().Clear(); TPacketGCOfflineShopStart* pShopStartPacket = (TPacketGCOfflineShopStart*)vecBuffer.data(); for (BYTE iItemIndex = 0; iItemIndex < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex) CPythonShop::Instance().SetOfflineShopItemData(iItemIndex, pShopStartPacket->items[iItemIndex]); CPythonShop::Instance().SetShopDisplayedCount(pShopStartPacket->m_dwDisplayedCount); CPythonShop::Instance().SetRealWatcherCount(pShopStartPacket->m_dwRealWatcherCount); CPythonShop::Instance().SetCurrentOfflineShopMoney(pShopStartPacket->price); CPythonShop::Instance().SetShopSign(pShopStartPacket->title); CPythonShop::Instance().SetShopFlag(pShopStartPacket->flag); CPythonShop::Instance().SetShopType(pShopStartPacket->type); CPythonShop::Instance().SetShopTime(pShopStartPacket->time); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ClearOfflineShopLog", Py_BuildValue("()")); for (int logIndex = OFFLINE_SHOP_HOST_ITEM_MAX_NUM-1; logIndex >= 0; --logIndex) if (pShopStartPacket->log[logIndex].price != 0) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendShopLog", Py_BuildValue("(ssiiL)", pShopStartPacket->log[logIndex].name, pShopStartPacket->log[logIndex].date, pShopStartPacket->log[logIndex].itemVnum, pShopStartPacket->log[logIndex].itemCount, pShopStartPacket->log[logIndex].price)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartOfflineShop", Py_BuildValue("(ii)", pShopStartPacket->owner_vid, pShopStartPacket->IsOwner == true ? 1 : 0)); } break; case SHOP_SUBHEADER_GC_END: { CPythonShop::instance().Clear(); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ClearOfflineShopLog", Py_BuildValue("()")); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_UPDATE_ITEM: { TPacketGCOfflineShopUpdateItem* pShopUpdateItemPacket = (TPacketGCOfflineShopUpdateItem*)vecBuffer.data(); CPythonShop::Instance().SetShopDisplayedCount(pShopUpdateItemPacket->m_dwDisplayedCount); CPythonShop::Instance().SetRealWatcherCount(pShopUpdateItemPacket->m_dwRealWatcherCount); CPythonShop::Instance().SetShopFlag(pShopUpdateItemPacket->flag); CPythonShop::Instance().SetShopTime(pShopUpdateItemPacket->time); CPythonShop::Instance().SetShopSign(pShopUpdateItemPacket->title); CPythonShop::Instance().SetShopType(pShopUpdateItemPacket->type); CPythonShop::Instance().SetOfflineShopItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item); CPythonShop::Instance().SetCurrentOfflineShopMoney(pShopUpdateItemPacket->price); if (pShopUpdateItemPacket->log.price != 0) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendShopLogFirst", Py_BuildValue("(ssiiL)", pShopUpdateItemPacket->log.name, pShopUpdateItemPacket->log.date, pShopUpdateItemPacket->log.itemVnum, pShopUpdateItemPacket->log.itemCount, pShopUpdateItemPacket->log.price)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY")); break; case SHOP_SUBHEADER_GC_SOLD_OUT: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT")); break; case SHOP_SUBHEADER_GC_OK: //PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT")); break; case SHOP_SUBHEADER_GC_INVENTORY_FULL: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL")); break; case SHOP_SUBHEADER_GC_INVALID_POS: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS")); break; case SHOP_SUBHEADER_GC_REFRESH_MONEY: { long long llMoney = 0; if (!Recv(sizeof(long long), &llMoney)) return false; CPythonShop::Instance().SetCurrentOfflineShopMoney(llMoney); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_CHECK_RESULT: { BYTE bHasOfflineShop = 0; if (!Recv(sizeof(BYTE), &bHasOfflineShop)) return false; CPythonShop::instance().SetHasOfflineShop(bHasOfflineShop == 1 ? true : false); } break; case SHOP_SUBHEADER_GC_REFRESH_DISPLAY_COUNT: { DWORD displayCount = 0; if (!Recv(sizeof(DWORD), &displayCount)) return false; CPythonShop::Instance().SetShopDisplayedCount(displayCount); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_REALWATCHER_COUNT: { DWORD realWatcher = 0; if (!Recv(sizeof(DWORD), &realWatcher)) return false; CPythonShop::Instance().SetRealWatcherCount(realWatcher); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_REFRESH_COUNT: { DWORD count[2] = { 0,0 }; if (!Recv(sizeof(count), &count)) return false; CPythonShop::Instance().SetShopDisplayedCount(count[0]); CPythonShop::Instance().SetRealWatcherCount(count[1]); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; case SHOP_SUBHEADER_GC_CHANGE_TITLE: { char sign[SHOP_SIGN_MAX_LEN + 1]; if (!Recv(sizeof(sign), &sign)) return false; CPythonShop::Instance().SetShopSign(sign); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()")); } break; #ifdef ENABLE_ZODIAC_MISSION case SHOP_SUBHEADER_GC_NOT_ENOUGH_LUCKY: PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_LUCKY")); break; #endif default: TraceError("CPythonNetworkStream::RecvOfflineShopPacket: Unknown subheader %d\n", packet_shop.subheader); break; } return true; } #endif #ifdef ENABLE_SHOP_SEARCH_SYSTEM bool CPythonNetworkStream::SendPrivateShopSearchInfo(TPacketCGShopSearch* p) { if (!__CanActMainInstance()) return true; if (!Send(sizeof(TPacketCGShopSearch), p)) { #ifdef ENABLE_CONSOLE_LOG_WINDOW Tracen("SendPrivateShopSearchInfo Error"); #endif return false; } return true; } bool CPythonNetworkStream::RecvShopSearchSet() { TPacketGCShopSearchItemSet packet_item_set; if (!Recv(sizeof(TPacketGCShopSearchItemSet), &packet_item_set)) return false; WORD itemCount; if (!Recv(sizeof(itemCount), &itemCount)) return false; std::vector m_vec; m_vec.resize(itemCount); if (!Recv(itemCount * sizeof(TOfflineShopItemData), m_vec.data())) return false; for (WORD j = 0; j < itemCount; j++) CPythonPrivateShopSearch::Instance().AddItemData(m_vec[j]); __RefreshShopSearchWindow(); return true; } #endif #ifdef ENABLE_ITEMSHOP bool CPythonNetworkStream::RecvItemShop() { TPacketGCItemShop p; if (!Recv(sizeof(TPacketGCItemShop), &p)) return false; BYTE subIndex; if (!Recv(sizeof(BYTE), &subIndex)) return false; switch (subIndex) { case ITEMSHOP_DRAGONCOIN: { long long dragonCoin; if (!Recv(sizeof(long long), &dragonCoin)) return false; bool isLogOpen; if (!Recv(sizeof(bool), &isLogOpen)) return false; if (isLogOpen) { TIShopLogData logData; if (!Recv(sizeof(TIShopLogData), &logData)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopAppendLog", Py_BuildValue("(sissiiL)", logData.buyDate, logData.buyTime, logData.playerName, logData.ipAdress, logData.itemVnum, logData.itemCount, logData.itemPrice)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopSetDragonCoin", Py_BuildValue("(L)", dragonCoin)); } break; case ITEMSHOP_LOG: { int logCount; if (!Recv(sizeof(int), &logCount)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopHideLoading", Py_BuildValue("()")); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopLogClear", Py_BuildValue("()")); if (logCount) { std::vector m_vec; m_vec.resize(logCount); if (!Recv(sizeof(TIShopLogData)*logCount, &m_vec[0])) return false; for (DWORD j = 0; j < m_vec.size(); ++j) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopAppendLog", Py_BuildValue("(sissiiL)", m_vec[j].buyDate, m_vec[j].buyTime, m_vec[j].playerName, m_vec[j].ipAdress, m_vec[j].itemVnum, m_vec[j].itemCount, m_vec[j].itemPrice)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopPurchasesWindow", Py_BuildValue("()")); } break; case ITEMSHOP_UPDATE_ITEM: { TIShopData updateItem; if (!Recv(sizeof(TIShopData), &updateItem)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopUpdateItem", Py_BuildValue("(iiLiiiiLi)", updateItem.id, updateItem.itemVnum, updateItem.itemPrice, updateItem.discount, updateItem.offerTime, updateItem.topSellingIndex, updateItem.addedTime, updateItem.sellCount, updateItem.maxSellCount)); } break; case ITEMSHOP_LOAD: { long long dragonCoin; if (!Recv(sizeof(long long), &dragonCoin)) return false; int updateTime; if (!Recv(sizeof(int), &updateTime)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopSetDragonCoin", Py_BuildValue("(L)", dragonCoin)); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopHideLoading", Py_BuildValue("()")); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopClear", Py_BuildValue("(i)", updateTime)); int categoryTotalSize; if (!Recv(sizeof(int), &categoryTotalSize)) return false; if (categoryTotalSize == 9999) { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopOpenMainPage", Py_BuildValue("()")); return true; } for (DWORD j = 0; j < categoryTotalSize; ++j) { BYTE categoryIndex, categorySize; if (!Recv(sizeof(BYTE), &categoryIndex)) return false; if (!Recv(sizeof(BYTE), &categorySize)) return false; for (DWORD x = 0; x < categorySize; ++x) { BYTE categorySubIndex, categorySubSize=0; if (!Recv(sizeof(BYTE), &categorySubIndex)) return false; if (!Recv(sizeof(BYTE), &categorySubSize)) return false; if (categorySubSize) { for (DWORD k = 0; k < categorySubSize; ++k) { TIShopData shopData; if (!Recv(sizeof(TIShopData),&shopData)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopAppendItem", Py_BuildValue("(iiiiLiiiiLi)", categoryIndex, categorySubIndex, shopData.id, shopData.itemVnum, shopData.itemPrice, shopData.discount, shopData.offerTime, shopData.topSellingIndex, shopData.addedTime, shopData.sellCount, shopData.maxSellCount)); } /* std::vector m_vec; m_vec.resize(categorySubSize); if (!Recv(sizeof(TIShopData) * categorySubSize, m_vec.data())) return false; for (DWORD k = 0; k < m_vec.size(); ++k) { const TIShopData& shopData = m_vec[k]; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopAppendItem", Py_BuildValue("(iiiiLiiiiL)", categoryIndex, categorySubIndex, shopData.id, shopData.itemVnum, shopData.itemPrice, shopData.discount, shopData.offerTime, shopData.topSellingIndex, shopData.addedTime, shopData.sellCount)); } */ } } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ItemShopOpenMainPage", Py_BuildValue("()")); } } break; } return true; } #endif #ifdef ENABLE_EVENT_MANAGER bool CPythonNetworkStream::RecvEventManager() { TPacketGCEventManager p; if (!Recv(sizeof(TPacketGCEventManager), &p)) return false; BYTE subIndex; if (!Recv(sizeof(BYTE), &subIndex)) return false; if (subIndex == EVENT_MANAGER_LOAD) { BYTE dayCount; if (!Recv(sizeof(BYTE), &dayCount)) return false; int serverTime; if (!Recv(sizeof(int), &serverTime)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ClearEventManager", Py_BuildValue("()")); for (BYTE j = 0; j < dayCount; ++j) { BYTE dayIndex; if (!Recv(sizeof(BYTE), &dayIndex)) return false; BYTE dayEventCount; if (!Recv(sizeof(BYTE), &dayEventCount)) return false; if (dayEventCount > 0) { std::vector m_vec; m_vec.resize(dayEventCount); if (!Recv(dayEventCount * sizeof(TEventManagerData), &m_vec[0])) return false; for (const auto& eventPtr : m_vec) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendEvent", Py_BuildValue("(iiissiiiiiiiii)", dayIndex, eventPtr.eventID, eventPtr.eventIndex, eventPtr.startTimeText, eventPtr.endTimeText, eventPtr.empireFlag, eventPtr.channelFlag, eventPtr.value[0], eventPtr.value[1], eventPtr.value[2], eventPtr.value[3], eventPtr.startTime - serverTime, eventPtr.endTime == 0 ? 0 : eventPtr.endTime - serverTime, eventPtr.eventStatus)); } } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEventManager", Py_BuildValue("()")); } else if (subIndex == EVENT_MANAGER_EVENT_STATUS) { WORD eventID; if (!Recv(sizeof(WORD), &eventID)) return false; bool eventStatus; if (!Recv(sizeof(bool), &eventStatus)) return false; int endTime; if (!Recv(sizeof(int), &endTime)) return false; char endTimeText[25]; if (!Recv(sizeof(endTimeText), &endTimeText)) return false; int serverTime; if (!Recv(sizeof(int), &serverTime)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEventStatus", Py_BuildValue("(iiis)", eventID, eventStatus, endTime == 0 ? 0 : endTime - serverTime, endTimeText)); } return true; } #endif #ifdef ENABLE_NEW_DETAILS_GUI bool CPythonNetworkStream::RecvKillLOG() { TPacketGCKillLOG log; if (!Recv(sizeof(TPacketGCKillLOG), &log)) return false; CPythonPlayer::Instance().SetKillLOG(log.kill_log); PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()")); return true; } #endif #if defined(ENABLE_CSHIELD) && !defined(_DEBUG) bool CPythonNetworkStream::RecvCShieldPacket() { TPacketGCCShield pCShieldPacket; if (!Recv(sizeof(TPacketGCCShield), &pCShieldPacket)) { Tracen("Recv CShield Packet Error"); return false; } SendCShieldPacket(pCShieldPacket.start, pCShieldPacket.num); return true; } bool CPythonNetworkStream::SendCShieldPacket(bool start, DWORD num) { TPacketCGCShield pCShieldPacket; pCShieldPacket.header = HEADER_CG_CSHIELD; strncpy(pCShieldPacket.key, GenKey(start, num).c_str(), sizeof(pCShieldPacket.key) - 1); if (!Send(sizeof(pCShieldPacket), &pCShieldPacket)) return false; return true; } #endif #ifdef ENABLE_EXCHANGE_LOG bool CPythonNetworkStream::RecvExchangeLog() { TPacketGCExchangeLog p; if (!Recv(sizeof(TPacketGCExchangeLog), &p)) return false; BYTE subIndex; if (!Recv(sizeof(BYTE), &subIndex)) return false; if (subIndex == SUB_EXCHANGELOG_LOAD) { char playerCode[19]; if (!Recv(sizeof(playerCode), &playerCode)) return false; bool isNeedClean; if (!Recv(sizeof(bool), &isNeedClean)) return false; WORD logCount; if (!Recv(sizeof(WORD), &logCount)) return false; if (isNeedClean) PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ExchangeLogClear", Py_BuildValue("(s)", playerCode)); for (DWORD j = 0; j < logCount; ++j) { DWORD logID; if (!Recv(sizeof(DWORD), &logID)) return false; TExchangeLog logData; if (!Recv(sizeof(TExchangeLog), &logData)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ExchangeLogAppend", Py_BuildValue("(isLssLss)", logID, logData.owner, logData.ownerGold, logData.ownerIP, logData.target, logData.targetGold, logData.targetIP, logData.date)); } PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ExchangeLogRefresh", Py_BuildValue("(i)", 0)); } else if (subIndex == SUB_EXCHANGELOG_LOAD_ITEM) { WORD logItemCount; if (!Recv(sizeof(WORD), &logItemCount)) return false; DWORD logID; if (!Recv(sizeof(DWORD), &logID)) return false; if (logItemCount) { std::vector m_vecLogItems; m_vecLogItems.resize(logItemCount); if (!Recv(logItemCount * sizeof(TExchangeLogItem), m_vecLogItems.data())) return false; for (DWORD j = 0; j < m_vecLogItems.size(); ++j) { const TExchangeLogItem& logItem = m_vecLogItems[j]; PyObject* poSockets = PyList_New(0); for(DWORD x=0;x 0) { TSubPacketGCCatchKingEventInfo kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingEventInfo) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingEventInfo), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingEvent", Py_BuildValue("(b)", kSubPacket.bIsEnable)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC1", kMiniGamePacket.bSubheader); break; } case SUBHEADER_GC_CATCH_KING_START: { if (iPacketSize > 0) { TSubPacketGCCatchKingStart kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingStart) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingStart), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingEventStart", Py_BuildValue("(i)", kSubPacket.dwBigScore)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC2", kMiniGamePacket.bSubheader); break; } case SUBHEADER_GC_CATCH_KING_SET_CARD: { if (iPacketSize > 0) { TSubPacketGCCatchKingSetCard kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingSetCard) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingSetCard), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingSetHandCard", Py_BuildValue("(i)", kSubPacket.bCardInHand)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC3", kMiniGamePacket.bSubheader); break; } case SUBHEADER_GC_CATCH_KING_RESULT_FIELD: { if (iPacketSize > 0) { TSubPacketGCCatchKingResult kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingResult) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingResult), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingResultField", Py_BuildValue("(iiiibbbb)", kSubPacket.dwPoints, kSubPacket.bRowType, kSubPacket.bCardPos, kSubPacket.bCardValue, kSubPacket.bKeepFieldCard, kSubPacket.bDestroyHandCard, kSubPacket.bGetReward, kSubPacket.bIsFiveNearBy)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC4", kMiniGamePacket.bSubheader); break; } case SUBHEADER_GC_CATCH_KING_SET_END_CARD: { if (iPacketSize > 0) { TSubPacketGCCatchKingSetEndCard kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingSetEndCard) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingSetEndCard), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingSetEndCard", Py_BuildValue("(ii)", kSubPacket.bCardPos, kSubPacket.bCardValue)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC5", kMiniGamePacket.bSubheader); break; } case SUBHEADER_GC_CATCH_KING_REWARD: { if (iPacketSize > 0) { TSubPacketGCCatchKingReward kSubPacket; assert(iPacketSize % sizeof(TSubPacketGCCatchKingReward) == 0 && "MINI_GAME_RUMI_CARD_REWARD"); if (!Recv(sizeof(TSubPacketGCCatchKingReward), &kSubPacket)) return false; PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "MiniGameCatchKingReward", Py_BuildValue("(i)", kSubPacket.bReturnCode)); } else TraceError(" RecvMiniGamePacket Error 0x040%uBEBC6", kMiniGamePacket.bSubheader); break; } } return true; } bool CPythonNetworkStream::SendOpenCatchKing() { PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartCatchKing", Py_BuildValue("()")); return true; } #endif