// 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("()"));
}
}
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;
}
PyObject* dbgTracen(PyObject* poSelf, PyObject* poArgs)
{
char* szMsg;
if (!PyTuple_GetString(poArgs, 0, &szMsg))
return Py_BuildException();
Tracen(szMsg);
return Py_BuildNone();
}
bool CActorInstance::__BindMotionData(DWORD dwMotionKey)
{
if (!m_pkCurRaceData->GetMotionDataPointer(dwMotionKey, &m_pkCurRaceMotionData))
{
Tracen("Failed to bind motion.");
m_pkCurRaceMotionData=NULL;
m_dwcurComboIndex=0;
return false;
}
return true;
}
// Set
void CPythonNetworkStream::SetOffLinePhase()
{
if ("OffLine" != m_strPhase)
m_phaseLeaveFunc.Run();
m_strPhase = "OffLine";
Tracen("");
Tracen("## Network - OffLine Phase ##");
Tracen("");
m_dwChangingPhaseTime = ELTimer_GetMSec();
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::OffLinePhase);
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveOfflinePhase);
SetGameOffline();
m_dwSelectedCharacterIndex = 0;
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
}
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::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::SendItemPickUpPacket(DWORD vid)
{
if (!__CanActMainInstance())
return true;
TPacketCGItemPickUp itemPickUpPacket;
itemPickUpPacket.header = HEADER_CG_ITEM_PICKUP;
itemPickUpPacket.vid = vid;
if (!Send(sizeof(TPacketCGItemPickUp), &itemPickUpPacket))
{
Tracen("SendItemPickUpPacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, BYTE num)
{
if (!__CanActMainInstance())
return true;
if (__IsEquipItemInSlot(pos))
{
if (CPythonExchange::Instance().isTrading())
{
if (pos.IsEquipCell() || change_pos.IsEquipCell())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
return true;
}
}
if (CPythonShop::Instance().IsOpen())
{
if (pos.IsEquipCell() || change_pos.IsEquipCell())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
return true;
}
}
if (__IsPlayerAttacking())
return true;
}
__PlayInventoryItemDropSound(pos);
TPacketCGItemMove itemMovePacket;
itemMovePacket.header = HEADER_CG_ITEM_MOVE;
itemMovePacket.pos = pos;
itemMovePacket.change_pos = change_pos;
itemMovePacket.num = num;
if (!Send(sizeof(TPacketCGItemMove), &itemMovePacket))
{
Tracen("SendItemMovePacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendQuickSlotDelPacket(BYTE pos)
{
if (!__CanActMainInstance())
return true;
TPacketCGQuickSlotDel quickSlotDelPacket;
quickSlotDelPacket.header = HEADER_CG_QUICKSLOT_DEL;
quickSlotDelPacket.pos = pos;
if (!Send(sizeof(TPacketCGQuickSlotDel), &quickSlotDelPacket))
{
Tracen("SendQuickSlotDelPacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendItemDropPacket(TItemPos pos, DWORD elk)
{
if (!__CanActMainInstance())
return true;
TPacketCGItemDrop itemDropPacket;
itemDropPacket.header = HEADER_CG_ITEM_DROP;
itemDropPacket.pos = pos;
itemDropPacket.elk = elk;
if (!Send(sizeof(TPacketCGItemDrop), &itemDropPacket))
{
Tracen("SendItemDropPacket Error");
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();
}
bool CGuildMarkUploader::__LoginState_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 CPythonNetworkStream::SendQuickSlotMovePacket(BYTE pos, BYTE change_pos)
{
if (!__CanActMainInstance())
return true;
TPacketCGQuickSlotSwap quickSlotSwapPacket;
quickSlotSwapPacket.header = HEADER_CG_QUICKSLOT_SWAP;
quickSlotSwapPacket.pos = pos;
quickSlotSwapPacket.change_pos = change_pos;
if (!Send(sizeof(TPacketCGQuickSlotSwap), &quickSlotSwapPacket))
{
Tracen("SendQuickSlotSwapPacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendItemDropPacketNew(TItemPos pos, DWORD elk, DWORD count)
{
if (!__CanActMainInstance())
return true;
TPacketCGItemDrop2 itemDropPacket;
itemDropPacket.header = HEADER_CG_ITEM_DROP2;
itemDropPacket.pos = pos;
itemDropPacket.gold = elk;
itemDropPacket.count = count;
if (!Send(sizeof(itemDropPacket), &itemDropPacket))
{
Tracen("SendItemDropPacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos)
{
if (!__CanActMainInstance())
return true;
TPacketCGQuickSlotAdd quickSlotAddPacket;
quickSlotAddPacket.header = HEADER_CG_QUICKSLOT_ADD;
quickSlotAddPacket.pos = wpos;
quickSlotAddPacket.slot.Type = type;
quickSlotAddPacket.slot.Position = pos;
if (!Send(sizeof(TPacketCGQuickSlotAdd), &quickSlotAddPacket))
{
Tracen("SendQuickSlotAddPacket Error");
return false;
}
return SendSequence();
}
bool CPythonNetworkStream::SendItemUseToItemPacket(TItemPos source_pos, TItemPos target_pos)
{
if (!__CanActMainInstance())
return true;
TPacketCGItemUseToItem itemUseToItemPacket;
itemUseToItemPacket.header = HEADER_CG_ITEM_USE_TO_ITEM;
itemUseToItemPacket.source_pos = source_pos;
itemUseToItemPacket.target_pos = target_pos;
if (!Send(sizeof(TPacketCGItemUseToItem), &itemUseToItemPacket))
{
Tracen("SendItemUseToItemPacket Error");
return false;
}
#ifdef _DEBUG
Tracef(" << SendItemUseToItemPacket(src=%d, dst=%d)\n", source_pos, target_pos);
#endif
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();
}
void CPythonPlayer::NEW_SetMultiDirKeyState(bool isLeft, bool isRight, bool isUp, bool isDown)
{
if (!__CanMove())
return;
bool isAny=(isLeft || isRight || isUp || isDown);
if (isAny)
{
float fDirRot=0.0f;
NEW_GetMultiKeyDirRotation(isLeft, isRight, isUp, isDown, &fDirRot);
if (!NEW_MoveToDirection(fDirRot))
{
Tracen("CPythonPlayer::NEW_SetMultiKeyState - NEW_Move -> ERROR");
return;
}
}
else
{
NEW_Stop();
}
}
CPythonNetworkStream::~CPythonNetworkStream()
{
Tracen("PythonNetworkMainStream Clear");
}
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;
}
