metin2/client
metin2
/
client
1
0
Fork 4
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity
client/UserInterface/PythonNetworkStream.cpp

895 lines
29 KiB
C++
Raw Normal View History

Initial commit based on the 40250 Test Client
2022-11-20 23:11:54 +02:00
#include "StdAfx.h"
#include "../eterLib/NetPacketHeaderMap.h"
#include "PythonNetworkStream.h"
#include "Packet.h"
#include "NetworkActorManager.h"
#include "GuildMarkDownloader.h"
#include "GuildMarkUploader.h"
#include "MarkManager.h"
#include "ProcessCRC.h"
// MARK_BUG_FIX
static DWORD gs_nextDownloadMarkTime = 0;
// END_OF_MARK_BUG_FIX
// Packet ---------------------------------------------------------------------------
class CMainPacketHeaderMap : public CNetworkPacketHeaderMap
{
public:
enum
{
STATIC_SIZE_PACKET = false,
DYNAMIC_SIZE_PACKET = true,
};
public:
CMainPacketHeaderMap()
{
Set(HEADER_GC_EMPIRE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCEmpire), STATIC_SIZE_PACKET));
Set(HEADER_GC_WARP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWarp), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_COOLTIME_END, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillCoolTimeEnd), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUEST_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestInfo), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_REQUEST_MAKE_GUILD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_PVP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPVP), STATIC_SIZE_PACKET));
Set(HEADER_GC_DUEL_START, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDuelStart), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHAR_ADDITIONAL_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdditionalInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_ADD2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd2), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_UPDATE2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate2), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterDelete), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_MOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMove), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHAT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChat), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SYNC_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCC2C), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_SUCCESS3, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess3), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_SUCCESS4, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess4), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_CREATE_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPlayerCreateSuccess), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_CREATE_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_DELETE_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_STUN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCStun), STATIC_SIZE_PACKET));
Set(HEADER_GC_DEAD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDead), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter), STATIC_SIZE_PACKET));
// SUPPORT_BGM
Set(HEADER_GC_MAIN_CHARACTER2_EMPIRE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter2_EMPIRE), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER3_BGM, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter3_BGM), STATIC_SIZE_PACKET));
Set(HEADER_GC_MAIN_CHARACTER4_BGM_VOL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter4_BGM_VOL), STATIC_SIZE_PACKET));
// END_OFSUPPORT_BGM
Set(HEADER_GC_PLAYER_POINTS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPoints), STATIC_SIZE_PACKET));
Set(HEADER_GC_PLAYER_POINT_CHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPointChange), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_SET2, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet2), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_USE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUse), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_GROUND_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_GROUND_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_ITEM_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemOwnership), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_QUICKSLOT_SWAP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotSwap), STATIC_SIZE_PACKET));
Set(HEADER_GC_WHISPER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWhisper), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHARACTER_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPosition), STATIC_SIZE_PACKET));
Set(HEADER_GC_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMotion), STATIC_SIZE_PACKET));
Set(HEADER_GC_SHOP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShop), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SHOP_SIGN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShopSign), STATIC_SIZE_PACKET));
Set(HEADER_GC_EXCHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCExchange), STATIC_SIZE_PACKET));
Set(HEADER_GC_PING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPing), STATIC_SIZE_PACKET));
Set(HEADER_GC_SCRIPT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCScript), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_QUEST_CONFIRM, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestConfirm), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTarget), STATIC_SIZE_PACKET));
Set(HEADER_GC_MOUNT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMount), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_SPEED, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSpeed), STATIC_SIZE_PACKET));
Set(HEADER_GC_HANDSHAKE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHandshake), STATIC_SIZE_PACKET));
Set(HEADER_GC_HANDSHAKE_OK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_BINDUDP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBindUDP), STATIC_SIZE_PACKET));
Set(HEADER_GC_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCOwnership), STATIC_SIZE_PACKET));
Set(HEADER_GC_CREATE_FLY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), STATIC_SIZE_PACKET));
Set(HEADER_GC_ADD_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
Set(HEADER_GC_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
Set(HEADER_GC_PHASE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPhase), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_LEVEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevel), STATIC_SIZE_PACKET));
Set(HEADER_GC_SKILL_LEVEL_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevelNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_MESSENGER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMessenger), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_GUILD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCGuild), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_INVITE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyInvite), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_REMOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyRemove), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_LINK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyLink), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_UNLINK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUnlink), STATIC_SIZE_PACKET));
Set(HEADER_GC_PARTY_PARAMETER, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyParameter), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_WRONG_PASSWORD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxWrongPassword), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_SIZE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxSize), STATIC_SIZE_PACKET));
Set(HEADER_GC_SAFEBOX_MONEY_CHANGE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxMoneyChange), STATIC_SIZE_PACKET));
Set(HEADER_GC_FISHING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFishing), STATIC_SIZE_PACKET));
Set(HEADER_GC_DUNGEON, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDungeon), DYNAMIC_SIZE_PACKET));
//Set(HEADER_GC_SLOW_TIMER, CNetworkPacketHeaderMap::TPacketType(sizeof(BYTE), STATIC_SIZE_PACKET));
Set(HEADER_GC_TIME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTime), STATIC_SIZE_PACKET));
Set(HEADER_GC_WALK_MODE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWalkMode), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_SKILL_GROUP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSkillGroup), STATIC_SIZE_PACKET));
Set(HEADER_GC_REFINE_INFORMATION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformation), STATIC_SIZE_PACKET));
Set(HEADER_GC_REFINE_INFORMATION_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformationNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_SEPCIAL_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecialEffect), STATIC_SIZE_PACKET));
Set(HEADER_GC_NPC_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNPCPosition), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_CHANGE_NAME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeName), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHINA_MATRIX_CARD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChinaMatrixCard), STATIC_SIZE_PACKET));
Set(HEADER_GC_RUNUP_MATRIX_QUIZ, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRunupMatrixQuiz), STATIC_SIZE_PACKET));
Set(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodRequest), STATIC_SIZE_PACKET));
Set(HEADER_GC_NEWCIBN_PASSPOD_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodFailure), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOGIN_KEY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginKey), STATIC_SIZE_PACKET));
Set(HEADER_GC_AUTH_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccess), STATIC_SIZE_PACKET));
Set(HEADER_GC_AUTH_SUCCESS_OPENID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccessOpenID), STATIC_SIZE_PACKET));
Set(HEADER_GC_CHANNEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChannel), STATIC_SIZE_PACKET));
Set(HEADER_GC_VIEW_EQUIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCViewEquip), STATIC_SIZE_PACKET));
Set(HEADER_GC_LAND_LIST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLandList), DYNAMIC_SIZE_PACKET));
//Set(HEADER_GC_TARGET_CREATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreate), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_DELETE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetDelete), STATIC_SIZE_PACKET));
Set(HEADER_GC_TARGET_CREATE_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreateNew), STATIC_SIZE_PACKET));
Set(HEADER_GC_AFFECT_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectAdd), STATIC_SIZE_PACKET));
Set(HEADER_GC_AFFECT_REMOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectRemove), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_OPEN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMallOpen), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
Set(HEADER_GC_MALL_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOVER_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoverInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_LOVE_POINT_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLovePointUpdate), STATIC_SIZE_PACKET));
Set(HEADER_GC_DIG_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDigMotion), STATIC_SIZE_PACKET));
Set(HEADER_GC_DAMAGE_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDamageInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_HS_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketHSCheck), STATIC_SIZE_PACKET));
Set(HEADER_GC_XTRAP_CS1_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketXTrapCSVerify), STATIC_SIZE_PACKET));
Set(HEADER_GC_HYBRIDCRYPT_KEYS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridCryptKeys), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_HYBRIDCRYPT_SDB, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridSDB), DYNAMIC_SIZE_PACKET));
Set(HEADER_GC_SPECIFIC_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecificEffect), STATIC_SIZE_PACKET));
Set(HEADER_GC_DRAGON_SOUL_REFINE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET));
}
};
int g_iLastPacket[2] = { 0, 0 };
void CPythonNetworkStream::ExitApplication()
{
if (__IsNotPing())
{
AbsoluteExitApplication();
}
else
{
SendChatPacket("/quit");
}
}
void CPythonNetworkStream::ExitGame()
{
if (__IsNotPing())
{
LogOutGame();
}
else
{
SendChatPacket("/phase_select");
}
}
void CPythonNetworkStream::LogOutGame()
{
if (__IsNotPing())
{
AbsoluteExitGame();
}
else
{
SendChatPacket("/logout");
}
}
void CPythonNetworkStream::AbsoluteExitGame()
{
if (!IsOnline())
return;
OnRemoteDisconnect();
Disconnect();
}
void CPythonNetworkStream::AbsoluteExitApplication()
{
PostQuitMessage(0);
}
bool CPythonNetworkStream::__IsNotPing()
{
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ȿö<C8BF> üũ<C3BC>̳<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ȯ<EFBFBD><C8AE> <20><><EFBFBD>߾<EFBFBD><DFBE><EFBFBD> <20>Ѵ<EFBFBD>.
return false;
}
DWORD CPythonNetworkStream::GetGuildID()
{
return m_dwGuildID;
}
UINT CPythonNetworkStream::UploadMark(const char * c_szImageFileName)
{
// MARK_BUG_FIX
// <20><><EFBFBD>带 <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ĵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> 0<>̴<EFBFBD>.
if (0 == m_dwGuildID)
return ERROR_MARK_UPLOAD_NEED_RECONNECT;
gs_nextDownloadMarkTime = 0;
// END_OF_MARK_BUG_FIX
UINT uError=ERROR_UNKNOWN;
CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
if (!rkGuildMarkUploader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
{
switch (uError)
{
case CGuildMarkUploader::ERROR_CONNECT:
return ERROR_CONNECT_MARK_SERVER;
break;
case CGuildMarkUploader::ERROR_LOAD:
return ERROR_LOAD_MARK;
break;
case CGuildMarkUploader::ERROR_WIDTH:
return ERROR_MARK_WIDTH;
break;
case CGuildMarkUploader::ERROR_HEIGHT:
return ERROR_MARK_HEIGHT;
break;
default:
return ERROR_UNKNOWN;
}
}
// MARK_BUG_FIX
__DownloadMark();
// END_OF_MARK_BUG_FIX
if (CGuildMarkManager::INVALID_MARK_ID == CGuildMarkManager::Instance().GetMarkID(m_dwGuildID))
return ERROR_MARK_CHECK_NEED_RECONNECT;
return ERROR_NONE;
}
UINT CPythonNetworkStream::UploadSymbol(const char* c_szImageFileName)
{
UINT uError=ERROR_UNKNOWN;
CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
if (!rkGuildMarkUploader.ConnectToSendSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
{
switch (uError)
{
case CGuildMarkUploader::ERROR_CONNECT:
return ERROR_CONNECT_MARK_SERVER;
break;
case CGuildMarkUploader::ERROR_LOAD:
return ERROR_LOAD_MARK;
break;
case CGuildMarkUploader::ERROR_WIDTH:
return ERROR_MARK_WIDTH;
break;
case CGuildMarkUploader::ERROR_HEIGHT:
return ERROR_MARK_HEIGHT;
break;
default:
return ERROR_UNKNOWN;
}
}
return ERROR_NONE;
}
void CPythonNetworkStream::__DownloadMark()
{
// 3<><33> <20>ȿ<EFBFBD><C8BF><EFBFBD> <20>ٽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
DWORD curTime = ELTimer_GetMSec();
if (curTime < gs_nextDownloadMarkTime)
return;
gs_nextDownloadMarkTime = curTime + 60000 * 3; // 3<><33>
CGuildMarkDownloader& rkGuildMarkDownloader = CGuildMarkDownloader::Instance();
rkGuildMarkDownloader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey);
}
void CPythonNetworkStream::__DownloadSymbol(const std::vector<DWORD> & c_rkVec_dwGuildID)
{
CGuildMarkDownloader& rkGuildMarkDownloader=CGuildMarkDownloader::Instance();
rkGuildMarkDownloader.ConnectToRecvSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, c_rkVec_dwGuildID);
}
void CPythonNetworkStream::SetPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
{
if (ePhaseWnd>=PHASE_WINDOW_NUM)
return;
m_apoPhaseWnd[ePhaseWnd]=poPhaseWnd;
}
void CPythonNetworkStream::ClearPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
{
if (ePhaseWnd>=PHASE_WINDOW_NUM)
return;
if (poPhaseWnd != m_apoPhaseWnd[ePhaseWnd])
return;
m_apoPhaseWnd[ePhaseWnd]=0;
}
void CPythonNetworkStream::SetServerCommandParserWindow(PyObject* poWnd)
{
m_poSerCommandParserWnd = poWnd;
}
bool CPythonNetworkStream::IsSelectedEmpire()
{
if (m_dwEmpireID)
return true;
return false;
}
UINT CPythonNetworkStream::GetAccountCharacterSlotDatau(UINT iSlot, UINT eType)
{
if (iSlot >= PLAYER_PER_ACCOUNT4)
return 0;
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
switch (eType)
{
case ACCOUNT_CHARACTER_SLOT_ID:
return rkSimplePlayerInfo.dwID;
case ACCOUNT_CHARACTER_SLOT_RACE:
return rkSimplePlayerInfo.byJob;
case ACCOUNT_CHARACTER_SLOT_LEVEL:
return rkSimplePlayerInfo.byLevel;
case ACCOUNT_CHARACTER_SLOT_STR:
return rkSimplePlayerInfo.byST;
case ACCOUNT_CHARACTER_SLOT_DEX:
return rkSimplePlayerInfo.byDX;
case ACCOUNT_CHARACTER_SLOT_HTH:
return rkSimplePlayerInfo.byHT;
case ACCOUNT_CHARACTER_SLOT_INT:
return rkSimplePlayerInfo.byIQ;
case ACCOUNT_CHARACTER_SLOT_PLAYTIME:
return rkSimplePlayerInfo.dwPlayMinutes;
case ACCOUNT_CHARACTER_SLOT_FORM:
// return rkSimplePlayerInfo.wParts[CRaceData::PART_MAIN];
return rkSimplePlayerInfo.wMainPart;
case ACCOUNT_CHARACTER_SLOT_PORT:
return rkSimplePlayerInfo.wPort;
case ACCOUNT_CHARACTER_SLOT_GUILD_ID:
return m_adwGuildID[iSlot];
break;
case ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG:
return rkSimplePlayerInfo.bChangeName;
break;
case ACCOUNT_CHARACTER_SLOT_HAIR:
return rkSimplePlayerInfo.wHairPart;
break;
}
return 0;
}
const char* CPythonNetworkStream::GetAccountCharacterSlotDataz(UINT iSlot, UINT eType)
{
static const char* sc_szEmpty="";
if (iSlot >= PLAYER_PER_ACCOUNT4)
return sc_szEmpty;
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
switch (eType)
{
case ACCOUNT_CHARACTER_SLOT_ADDR:
{
BYTE ip[4];
const int LEN = 4;
for (int i = 0; i < LEN; i++)
{
ip[i] = BYTE(rkSimplePlayerInfo.lAddr&0xff);
rkSimplePlayerInfo.lAddr>>=8;
}
static char s_szAddr[256];
sprintf(s_szAddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
return s_szAddr;
}
break;
case ACCOUNT_CHARACTER_SLOT_NAME:
return rkSimplePlayerInfo.szName;
break;
case ACCOUNT_CHARACTER_SLOT_GUILD_NAME:
return m_astrGuildName[iSlot].c_str();
break;
}
return sc_szEmpty;
}
void CPythonNetworkStream::ConnectLoginServer(const char* c_szAddr, UINT uPort)
{
CNetworkStream::Connect(c_szAddr, uPort);
}
void CPythonNetworkStream::SetMarkServer(const char* c_szAddr, UINT uPort)
{
m_kMarkAuth.m_kNetAddr.Set(c_szAddr, uPort);
}
void CPythonNetworkStream::ConnectGameServer(UINT iChrSlot)
{
if (iChrSlot >= PLAYER_PER_ACCOUNT4)
return;
m_dwSelectedCharacterIndex = iChrSlot;
__DirectEnterMode_Set(iChrSlot);
TSimplePlayerInformation& rkSimplePlayerInfo=m_akSimplePlayerInfo[iChrSlot];
CNetworkStream::Connect((DWORD)rkSimplePlayerInfo.lAddr, rkSimplePlayerInfo.wPort);
}
void CPythonNetworkStream::SetLoginInfo(const char* c_szID, const char* c_szPassword)
{
m_stID=c_szID;
m_stPassword=c_szPassword;
}
void CPythonNetworkStream::ClearLoginInfo( void )
{
m_stPassword = "";
}
void CPythonNetworkStream::SetLoginKey(DWORD dwLoginKey)
{
m_dwLoginKey = dwLoginKey;
}
bool CPythonNetworkStream::CheckPacket(TPacketHeader * pRetHeader)
{
*pRetHeader = 0;
static CMainPacketHeaderMap s_packetHeaderMap;
TPacketHeader header;
if (!Peek(sizeof(TPacketHeader), &header))
return false;
if (0 == header)
{
if (!Recv(sizeof(TPacketHeader), &header))
return false;
while (Peek(sizeof(TPacketHeader), &header))
{
if (0 == header)
{
if (!Recv(sizeof(TPacketHeader), &header))
return false;
}
else
{
break;
}
}
if (0 == header)
return false;
}
CNetworkPacketHeaderMap::TPacketType PacketType;
if (!s_packetHeaderMap.Get(header, &PacketType))
{
TraceError("Unknown packet header: %d, last: %d %d", header, g_iLastPacket[0], g_iLastPacket[1]);
ClearRecvBuffer();
PostQuitMessage(0);
return false;
}
// Code for dynamic size packet
if (PacketType.isDynamicSizePacket)
{
TDynamicSizePacketHeader DynamicSizePacketHeader;
if (!Peek(sizeof(TDynamicSizePacketHeader), &DynamicSizePacketHeader))
return false;
if (!Peek(DynamicSizePacketHeader.size))
{
Tracef("CPythonNetworkStream::CheckPacket - Not enough dynamic packet size: header %d packet size: %d\n",
DynamicSizePacketHeader.header,
DynamicSizePacketHeader.size);
return false;
}
}
else
{
if (!Peek(PacketType.iPacketSize))
{
//Tracef("Not enough packet size: header %d packet size: %d, recv buffer size: %d",
// header,
// PacketType.iPacketSize,
// GetRecvBufferSize());
return false;
}
}
if (!header)
return false;
*pRetHeader = header;
g_iLastPacket[0] = g_iLastPacket[1];
g_iLastPacket[1] = header;
//Tracenf("header %d size %d", header, PacketType.iPacketSize);
//Tracenf("header %d size %d outputpos[%d] security %u", header, PacketType.iPacketSize, m_recvBufOutputPos, IsSecurityMode());
return true;
}
bool CPythonNetworkStream::RecvErrorPacket(int header)
{
TraceError("Phase %s does not handle this header (header: %d, last: %d, %d)",
m_strPhase.c_str(), header, g_iLastPacket[0], g_iLastPacket[1]);
ClearRecvBuffer();
return true;
}
bool CPythonNetworkStream::RecvPhasePacket()
{
TPacketGCPhase packet_phase;
if (!Recv(sizeof(TPacketGCPhase), &packet_phase))
return false;
switch (packet_phase.phase)
{
case PHASE_CLOSE: // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>)
ClosePhase();
break;
case PHASE_HANDSHAKE: // <20>Ǽ<EFBFBD>..;;
SetHandShakePhase();
break;
case PHASE_LOGIN: // <20>α<EFBFBD><CEB1><EFBFBD> <20><>
SetLoginPhase();
break;
case PHASE_SELECT: // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ȭ<><C8AD>
SetSelectPhase();
BuildProcessCRC();
// MARK_BUG_FIX
__DownloadMark();
// END_OF_MARK_BUG_FIX
break;
case PHASE_LOADING: // <20><><EFBFBD><EFBFBD> <20><> <20>ε<EFBFBD> ȭ<><C8AD>
SetLoadingPhase();
break;
case PHASE_GAME: // <20><><EFBFBD><EFBFBD> ȭ<><C8AD>
SetGamePhase();
break;
case PHASE_DEAD: // <20>׾<EFBFBD><D7BE><EFBFBD> <20><>.. (<28><><EFBFBD><EFBFBD> <20>ȿ<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>..)
break;
}
return true;
}
bool CPythonNetworkStream::RecvPingPacket()
{
Tracef("recv ping packet.\n");
TPacketGCPing kPacketPing;
if (!Recv(sizeof(TPacketGCPing), &kPacketPing))
return false;
m_dwLastGamePingTime = ELTimer_GetMSec();
TPacketCGPong kPacketPong;
kPacketPong.bHeader = HEADER_CG_PONG;
if (!Send(sizeof(TPacketCGPong), &kPacketPong))
return false;
return SendSequence();
}
bool CPythonNetworkStream::RecvDefaultPacket(int header)
{
if (!header)
return true;
TraceError("ó<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> %d, state %s\n", header, m_strPhase.c_str());
ClearRecvBuffer();
return true;
}
bool CPythonNetworkStream::OnProcess()
{
if (m_isStartGame)
{
m_isStartGame = FALSE;
PyCallClassMemberFunc(m_poHandler, "SetGamePhase", Py_BuildValue("()"));
// PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartGame", Py_BuildValue("()"));
}
m_rokNetActorMgr->Update();
if (m_phaseProcessFunc.IsEmpty())
return true;
//TPacketHeader header;
//while(CheckPacket(&header))
{
m_phaseProcessFunc.Run();
}
return true;
}
// Set
void CPythonNetworkStream::SetOffLinePhase()
{
if ("OffLine" != m_strPhase)
m_phaseLeaveFunc.Run();
m_strPhase = "OffLine";
Tracen("");
Tracen("## Network - OffLine Phase ##");
Tracen("");
m_dwChangingPhaseTime = ELTimer_GetMSec();
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::OffLinePhase);
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveOfflinePhase);
SetGameOffline();
m_dwSelectedCharacterIndex = 0;
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
}
void CPythonNetworkStream::ClosePhase()
{
PyCallClassMemberFunc(m_poHandler, "SetLoginPhase", Py_BuildValue("()"));
}
// Game Online
void CPythonNetworkStream::SetGameOnline()
{
m_isGameOnline = TRUE;
}
void CPythonNetworkStream::SetGameOffline()
{
m_isGameOnline = FALSE;
}
BOOL CPythonNetworkStream::IsGameOnline()
{
return m_isGameOnline;
}
// Handler
void CPythonNetworkStream::SetHandler(PyObject* poHandler)
{
m_poHandler = poHandler;
}
// ETC
DWORD CPythonNetworkStream::GetMainActorVID()
{
return m_dwMainActorVID;
}
DWORD CPythonNetworkStream::GetMainActorRace()
{
return m_dwMainActorRace;
}
DWORD CPythonNetworkStream::GetMainActorEmpire()
{
return m_dwMainActorEmpire;
}
DWORD CPythonNetworkStream::GetMainActorSkillGroup()
{
return m_dwMainActorSkillGroup;
}
void CPythonNetworkStream::SetEmpireID(DWORD dwEmpireID)
{
m_dwEmpireID = dwEmpireID;
}
DWORD CPythonNetworkStream::GetEmpireID()
{
return m_dwEmpireID;
}
void CPythonNetworkStream::__ClearSelectCharacterData()
{
NANOBEGIN
memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
{
m_adwGuildID[i] = 0;
m_astrGuildName[i] = "";
}
NANOEND
}
void CPythonNetworkStream::__DirectEnterMode_Initialize()
{
m_kDirectEnterMode.m_isSet=false;
m_kDirectEnterMode.m_dwChrSlotIndex=0;
}
void CPythonNetworkStream::__DirectEnterMode_Set(UINT uChrSlotIndex)
{
m_kDirectEnterMode.m_isSet=true;
m_kDirectEnterMode.m_dwChrSlotIndex=uChrSlotIndex;
}
bool CPythonNetworkStream::__DirectEnterMode_IsSet()
{
return m_kDirectEnterMode.m_isSet;
}
void CPythonNetworkStream::__InitializeMarkAuth()
{
m_kMarkAuth.m_dwHandle=0;
m_kMarkAuth.m_dwRandomKey=0;
}
void CPythonNetworkStream::__BettingGuildWar_Initialize()
{
m_kBettingGuildWar.m_dwBettingMoney=0;
m_kBettingGuildWar.m_dwObserverCount=0;
}
void CPythonNetworkStream::__BettingGuildWar_SetObserverCount(UINT uObserverCount)
{
m_kBettingGuildWar.m_dwObserverCount=uObserverCount;
}
void CPythonNetworkStream::__BettingGuildWar_SetBettingMoney(UINT uBettingMoney)
{
m_kBettingGuildWar.m_dwBettingMoney=uBettingMoney;
}
DWORD CPythonNetworkStream::EXPORT_GetBettingGuildWarValue(const char* c_szValueName)
{
if (stricmp(c_szValueName, "OBSERVER_COUNT") == 0)
return m_kBettingGuildWar.m_dwObserverCount;
if (stricmp(c_szValueName, "BETTING_MONEY") == 0)
return m_kBettingGuildWar.m_dwBettingMoney;
return 0;
}
void CPythonNetworkStream::__ServerTimeSync_Initialize()
{
m_kServerTimeSync.m_dwChangeClientTime=0;
m_kServerTimeSync.m_dwChangeServerTime=0;
}
void CPythonNetworkStream::SetWaitFlag()
{
m_isWaitLoginKey = TRUE;
}
void CPythonNetworkStream::SendEmoticon(UINT eEmoticon)
{
if(eEmoticon < m_EmoticonStringVector.size())
SendChatPacket(m_EmoticonStringVector[eEmoticon].c_str());
else
assert(false && "SendEmoticon Error");
}
CPythonNetworkStream::CPythonNetworkStream()
{
m_rokNetActorMgr=new CNetworkActorManager;
memset(m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
m_phaseProcessFunc.Clear();
m_dwEmpireID = 0;
m_dwGuildID = 0;
m_dwMainActorVID = 0;
m_dwMainActorRace = 0;
m_dwMainActorEmpire = 0;
m_dwMainActorSkillGroup = 0;
m_poHandler = NULL;
m_dwLastGamePingTime = 0;
m_dwLoginKey = 0;
m_isWaitLoginKey = FALSE;
m_isStartGame = FALSE;
m_isEnableChatInsultFilter = FALSE;
m_bComboSkillFlag = FALSE;
m_strPhase = "OffLine";
__InitializeGamePhase();
__InitializeMarkAuth();
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
std::fill(m_apoPhaseWnd, m_apoPhaseWnd+PHASE_WINDOW_NUM, (PyObject*)NULL);
m_poSerCommandParserWnd = NULL;
SetOffLinePhase();
}
CPythonNetworkStream::~CPythonNetworkStream()
{
Tracen("PythonNetworkMainStream Clear");
}