2V1-b/c: PythonNetworkStream phases, AccountConnector and the net module
Port PythonNetworkStream with its HandShake/Login/Select/Loading/Offline phases, AccountConnector and PythonNetworkStreamModule verbatim; the net stub goes. PythonBoot creates the network stream, account connector, player, flying manager and effect manager like CPythonApplication, and app.Create/Process drive CNetworkDevice and both connectors. Packet.h long fields become 32-bit LONG; port.packet checks 38 login/select/loading packet sizes against wire_classic.h. Unported units in the link closure live under platform/pending/ as stand-ins. The macOS gate now builds all and finds iconv. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
shenlei
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
cd3b8b506f
commit
4d9b800efb
@@ -0,0 +1,745 @@
|
||||
#include "StdAfx.h"
|
||||
#include "AccountConnector.h"
|
||||
#include "Packet.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "../EterBase/tea.h"
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
|
||||
#include "Hackshield.h"
|
||||
#include "WiseLogicXTrap.h"
|
||||
|
||||
// CHINA_CRYPT_KEY
|
||||
extern DWORD g_adwEncryptKey[4];
|
||||
extern DWORD g_adwDecryptKey[4];
|
||||
// END_OF_CHINA_CRYPT_KEY
|
||||
|
||||
#ifdef USE_OPENID
|
||||
extern int openid_test;
|
||||
#endif
|
||||
|
||||
void CAccountConnector::SetHandler(PyObject* poHandler)
|
||||
{
|
||||
m_poHandler = poHandler;
|
||||
}
|
||||
|
||||
void CAccountConnector::SetLoginInfo(const char * c_szName, const char * c_szPwd)
|
||||
{
|
||||
m_strID = c_szName;
|
||||
m_strPassword = c_szPwd;
|
||||
}
|
||||
|
||||
|
||||
void CAccountConnector::ClearLoginInfo( void )
|
||||
{
|
||||
m_strPassword = "";
|
||||
}
|
||||
|
||||
bool CAccountConnector::Connect(const char * c_szAddr, int iPort, const char * c_szAccountAddr, int iAccountPort)
|
||||
{
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
__BuildClientKey();
|
||||
#endif
|
||||
|
||||
m_strAddr = c_szAddr;
|
||||
m_iPort = iPort;
|
||||
|
||||
__OfflineState_Set();
|
||||
|
||||
// CHINA_CRYPT_KEY
|
||||
if (LocaleService_IsYMIR())
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
__BuildClientKey_20050304Myevan();
|
||||
}
|
||||
// END_OF_CHINA_CRYPT_KEY
|
||||
|
||||
return CNetworkStream::Connect(c_szAccountAddr, iAccountPort);
|
||||
}
|
||||
|
||||
void CAccountConnector::Disconnect()
|
||||
{
|
||||
CNetworkStream::Disconnect();
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
bool CAccountConnector::SendNEWCIBNPasspodAnswerPacket(const char * answer)
|
||||
{
|
||||
TPacketCGNEWCIBNPasspodAnswer answerPacket;
|
||||
answerPacket.bHeader = HEADER_CG_NEWCIBN_PASSPOD_ANSWER;
|
||||
strncpy(answerPacket.szAnswer, answer, NEWCIBN_PASSPOD_ANSWER_MAX_LEN);
|
||||
answerPacket.szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN] = '\0';
|
||||
if (!Send(sizeof(answerPacket), &answerPacket))
|
||||
{
|
||||
TraceError("SendNEWCIBNPasspodAnswerPacket");
|
||||
return false;
|
||||
}
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CAccountConnector::SendRunupMatrixCardPacket(const char * c_szMatrixCardString)
|
||||
{
|
||||
TPacketCGRunupMatrixAnswer answerPacket;
|
||||
answerPacket.bHeader = HEADER_CG_RUNUP_MATRIX_ANSWER;
|
||||
strncpy(answerPacket.szAnswer, c_szMatrixCardString, RUNUP_MATRIX_ANSWER_MAX_LEN);
|
||||
answerPacket.szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN] = '\0';
|
||||
if (!Send(sizeof(answerPacket), &answerPacket))
|
||||
{
|
||||
TraceError("SendRunupMatrixCardPacketError");
|
||||
return false;
|
||||
}
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CAccountConnector::SendChinaMatrixCardPacket(const char * c_szMatrixCardString)
|
||||
{
|
||||
TPacketCGChinaMatrixCard MatrixCardPacket;
|
||||
MatrixCardPacket.bHeader = HEADER_CG_CHINA_MATRIX_CARD;
|
||||
strncpy(MatrixCardPacket.szAnswer, c_szMatrixCardString, CHINA_MATRIX_ANSWER_MAX_LEN);
|
||||
MatrixCardPacket.szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN] = '\0';
|
||||
|
||||
if (!Send(sizeof(MatrixCardPacket), &MatrixCardPacket))
|
||||
{
|
||||
Tracen("SendLogin Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
CPythonNetworkStream::Instance().SetWaitFlag();
|
||||
m_isWaitKey = TRUE;
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
void CAccountConnector::Process()
|
||||
{
|
||||
CNetworkStream::Process();
|
||||
|
||||
if (!__StateProcess())
|
||||
{
|
||||
__OfflineState_Set();
|
||||
Disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
bool CAccountConnector::__StateProcess()
|
||||
{
|
||||
switch (m_eState)
|
||||
{
|
||||
case STATE_HANDSHAKE:
|
||||
return __HandshakeState_Process();
|
||||
break;
|
||||
case STATE_AUTH:
|
||||
return __AuthState_Process();
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__HandshakeState_Process()
|
||||
{
|
||||
if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
|
||||
return false;
|
||||
|
||||
// TODO : 차후 서버와 동일하게 가변길이 data serialize & deserialize 작업해야 한다.
|
||||
if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
|
||||
return false;
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT, sizeof(TPacketKeyAgreement), &CAccountConnector::__AuthState_RecvKeyAgreement))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT_COMPLETED, sizeof(TPacketKeyAgreementCompleted), &CAccountConnector::__AuthState_RecvKeyAgreementCompleted))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_Process()
|
||||
{
|
||||
if (!__AnalyzePacket(0, sizeof(BYTE), &CAccountConnector::__AuthState_RecvEmpty))
|
||||
return true;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess))
|
||||
return true;
|
||||
|
||||
#ifdef USE_OPENID
|
||||
if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS_OPENID, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess_OpenID))
|
||||
return true;
|
||||
#endif /* USE_OPENID */
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_LOGIN_FAILURE, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthFailure))
|
||||
return true;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_CHINA_MATRIX_CARD, sizeof(TPacketGCChinaMatrixCard), &CAccountConnector::__AuthState_RecvChinaMatrixCard))
|
||||
return true;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_RUNUP_MATRIX_QUIZ, sizeof(TPacketGCRunupMatrixQuiz), &CAccountConnector::__AuthState_RecvRunupMatrixQuiz))
|
||||
return true;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, sizeof(TPacketGCNEWCIBNPasspodRequest), &CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest))
|
||||
return true;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_PANAMA_PACK, sizeof(TPacketGCPanamaPack), &CAccountConnector::__AuthState_RecvPanamaPack))
|
||||
return false;
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT, sizeof(TPacketKeyAgreement), &CAccountConnector::__AuthState_RecvKeyAgreement))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT_COMPLETED, sizeof(TPacketKeyAgreementCompleted), &CAccountConnector::__AuthState_RecvKeyAgreementCompleted))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
// TODO : 차후 서버와 동일하게 가변길이 data serialize & deserialize 작업해야 한다.
|
||||
if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvEmpty()
|
||||
{
|
||||
BYTE byEmpty;
|
||||
Recv(sizeof(BYTE), &byEmpty);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvPhase()
|
||||
{
|
||||
TPacketGCPhase kPacketPhase;
|
||||
if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
|
||||
return false;
|
||||
|
||||
if (kPacketPhase.phase == PHASE_HANDSHAKE)
|
||||
{
|
||||
__HandshakeState_Set();
|
||||
}
|
||||
else if (kPacketPhase.phase == PHASE_AUTH)
|
||||
{
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
const char* key = LocaleService_GetSecurityKey();
|
||||
SetSecurityMode(true, key);
|
||||
#endif
|
||||
|
||||
#ifdef USE_OPENID
|
||||
if (!openid_test)
|
||||
{
|
||||
//2012.07.19 OpenID : 김용욱
|
||||
//Ongoing : 오픈 아이디 경우-> TPacketCGLogin5
|
||||
//클라가 가지고 있는 인증키만을 서버에 보내도록.
|
||||
|
||||
//const char* tempAuthKey = "d4025bc1f752b64fe5d51ae575ec4730"; //하드코딩 길이 32
|
||||
TPacketCGLogin5 LoginPacket;
|
||||
LoginPacket.header = HEADER_CG_LOGIN5_OPENID;
|
||||
|
||||
strncpy(LoginPacket.authKey, LocaleService_GetOpenIDAuthKey(), OPENID_AUTHKEY_LEN);
|
||||
LoginPacket.authKey[OPENID_AUTHKEY_LEN] = '\0';
|
||||
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
|
||||
|
||||
if (!Send(sizeof(LoginPacket), &LoginPacket))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin5 Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SendSequence())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
TPacketCGLogin3 LoginPacket;
|
||||
LoginPacket.header = HEADER_CG_LOGIN3;
|
||||
|
||||
strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
|
||||
strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
|
||||
LoginPacket.name[ID_MAX_NUM] = '\0';
|
||||
LoginPacket.pwd[PASS_MAX_NUM] = '\0';
|
||||
|
||||
// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
|
||||
ClearLoginInfo();
|
||||
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
|
||||
rkNetStream.ClearLoginInfo();
|
||||
|
||||
m_strPassword = "";
|
||||
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
|
||||
|
||||
if (!Send(sizeof(LoginPacket), &LoginPacket))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SendSequence())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#else /* USE_OPENID */
|
||||
|
||||
#ifdef USE_AHNLAB_HACKSHIELD
|
||||
HackShield_SetUserInfo(m_strID.c_str());
|
||||
#endif
|
||||
#ifdef XTRAP_CLIENT_ENABLE
|
||||
XTrap_SetUserInfo(m_strID.c_str(), NULL, NULL, NULL, NULL);
|
||||
#endif
|
||||
|
||||
|
||||
TPacketCGLogin3 LoginPacket;
|
||||
LoginPacket.header = HEADER_CG_LOGIN3;
|
||||
|
||||
strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
|
||||
strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
|
||||
LoginPacket.name[ID_MAX_NUM] = '\0';
|
||||
LoginPacket.pwd[PASS_MAX_NUM] = '\0';
|
||||
|
||||
// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
|
||||
ClearLoginInfo();
|
||||
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
|
||||
rkNetStream.ClearLoginInfo();
|
||||
|
||||
m_strPassword = "";
|
||||
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
|
||||
|
||||
if (!Send(sizeof(LoginPacket), &LoginPacket))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SendSequence())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif /* USE_OPENID */
|
||||
|
||||
__AuthState_Set();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvHandshake()
|
||||
{
|
||||
TPacketGCHandshake kPacketHandshake;
|
||||
if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
|
||||
return false;
|
||||
|
||||
// HandShake
|
||||
{
|
||||
Tracenf("HANDSHAKE RECV %u %d", kPacketHandshake.dwTime, kPacketHandshake.lDelta);
|
||||
|
||||
ELTimer_SetServerMSec(kPacketHandshake.dwTime+ kPacketHandshake.lDelta);
|
||||
|
||||
//DWORD dwBaseServerTime = kPacketHandshake.dwTime+ kPacketHandshake.lDelta;
|
||||
//DWORD dwBaseClientTime = ELTimer_GetMSec();
|
||||
|
||||
kPacketHandshake.dwTime = kPacketHandshake.dwTime + kPacketHandshake.lDelta + kPacketHandshake.lDelta;
|
||||
kPacketHandshake.lDelta = 0;
|
||||
|
||||
Tracenf("HANDSHAKE SEND %u", kPacketHandshake.dwTime);
|
||||
|
||||
if (!Send(sizeof(kPacketHandshake), &kPacketHandshake))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvHandshake - SendHandshake Error");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvPanamaPack()
|
||||
{
|
||||
TPacketGCPanamaPack kPacket;
|
||||
|
||||
if (!Recv(sizeof(TPacketGCPanamaPack), &kPacket))
|
||||
return false;
|
||||
|
||||
CEterPackManager::instance().RegisterPack(kPacket.szPackName, "*", kPacket.abIV);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvHybridCryptKeys(int iTotalSize)
|
||||
{
|
||||
int iFixedHeaderSize = TPacketGCHybridCryptKeys::GetFixedHeaderSize();
|
||||
|
||||
TPacketGCHybridCryptKeys kPacket(iTotalSize-iFixedHeaderSize);
|
||||
|
||||
if (!Recv(iFixedHeaderSize, &kPacket))
|
||||
return false;
|
||||
|
||||
if (!Recv(kPacket.iKeyStreamLen, kPacket.m_pStream))
|
||||
return false;
|
||||
|
||||
CEterPackManager::Instance().RetrieveHybridCryptPackKeys( kPacket.m_pStream );
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvHybridCryptSDB(int iTotalSize)
|
||||
{
|
||||
int iFixedHeaderSize = TPacketGCHybridSDB::GetFixedHeaderSize();
|
||||
|
||||
TPacketGCHybridSDB kPacket(iTotalSize-iFixedHeaderSize);
|
||||
|
||||
if (!Recv(iFixedHeaderSize, &kPacket))
|
||||
return false;
|
||||
|
||||
if (!Recv(kPacket.iSDBStreamLen, kPacket.m_pStream))
|
||||
return false;
|
||||
|
||||
CEterPackManager::Instance().RetrieveHybridCryptPackSDB( kPacket.m_pStream );
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvPing()
|
||||
{
|
||||
TPacketGCPing kPacketPing;
|
||||
if (!Recv(sizeof(kPacketPing), &kPacketPing))
|
||||
return false;
|
||||
|
||||
__AuthState_SendPong();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_SendPong()
|
||||
{
|
||||
TPacketCGPong kPacketPong;
|
||||
kPacketPong.bHeader = HEADER_CG_PONG;
|
||||
if (!Send(sizeof(kPacketPong), &kPacketPong))
|
||||
return false;
|
||||
|
||||
if (IsSecurityMode())
|
||||
return SendSequence();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvAuthSuccess()
|
||||
{
|
||||
TPacketGCAuthSuccess kAuthSuccessPacket;
|
||||
if (!Recv(sizeof(kAuthSuccessPacket), &kAuthSuccessPacket))
|
||||
return false;
|
||||
|
||||
if (!kAuthSuccessPacket.bResult)
|
||||
{
|
||||
if (m_poHandler)
|
||||
PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
|
||||
}
|
||||
else
|
||||
{
|
||||
DWORD dwPanamaKey = kAuthSuccessPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
|
||||
CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
|
||||
|
||||
CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
|
||||
rkNet.SetLoginKey(kAuthSuccessPacket.dwLoginKey);
|
||||
rkNet.Connect(m_strAddr.c_str(), m_iPort);
|
||||
}
|
||||
|
||||
Disconnect();
|
||||
__OfflineState_Set();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef USE_OPENID
|
||||
bool CAccountConnector::__AuthState_RecvAuthSuccess_OpenID()
|
||||
{
|
||||
TPacketGCAuthSuccessOpenID kAuthSuccessOpenIDPacket;
|
||||
if (!Recv(sizeof(kAuthSuccessOpenIDPacket), &kAuthSuccessOpenIDPacket))
|
||||
return false;
|
||||
|
||||
if (!kAuthSuccessOpenIDPacket.bResult)
|
||||
{
|
||||
if (m_poHandler)
|
||||
PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
|
||||
}
|
||||
else
|
||||
{
|
||||
DWORD dwPanamaKey = kAuthSuccessOpenIDPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
|
||||
CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
|
||||
|
||||
CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
|
||||
rkNet.SetLoginInfo(kAuthSuccessOpenIDPacket.login, "0000"); //OpenID 인증 과정에서 비밀번호는 사용되지 않는다.
|
||||
rkNet.SetLoginKey(kAuthSuccessOpenIDPacket.dwLoginKey);
|
||||
rkNet.Connect(m_strAddr.c_str(), m_iPort);
|
||||
}
|
||||
|
||||
Disconnect();
|
||||
__OfflineState_Set();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif /* USE_OPENID */
|
||||
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvAuthFailure()
|
||||
{
|
||||
TPacketGCLoginFailure packet_failure;
|
||||
if (!Recv(sizeof(TPacketGCLoginFailure), &packet_failure))
|
||||
return false;
|
||||
|
||||
if (m_poHandler)
|
||||
PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", packet_failure.szStatus));
|
||||
|
||||
// __OfflineState_Set();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvRunupMatrixQuiz()
|
||||
{
|
||||
TPacketGCRunupMatrixQuiz kMatrixQuizPacket;
|
||||
if (!Recv(sizeof(TPacketGCRunupMatrixQuiz), &kMatrixQuizPacket))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_poHandler, "BINARY_OnRunupMatrixQuiz", Py_BuildValue("(s)", kMatrixQuizPacket.szQuiz));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest()
|
||||
{
|
||||
TPacketGCNEWCIBNPasspodRequest kRequestPacket;
|
||||
if (!Recv(sizeof(kRequestPacket), &kRequestPacket))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_poHandler, "BINARY_OnNEWCIBNPasspodRequest", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
#define ROW(rows, i) ((rows >> ((4 - i - 1) * 8)) & 0x000000FF)
|
||||
#define COL(cols, i) ((cols >> ((4 - i - 1) * 8)) & 0x000000FF)
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvChinaMatrixCard()
|
||||
{
|
||||
TPacketGCChinaMatrixCard kMatrixCardPacket;
|
||||
if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
|
||||
return false;
|
||||
|
||||
if (m_poHandler)
|
||||
{
|
||||
PyObject * pyValue = Py_BuildValue("(iiiiiiii)", ROW(kMatrixCardPacket.dwRows, 0),
|
||||
ROW(kMatrixCardPacket.dwRows, 1),
|
||||
ROW(kMatrixCardPacket.dwRows, 2),
|
||||
ROW(kMatrixCardPacket.dwRows, 3),
|
||||
COL(kMatrixCardPacket.dwCols, 0),
|
||||
COL(kMatrixCardPacket.dwCols, 1),
|
||||
COL(kMatrixCardPacket.dwCols, 2),
|
||||
COL(kMatrixCardPacket.dwCols, 3));
|
||||
PyCallClassMemberFunc(m_poHandler, "OnMatrixCard", pyValue);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
bool CAccountConnector::__AuthState_RecvKeyAgreement()
|
||||
{
|
||||
TPacketKeyAgreement packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
|
||||
|
||||
TPacketKeyAgreement packetToSend;
|
||||
size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
|
||||
size_t agreedLength = Prepare(packetToSend.data, &dataLength);
|
||||
if (agreedLength == 0)
|
||||
{
|
||||
// 초기화 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
|
||||
|
||||
if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
|
||||
{
|
||||
// Key agreement 성공, 응답 전송
|
||||
packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
|
||||
packetToSend.wAgreedLength = (WORD)agreedLength;
|
||||
packetToSend.wDataLength = (WORD)dataLength;
|
||||
|
||||
if (!Send(sizeof(packetToSend), &packetToSend))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvKeyAgreement - SendKeyAgreement Error");
|
||||
return false;
|
||||
}
|
||||
Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 키 협상 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AuthState_RecvKeyAgreementCompleted()
|
||||
{
|
||||
TPacketKeyAgreementCompleted packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT_COMPLETED RECV");
|
||||
|
||||
ActivateCipher();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif // _IMPROVED_PACKET_ENCRYPTION_
|
||||
|
||||
bool CAccountConnector::__AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CAccountConnector::*pfnDispatchPacket)())
|
||||
{
|
||||
BYTE bHeader;
|
||||
if (!Peek(sizeof(bHeader), &bHeader))
|
||||
return true;
|
||||
|
||||
if (bHeader!=uHeader)
|
||||
return true;
|
||||
|
||||
if (!Peek(uPacketSize))
|
||||
return true;
|
||||
|
||||
return (this->*pfnDispatchPacket)();
|
||||
}
|
||||
|
||||
bool CAccountConnector::__AnalyzeVarSizePacket(UINT uHeader, bool (CAccountConnector::*pfnDispatchPacket)(int))
|
||||
{
|
||||
BYTE bHeader;
|
||||
if (!Peek(sizeof(bHeader), &bHeader))
|
||||
return true;
|
||||
|
||||
if (bHeader!=uHeader)
|
||||
return true;
|
||||
|
||||
TDynamicSizePacketHeader dynamicHeader;
|
||||
|
||||
if (!Peek(sizeof(dynamicHeader), &dynamicHeader))
|
||||
return true;
|
||||
|
||||
if (!Peek(dynamicHeader.size))
|
||||
return true;
|
||||
|
||||
return (this->*pfnDispatchPacket)(dynamicHeader.size);
|
||||
}
|
||||
|
||||
|
||||
void CAccountConnector::__OfflineState_Set()
|
||||
{
|
||||
__Inialize();
|
||||
}
|
||||
|
||||
void CAccountConnector::__HandshakeState_Set()
|
||||
{
|
||||
m_eState=STATE_HANDSHAKE;
|
||||
}
|
||||
|
||||
void CAccountConnector::__AuthState_Set()
|
||||
{
|
||||
m_eState=STATE_AUTH;
|
||||
}
|
||||
|
||||
void CAccountConnector::OnConnectFailure()
|
||||
{
|
||||
if (m_poHandler)
|
||||
PyCallClassMemberFunc(m_poHandler, "OnConnectFailure", Py_BuildValue("()"));
|
||||
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CAccountConnector::OnConnectSuccess()
|
||||
{
|
||||
m_eState = STATE_HANDSHAKE;
|
||||
}
|
||||
|
||||
void CAccountConnector::OnRemoteDisconnect()
|
||||
{
|
||||
// Matrix Card Number 를 보내 놓았는데 close 되면 프로그램을 종료 한다.
|
||||
if (m_isWaitKey)
|
||||
{
|
||||
if (m_poHandler)
|
||||
{
|
||||
PyCallClassMemberFunc(m_poHandler, "OnExit", Py_BuildValue("()"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CAccountConnector::OnDisconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
void CAccountConnector::__BuildClientKey()
|
||||
{
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
g_adwEncryptKey[i] = random();
|
||||
|
||||
const BYTE * c_pszKey = (const BYTE *) "JyTxtHljHJlVJHorRM301vf@4fvj10-v";
|
||||
tea_encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) c_pszKey, 16);
|
||||
}
|
||||
#endif
|
||||
|
||||
void CAccountConnector::__Inialize()
|
||||
{
|
||||
m_eState=STATE_OFFLINE;
|
||||
m_isWaitKey = FALSE;
|
||||
}
|
||||
|
||||
CAccountConnector::CAccountConnector()
|
||||
{
|
||||
m_poHandler = NULL;
|
||||
m_strAddr = "";
|
||||
m_iPort = 0;
|
||||
|
||||
SetLoginInfo("", "");
|
||||
SetRecvBufferSize(1024 * 128);
|
||||
SetSendBufferSize(2048);
|
||||
__Inialize();
|
||||
}
|
||||
|
||||
CAccountConnector::~CAccountConnector()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
#include "StdAfx.h"
|
||||
#include "AffectFlagContainer.h"
|
||||
|
||||
CAffectFlagContainer::CAffectFlagContainer()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
CAffectFlagContainer::~CAffectFlagContainer()
|
||||
{
|
||||
}
|
||||
|
||||
void CAffectFlagContainer::Clear()
|
||||
{
|
||||
memset(m_aElement, 0, sizeof(m_aElement));
|
||||
}
|
||||
|
||||
void CAffectFlagContainer::CopyInstance(const CAffectFlagContainer& c_rkAffectContainer)
|
||||
{
|
||||
memcpy(m_aElement, c_rkAffectContainer.m_aElement, sizeof(m_aElement));
|
||||
}
|
||||
|
||||
void CAffectFlagContainer::CopyData(UINT uPos, UINT uByteSize, const void* c_pvData)
|
||||
{
|
||||
const BYTE* c_pbData=(const BYTE*)c_pvData;
|
||||
Element bMask=0x01;
|
||||
|
||||
UINT uBitEnd=uPos+uByteSize*8;
|
||||
for (UINT i=uPos; i<uBitEnd; ++i)
|
||||
{
|
||||
Set(i, (*c_pbData & bMask) ? true : false);
|
||||
bMask<<=1;
|
||||
|
||||
if (bMask==0)
|
||||
{
|
||||
++c_pbData;
|
||||
bMask=0x01;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CAffectFlagContainer::ConvertToPosition(unsigned* uRetX, unsigned* uRetY) const
|
||||
{
|
||||
DWORD* pos = (DWORD*)m_aElement;
|
||||
*uRetX = pos[0];
|
||||
*uRetY = pos[1];
|
||||
}
|
||||
/*
|
||||
const void * CAffectFlagContainer::GetDataPtr(UINT uPos) const
|
||||
{
|
||||
if (uPos/8>=BYTE_SIZE)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (const void *)&m_aElement[uPos];
|
||||
}
|
||||
*/
|
||||
|
||||
void CAffectFlagContainer::Set(UINT uPos, bool isSet)
|
||||
{
|
||||
if (uPos/8>=BYTE_SIZE)
|
||||
{
|
||||
TraceError("CAffectFlagContainer::Set(uPos=%d>%d, isSet=%d", uPos, BYTE_SIZE*8, isSet);
|
||||
return;
|
||||
}
|
||||
|
||||
BYTE& rElement=m_aElement[uPos/8];
|
||||
|
||||
BYTE bMask=BYTE(1<<(uPos&7));
|
||||
if (isSet)
|
||||
rElement|=bMask;
|
||||
else
|
||||
rElement&=~bMask;
|
||||
}
|
||||
|
||||
bool CAffectFlagContainer::IsSet(UINT uPos) const
|
||||
{
|
||||
if (uPos/8>=BYTE_SIZE)
|
||||
{
|
||||
TraceError("CAffectFlagContainer::IsSet(uPos=%d>%d", uPos, BYTE_SIZE*8);
|
||||
return false;
|
||||
}
|
||||
|
||||
const BYTE& c_rElement=m_aElement[uPos/8];
|
||||
|
||||
BYTE bMask=BYTE(1<<(uPos&7));
|
||||
if (c_rElement&bMask)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
#include "StdAfx.h"
|
||||
#include "InsultChecker.h"
|
||||
|
||||
CInsultChecker& CInsultChecker::GetSingleton()
|
||||
{
|
||||
static CInsultChecker s_kInsultChecker;
|
||||
return s_kInsultChecker;
|
||||
}
|
||||
|
||||
CInsultChecker::CInsultChecker()
|
||||
{
|
||||
}
|
||||
|
||||
CInsultChecker::~CInsultChecker()
|
||||
{
|
||||
}
|
||||
|
||||
void CInsultChecker::Clear()
|
||||
{
|
||||
m_kList_stInsult.clear();
|
||||
}
|
||||
|
||||
void CInsultChecker::AppendInsult(const std::string& c_rstInsult)
|
||||
{
|
||||
if (c_rstInsult.length()>0)
|
||||
m_kList_stInsult.push_back(c_rstInsult);
|
||||
}
|
||||
|
||||
bool CInsultChecker::__GetInsultLength(const char* c_szWord, UINT* puInsultLen)
|
||||
{
|
||||
std::list<std::string>::iterator i;
|
||||
for (i=m_kList_stInsult.begin(); i!=m_kList_stInsult.end(); ++i)
|
||||
{
|
||||
std::string& rstInsult=*i;
|
||||
|
||||
int ret=LocaleService_StringCompareCI(c_szWord, rstInsult.c_str(), rstInsult.length());
|
||||
if (0==ret)
|
||||
{
|
||||
*puInsultLen=rstInsult.length();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CInsultChecker::__IsInsult(const char* c_szWord)
|
||||
{
|
||||
UINT uInsultLen;
|
||||
return __GetInsultLength(c_szWord, &uInsultLen);
|
||||
}
|
||||
|
||||
void CInsultChecker::FilterInsult(char* szLine, UINT uLineLen)
|
||||
{
|
||||
const char INSULT_FILTER_CHAR = '*';
|
||||
for (UINT uPos=0; uPos<uLineLen;)
|
||||
{
|
||||
BYTE bChr=szLine[uPos];
|
||||
UINT uInsultLen;
|
||||
if (__GetInsultLength(szLine+uPos, &uInsultLen))
|
||||
{
|
||||
memset(szLine+uPos, INSULT_FILTER_CHAR, uInsultLen);
|
||||
uPos += uInsultLen;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( LocaleService_IsLeadByte( bChr ) )
|
||||
uPos += 2;
|
||||
else
|
||||
uPos++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool CInsultChecker::IsInsultIn(const char* c_szLine, UINT uLineLen)
|
||||
{
|
||||
for (UINT uPos=0; uPos<uLineLen;)
|
||||
{
|
||||
BYTE bChr=c_szLine[uPos];
|
||||
if (bChr & 0x80)
|
||||
{
|
||||
if (__IsInsult(c_szLine+uPos))
|
||||
return true;
|
||||
|
||||
uPos+=2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (__IsInsult(c_szLine+uPos))
|
||||
return true;
|
||||
|
||||
uPos++;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,164 @@
|
||||
#pragma once
|
||||
|
||||
#include "InstanceBase.h"
|
||||
|
||||
struct SNetworkActorData
|
||||
{
|
||||
std::string m_stName;
|
||||
|
||||
CAffectFlagContainer m_kAffectFlags;
|
||||
|
||||
BYTE m_bType;
|
||||
DWORD m_dwVID;
|
||||
DWORD m_dwStateFlags;
|
||||
DWORD m_dwEmpireID;
|
||||
DWORD m_dwRace;
|
||||
DWORD m_dwMovSpd;
|
||||
DWORD m_dwAtkSpd;
|
||||
FLOAT m_fRot;
|
||||
LONG m_lCurX;
|
||||
LONG m_lCurY;
|
||||
LONG m_lSrcX;
|
||||
LONG m_lSrcY;
|
||||
LONG m_lDstX;
|
||||
LONG m_lDstY;
|
||||
|
||||
|
||||
DWORD m_dwServerSrcTime;
|
||||
DWORD m_dwClientSrcTime;
|
||||
DWORD m_dwDuration;
|
||||
|
||||
DWORD m_dwArmor;
|
||||
DWORD m_dwWeapon;
|
||||
DWORD m_dwHair;
|
||||
|
||||
DWORD m_dwOwnerVID;
|
||||
|
||||
short m_sAlignment;
|
||||
BYTE m_byPKMode;
|
||||
DWORD m_dwMountVnum;
|
||||
|
||||
DWORD m_dwGuildID;
|
||||
DWORD m_dwLevel;
|
||||
|
||||
SNetworkActorData();
|
||||
|
||||
void SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration);
|
||||
void SetPosition(LONG lPosX, LONG lPosY);
|
||||
void UpdatePosition();
|
||||
|
||||
// NETWORK_ACTOR_DATA_COPY
|
||||
SNetworkActorData(const SNetworkActorData& src);
|
||||
void operator=(const SNetworkActorData& src);
|
||||
void __copy__(const SNetworkActorData& src);
|
||||
// END_OF_NETWORK_ACTOR_DATA_COPY
|
||||
};
|
||||
|
||||
struct SNetworkMoveActorData
|
||||
{
|
||||
DWORD m_dwVID;
|
||||
DWORD m_dwTime;
|
||||
LONG m_lPosX;
|
||||
LONG m_lPosY;
|
||||
float m_fRot;
|
||||
DWORD m_dwFunc;
|
||||
DWORD m_dwArg;
|
||||
DWORD m_dwDuration;
|
||||
|
||||
SNetworkMoveActorData()
|
||||
{
|
||||
m_dwVID=0;
|
||||
m_dwTime=0;
|
||||
m_fRot=0.0f;
|
||||
m_lPosX=0;
|
||||
m_lPosY=0;
|
||||
m_dwFunc=0;
|
||||
m_dwArg=0;
|
||||
m_dwDuration=0;
|
||||
}
|
||||
};
|
||||
|
||||
struct SNetworkUpdateActorData
|
||||
{
|
||||
DWORD m_dwVID;
|
||||
DWORD m_dwGuildID;
|
||||
DWORD m_dwArmor;
|
||||
DWORD m_dwWeapon;
|
||||
DWORD m_dwHair;
|
||||
DWORD m_dwMovSpd;
|
||||
DWORD m_dwAtkSpd;
|
||||
short m_sAlignment;
|
||||
BYTE m_byPKMode;
|
||||
DWORD m_dwMountVnum;
|
||||
DWORD m_dwStateFlags; // 본래 Create 때만 쓰이는 변수임
|
||||
CAffectFlagContainer m_kAffectFlags;
|
||||
|
||||
SNetworkUpdateActorData()
|
||||
{
|
||||
m_dwGuildID=0;
|
||||
m_dwVID=0;
|
||||
m_dwArmor=0;
|
||||
m_dwWeapon=0;
|
||||
m_dwHair=0;
|
||||
m_dwMovSpd=0;
|
||||
m_dwAtkSpd=0;
|
||||
m_sAlignment=0;
|
||||
m_byPKMode=0;
|
||||
m_dwMountVnum=0;
|
||||
m_dwStateFlags=0;
|
||||
m_kAffectFlags.Clear();
|
||||
}
|
||||
};
|
||||
|
||||
class CPythonCharacterManager;
|
||||
|
||||
class CNetworkActorManager : public CReferenceObject
|
||||
{
|
||||
public:
|
||||
CNetworkActorManager();
|
||||
virtual ~CNetworkActorManager();
|
||||
|
||||
void Destroy();
|
||||
|
||||
void SetMainActorVID(DWORD dwVID);
|
||||
|
||||
void RemoveActor(DWORD dwVID);
|
||||
void AppendActor(const SNetworkActorData& c_rkNetActorData);
|
||||
void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
|
||||
void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);
|
||||
|
||||
void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
|
||||
void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);
|
||||
|
||||
void Update();
|
||||
|
||||
protected:
|
||||
void __OLD_Update();
|
||||
|
||||
void __UpdateMainActor();
|
||||
|
||||
bool __IsVisiblePos(LONG lPosX, LONG lPosY);
|
||||
bool __IsVisibleActor(const SNetworkActorData& c_rkNetActorData);
|
||||
bool __IsMainActorVID(DWORD dwVID);
|
||||
|
||||
void __RemoveAllGroundItems();
|
||||
void __RemoveAllActors();
|
||||
void __RemoveDynamicActors();
|
||||
void __RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData);
|
||||
|
||||
SNetworkActorData* __FindActorData(DWORD dwVID);
|
||||
|
||||
CInstanceBase* __AppendCharacterManagerActor(SNetworkActorData& rkNetActorData);
|
||||
CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData);
|
||||
CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY);
|
||||
|
||||
CPythonCharacterManager& __GetCharacterManager();
|
||||
|
||||
protected:
|
||||
DWORD m_dwMainVID;
|
||||
|
||||
LONG m_lMainPosX;
|
||||
LONG m_lMainPosY;
|
||||
|
||||
std::map<DWORD, SNetworkActorData> m_kNetActorDict;
|
||||
};
|
||||
@@ -766,8 +766,8 @@ typedef struct command_move
|
||||
typedef struct command_sync_position_element
|
||||
{
|
||||
DWORD dwVID;
|
||||
long lX;
|
||||
long lY;
|
||||
LONG lX; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lY; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketCGSyncPositionElement;
|
||||
|
||||
typedef struct command_sync_position
|
||||
@@ -780,8 +780,8 @@ typedef struct command_fly_targeting
|
||||
{
|
||||
BYTE bHeader;
|
||||
DWORD dwTargetVID;
|
||||
long lX;
|
||||
long lY;
|
||||
LONG lX; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lY; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketCGFlyTargeting;
|
||||
|
||||
typedef struct packet_fly_targeting
|
||||
@@ -789,8 +789,8 @@ typedef struct packet_fly_targeting
|
||||
BYTE bHeader;
|
||||
DWORD dwShooterVID;
|
||||
DWORD dwTargetVID;
|
||||
long lX;
|
||||
long lY;
|
||||
LONG lX; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lY; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCFlyTargeting;
|
||||
|
||||
typedef struct packet_shoot
|
||||
@@ -1186,7 +1186,7 @@ typedef struct SSimplePlayerInformation
|
||||
BYTE bChangeName;
|
||||
WORD wHairPart;
|
||||
BYTE bDummy[4];
|
||||
long x, y;
|
||||
LONG x, y; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lAddr;
|
||||
WORD wPort;
|
||||
BYTE bySkillGroup;
|
||||
@@ -1312,9 +1312,9 @@ typedef struct packet_add_char
|
||||
//char name[CHARACTER_NAME_MAX_LEN + 1];
|
||||
|
||||
float angle;
|
||||
long x;
|
||||
long y;
|
||||
long z;
|
||||
LONG x; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG y; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG z; // PORT: LONG, the 32-bit Win32 long
|
||||
|
||||
BYTE bType;
|
||||
WORD wRaceNum;
|
||||
@@ -1340,9 +1340,9 @@ typedef struct packet_add_char2
|
||||
char name[CHARACTER_NAME_MAX_LEN + 1];
|
||||
|
||||
float angle;
|
||||
long x;
|
||||
long y;
|
||||
long z;
|
||||
LONG x; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG y; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG z; // PORT: LONG, the 32-bit Win32 long
|
||||
|
||||
BYTE bType;
|
||||
WORD wRaceNum;
|
||||
@@ -1457,7 +1457,7 @@ typedef struct packet_main_character
|
||||
DWORD dwVID;
|
||||
WORD wRaceNum;
|
||||
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
||||
long lX, lY, lZ;
|
||||
LONG lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
|
||||
BYTE bySkillGroup;
|
||||
} TPacketGCMainCharacter;
|
||||
|
||||
@@ -1468,7 +1468,7 @@ typedef struct packet_main_character2_empire
|
||||
DWORD dwVID;
|
||||
WORD wRaceNum;
|
||||
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
||||
long lX, lY, lZ;
|
||||
LONG lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
|
||||
BYTE byEmpire;
|
||||
BYTE bySkillGroup;
|
||||
} TPacketGCMainCharacter2_EMPIRE;
|
||||
@@ -1484,7 +1484,7 @@ typedef struct packet_main_character3_bgm
|
||||
WORD wRaceNum;
|
||||
char szUserName[CHARACTER_NAME_MAX_LEN + 1];
|
||||
char szBGMName[MUSIC_NAME_MAX_LEN + 1];
|
||||
long lX, lY, lZ;
|
||||
LONG lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
|
||||
BYTE byEmpire;
|
||||
BYTE bySkillGroup;
|
||||
} TPacketGCMainCharacter3_BGM;
|
||||
@@ -1501,7 +1501,7 @@ typedef struct packet_main_character4_bgm_vol
|
||||
char szUserName[CHARACTER_NAME_MAX_LEN + 1];
|
||||
char szBGMName[MUSIC_NAME_MAX_LEN + 1];
|
||||
float fBGMVol;
|
||||
long lX, lY, lZ;
|
||||
LONG lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
|
||||
BYTE byEmpire;
|
||||
BYTE bySkillGroup;
|
||||
} TPacketGCMainCharacter4_BGM_VOL;
|
||||
@@ -1679,7 +1679,7 @@ enum EPointTypes
|
||||
typedef struct packet_points
|
||||
{
|
||||
BYTE header;
|
||||
long points[POINT_MAX_NUM];
|
||||
LONG points[POINT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCPoints;
|
||||
|
||||
typedef struct packet_point_change
|
||||
@@ -1689,8 +1689,8 @@ typedef struct packet_point_change
|
||||
DWORD dwVID;
|
||||
BYTE Type;
|
||||
|
||||
long amount; // 바뀐 값
|
||||
long value; // 현재 값
|
||||
LONG amount; // 바뀐 값 // PORT: LONG, the 32-bit Win32 long
|
||||
LONG value; // 현재 값 // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCPointChange;
|
||||
|
||||
typedef struct packet_motion
|
||||
@@ -1718,7 +1718,7 @@ struct TPacketGCItemDelDeprecate
|
||||
BYTE pos;
|
||||
DWORD vnum;
|
||||
BYTE count;
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
};
|
||||
|
||||
@@ -1729,7 +1729,7 @@ typedef struct packet_set_item
|
||||
DWORD vnum;
|
||||
BYTE count;
|
||||
DWORD flags; // 플래그 추가
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TPacketGCItemSet;
|
||||
|
||||
@@ -1745,7 +1745,7 @@ typedef struct packet_set_item
|
||||
TItemPos Cell;
|
||||
DWORD vnum;
|
||||
BYTE count;
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TPacketGCItemSet;
|
||||
|
||||
@@ -1758,7 +1758,7 @@ typedef struct packet_set_item2
|
||||
DWORD flags; // 플래그 추가
|
||||
DWORD anti_flags; // 플래그 추가
|
||||
bool highlight;
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TPacketGCItemSet2;
|
||||
#endif
|
||||
@@ -1784,16 +1784,16 @@ typedef struct packet_update_item
|
||||
BYTE header;
|
||||
TItemPos Cell;
|
||||
BYTE count;
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TPacketGCItemUpdate;
|
||||
|
||||
typedef struct packet_ground_add_item
|
||||
{
|
||||
BYTE bHeader;
|
||||
long lX;
|
||||
long lY;
|
||||
long lZ;
|
||||
LONG lX; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lY; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lZ; // PORT: LONG, the 32-bit Win32 long
|
||||
|
||||
DWORD dwVID;
|
||||
DWORD dwVnum;
|
||||
@@ -1892,7 +1892,7 @@ typedef struct packet_exchange
|
||||
DWORD arg1;
|
||||
TItemPos arg2;
|
||||
DWORD arg3;
|
||||
long alValues[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alValues[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TPacketGCExchange;
|
||||
|
||||
@@ -2000,7 +2000,7 @@ typedef struct packet_quest_confirm
|
||||
{
|
||||
BYTE header;
|
||||
char msg[64+1];
|
||||
long timeout;
|
||||
LONG timeout; // PORT: LONG, the 32-bit Win32 long
|
||||
DWORD requestPID;
|
||||
} TPacketGCQuestConfirm;
|
||||
|
||||
@@ -2021,8 +2021,8 @@ typedef struct packet_c2c
|
||||
typedef struct packetd_sync_position_element
|
||||
{
|
||||
DWORD dwVID;
|
||||
long lX;
|
||||
long lY;
|
||||
LONG lX; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lY; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCSyncPositionElement;
|
||||
|
||||
typedef struct packetd_sync_position
|
||||
@@ -2291,7 +2291,7 @@ typedef struct SPacketGuildWarPoint
|
||||
{
|
||||
DWORD dwGainGuildID;
|
||||
DWORD dwOpponentGuildID;
|
||||
long lPoint;
|
||||
LONG lPoint; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGuildWarPoint;
|
||||
|
||||
// SubHeader - Dungeon
|
||||
@@ -2419,8 +2419,8 @@ struct TNPCPosition
|
||||
{
|
||||
BYTE bType;
|
||||
char name[CHARACTER_NAME_MAX_LEN+1];
|
||||
long x;
|
||||
long y;
|
||||
LONG x; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG y; // PORT: LONG, the 32-bit Win32 long
|
||||
};
|
||||
|
||||
typedef struct SPacketGCChangeName
|
||||
@@ -2495,7 +2495,7 @@ typedef struct SEquipmentItemSet
|
||||
{
|
||||
DWORD vnum;
|
||||
BYTE count;
|
||||
long alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
|
||||
LONG alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
|
||||
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
|
||||
} TEquipmentItemSet;
|
||||
|
||||
@@ -2509,8 +2509,8 @@ typedef struct pakcet_view_equip
|
||||
typedef struct
|
||||
{
|
||||
DWORD dwID;
|
||||
long x, y;
|
||||
long width, height;
|
||||
LONG x, y; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG width, height; // PORT: LONG, the 32-bit Win32 long
|
||||
DWORD dwGuildID;
|
||||
} TLandPacketElement;
|
||||
|
||||
@@ -2523,7 +2523,7 @@ typedef struct packet_land_list
|
||||
typedef struct
|
||||
{
|
||||
BYTE bHeader;
|
||||
long lID;
|
||||
LONG lID; // PORT: LONG, the 32-bit Win32 long
|
||||
char szTargetName[32+1];
|
||||
} TPacketGCTargetCreate;
|
||||
|
||||
@@ -2537,7 +2537,7 @@ enum
|
||||
typedef struct
|
||||
{
|
||||
BYTE bHeader;
|
||||
long lID;
|
||||
LONG lID; // PORT: LONG, the 32-bit Win32 long
|
||||
char szTargetName[32+1];
|
||||
DWORD dwVID;
|
||||
BYTE byType;
|
||||
@@ -2546,24 +2546,24 @@ typedef struct
|
||||
typedef struct
|
||||
{
|
||||
BYTE bHeader;
|
||||
long lID;
|
||||
long lX, lY;
|
||||
LONG lID; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lX, lY; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCTargetUpdate;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
BYTE bHeader;
|
||||
long lID;
|
||||
LONG lID; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketGCTargetDelete;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
DWORD dwType;
|
||||
BYTE bPointIdxApplyOn;
|
||||
long lApplyValue;
|
||||
LONG lApplyValue; // PORT: LONG, the 32-bit Win32 long
|
||||
DWORD dwFlag;
|
||||
long lDuration;
|
||||
long lSPCost;
|
||||
LONG lDuration; // PORT: LONG, the 32-bit Win32 long
|
||||
LONG lSPCost; // PORT: LONG, the 32-bit Win32 long
|
||||
} TPacketAffectElement;
|
||||
|
||||
typedef struct
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
extern bool GetExeCRC(DWORD & r_dwProcCRC, DWORD & r_dwFileCRC);
|
||||
|
||||
extern void BuildProcessCRC();
|
||||
extern BYTE GetProcessCRCMagicCubePiece();
|
||||
@@ -0,0 +1,911 @@
|
||||
#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));
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
Set(HEADER_GC_KEY_AGREEMENT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreement), STATIC_SIZE_PACKET));
|
||||
Set(HEADER_GC_KEY_AGREEMENT_COMPLETED, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreementCompleted), STATIC_SIZE_PACKET));
|
||||
#endif
|
||||
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()
|
||||
{
|
||||
// 원래는 핑이 안올때 체크이나 서버랑 정확히 맞추어야 한다.
|
||||
return false;
|
||||
}
|
||||
|
||||
DWORD CPythonNetworkStream::GetGuildID()
|
||||
{
|
||||
return m_dwGuildID;
|
||||
}
|
||||
|
||||
UINT CPythonNetworkStream::UploadMark(const char * c_szImageFileName)
|
||||
{
|
||||
// MARK_BUG_FIX
|
||||
// 길드를 만든 직후는 길드 아이디가 0이다.
|
||||
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분 안에는 다시 접속하지 않는다.
|
||||
DWORD curTime = ELTimer_GetMSec();
|
||||
|
||||
if (curTime < gs_nextDownloadMarkTime)
|
||||
return;
|
||||
|
||||
gs_nextDownloadMarkTime = curTime + 60000 * 3; // 3분
|
||||
|
||||
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: // 끊기는 상태 (또는 끊기 전 상태)
|
||||
ClosePhase();
|
||||
break;
|
||||
|
||||
case PHASE_HANDSHAKE: // 악수..;;
|
||||
SetHandShakePhase();
|
||||
break;
|
||||
|
||||
case PHASE_LOGIN: // 로그인 중
|
||||
SetLoginPhase();
|
||||
break;
|
||||
|
||||
case PHASE_SELECT: // 캐릭터 선택 화면
|
||||
SetSelectPhase();
|
||||
#if defined(ENABLE_DISCORD_RPC)
|
||||
Discord_Update(false);
|
||||
#endif
|
||||
|
||||
BuildProcessCRC();
|
||||
|
||||
// MARK_BUG_FIX
|
||||
__DownloadMark();
|
||||
// END_OF_MARK_BUG_FIX
|
||||
break;
|
||||
|
||||
case PHASE_LOADING: // 선택 후 로딩 화면
|
||||
SetLoadingPhase();
|
||||
break;
|
||||
|
||||
case PHASE_GAME: // 게임 화면
|
||||
SetGamePhase();
|
||||
#if defined(ENABLE_DISCORD_RPC)
|
||||
Discord_Update(true);
|
||||
#endif
|
||||
break;
|
||||
|
||||
case PHASE_DEAD: // 죽었을 때.. (게임 안에 있는 것일 수도..)
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvPingPacket()
|
||||
{
|
||||
Tracef("recv ping packet. (securitymode %u)\n", IsSecurityMode());
|
||||
|
||||
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;
|
||||
|
||||
if (IsSecurityMode())
|
||||
return SendSequence();
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvDefaultPacket(int header)
|
||||
{
|
||||
if (!header)
|
||||
return true;
|
||||
|
||||
TraceError("\xc3\xb3\xb8\xae\xb5\xc7\xc1\xf6 \xbe\xca\xc0\xba \xc6\xd0\xc5\xb6 \xc7\xec\xb4\xf5 %d, state %s\n", header, m_strPhase.c_str()); // PORT: CP949 bytes of "처리되지 않은 패킷 헤더 %d, state %s\n"
|
||||
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("");
|
||||
|
||||
#if defined(ENABLE_DISCORD_RPC)
|
||||
Discord_Update(false);
|
||||
#endif
|
||||
|
||||
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");
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
|
||||
void CPythonNetworkStream::OnRemoteDisconnect()
|
||||
{
|
||||
PyCallClassMemberFunc(m_poHandler, "SetLoginPhase", Py_BuildValue("()"));
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::OnDisconnect()
|
||||
{
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Main Game
|
||||
void CPythonNetworkStream::OnScriptEventStart(int iSkin, int iIndex)
|
||||
{
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenQuestWindow", Py_BuildValue("(ii)", iSkin, iIndex));
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,331 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "PythonApplication.h"
|
||||
#include "Packet.h"
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
#include "Hackshield.h"
|
||||
#include "WiseLogicXTrap.h"
|
||||
|
||||
#ifdef USE_AHNLAB_HACKSHIELD
|
||||
#include METIN2HS_INCLUDE_HSHIELD
|
||||
#endif
|
||||
|
||||
// HandShake ---------------------------------------------------------------------------
|
||||
void CPythonNetworkStream::HandShakePhase()
|
||||
{
|
||||
TPacketHeader header;
|
||||
|
||||
if (!CheckPacket(&header))
|
||||
return;
|
||||
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
if (RecvPhasePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_BINDUDP:
|
||||
{
|
||||
TPacketGCBindUDP BindUDP;
|
||||
|
||||
if (!Recv(sizeof(TPacketGCBindUDP), &BindUDP))
|
||||
return;
|
||||
|
||||
return;
|
||||
}
|
||||
break;
|
||||
|
||||
case HEADER_GC_HANDSHAKE:
|
||||
{
|
||||
if (!Recv(sizeof(TPacketGCHandshake), &m_HandshakeData))
|
||||
return;
|
||||
|
||||
Tracenf("HANDSHAKE RECV %u %d", m_HandshakeData.dwTime, m_HandshakeData.lDelta);
|
||||
|
||||
ELTimer_SetServerMSec(m_HandshakeData.dwTime+ m_HandshakeData.lDelta);
|
||||
|
||||
//m_dwBaseServerTime = m_HandshakeData.dwTime+ m_HandshakeData.lDelta;
|
||||
//m_dwBaseClientTime = ELTimer_GetMSec();
|
||||
|
||||
m_HandshakeData.dwTime = m_HandshakeData.dwTime + m_HandshakeData.lDelta + m_HandshakeData.lDelta;
|
||||
m_HandshakeData.lDelta = 0;
|
||||
|
||||
Tracenf("HANDSHAKE SEND %u", m_HandshakeData.dwTime);
|
||||
|
||||
if (!Send(sizeof(TPacketGCHandshake), &m_HandshakeData))
|
||||
{
|
||||
assert(!"Failed Sending Handshake");
|
||||
return;
|
||||
}
|
||||
|
||||
CTimer::Instance().SetBaseTime();
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case HEADER_GC_PING:
|
||||
RecvPingPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_KEYS:
|
||||
RecvHybridCryptKeyPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_SDB:
|
||||
RecvHybridCryptSDBPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
case HEADER_GC_KEY_AGREEMENT:
|
||||
RecvKeyAgreementPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_KEY_AGREEMENT_COMPLETED:
|
||||
RecvKeyAgreementCompletedPacket();
|
||||
return;
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
RecvErrorPacket(header);
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::SetHandShakePhase()
|
||||
{
|
||||
if ("HandShake"!=m_strPhase)
|
||||
m_phaseLeaveFunc.Run();
|
||||
|
||||
Tracen("");
|
||||
Tracen("## Network - Hand Shake Phase ##");
|
||||
Tracen("");
|
||||
|
||||
m_strPhase = "HandShake";
|
||||
|
||||
m_dwChangingPhaseTime = ELTimer_GetMSec();
|
||||
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::HandShakePhase);
|
||||
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveHandshakePhase);
|
||||
|
||||
SetGameOnline();
|
||||
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
// None
|
||||
}
|
||||
else
|
||||
{
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnHandShake", Py_BuildValue("()"));
|
||||
}
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvHandshakePacket()
|
||||
{
|
||||
TPacketGCHandshake kHandshakeData;
|
||||
if (!Recv(sizeof(TPacketGCHandshake), &kHandshakeData))
|
||||
return false;
|
||||
|
||||
Tracenf("HANDSHAKE RECV %u %d", kHandshakeData.dwTime, kHandshakeData.lDelta);
|
||||
|
||||
m_kServerTimeSync.m_dwChangeServerTime = kHandshakeData.dwTime + kHandshakeData.lDelta;
|
||||
m_kServerTimeSync.m_dwChangeClientTime = ELTimer_GetMSec();
|
||||
|
||||
kHandshakeData.dwTime = kHandshakeData.dwTime + kHandshakeData.lDelta + kHandshakeData.lDelta;
|
||||
kHandshakeData.lDelta = 0;
|
||||
|
||||
Tracenf("HANDSHAKE SEND %u", kHandshakeData.dwTime);
|
||||
|
||||
kHandshakeData.header = HEADER_CG_TIME_SYNC;
|
||||
if (!Send(sizeof(TPacketGCHandshake), &kHandshakeData))
|
||||
{
|
||||
assert(!"Failed Sending Handshake");
|
||||
return false;
|
||||
}
|
||||
|
||||
SendSequence();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvHandshakeOKPacket()
|
||||
{
|
||||
TPacketGCBlank kBlankPacket;
|
||||
if (!Recv(sizeof(TPacketGCBlank), &kBlankPacket))
|
||||
return false;
|
||||
|
||||
DWORD dwDelta=ELTimer_GetMSec()-m_kServerTimeSync.m_dwChangeClientTime;
|
||||
ELTimer_SetServerMSec(m_kServerTimeSync.m_dwChangeServerTime+dwDelta);
|
||||
|
||||
Tracenf("HANDSHAKE OK RECV %u %u", m_kServerTimeSync.m_dwChangeServerTime, dwDelta);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvHybridCryptKeyPacket()
|
||||
{
|
||||
int iFixedHeaderSize = TPacketGCHybridCryptKeys::GetFixedHeaderSize();
|
||||
|
||||
TDynamicSizePacketHeader header;
|
||||
if( !Peek( sizeof(header), &header) )
|
||||
return false;
|
||||
|
||||
TPacketGCHybridCryptKeys kPacket(header.size-iFixedHeaderSize);
|
||||
|
||||
if (!Recv(iFixedHeaderSize, &kPacket))
|
||||
return false;
|
||||
|
||||
if (!Recv(kPacket.iKeyStreamLen, kPacket.m_pStream))
|
||||
return false;
|
||||
|
||||
CEterPackManager::Instance().RetrieveHybridCryptPackKeys( kPacket.m_pStream );
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvHybridCryptSDBPacket()
|
||||
{
|
||||
int iFixedHeaderSize = TPacketGCHybridSDB::GetFixedHeaderSize();
|
||||
|
||||
TDynamicSizePacketHeader header;
|
||||
if( !Peek( sizeof(header), &header) )
|
||||
return false;
|
||||
|
||||
TPacketGCHybridSDB kPacket(header.size-iFixedHeaderSize);
|
||||
|
||||
if (!Recv(iFixedHeaderSize, &kPacket))
|
||||
return false;
|
||||
|
||||
if (!Recv(kPacket.iSDBStreamLen, kPacket.m_pStream))
|
||||
return false;
|
||||
|
||||
CEterPackManager::Instance().RetrieveHybridCryptPackSDB( kPacket.m_pStream );
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
bool CPythonNetworkStream::RecvKeyAgreementPacket()
|
||||
{
|
||||
TPacketKeyAgreement packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
|
||||
|
||||
TPacketKeyAgreement packetToSend;
|
||||
size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
|
||||
size_t agreedLength = Prepare(packetToSend.data, &dataLength);
|
||||
if (agreedLength == 0)
|
||||
{
|
||||
// 초기화 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
|
||||
|
||||
if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
|
||||
{
|
||||
// Key agreement 성공, 응답 전송
|
||||
packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
|
||||
packetToSend.wAgreedLength = (WORD)agreedLength;
|
||||
packetToSend.wDataLength = (WORD)dataLength;
|
||||
|
||||
if (!Send(sizeof(packetToSend), &packetToSend))
|
||||
{
|
||||
assert(!"Failed Sending KeyAgreement");
|
||||
return false;
|
||||
}
|
||||
Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 키 협상 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvKeyAgreementCompletedPacket()
|
||||
{
|
||||
TPacketKeyAgreementCompleted packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT_COMPLETED RECV");
|
||||
|
||||
ActivateCipher();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif // _IMPROVED_PACKET_ENCRYPTION_
|
||||
|
||||
bool CPythonNetworkStream::RecvHSCheckRequest()
|
||||
{
|
||||
TPacketHSCheck packet;
|
||||
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
TraceError("HShield: Recv failed");
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#if defined(USE_AHNLAB_HACKSHIELD) || defined(LOCALE_SERVICE_GLOBAL)
|
||||
TPacketHSCheck pack_ret;
|
||||
memset(&pack_ret, 0, sizeof(pack_ret));
|
||||
pack_ret.bHeader = HEADER_CG_HS_ACK;
|
||||
|
||||
#if defined(USE_AHNLAB_HACKSHIELD)
|
||||
unsigned long ret = _AhnHS_MakeResponse( packet.Req.byBuffer, packet.Req.nLength, &pack_ret.Req );
|
||||
|
||||
if (ERROR_SUCCESS != ret)
|
||||
{
|
||||
TraceError("HShield: _AhnHS_MakeResponse return error(%u)", ret);
|
||||
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!Send(sizeof(pack_ret), &pack_ret))
|
||||
{
|
||||
TraceError("HShield: Send failed");
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvXTrapVerifyRequest()
|
||||
{
|
||||
TPacketXTrapCSVerify packet;
|
||||
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
TraceError("XTrap: Recv failed");
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
TPacketXTrapCSVerify packet_res;
|
||||
packet_res.bHeader = HEADER_CG_XTRAP_ACK;
|
||||
|
||||
XTrap_ValidateCheckStream( packet.bPacketData, packet_res.bPacketData );
|
||||
|
||||
if (!Send(sizeof(packet_res), &packet_res))
|
||||
{
|
||||
TraceError("XTrap: Send failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,361 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "Packet.h"
|
||||
#include "PythonApplication.h"
|
||||
#include "NetworkActorManager.h"
|
||||
|
||||
#include "AbstractPlayer.h"
|
||||
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
|
||||
void CPythonNetworkStream::EnableChatInsultFilter(bool isEnable)
|
||||
{
|
||||
m_isEnableChatInsultFilter=isEnable;
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::__FilterInsult(char* szLine, UINT uLineLen)
|
||||
{
|
||||
m_kInsultChecker.FilterInsult(szLine, uLineLen);
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::IsChatInsultIn(const char* c_szMsg)
|
||||
{
|
||||
if (m_isEnableChatInsultFilter)
|
||||
return false;
|
||||
|
||||
return IsInsultIn(c_szMsg);
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::IsInsultIn(const char* c_szMsg)
|
||||
{
|
||||
return m_kInsultChecker.IsInsultIn(c_szMsg, strlen(c_szMsg));
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::LoadInsultList(const char* c_szInsultListFileName)
|
||||
{
|
||||
CMappedFile file;
|
||||
const VOID* pvData;
|
||||
if (!CEterPackManager::Instance().Get(file, c_szInsultListFileName, &pvData))
|
||||
return false;
|
||||
|
||||
CMemoryTextFileLoader kMemTextFileLoader;
|
||||
kMemTextFileLoader.Bind(file.Size(), pvData);
|
||||
|
||||
m_kInsultChecker.Clear();
|
||||
for (DWORD dwLineIndex=0; dwLineIndex<kMemTextFileLoader.GetLineCount(); ++dwLineIndex)
|
||||
{
|
||||
const std::string& c_rstLine=kMemTextFileLoader.GetLineString(dwLineIndex);
|
||||
m_kInsultChecker.AppendInsult(c_rstLine);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::LoadConvertTable(DWORD dwEmpireID, const char* c_szFileName)
|
||||
{
|
||||
if (dwEmpireID<1 || dwEmpireID>=4)
|
||||
return false;
|
||||
|
||||
CMappedFile file;
|
||||
const VOID* pvData;
|
||||
if (!CEterPackManager::Instance().Get(file, c_szFileName, &pvData))
|
||||
return false;
|
||||
|
||||
DWORD dwEngCount=26;
|
||||
DWORD dwHanCount=(0xc8-0xb0+1)*(0xfe - 0xa1+1); // PORT: `0xfe-0xa1` lexes as one pp-number (the `e-` exponent) outside MSVC
|
||||
DWORD dwHanSize=dwHanCount*2;
|
||||
DWORD dwFileSize=dwEngCount*2+dwHanSize;
|
||||
|
||||
if (file.Size()<dwFileSize)
|
||||
return false;
|
||||
|
||||
char* pcData=(char*)pvData;
|
||||
|
||||
STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1];
|
||||
memcpy(rkTextConvTable.acUpper, pcData, dwEngCount);pcData+=dwEngCount;
|
||||
memcpy(rkTextConvTable.acLower, pcData, dwEngCount);pcData+=dwEngCount;
|
||||
memcpy(rkTextConvTable.aacHan, pcData, dwHanSize);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Loading ---------------------------------------------------------------------------
|
||||
void CPythonNetworkStream::LoadingPhase()
|
||||
{
|
||||
TPacketHeader header;
|
||||
|
||||
if (!CheckPacket(&header))
|
||||
return;
|
||||
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
if (RecvPhasePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_MAIN_CHARACTER:
|
||||
if (RecvMainCharacter())
|
||||
return;
|
||||
break;
|
||||
|
||||
// SUPPORT_BGM
|
||||
case HEADER_GC_MAIN_CHARACTER2_EMPIRE:
|
||||
if (RecvMainCharacter2_EMPIRE())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_MAIN_CHARACTER3_BGM:
|
||||
if (RecvMainCharacter3_BGM())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_MAIN_CHARACTER4_BGM_VOL:
|
||||
if (RecvMainCharacter4_BGM_VOL())
|
||||
return;
|
||||
break;
|
||||
|
||||
// END_OF_SUPPORT_BGM
|
||||
|
||||
case HEADER_GC_CHARACTER_UPDATE:
|
||||
if (RecvCharacterUpdatePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PLAYER_POINTS:
|
||||
if (__RecvPlayerPoints())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PLAYER_POINT_CHANGE:
|
||||
if (RecvPointChange())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_ITEM_SET:
|
||||
if (RecvItemSetPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PING:
|
||||
if (RecvPingPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_QUICKSLOT_ADD:
|
||||
if (RecvQuickSlotAddPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_KEYS:
|
||||
RecvHybridCryptKeyPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_SDB:
|
||||
RecvHybridCryptSDBPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
GamePhase();
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
||||
RecvErrorPacket(header);
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::SetLoadingPhase()
|
||||
{
|
||||
if ("Loading"!=m_strPhase)
|
||||
m_phaseLeaveFunc.Run();
|
||||
|
||||
Tracen("");
|
||||
Tracen("## Network - Loading Phase ##");
|
||||
Tracen("");
|
||||
|
||||
m_strPhase = "Loading";
|
||||
|
||||
m_dwChangingPhaseTime = ELTimer_GetMSec();
|
||||
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::LoadingPhase);
|
||||
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveLoadingPhase);
|
||||
|
||||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||||
rkPlayer.Clear();
|
||||
|
||||
CFlyingManager::Instance().DeleteAllInstances();
|
||||
CEffectManager::Instance().DeleteAllInstances();
|
||||
|
||||
__DirectEnterMode_Initialize();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvMainCharacter()
|
||||
{
|
||||
TPacketGCMainCharacter MainChrPacket;
|
||||
if (!Recv(sizeof(TPacketGCMainCharacter), &MainChrPacket))
|
||||
return false;
|
||||
|
||||
m_dwMainActorVID = MainChrPacket.dwVID;
|
||||
m_dwMainActorRace = MainChrPacket.wRaceNum;
|
||||
m_dwMainActorEmpire = 0;
|
||||
m_dwMainActorSkillGroup = MainChrPacket.bySkillGroup;
|
||||
|
||||
m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
|
||||
|
||||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||||
rkPlayer.SetName(MainChrPacket.szName);
|
||||
rkPlayer.SetMainCharacterIndex(GetMainActorVID());
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", MainChrPacket.lX, MainChrPacket.lY));
|
||||
|
||||
//Tracef(" >> RecvMainCharacter\n");
|
||||
|
||||
SendClientVersionPacket();
|
||||
return true;
|
||||
}
|
||||
|
||||
// SUPPORT_BGM
|
||||
bool CPythonNetworkStream::RecvMainCharacter2_EMPIRE()
|
||||
{
|
||||
TPacketGCMainCharacter2_EMPIRE mainChrPacket;
|
||||
if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
|
||||
return false;
|
||||
|
||||
m_dwMainActorVID = mainChrPacket.dwVID;
|
||||
m_dwMainActorRace = mainChrPacket.wRaceNum;
|
||||
m_dwMainActorEmpire = mainChrPacket.byEmpire;
|
||||
m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
|
||||
|
||||
m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
|
||||
|
||||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||||
rkPlayer.SetName(mainChrPacket.szName);
|
||||
rkPlayer.SetMainCharacterIndex(GetMainActorVID());
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
|
||||
|
||||
//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
|
||||
|
||||
SendClientVersionPacket();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvMainCharacter3_BGM()
|
||||
{
|
||||
TPacketGCMainCharacter3_BGM mainChrPacket;
|
||||
if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
|
||||
return false;
|
||||
|
||||
m_dwMainActorVID = mainChrPacket.dwVID;
|
||||
m_dwMainActorRace = mainChrPacket.wRaceNum;
|
||||
m_dwMainActorEmpire = mainChrPacket.byEmpire;
|
||||
m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
|
||||
|
||||
m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
|
||||
|
||||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||||
rkPlayer.SetName(mainChrPacket.szUserName);
|
||||
rkPlayer.SetMainCharacterIndex(GetMainActorVID());
|
||||
|
||||
__SetFieldMusicFileName(mainChrPacket.szBGMName);
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
|
||||
|
||||
//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
|
||||
|
||||
SendClientVersionPacket();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::RecvMainCharacter4_BGM_VOL()
|
||||
{
|
||||
TPacketGCMainCharacter4_BGM_VOL mainChrPacket;
|
||||
if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
|
||||
return false;
|
||||
|
||||
m_dwMainActorVID = mainChrPacket.dwVID;
|
||||
m_dwMainActorRace = mainChrPacket.wRaceNum;
|
||||
m_dwMainActorEmpire = mainChrPacket.byEmpire;
|
||||
m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
|
||||
|
||||
m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
|
||||
|
||||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||||
rkPlayer.SetName(mainChrPacket.szUserName);
|
||||
rkPlayer.SetMainCharacterIndex(GetMainActorVID());
|
||||
|
||||
__SetFieldMusicFileInfo(mainChrPacket.szBGMName, mainChrPacket.fBGMVol);
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
|
||||
|
||||
//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
|
||||
|
||||
SendClientVersionPacket();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static std::string gs_fieldMusic_fileName;
|
||||
static float gs_fieldMusic_volume = 1.0f / 5.0f * 0.1f;
|
||||
|
||||
void CPythonNetworkStream::__SetFieldMusicFileName(const char* musicName)
|
||||
{
|
||||
gs_fieldMusic_fileName = musicName;
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::__SetFieldMusicFileInfo(const char* musicName, float vol)
|
||||
{
|
||||
gs_fieldMusic_fileName = musicName;
|
||||
gs_fieldMusic_volume = vol;
|
||||
}
|
||||
|
||||
const char* CPythonNetworkStream::GetFieldMusicFileName()
|
||||
{
|
||||
return gs_fieldMusic_fileName.c_str();
|
||||
}
|
||||
|
||||
float CPythonNetworkStream::GetFieldMusicVolume()
|
||||
{
|
||||
return gs_fieldMusic_volume;
|
||||
}
|
||||
// END_OF_SUPPORT_BGM
|
||||
|
||||
|
||||
bool CPythonNetworkStream::__RecvPlayerPoints()
|
||||
{
|
||||
TPacketGCPoints PointsPacket;
|
||||
|
||||
if (!Recv(sizeof(TPacketGCPoints), &PointsPacket))
|
||||
return false;
|
||||
|
||||
for (DWORD i = 0; i < POINT_MAX_NUM; ++i)
|
||||
CPythonPlayer::Instance().SetStatus(i, PointsPacket.points[i]);
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::StartGame()
|
||||
{
|
||||
m_isStartGame=TRUE;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendEnterGame()
|
||||
{
|
||||
TPacketCGEnterFrontGame EnterFrontGamePacket;
|
||||
|
||||
EnterFrontGamePacket.header = HEADER_CG_ENTERGAME;
|
||||
|
||||
if (!Send(sizeof(EnterFrontGamePacket), &EnterFrontGamePacket))
|
||||
{
|
||||
Tracen("Send EnterFrontGamePacket");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SendSequence())
|
||||
return false;
|
||||
|
||||
__SendInternalBuffer();
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,416 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "Packet.h"
|
||||
#include "Test.h"
|
||||
#include "AccountConnector.h"
|
||||
|
||||
#include "Hackshield.h"
|
||||
#include "WiseLogicXTrap.h"
|
||||
|
||||
// Login ---------------------------------------------------------------------------
|
||||
void CPythonNetworkStream::LoginPhase()
|
||||
{
|
||||
TPacketHeader header;
|
||||
if (!CheckPacket(&header))
|
||||
return;
|
||||
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
if (RecvPhasePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_LOGIN_SUCCESS3:
|
||||
if (__RecvLoginSuccessPacket3())
|
||||
return;
|
||||
break;
|
||||
case HEADER_GC_LOGIN_SUCCESS4:
|
||||
if (__RecvLoginSuccessPacket4())
|
||||
return;
|
||||
break;
|
||||
|
||||
|
||||
case HEADER_GC_LOGIN_FAILURE:
|
||||
if (__RecvLoginFailurePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_EMPIRE:
|
||||
if (__RecvEmpirePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_CHINA_MATRIX_CARD:
|
||||
if (__RecvChinaMatrixCardPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_RUNUP_MATRIX_QUIZ:
|
||||
if (__RecvRunupMatrixQuizPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_NEWCIBN_PASSPOD_REQUEST:
|
||||
if (__RecvNEWCIBNPasspodRequestPacket())
|
||||
return;
|
||||
break;
|
||||
case HEADER_GC_NEWCIBN_PASSPOD_FAILURE:
|
||||
if (__RecvNEWCIBNPasspodFailurePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
|
||||
case HEADER_GC_LOGIN_KEY:
|
||||
if (__RecvLoginKeyPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PING:
|
||||
if (RecvPingPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_KEYS:
|
||||
RecvHybridCryptKeyPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_SDB:
|
||||
RecvHybridCryptSDBPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
default:
|
||||
if (RecvDefaultPacket(header))
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
||||
RecvErrorPacket(header);
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::SetLoginPhase()
|
||||
{
|
||||
const char* key = LocaleService_GetSecurityKey();
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
SetSecurityMode(true, key);
|
||||
#endif
|
||||
|
||||
if ("Login" != m_strPhase)
|
||||
m_phaseLeaveFunc.Run();
|
||||
|
||||
Tracen("");
|
||||
Tracen("## Network - Login Phase ##");
|
||||
Tracen("");
|
||||
|
||||
m_strPhase = "Login";
|
||||
|
||||
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::LoginPhase);
|
||||
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveLoginPhase);
|
||||
|
||||
m_dwChangingPhaseTime = ELTimer_GetMSec();
|
||||
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
if (0 != m_dwLoginKey)
|
||||
SendLoginPacketNew(m_stID.c_str(), m_stPassword.c_str());
|
||||
else
|
||||
SendLoginPacket(m_stID.c_str(), m_stPassword.c_str());
|
||||
|
||||
// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
|
||||
ClearLoginInfo();
|
||||
CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
|
||||
rkAccountConnector.ClearLoginInfo();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (0 != m_dwLoginKey)
|
||||
SendLoginPacketNew(m_stID.c_str(), m_stPassword.c_str());
|
||||
else
|
||||
SendLoginPacket(m_stID.c_str(), m_stPassword.c_str());
|
||||
|
||||
// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
|
||||
ClearLoginInfo();
|
||||
CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
|
||||
rkAccountConnector.ClearLoginInfo();
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnLoginStart", Py_BuildValue("()"));
|
||||
|
||||
__ClearSelectCharacterData();
|
||||
}
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvEmpirePacket()
|
||||
{
|
||||
TPacketGCEmpire kPacketEmpire;
|
||||
if (!Recv(sizeof(kPacketEmpire), &kPacketEmpire))
|
||||
return false;
|
||||
|
||||
m_dwEmpireID=kPacketEmpire.bEmpire;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvLoginSuccessPacket3()
|
||||
{
|
||||
TPacketGCLoginSuccess3 kPacketLoginSuccess;
|
||||
|
||||
if (!Recv(sizeof(kPacketLoginSuccess), &kPacketLoginSuccess))
|
||||
return false;
|
||||
|
||||
for (int i = 0; i<PLAYER_PER_ACCOUNT3; ++i)
|
||||
{
|
||||
m_akSimplePlayerInfo[i]=kPacketLoginSuccess.akSimplePlayerInformation[i];
|
||||
m_adwGuildID[i]=kPacketLoginSuccess.guild_id[i];
|
||||
m_astrGuildName[i]=kPacketLoginSuccess.guild_name[i];
|
||||
}
|
||||
|
||||
m_kMarkAuth.m_dwHandle=kPacketLoginSuccess.handle;
|
||||
m_kMarkAuth.m_dwRandomKey=kPacketLoginSuccess.random_key;
|
||||
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "Refresh", Py_BuildValue("()"));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvLoginSuccessPacket4()
|
||||
{
|
||||
TPacketGCLoginSuccess4 kPacketLoginSuccess;
|
||||
|
||||
if (!Recv(sizeof(kPacketLoginSuccess), &kPacketLoginSuccess))
|
||||
return false;
|
||||
|
||||
for (int i = 0; i<PLAYER_PER_ACCOUNT4; ++i)
|
||||
{
|
||||
m_akSimplePlayerInfo[i]=kPacketLoginSuccess.akSimplePlayerInformation[i];
|
||||
m_adwGuildID[i]=kPacketLoginSuccess.guild_id[i];
|
||||
m_astrGuildName[i]=kPacketLoginSuccess.guild_name[i];
|
||||
}
|
||||
|
||||
m_kMarkAuth.m_dwHandle=kPacketLoginSuccess.handle;
|
||||
m_kMarkAuth.m_dwRandomKey=kPacketLoginSuccess.random_key;
|
||||
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "Refresh", Py_BuildValue("()"));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void CPythonNetworkStream::OnConnectFailure()
|
||||
{
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
ClosePhase();
|
||||
}
|
||||
else
|
||||
{
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnConnectFailure", Py_BuildValue("()"));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool CPythonNetworkStream::__RecvLoginFailurePacket()
|
||||
{
|
||||
TPacketGCLoginFailure packet_failure;
|
||||
if (!Recv(sizeof(TPacketGCLoginFailure), &packet_failure))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnLoginFailure", Py_BuildValue("(s)", packet_failure.szStatus));
|
||||
#ifdef _DEBUG
|
||||
Tracef(" RecvLoginFailurePacket : [%s]\n", packet_failure.szStatus);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendDirectEnterPacket(const char* c_szID, const char* c_szPassword, UINT uChrSlot)
|
||||
{
|
||||
TPacketCGDirectEnter kPacketDirectEnter;
|
||||
kPacketDirectEnter.bHeader=HEADER_CG_DIRECT_ENTER;
|
||||
kPacketDirectEnter.index=uChrSlot;
|
||||
strncpy(kPacketDirectEnter.login, c_szID, ID_MAX_NUM);
|
||||
strncpy(kPacketDirectEnter.passwd, c_szPassword, PASS_MAX_NUM);
|
||||
|
||||
if (!Send(sizeof(kPacketDirectEnter), &kPacketDirectEnter))
|
||||
{
|
||||
Tracen("SendDirectEnter");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendLoginPacket(const char* c_szName, const char* c_szPassword)
|
||||
{
|
||||
TPacketCGLogin LoginPacket;
|
||||
LoginPacket.header = HEADER_CG_LOGIN;
|
||||
|
||||
strncpy(LoginPacket.name, c_szName, sizeof(LoginPacket.name)-1);
|
||||
strncpy(LoginPacket.pwd, c_szPassword, sizeof(LoginPacket.pwd)-1);
|
||||
|
||||
LoginPacket.name[ID_MAX_NUM]='\0';
|
||||
LoginPacket.pwd[PASS_MAX_NUM]='\0';
|
||||
|
||||
if (!Send(sizeof(LoginPacket), &LoginPacket))
|
||||
{
|
||||
Tracen("SendLogin Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendLoginPacketNew(const char * c_szName, const char * c_szPassword)
|
||||
{
|
||||
TPacketCGLogin2 LoginPacket;
|
||||
LoginPacket.header = HEADER_CG_LOGIN2;
|
||||
LoginPacket.login_key = m_dwLoginKey;
|
||||
|
||||
strncpy(LoginPacket.name, c_szName, sizeof(LoginPacket.name)-1);
|
||||
LoginPacket.name[ID_MAX_NUM]='\0';
|
||||
|
||||
extern DWORD g_adwEncryptKey[4];
|
||||
extern DWORD g_adwDecryptKey[4];
|
||||
for (DWORD i = 0; i < 4; ++i)
|
||||
LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
|
||||
|
||||
if (!Send(sizeof(LoginPacket), &LoginPacket))
|
||||
{
|
||||
Tracen("SendLogin Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SendSequence())
|
||||
{
|
||||
Tracen("SendLogin Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
__SendInternalBuffer();
|
||||
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
SetSecurityMode(true, (const char *) g_adwEncryptKey, (const char *) g_adwDecryptKey);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvRunupMatrixQuizPacket()
|
||||
{
|
||||
TPacketGCRunupMatrixQuiz kMatrixQuizPacket;
|
||||
if (!Recv(sizeof(TPacketGCRunupMatrixQuiz), &kMatrixQuizPacket))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnRunupMatrixQuiz", Py_BuildValue("(s)", kMatrixQuizPacket.szQuiz));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendRunupMatrixAnswerPacket(const char * c_szMatrixCardString)
|
||||
{
|
||||
TPacketCGRunupMatrixAnswer answerPacket;
|
||||
answerPacket.bHeader = HEADER_CG_RUNUP_MATRIX_ANSWER;
|
||||
strncpy(answerPacket.szAnswer, c_szMatrixCardString, RUNUP_MATRIX_ANSWER_MAX_LEN);
|
||||
answerPacket.szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN] = '\0';
|
||||
if (!Send(sizeof(answerPacket), &answerPacket))
|
||||
{
|
||||
TraceError("SendRunupMatrixCardPacketError");
|
||||
return false;
|
||||
}
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvNEWCIBNPasspodRequestPacket()
|
||||
{
|
||||
TPacketGCNEWCIBNPasspodRequest kRequestPacket;
|
||||
if (!Recv(sizeof(kRequestPacket), &kRequestPacket))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnNEWCIBNPasspodRequest", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvNEWCIBNPasspodFailurePacket()
|
||||
{
|
||||
TPacketGCNEWCIBNPasspodFailure kFailurePacket;
|
||||
if (!Recv(sizeof(kFailurePacket), &kFailurePacket))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnNEWCIBNPasspodFailure", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CPythonNetworkStream::SendNEWCIBNPasspodAnswerPacket(const char * answer)
|
||||
{
|
||||
TPacketCGNEWCIBNPasspodAnswer answerPacket;
|
||||
answerPacket.bHeader = HEADER_CG_NEWCIBN_PASSPOD_ANSWER;
|
||||
strncpy(answerPacket.szAnswer, answer, NEWCIBN_PASSPOD_ANSWER_MAX_LEN);
|
||||
answerPacket.szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN] = '\0';
|
||||
if (!Send(sizeof(answerPacket), &answerPacket))
|
||||
{
|
||||
TraceError("SendNEWCIBNPasspodAnswerPacket");
|
||||
return false;
|
||||
}
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendChinaMatrixCardPacket(const char * c_szMatrixCardString)
|
||||
{
|
||||
TPacketCGChinaMatrixCard MatrixCardPacket;
|
||||
MatrixCardPacket.bHeader = HEADER_CG_CHINA_MATRIX_CARD;
|
||||
strncpy(MatrixCardPacket.szAnswer, c_szMatrixCardString, CHINA_MATRIX_ANSWER_MAX_LEN);
|
||||
MatrixCardPacket.szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN]='\0';
|
||||
|
||||
if (!Send(sizeof(MatrixCardPacket), &MatrixCardPacket))
|
||||
{
|
||||
Tracen("SendLogin Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
m_isWaitLoginKey = TRUE;
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
#define ROW(rows, i) ((rows >> ((4 - i - 1) * 8)) & 0x000000FF)
|
||||
#define COL(cols, i) ((cols >> ((4 - i - 1) * 8)) & 0x000000FF)
|
||||
|
||||
bool CPythonNetworkStream::__RecvChinaMatrixCardPacket()
|
||||
{
|
||||
TPacketGCChinaMatrixCard kMatrixCardPacket;
|
||||
if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
|
||||
return false;
|
||||
|
||||
PyObject * pyValue = Py_BuildValue("(iiiiiiii)", ROW(kMatrixCardPacket.dwRows, 0),
|
||||
ROW(kMatrixCardPacket.dwRows, 1),
|
||||
ROW(kMatrixCardPacket.dwRows, 2),
|
||||
ROW(kMatrixCardPacket.dwRows, 3),
|
||||
COL(kMatrixCardPacket.dwCols, 0),
|
||||
COL(kMatrixCardPacket.dwCols, 1),
|
||||
COL(kMatrixCardPacket.dwCols, 2),
|
||||
COL(kMatrixCardPacket.dwCols, 3));
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnMatrixCard", pyValue);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvLoginKeyPacket()
|
||||
{
|
||||
TPacketGCLoginKey kLoginKeyPacket;
|
||||
if (!Recv(sizeof(TPacketGCLoginKey), &kLoginKeyPacket))
|
||||
return false;
|
||||
|
||||
m_dwLoginKey = kLoginKeyPacket.dwLoginKey;
|
||||
m_isWaitLoginKey = FALSE;
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "PythonApplication.h"
|
||||
#include "Packet.h"
|
||||
|
||||
void CPythonNetworkStream::OffLinePhase()
|
||||
{
|
||||
TPacketHeader header;
|
||||
|
||||
if (!CheckPacket(&header))
|
||||
return;
|
||||
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
if (RecvPhasePacket())
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
||||
RecvErrorPacket(header);
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonNetworkStream.h"
|
||||
#include "Packet.h"
|
||||
|
||||
extern DWORD g_adwEncryptKey[4];
|
||||
extern DWORD g_adwDecryptKey[4];
|
||||
|
||||
// Select Character ---------------------------------------------------------------------------
|
||||
void CPythonNetworkStream::SetSelectPhase()
|
||||
{
|
||||
if ("Select" != m_strPhase)
|
||||
m_phaseLeaveFunc.Run();
|
||||
|
||||
Tracen("");
|
||||
Tracen("## Network - Select Phase ##");
|
||||
Tracen("");
|
||||
|
||||
m_strPhase = "Select";
|
||||
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
SetSecurityMode(true, (const char *) g_adwEncryptKey, (const char *) g_adwDecryptKey);
|
||||
#endif
|
||||
|
||||
m_dwChangingPhaseTime = ELTimer_GetMSec();
|
||||
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::SelectPhase);
|
||||
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveSelectPhase);
|
||||
|
||||
if (__DirectEnterMode_IsSet())
|
||||
{
|
||||
PyCallClassMemberFunc(m_poHandler, "SetLoadingPhase", Py_BuildValue("()"));
|
||||
}
|
||||
else
|
||||
{
|
||||
if (IsSelectedEmpire())
|
||||
PyCallClassMemberFunc(m_poHandler, "SetSelectCharacterPhase", Py_BuildValue("()"));
|
||||
else
|
||||
PyCallClassMemberFunc(m_poHandler, "SetSelectEmpirePhase", Py_BuildValue("()"));
|
||||
}
|
||||
}
|
||||
|
||||
void CPythonNetworkStream::SelectPhase()
|
||||
{
|
||||
TPacketHeader header;
|
||||
|
||||
if (!CheckPacket(&header))
|
||||
return;
|
||||
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
if (RecvPhasePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_EMPIRE:
|
||||
if (__RecvEmpirePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_LOGIN_SUCCESS3:
|
||||
if (__RecvLoginSuccessPacket3())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_LOGIN_SUCCESS4:
|
||||
if (__RecvLoginSuccessPacket4())
|
||||
return;
|
||||
break;
|
||||
|
||||
|
||||
case HEADER_GC_PLAYER_CREATE_SUCCESS:
|
||||
if (__RecvPlayerCreateSuccessPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PLAYER_CREATE_FAILURE:
|
||||
if (__RecvPlayerCreateFailurePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID:
|
||||
if (__RecvPlayerDestroyFailurePacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_PLAYER_DELETE_SUCCESS:
|
||||
if (__RecvPlayerDestroySuccessPacket())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_CHANGE_NAME:
|
||||
if (__RecvChangeName())
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HANDSHAKE:
|
||||
RecvHandshakePacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HANDSHAKE_OK:
|
||||
RecvHandshakeOKPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_KEYS:
|
||||
RecvHybridCryptKeyPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
case HEADER_GC_HYBRIDCRYPT_SDB:
|
||||
RecvHybridCryptSDBPacket();
|
||||
return;
|
||||
break;
|
||||
|
||||
|
||||
#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_PLAYER_POINT_CHANGE:
|
||||
TPacketGCPointChange PointChange;
|
||||
Recv(sizeof(TPacketGCPointChange), &PointChange);
|
||||
return;
|
||||
break;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
case HEADER_GC_PING:
|
||||
if (RecvPingPacket())
|
||||
return;
|
||||
break;
|
||||
}
|
||||
|
||||
RecvErrorPacket(header);
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendSelectEmpirePacket(DWORD dwEmpireID)
|
||||
{
|
||||
TPacketCGEmpire kPacketEmpire;
|
||||
kPacketEmpire.bHeader=HEADER_CG_EMPIRE;
|
||||
kPacketEmpire.bEmpire=dwEmpireID;
|
||||
|
||||
if (!Send(sizeof(kPacketEmpire), &kPacketEmpire))
|
||||
{
|
||||
Tracen("SendSelectEmpirePacket - Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
SetEmpireID(dwEmpireID);
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendSelectCharacterPacket(BYTE Index)
|
||||
{
|
||||
TPacketCGSelectCharacter SelectCharacterPacket;
|
||||
|
||||
SelectCharacterPacket.header = HEADER_CG_PLAYER_SELECT;
|
||||
SelectCharacterPacket.player_index = Index;
|
||||
|
||||
if (!Send(sizeof(TPacketCGSelectCharacter), &SelectCharacterPacket))
|
||||
{
|
||||
Tracen("SendSelectCharacterPacket - Error");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendDestroyCharacterPacket(BYTE index, const char * szPrivateCode)
|
||||
{
|
||||
TPacketCGDestroyCharacter DestroyCharacterPacket;
|
||||
|
||||
DestroyCharacterPacket.header = HEADER_CG_PLAYER_DESTROY;
|
||||
DestroyCharacterPacket.index = index;
|
||||
strncpy(DestroyCharacterPacket.szPrivateCode, szPrivateCode, PRIVATE_CODE_LENGTH-1);
|
||||
|
||||
if (!Send(sizeof(TPacketCGDestroyCharacter), &DestroyCharacterPacket))
|
||||
{
|
||||
Tracen("SendDestroyCharacterPacket");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendCreateCharacterPacket(BYTE index, const char *name, BYTE job, BYTE shape, BYTE byCON, BYTE byINT, BYTE bySTR, BYTE byDEX)
|
||||
{
|
||||
TPacketCGCreateCharacter createCharacterPacket;
|
||||
|
||||
createCharacterPacket.header = HEADER_CG_PLAYER_CREATE;
|
||||
createCharacterPacket.index = index;
|
||||
strncpy(createCharacterPacket.name, name, CHARACTER_NAME_MAX_LEN);
|
||||
createCharacterPacket.job = job;
|
||||
createCharacterPacket.shape = shape;
|
||||
createCharacterPacket.CON = byCON;
|
||||
createCharacterPacket.INT = byINT;
|
||||
createCharacterPacket.STR = bySTR;
|
||||
createCharacterPacket.DEX = byDEX;
|
||||
|
||||
if (!Send(sizeof(TPacketCGCreateCharacter), &createCharacterPacket))
|
||||
{
|
||||
Tracen("Failed to SendCreateCharacterPacket");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::SendChangeNamePacket(BYTE index, const char *name)
|
||||
{
|
||||
TPacketCGChangeName ChangeNamePacket;
|
||||
ChangeNamePacket.header = HEADER_CG_CHANGE_NAME;
|
||||
ChangeNamePacket.index = index;
|
||||
strncpy(ChangeNamePacket.name, name, CHARACTER_NAME_MAX_LEN);
|
||||
|
||||
if (!Send(sizeof(TPacketCGChangeName), &ChangeNamePacket))
|
||||
{
|
||||
Tracen("Failed to SendChangeNamePacket");
|
||||
return false;
|
||||
}
|
||||
|
||||
return SendSequence();
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvPlayerCreateSuccessPacket()
|
||||
{
|
||||
TPacketGCPlayerCreateSuccess kCreateSuccessPacket;
|
||||
|
||||
if (!Recv(sizeof(kCreateSuccessPacket), &kCreateSuccessPacket))
|
||||
return false;
|
||||
|
||||
if (kCreateSuccessPacket.bAccountCharacterSlot>=PLAYER_PER_ACCOUNT4)
|
||||
{
|
||||
TraceError("CPythonNetworkStream::RecvPlayerCreateSuccessPacket - OUT OF RANGE SLOT(%d) > PLATER_PER_ACCOUNT(%d)",
|
||||
kCreateSuccessPacket.bAccountCharacterSlot, PLAYER_PER_ACCOUNT4);
|
||||
return true;
|
||||
}
|
||||
|
||||
m_akSimplePlayerInfo[kCreateSuccessPacket.bAccountCharacterSlot]=kCreateSuccessPacket.kSimplePlayerInfomation;
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_CREATE], "OnCreateSuccess", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvPlayerCreateFailurePacket()
|
||||
{
|
||||
TPacketGCCreateFailure packet;
|
||||
|
||||
if (!Recv(sizeof(TPacketGCCreateFailure), &packet))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_CREATE], "OnCreateFailure", Py_BuildValue("(i)", packet.bType));
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnCreateFailure", Py_BuildValue("(i)", packet.bType));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvPlayerDestroySuccessPacket()
|
||||
{
|
||||
TPacketGCDestroyCharacterSuccess packet;
|
||||
if (!Recv(sizeof(TPacketGCDestroyCharacterSuccess), &packet))
|
||||
return false;
|
||||
|
||||
memset(&m_akSimplePlayerInfo[packet.account_index], 0, sizeof(m_akSimplePlayerInfo[packet.account_index]));
|
||||
m_adwGuildID[packet.account_index] = 0;
|
||||
m_astrGuildName[packet.account_index] = "";
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnDeleteSuccess", Py_BuildValue("(i)", packet.account_index));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvPlayerDestroyFailurePacket()
|
||||
{
|
||||
TPacketGCBlank packet_blank;
|
||||
if (!Recv(sizeof(TPacketGCBlank), &packet_blank))
|
||||
return false;
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnDeleteFailure", Py_BuildValue("()"));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonNetworkStream::__RecvChangeName()
|
||||
{
|
||||
TPacketGCChangeName ChangeNamePacket;
|
||||
if (!Recv(sizeof(TPacketGCChangeName), &ChangeNamePacket))
|
||||
return false;
|
||||
|
||||
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
|
||||
{
|
||||
if (ChangeNamePacket.pid == m_akSimplePlayerInfo[i].dwID)
|
||||
{
|
||||
m_akSimplePlayerInfo[i].bChangeName = FALSE;
|
||||
strncpy(m_akSimplePlayerInfo[i].szName, ChangeNamePacket.name, CHARACTER_NAME_MAX_LEN);
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnChangeName", Py_BuildValue("(is)", i, ChangeNamePacket.name));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnCreateFailure", Py_BuildValue("(i)", 100));
|
||||
return true;
|
||||
}
|
||||
@@ -6,10 +6,6 @@
|
||||
DWORD g_adwEncryptKey[4];
|
||||
DWORD g_adwDecryptKey[4];
|
||||
|
||||
// PORT: the login cipher's key builder happens to live in this unit, but it is CAccountConnector's —
|
||||
// AccountConnector.h and the class come with the login slice (docs/PORT-PLAN.md 批次 2V1). Kept verbatim
|
||||
// and compiled out until then; the two keys above stay, they are what the network stream reads.
|
||||
#if 0
|
||||
#include "AccountConnector.h"
|
||||
|
||||
inline const BYTE* GetKey_20050304Myevan()
|
||||
@@ -40,7 +36,6 @@ void CAccountConnector::__BuildClientKey_20050304Myevan()
|
||||
tea_encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) (c_pszKey+37), 16);
|
||||
// TEA_Encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) (c_pszKey+37), 16);
|
||||
}
|
||||
#endif
|
||||
// END_OF_CHINA_CRYPT_KEY
|
||||
|
||||
PyObject * packExist(PyObject * poSelf, PyObject * poArgs)
|
||||
|
||||
@@ -44,3 +44,4 @@ enum
|
||||
// Listed here as 40250 lists them; only the ported ones are defined.
|
||||
void initpack();
|
||||
void initapp();
|
||||
void initnet();
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
#pragma once
|
||||
|
||||
extern bool __IS_TEST_SERVER_MODE__;
|
||||
@@ -0,0 +1,8 @@
|
||||
#pragma once
|
||||
|
||||
bool XTrap_Init();
|
||||
bool XTrap_CheckInit();
|
||||
void XTrap_PollEvent();
|
||||
void XTrap_ValidateCheckStream( LPVOID PacketBufferIn, LPVOID PacketBufferOut );
|
||||
void XTrap_SetUserInfo(LPCSTR szUserID, LPCSTR szServerName, LPCSTR szCharacterName, LPCSTR szCharacterClass, SOCKET hSocket);
|
||||
|
||||
Reference in New Issue
Block a user