Files
AVA2/upstream/ava2-client/UserInterface/PythonNetworkStreamPhaseGame.cpp
T

7682 lines
209 KiB
C++

#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 <XORstr.h>
#ifdef ENABLE_DROP_ITEM_WORLDARD
#include "PythonDropItem.h"
#endif
#ifdef ENABLE_CUBE_RENEWAL_WORLDARD
#include "PythonCubeRenewal.h"
#endif
#include <thread>
#include <chrono>
BOOL gs_bEmpireLanuageEnable = TRUE;
static std::vector <std::string> 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 <std::string> 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 <std::string> 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<DWORD, PERF_PacketInfo>::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<DWORD, PERF_PacketInfo> 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<DWORD, PERF_PacketInfo> 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<DWORD, PERF_PacketInfo>::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<BYTE>(HEADER_CG_67_ATTR),
static_cast<BYTE>(iMaterialCount),
static_cast<BYTE>(iSupportCount),
static_cast<short>(iSupportPos),
static_cast<short>(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<char> 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(" <Login> %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(" <Logout> %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(" <Remove> %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(" <List> %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(" <Grade> [%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(" <Change Grade Name> %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(" <Change Grade Authority> %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(" <Info> %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(" <ChangeEXP> %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(" <ChangeMemberGrade> %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(" <SkillInfo> %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(" <ChangeMemberGeneralFlag> %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(" <Guild Invite> %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<DWORD> 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<CPythonSwitchbot::TSwitchbotAttributeAlternativeTable> 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<TOfflineShopItemTable>& 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<TOfflineShopItemTable>::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<char> 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<TOfflineShopItemData> 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<TIShopLogData> 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<TIShopData> 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<TEventManagerData> 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<TExchangeLogItem> 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<ITEM_SOCKET_SLOT_MAX_NUM;++x)
PyList_Append(poSockets, PyInt_FromLong(logItem.alSockets[x]));
PyObject* poAttrType = PyList_New(0);
PyObject* poAttrValue = PyList_New(0);
for (DWORD x = 0; x < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++x)
{
PyList_Append(poAttrType, PyInt_FromLong(logItem.aAttr[x].bType));
PyList_Append(poAttrValue, PyInt_FromLong(logItem.aAttr[x].sValue));
}
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ExchangeLogItemAppend", Py_BuildValue("(iiiiOOOi)", logID, logItem.pos, logItem.vnum, logItem.count, poSockets, poAttrType, poAttrValue, logItem.isOwnerItem));
Py_DECREF(poSockets);
Py_DECREF(poAttrType);
Py_DECREF(poAttrValue);
}
}
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ExchangeLogRefresh", Py_BuildValue("(i)", logID));
}
return true;
}
#endif
#ifdef ENABLE_MINI_GAME_CATCH_KING
bool CPythonNetworkStream::SendMiniGameCatchKingStart(int ibetNumber)
{
TPacketCGMiniGameCatchKing kMiniGamePacket;
kMiniGamePacket.wSize = sizeof(TPacketCGMiniGameCatchKing) + sizeof(TSubPacketCGMiniGameCatchKingStart);
kMiniGamePacket.bSubheader = SUBHEADER_CG_CATCH_KING_START;
TSubPacketCGMiniGameCatchKingStart kMiniGameSubPacket;
kMiniGameSubPacket.betNumber = ibetNumber;
if (!Send(sizeof(TPacketCGMiniGameCatchKing), &kMiniGamePacket))
return false;
if (!Send(sizeof(TSubPacketCGMiniGameCatchKingStart), &kMiniGameSubPacket))
return false;
return SendSequence();
}
bool CPythonNetworkStream::SendMiniGameCatchKingDeckCardClick()
{
TPacketCGMiniGameCatchKing kMiniGamePacket;
kMiniGamePacket.wSize = sizeof(TPacketCGMiniGameCatchKing);
kMiniGamePacket.bSubheader = SUBHEADER_CG_CATCH_KING_DECKCARD_CLICK;
if (!Send(sizeof(TPacketCGMiniGameCatchKing), &kMiniGamePacket))
return false;
return SendSequence();
}
bool CPythonNetworkStream::SendMiniGameCatchKingFieldCardClick(int icardNumber)
{
TPacketCGMiniGameCatchKing kMiniGamePacket;
kMiniGamePacket.wSize = sizeof(TPacketCGMiniGameCatchKing) + sizeof(TSubPacketCGMiniGameCatchKingFieldCardClick);
kMiniGamePacket.bSubheader = SUBHEADER_CG_CATCH_KING_FIELDCARD_CLICK;
TSubPacketCGMiniGameCatchKingFieldCardClick kMiniGameSubPacket;
kMiniGameSubPacket.cardNumber = icardNumber;
if (!Send(sizeof(TPacketCGMiniGameCatchKing), &kMiniGamePacket))
return false;
if (!Send(sizeof(TSubPacketCGMiniGameCatchKingFieldCardClick), &kMiniGameSubPacket))
return false;
return SendSequence();
}
bool CPythonNetworkStream::SendMiniGameCatchKingReward()
{
TPacketCGMiniGameCatchKing kMiniGamePacket;
kMiniGamePacket.wSize = sizeof(TPacketCGMiniGameCatchKing);
kMiniGamePacket.bSubheader = SUBHEADER_CG_CATCH_KING_REWARD;
if (!Send(sizeof(TPacketCGMiniGameCatchKing), &kMiniGamePacket))
return false;
return SendSequence();
}
bool CPythonNetworkStream::RecvMiniGameCatchKingPacket()
{
TPacketGCMiniGameCatchKing kMiniGamePacket;
if (!Recv(sizeof(TPacketGCMiniGameCatchKing), &kMiniGamePacket))
{
Tracef("MiniGame Packet Error SubHeader %u\n", kMiniGamePacket.bSubheader);
return false;
}
int iPacketSize = int(kMiniGamePacket.wSize) - sizeof(TPacketGCMiniGameCatchKing);
switch (kMiniGamePacket.bSubheader)
{
case SUBHEADER_GC_CATCH_KING_EVENT_INFO:
{
if (iPacketSize > 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