// 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; }