LGram16
dd97ddec92
Move git root from Client/ to src/ to track all source code: - Client: Game client source (moved to Client/Client/) - Server: Game server source - GameTools: Development tools - CryptoSource: Encryption utilities - database: Database scripts - Script: Game scripts - rylCoder_16.02.2008_src: Legacy coder tools - GMFont, Game: Additional resources 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2488 lines
88 KiB
C++
2488 lines
88 KiB
C++
#include "stdafx.h"
|
|
#include "./res/resource.h"
|
|
|
|
#include "AdminToolClient.h"
|
|
#include "Dispatch.h"
|
|
#include "WindowMgr.h"
|
|
#include "UserInfoDoc.h"
|
|
#include "CharacterDoc.h"
|
|
#include "CharSheetView.h"
|
|
#include "ItemManageDlg.h"
|
|
#include "PacketManager.h"
|
|
#include "GuildSearchDlg.h"
|
|
#include "GuildMainDlg.h"
|
|
#include "GuildRestoreDlg.h"
|
|
#include "FortInfoDlg.h"
|
|
#include "ShopCampPage.h"
|
|
#include "MiningCampDlg.h"
|
|
#include "CastleSearchDlg.h"
|
|
#include "CastleCreatureDlg.h"
|
|
#include "ItemQuantityControlDlg.h"
|
|
#include "UserBillingLogDlg.h"
|
|
#include "QuickMenuDlgBar.h"
|
|
#include "GAdminManagementDlg.h"
|
|
#include "InitDialogBar.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "UserCharTreeView.h"
|
|
#include "InterestedUserDlg.h"
|
|
#include "ConnectionInfoDlg.h"
|
|
#include "DuplicatedItemDlg.h"
|
|
#include "ItemDistributeDlg.h"
|
|
#include "UnifiedCharInfoDlg.h"
|
|
#include "UnifiedGuildInfoDlg.h"
|
|
#include "DetailCharInfo.h"
|
|
#include "AdminStoreDlgBar.h"
|
|
#include "GMLogMsgDlg.h"
|
|
#include "CharInfoTime.h"
|
|
|
|
|
|
|
|
#include <Network/Packet/PacketBase.h>
|
|
#include <Network/Packet/PacketStruct/GuildPacket.h>
|
|
#include <Utility/Debug/DebugMacros.h>
|
|
#include <Network/SingleSession/ClientSingleSession.h>
|
|
#include <Network/Protocol/Ryl_AdminMgrProtocol.h>
|
|
#include <Character/ModifyCharacter.h>
|
|
#include <Item/ItemMgr.h>
|
|
#include <Item/ItemFactory.h>
|
|
#include <Item/Container/ItemContainer.h>
|
|
#include <Item/Container/EquipmentsContainer.h>
|
|
|
|
#define RADIAN 57.2957
|
|
|
|
|
|
|
|
bool CClientDispatch::DispatchPacket(PktBase* lpPktBase)
|
|
{
|
|
using namespace PktAdminMgr;
|
|
|
|
unsigned char cCmd = lpPktBase->GetCmd();
|
|
switch(cCmd)
|
|
{
|
|
case PktCMD::PktResultAck: return PktResultAck (lpPktBase);
|
|
case PktCMD::PktNewAdminAck: return PktAdminListAck (lpPktBase); // 형태가 PktAdminListAck와 같다 이놈은 싱글
|
|
case PktCMD::PktAdminListAck: return PktAdminListAck (lpPktBase); // 이놈은 멀티?
|
|
case PktCMD::PktLoginInfoAck: return PktLoginInfoAck (lpPktBase);
|
|
case PktCMD::PktDelAdminAck: return PktDelAdminAck (lpPktBase);
|
|
case PktCMD::PktUpdateLevelAck: return PktUpdateLevelAck (lpPktBase);
|
|
case PktCMD::PktUpdateIPAck: return PktUpdateIPAck (lpPktBase);
|
|
case PktCMD::PktLogListAck: return PktLogListAck (lpPktBase);
|
|
case PktCMD::PktDetailLogAck: return PktDetailLogAck (lpPktBase);
|
|
case PktCMD::PktGetExitLogAck: return PktGetExitLogAck (lpPktBase);
|
|
case PktCMD::PktBeforeAfterAck: return PktBeforeAfterAck (lpPktBase);
|
|
case PktCMD::PktAgentServerIndex: return PktAgentServerIndexAck (lpPktBase);
|
|
case PktCMD::PktSearchAck: return PktSearchAck (lpPktBase);
|
|
case PktCMD::PktSearchResultAck: return PktSearchResultAck (lpPktBase);
|
|
case PktCMD::PktGetCharacterAck: return PktGetCharacterAck (lpPktBase);
|
|
case PktCMD::PktCloseCharacterAck: return PktCloseCharacterAck (lpPktBase);
|
|
case PktCMD::PktCreateItemAck: return PktCreateItemAck (lpPktBase);
|
|
case PktCMD::PktUpdateItemAck: return PktUpdateItemAck (lpPktBase);
|
|
case PktCMD::PktDepositSync: return PktSyncDeposit (lpPktBase);
|
|
case PktCMD::PktRemoveItemAck: return PktRemoveItemAck (lpPktBase);
|
|
case PktCMD::PktItemResetAck: return PktItemResetAck (lpPktBase);
|
|
case PktCMD::PktInvenGold: return PktInvenGold (lpPktBase);
|
|
case PktCMD::PktSkillEditAck: return PktSkillEditAck (lpPktBase);
|
|
case PktCMD::PktSearchBlockAck: return PktSearchBlockAck (lpPktBase);
|
|
case PktCMD::PktSetZoneListAck: return PktSetZoneList (lpPktBase);
|
|
case PktCMD::PktChangeNameAck: return PktChangeNameAck (lpPktBase);
|
|
case PktCMD::PktDelCharListAck: return PktDelCharListAck (lpPktBase);
|
|
case PktCMD::PktCharRestoreAck: return PktCharRestoreAck (lpPktBase);
|
|
case PktCMD::PktAdminStoreInsertAck: return PktAdminStoreInsertAck (lpPktBase);
|
|
case PktCMD::PktAdminStoreDeleteAck: return PktAdminStoreDeleteAck (lpPktBase);
|
|
case PktCMD::PktGetAdminStoreItem: return PktGetAdminStoreItemAck (lpPktBase);
|
|
case PktCMD::PktGuildSearchAck: return PktGuildSearchAck (lpPktBase);
|
|
case PktCMD::PktRequestGuildMemberListAck: return PktRequestGuildMemberListAck (lpPktBase);
|
|
case PktCMD::PktGuildRestoreDataListAck: return PktGuildRestoreDataListAck (lpPktBase);
|
|
case PktCMD::PktFortSearchAck: return PktFortSearchAck (lpPktBase);
|
|
case PktCMD::PktMiningCampAck: return PktMiningCampAck (lpPktBase);
|
|
case PktCMD::PktShopCampAck: return PktShopCampAck (lpPktBase);
|
|
case PktCMD::PktCastleSearchAck: return PktCastleSearchAck (lpPktBase);
|
|
case PktCMD::PktCastleCreatureAck: return PktCastleCreatureAck (lpPktBase);
|
|
case PktCMD::PktItemQtyControl: return PktItemQtyControlAck (lpPktBase);
|
|
case PktCMD::PktUserBillingLogAck: return PktUserBillingLogAck (lpPktBase);
|
|
case PktCMD::PktGameAdminAck: return PktGameAdminAck (lpPktBase);
|
|
case PktCMD::PktRefreshConnectedList: return PktConnectAllServerzAck (lpPktBase);
|
|
case PktCMD::PktInterestedUser: return PktInterestedUserList (lpPktBase);
|
|
case PktCMD::PktConnectionChk: return PktConnectionChk (lpPktBase);
|
|
case PktCMD::PktConnectedUserList: return PktConnectedUserList (lpPktBase);
|
|
case PktCMD::PktDuplicatedItem: return PktDuplicatedItem (lpPktBase);
|
|
case PktCMD::PktItemDistributeAck: return PktItemDistributeAck (lpPktBase);
|
|
case PktCMD::PktGuildRight: return PktGuildRight (lpPktBase);
|
|
case PktCMD::PktUnifiedCharInfo: return PktUnifiedCharInfo (lpPktBase);
|
|
case PktCMD::PktUnifiedGuildInfo: return PktUnifiedGuildInfo (lpPktBase);
|
|
case PktCMD::PktDetailCharInfo: return PktDetailCharInfo (lpPktBase);
|
|
case PktCMD::PktCancelExecuteQuest: return PktCancelExecuteQuest (lpPktBase);
|
|
case PktCMD::PktDeleteHistoryQuest: return PktDeleteHistoryQuest (lpPktBase);
|
|
case PktCMD::PktUserNation: return PktUserNation (lpPktBase);
|
|
case PktCMD::PktShiftToUID: return PktShiftToUID (lpPktBase);
|
|
case PktCMD::PktStoreTabEdit: return PktStoreTabEdit (lpPktBase);
|
|
case PktCMD::PktGMLogMsg: return PktGMLogMsg (lpPktBase);
|
|
case PktCMD::PktGuildMemberEdit: return PktGuildMemberEdit (lpPktBase);
|
|
case PktCMD::PktGetCharInfoTimeAck: return PktResultCharInfoTime (lpPktBase);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 작업 결과 ACK
|
|
bool CClientDispatch::PktResultAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktResultAck* lpPktResultAck = static_cast<PktAdminMgr::PktResultAck*>(lpPktBase);
|
|
|
|
switch(lpPktResultAck->m_Result)
|
|
{
|
|
case PktAdminMgr::PktResult::Result_Null: AfxMessageBox(GetLocalString("MSG_0005"), MB_OK | MB_ICONINFORMATION); break;
|
|
case PktAdminMgr::PktResult::Err_Unknown: Report(GetLocalString("MSG_0006"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Database: Report(GetLocalString("MSG_0007"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Account: Report(GetLocalString("MSG_0008"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Passwd: Report(GetLocalString("MSG_0009"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_ConnectIP: Report(GetLocalString("MSG_0010"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_OverlapID: Report(GetLocalString("MSG_0011"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NewAdmin: Report(GetLocalString("MSG_0012"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_DelAdmin: Report(GetLocalString("MSG_0013"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_UpdateLevel: Report(GetLocalString("MSG_0014"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_UpdateIP: Report(GetLocalString("MSG_0015"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_UpdatePasswd: Report(GetLocalString("MSG_0016"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Authority: Report(GetLocalString("MSG_0017"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_UnkonwnPacket: Report(GetLocalString("MSG_0018"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_ModifyCharacter: Report(GetLocalString("MSG_0019"), FAILED); ResultErrModifyCharacter(lpPktBase); break;
|
|
case PktAdminMgr::PktResult::Err_NotFountDBComponent: Report(GetLocalString("MSG_0020"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_CloseCharacter: Report(GetLocalString("MSG_0021"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_ChangeStatus: Report(GetLocalString("MSG_0022"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_PacketDispatch: Report(GetLocalString("MSG_0023"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_CreateItem1: Report(GetLocalString("MSG_0024"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_CreateItem2: Report(GetLocalString("MSG_0025"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_CreateItem3: Report(GetLocalString("MSG_0026"), FAILED); break;
|
|
case PktAdminMgr::PktResult::UNKNOWN_ERROR: Report(GetLocalString("MSG_0027"), FAILED); break;
|
|
case PktAdminMgr::PktResult::INVALID_REQUEST: Report(GetLocalString("MSG_0028"), FAILED); break;
|
|
case PktAdminMgr::PktResult::GET_UIDCID_QUERY_FAILED: Report(GetLocalString("MSG_0029"), FAILED); break;
|
|
case PktAdminMgr::PktResult::INVALID_UID_CID_DATA: Report(GetLocalString("MSG_0030"), FAILED); break;
|
|
case PktAdminMgr::PktResult::GET_STORE_QUERY_FAILED: Report(GetLocalString("MSG_0031"), FAILED); break;
|
|
case PktAdminMgr::PktResult::GET_CHAR_DATA_QUERY_FAILED: Report(GetLocalString("MSG_0032"), FAILED); break;
|
|
case PktAdminMgr::PktResult::INVALID_UID_CID_ERROR: Report(GetLocalString("MSG_0033"), FAILED); break;
|
|
case PktAdminMgr::PktResult::LOGIN_ANOTHER_GAMESERVER: Report(GetLocalString("MSG_0034"), FAILED); break;
|
|
case PktAdminMgr::PktResult::SESSION_OPEN_FAILED: Report(GetLocalString("MSG_0035"), FAILED); break;
|
|
case PktAdminMgr::PktResult::ALREADY_LOGIN_USER_SESSION_OPEN: Report(GetLocalString("MSG_0036"), FAILED); break;
|
|
case PktAdminMgr::PktResult::ANOTHER_CHAR_LOAD_FAILED: Report(GetLocalString("MSG_0037"), CAUTION); break;
|
|
case PktAdminMgr::PktResult::SETTING_DATA_FAILED: Report(GetLocalString("MSG_0038"), FAILED); break;
|
|
case PktAdminMgr::PktResult::SESSION_START_FAILED: Report(GetLocalString("MSG_0039"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Invalid_ItemID: Report(GetLocalString("MSG_0040"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Invalid_Item: Report(GetLocalString("MSG_0041"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_Invalid_Character: Report(GetLocalString("MSG_0042"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_RemoveItem: Report(GetLocalString("MSG_0043"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotUseDeposit: Report(GetLocalString("MSG_0044"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotFoundAgentDispatch: Report(GetLocalString("MSG_0045"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_StateisSave: Report(GetLocalString("MSG_0046"), FAILED); ResultErrModifyCharacter(lpPktBase); break;
|
|
case PktAdminMgr::PktResult::Err_SetInventoryGold: Report(GetLocalString("MSG_0047"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_SkipCharacterSave: Report(GetLocalString("MSG_0048"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_SkillEdit: Report(GetLocalString("MSG_0049"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_DepositPasswd: Report(GetLocalString("MSG_0050"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotUseName: Report(GetLocalString("MSG_0051"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotChangeName: Report(GetLocalString("MSG_0052"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotCharacterInfo: Report(GetLocalString("MSG_0053"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NotUserInfoSlot: Report(GetLocalString("MSG_0054"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_AdminStore: Report(GetLocalString("MSG_0055"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_AdminStoreDelete: Report(GetLocalString("MSG_0056"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_GameAdminManage: Report(GetLocalString("MSG_0057"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_InterestedUserManage: Report(GetLocalString("MSG_0144"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NOT_ENOUGH_STAT: Report(GetLocalString("MSG_0145"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NOT_ENOUGH_SKILLSLOT: Report(GetLocalString("MSG_0146"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_FAILED_TO_GET_SKILLPROTOTYPE: Report(GetLocalString("MSG_0147"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_OVERED_MAX_LOCKCOUNT: Report(GetLocalString("MSG_0148"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_OVERED_MAX_SKILL_LEVEL: Report(GetLocalString("MSG_0149"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_NOT_CURRENT_CLASS: Report(GetLocalString("MSG_0150"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Success_Login: Report(GetLocalString("MSG_0058"), SUCCESS); SucessLogin(); break;
|
|
case PktAdminMgr::PktResult::Success_ConnectIP: Report(GetLocalString("MSG_0059"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_NewAdmin: Report(GetLocalString("MSG_0060"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_SearchCompleted: Report(GetLocalString("MSG_0061"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_ModifyCharacter: Report(GetLocalString("MSG_0062"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_ChangeStatus: Report(GetLocalString("MSG_0063"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_ChangePos: Report(GetLocalString("MSG_0064"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_DepositPasswd: Report(GetLocalString("MSG_0065"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_UseName: Report(GetLocalString("MSG_0066"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_CharacterRestore: Report(GetLocalString("MSG_0067"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_AdminStore: Report(GetLocalString("MSG_0068"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_UpdateAdminStore: Report(GetLocalString("MSG_0069"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_SaveCharacter: Report(GetLocalString("MSG_0070"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_ChkDuplicatedItem: Report(GetLocalString("MSG_0151"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_SUCCESS: Report(GetLocalString("MSG_0152"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_DeleteQuest: Report(GetLocalString("MSG_0180"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Err_DeleteQuest: Report(GetLocalString("MSG_0181"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Success_StoreTabEdit: Report(GetLocalString("ADDED_STRIMG_037"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_AddBlockUser: Report(GetLocalString("ADDED_STRING_054"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Success_DelBlockUser: Report(GetLocalString("ADDED_STRING_056"), SUCCESS); break;
|
|
case PktAdminMgr::PktResult::Err_AddBlockUser: Report(GetLocalString("ADDED_STRING_055"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Err_DelBlockUser: Report(GetLocalString("ADDED_STRING_057"), FAILED); break;
|
|
case PktAdminMgr::PktResult::Success_NameChangeCount: Report(GetLocalString("ADDED_STRING_081"), SUCCESS); break;
|
|
|
|
default: Report(GetLocalString("MSG_0071"), CAUTION); break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 로그인 성공
|
|
bool CClientDispatch::SucessLogin()
|
|
{
|
|
CDialog* lpDlg = static_cast<CDialog*>(GET_WINDOW(IDD_ADMIN_LOGIN));
|
|
|
|
if(NULL != lpDlg)
|
|
{
|
|
lpDlg->EndDialog(IDOK);
|
|
}
|
|
else
|
|
{
|
|
AfxMessageBox(GetLocalString("MSG_0004"));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 로그인 Ack
|
|
bool CClientDispatch::PktLoginInfoAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktLoginInfoAck* lpPktLoginInfo = static_cast<PktAdminMgr::PktLoginInfoAck*>(lpPktBase);
|
|
CAdminToolClientApp* pApp = static_cast<CAdminToolClientApp*>(AfxGetApp());
|
|
|
|
pApp->m_MyInfo.m_UID = lpPktLoginInfo->m_UID;
|
|
pApp->m_MyInfo.m_Level = lpPktLoginInfo->m_Level;
|
|
|
|
g_bIsLogin = true; // 인증을 통과했음을 체크!
|
|
|
|
_tcsncpy(pApp->m_MyInfo.m_szAccount, CONV_CLISTR(lpPktLoginInfo->m_szAccount), PktAdminMgr::MAX_ACCOUNT);
|
|
_tcsncpy(pApp->m_MyInfo.m_szPassword, CONV_CLISTR(lpPktLoginInfo->m_szPassword), PktAdminMgr::MAX_PASSWORD);
|
|
_tcsncpy(pApp->m_MyInfo.m_szIP, CONV_CLISTR(lpPktLoginInfo->m_szIP), PktAdminMgr::MAX_IP);
|
|
_tcsncpy(pApp->m_MyInfo.m_RegDate, CONV_CLISTR(lpPktLoginInfo->m_RegDate), PktAdminMgr::MAX_DATE);
|
|
_tcsncpy(pApp->m_MyInfo.m_szName, CONV_CLISTR(lpPktLoginInfo->m_szName), PktAdminMgr::MAX_NAME);
|
|
|
|
CPacketMgr::GetInstance()->SendRefrechConnectedServerList(); // 접속된 중계서버 리스트 요청
|
|
|
|
return true;
|
|
}
|
|
|
|
// 중계서버 정보 얻기
|
|
bool CClientDispatch::PktAgentServerIndexAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktAgentServerIndex* lpPktAgentServerIndex =
|
|
static_cast<PktAdminMgr::PktAgentServerIndex*>(lpPktBase);
|
|
|
|
// 구조체 ServerInfo(Name, Index)를 요소로 가진 리스트 셋팅
|
|
|
|
CString szServerName = CONV_CLISTR(lpPktAgentServerIndex->m_szServerName);
|
|
|
|
CCharacterDoc::GetInstance().PushServerGroup(szServerName,
|
|
lpPktAgentServerIndex->m_ServerGroup);
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 아이템창고 리스트
|
|
bool CClientDispatch::PktSetZoneList(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktSetZoneList* lpPktSetZoneAck = static_cast<PktAdminMgr::PktSetZoneList*>(lpPktBase);
|
|
CCharacterDoc& CharDocument = CCharacterDoc::GetInstance();
|
|
|
|
CharDocument.GetZoneList().Serialize_In(lpPktSetZoneAck->m_ZoneBuffer);
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 창고에 아이템삽입 Ack
|
|
bool CClientDispatch::PktAdminStoreInsertAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktAdminStoreInsertAck* lpPktAdminStore = static_cast< PktAdminMgr::PktAdminStoreInsertAck* >( lpPktBase );
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_STATUS_DLGBAR));
|
|
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_ADMINSTORELIST));
|
|
if(NULL != lpList)
|
|
{
|
|
int ItemCount = lpList->GetItemCount();
|
|
|
|
TCHAR szUID[10];
|
|
CString strServerName;
|
|
|
|
_sntprintf(szUID, sizeof(szUID), _T("%d"), lpPktAdminStore->m_dwStoreUID);
|
|
CCharacterDoc::GetInstance().GetServerName((unsigned long)lpPktAdminStore->m_cServerIdx, strServerName);
|
|
|
|
lpList->InsertItem(ItemCount, szUID);
|
|
lpList->SetItemText(ItemCount, 1, strServerName);
|
|
lpList->SetItemText(ItemCount, 2, CONV_CLISTR(lpPktAdminStore->m_szOwnerName));
|
|
lpList->SetItemText(ItemCount, 3, CONV_CLISTR(lpPktAdminStore->m_szItemName));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 상세로그 정보 ACK
|
|
bool CClientDispatch::PktBeforeAfterAck( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktBeforeAfterAck* lpPktBeforeAfter = static_cast< PktAdminMgr::PktBeforeAfterAck* >( lpPktBase );
|
|
CDialog* LogDlg = static_cast< CDialog* >( GET_WINDOW( IDD_TADMINUSELOGDLG ) );
|
|
|
|
LogDlg->SetDlgItemText(IDC_TADMINDETAILUSELOGBEFOREEDIT, CONV_CLISTR(lpPktBeforeAfter->m_szBefore));
|
|
LogDlg->SetDlgItemText(IDC_TADMINDETAILUSELOGAFTEREDIT, CONV_CLISTR(lpPktBeforeAfter->m_szAfter));
|
|
|
|
return true;
|
|
}
|
|
|
|
// 상세로그 리스트 Ack
|
|
bool CClientDispatch::PktDetailLogAck( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktDetailLogAck* lpPktDetailLog = static_cast<PktAdminMgr::PktDetailLogAck*>(lpPktBase);
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_TADMINUSELOGDLG));
|
|
|
|
if(NULL == lpDialog)
|
|
return true;
|
|
|
|
CListCtrl* lpListCtrl = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_TADMINDETAILUSELOGLIST));
|
|
|
|
if(NULL == lpListCtrl)
|
|
return true;
|
|
|
|
int ItemCount = lpListCtrl->GetItemCount();
|
|
TCHAR LogID[65], LogType[10];
|
|
|
|
_itot(lpPktDetailLog->m_UpdateType, LogType, 10);
|
|
_itot(lpPktDetailLog->m_DetailLogID, LogID, 10);
|
|
|
|
lpListCtrl->InsertItem(ItemCount, LogID);
|
|
lpListCtrl->SetItemText(ItemCount, 1, CONV_CLISTR(lpPktDetailLog->m_UpdateDate));
|
|
lpListCtrl->SetItemText(ItemCount, 2, LogType);
|
|
|
|
return true;
|
|
}
|
|
|
|
// 지워진 캐릭터리스트 목록
|
|
bool CClientDispatch::PktDelCharListAck( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktDelCharListAck* lpPktAck = static_cast<PktAdminMgr::PktDelCharListAck*>(lpPktBase);
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_CHARRESTOREDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_CR_DELHISTORYLIST));
|
|
|
|
if(NULL != lpList)
|
|
{
|
|
CString strForFormat;
|
|
|
|
strForFormat.Format(_T("%d"), lpPktAck->m_dwUID);
|
|
lpList->InsertItem(0, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpPktAck->m_dwCID);
|
|
lpList->SetItemText(0, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpPktAck->m_cNewServerGroupID);
|
|
lpList->SetItemText(0, 2, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpPktAck->m_cOldServerGroupID);
|
|
lpList->SetItemText(0, 3, strForFormat);
|
|
|
|
lpList->SetItemText(0, 4, CONV_CLISTR(lpPktAck->m_szCharName));
|
|
|
|
strForFormat.Format(_T("%d"), lpPktAck->m_nLevel);
|
|
lpList->SetItemText(0, 5, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktAck->m_dwGold);
|
|
lpList->SetItemText(0, 6, strForFormat);
|
|
|
|
lpList->SetItemText(0, 7, CONV_CLISTR(lpPktAck->m_szInsertTime));
|
|
lpList->SetItemText(0, 8, CONV_CLISTR(lpPktAck->m_szDeleteTime));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 사용사유 Ack
|
|
bool CClientDispatch::PktGetExitLogAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGetExitLogAck* lpPktExitLog = static_cast<PktAdminMgr::PktGetExitLogAck*>(lpPktBase);
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_TADMINUSELOGDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
lpDialog->SetDlgItemText(IDC_TADMINUSELOGREASON,
|
|
CONV_CLISTR(lpPktExitLog->m_szExitLog));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 로그 리스트 Ack
|
|
bool CClientDispatch::PktLogListAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktLogListAck* lpLogListAck = static_cast< PktAdminMgr::PktLogListAck* >( lpPktBase );
|
|
CDialog* CAdminLogDlg = static_cast<CDialog*>(GET_WINDOW(IDD_TADMINUSELOGDLG));
|
|
|
|
if(NULL == CAdminLogDlg)
|
|
return true;
|
|
|
|
CListCtrl* LogList = static_cast<CListCtrl*>(CAdminLogDlg->GetDlgItem(IDC_TADMINUSELOGLIST));
|
|
|
|
int ItemCount = LogList->GetItemCount();
|
|
TCHAR LogID[65];
|
|
|
|
_itot(lpLogListAck->m_LogID, LogID, 10);
|
|
|
|
LogList->InsertItem(ItemCount, LogID);
|
|
LogList->SetItemText(ItemCount, 1, CONV_CLISTR(lpLogListAck->m_Login));
|
|
|
|
if(_tcslen(CONV_CLISTR(lpLogListAck->m_Logout)))
|
|
{
|
|
LogList->SetItemText(ItemCount, 2, CONV_CLISTR(lpLogListAck->m_Logout));
|
|
}
|
|
else
|
|
{
|
|
LogList->SetItemText(ItemCount, 2, _T("Connected..."));
|
|
}
|
|
|
|
LogList->SetItemText(ItemCount, 3, CONV_CLISTR(lpLogListAck->m_UseIP));
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 레벨 변경 ACK
|
|
bool CClientDispatch::PktUpdateLevelAck( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktUpdateLevel* lpPktUpdateLevelAck = static_cast< PktAdminMgr::PktUpdateLevel* >( lpPktBase );
|
|
|
|
CDialog* ManagementDlg = static_cast< CDialog* >( GET_WINDOW( IDD_TADMINMANAGEMENTDLG ) );
|
|
if( ManagementDlg != NULL )
|
|
{
|
|
LVFINDINFO Info;
|
|
int Index;
|
|
CListCtrl* RegAdminz = static_cast< CListCtrl* >( ManagementDlg->GetDlgItem(IDC_TADMINLIST));
|
|
|
|
Info.flags = LVFI_PARTIAL | LVFI_STRING;
|
|
Info.psz = CONV_CLISTR(lpPktUpdateLevelAck->m_szAccount);
|
|
|
|
Index = RegAdminz->FindItem(&Info);
|
|
if(Index != -1)
|
|
{
|
|
RegAdminz->SetItemText(Index, 2,
|
|
GetAdminLVName(lpPktUpdateLevelAck->m_szLevel));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 접속 IP변경 ACK
|
|
bool CClientDispatch::PktUpdateIPAck( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktUpdateIP* lpIPAck = static_cast< PktAdminMgr::PktUpdateIP* >( lpPktBase );
|
|
|
|
CDialog* ManagementDlg = static_cast< CDialog* >( GET_WINDOW( IDD_TADMINMANAGEMENTDLG ) );
|
|
if( ManagementDlg != NULL )
|
|
{
|
|
LVFINDINFO Info;
|
|
int Index;
|
|
CListCtrl* RegAdminz = static_cast< CListCtrl* >( ManagementDlg->GetDlgItem( IDC_TADMINLIST ) );
|
|
|
|
Info.flags = LVFI_PARTIAL | LVFI_STRING;
|
|
Info.psz = CONV_CLISTR(lpIPAck->m_szAccount);
|
|
|
|
Index = RegAdminz->FindItem( &Info );
|
|
if( Index != -1 )
|
|
{
|
|
RegAdminz->SetItemText( Index, 3, CONV_CLISTR(lpIPAck->m_szIP) );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 계정 삭제 ACK
|
|
bool CClientDispatch::PktDelAdminAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktDelAdmin* lpPktDelAdmin =
|
|
static_cast<PktAdminMgr::PktDelAdmin*>(lpPktBase);
|
|
|
|
CDialog* ManagementDlg = static_cast<CDialog*>(GET_WINDOW(IDD_TADMINMANAGEMENTDLG));
|
|
if (ManagementDlg != NULL)
|
|
{
|
|
LVFINDINFO Info;
|
|
int Index;
|
|
CListCtrl* RegAdminz = static_cast<CListCtrl*>(ManagementDlg->GetDlgItem(IDC_TADMINLIST));
|
|
|
|
Info.flags = LVFI_PARTIAL | LVFI_STRING;
|
|
Info.psz = CONV_CLISTR(lpPktDelAdmin->m_szAccount);
|
|
|
|
Index = RegAdminz->FindItem(&Info);
|
|
|
|
if (Index != -1)
|
|
RegAdminz->DeleteItem(Index);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 정보 가져오기 오류 ACK
|
|
void CClientDispatch::ResultErrModifyCharacter(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktResultAck* lpResult = static_cast<PktAdminMgr::PktResultAck*>(lpPktBase);
|
|
|
|
unsigned long* dwRequest = reinterpret_cast<unsigned long*>(lpResult + 1);
|
|
|
|
CCharacterDoc::CharDocInfo* CharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(*dwRequest);
|
|
|
|
if (NULL != CharDocument)
|
|
{
|
|
CharDocument->m_cCharacterState = CCharacterDoc::CharDocInfo::FINISH;
|
|
|
|
CharDocument->ReleaseCharacter();
|
|
CharDocument->m_ModifyDocument->SetTitle(_T("UNLOADED"));
|
|
CharInfoParseFinish(CharDocument);
|
|
|
|
// MDI 자식윈도우들 아이콘 변경... 나중에 추가하자..
|
|
/*POSITION POS = CharDocument->m_ModifyDocument->GetFirstViewPosition();
|
|
CView* lpView = CharDocument->m_ModifyDocument->GetNextView(POS);
|
|
if (NULL != lpView)
|
|
{
|
|
CFrameWnd* lpFrame = lpView->GetParentFrame();
|
|
lpFrame->SetIcon(AfxGetApp()->LoadIcon(IDI_BLOCK), true);
|
|
}*/
|
|
}
|
|
}
|
|
|
|
// 캐릭터 복구 ACK
|
|
bool CClientDispatch::PktCharRestoreAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCharRestoreAck* lpPktAck = static_cast<PktAdminMgr::PktCharRestoreAck*>(lpPktBase);
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_CHARRESTOREDLG));
|
|
|
|
if (NULL == lpDialog)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_CR_DELHISTORYLIST));
|
|
|
|
TCHAR szUID[64], szCID[64], szNewServerGroupID[64], szOldServerGroupID[64];
|
|
|
|
_sntprintf(szUID, sizeof(szUID), _T("%d"), lpPktAck->m_dwUID);
|
|
_sntprintf(szCID, sizeof(szCID), _T("%d"), lpPktAck->m_dwCID);
|
|
_sntprintf(szNewServerGroupID, sizeof(szNewServerGroupID), _T("%d"), lpPktAck->m_cNewServerGroupID);
|
|
_sntprintf(szOldServerGroupID, sizeof(szOldServerGroupID), _T("%d"), lpPktAck->m_cOldServerGroupID);
|
|
|
|
for(int cnt = 0; cnt < lpList->GetItemCount(); cnt ++) // 무식검색
|
|
{
|
|
CString strUID = lpList->GetItemText(cnt, 0);
|
|
CString strCID = lpList->GetItemText(cnt, 1);
|
|
CString strNewServerGroupID = lpList->GetItemText(cnt, 2);
|
|
CString strOldServerGroupID = lpList->GetItemText(cnt, 3);
|
|
|
|
if((!_tcsicmp(strUID, szUID)) && (!_tcsicmp(strCID, szCID))
|
|
&& (!_tcsicmp(strNewServerGroupID, szNewServerGroupID))
|
|
&& (!_tcsicmp(strNewServerGroupID, szNewServerGroupID)))
|
|
{
|
|
lpList->DeleteItem(cnt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 각종 아이템 컨테이너 초기화 ACK
|
|
bool CClientDispatch::PktItemResetAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktItemResetAck* lpPktItemResetAck =
|
|
static_cast<PktAdminMgr::PktItemResetAck*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktItemResetAck->m_dwRequest);
|
|
|
|
if (NULL != lpCharDocument)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
|
|
if (NULL != lpCharacter)
|
|
{
|
|
switch(lpPktItemResetAck->m_cTakePos)
|
|
{
|
|
case TakeType::TS_DEPOSIT:
|
|
{
|
|
Item::CDepositContainer& Deposit = lpCharacter->GetDeposit();
|
|
|
|
for(int iMaxTab = 0; iMaxTab < Deposit.GetMaxTabNum(); ++iMaxTab)
|
|
{
|
|
Deposit.GetTab(iMaxTab)->ClearItems();
|
|
}
|
|
}
|
|
break;
|
|
case TakeType::TS_INVEN:
|
|
lpCharacter->GetInventory().ClearItems();
|
|
break;
|
|
case TakeType::TS_EQUIP:
|
|
lpCharacter->GetEquipments().ClearItems();
|
|
break;
|
|
case TakeType::TS_TEMPINVEN:
|
|
lpCharacter->GetTempInven().ClearItems();
|
|
break;
|
|
case TakeType::TS_EXTRA:
|
|
lpCharacter->GetExtra().ClearItems();
|
|
break;
|
|
}
|
|
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 등록되어있는 운영툴 계정 리스트 Ack
|
|
bool CClientDispatch::PktAdminListAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktAdminListAck* lpPktAdminListAck = static_cast<PktAdminMgr::PktAdminListAck*>(lpPktBase);
|
|
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_TADMINMANAGEMENTDLG));
|
|
if (NULL != lpDialog)
|
|
{
|
|
CListCtrl* ctrlAdminList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_TADMINLIST));
|
|
|
|
ctrlAdminList->InsertItem(0, CONV_CLISTR(lpPktAdminListAck->m_szAccount),
|
|
GetAdminLVIconIndex(lpPktAdminListAck->m_szLevel));
|
|
|
|
ctrlAdminList->SetItemText(0, 1, CONV_CLISTR(lpPktAdminListAck->m_szName));
|
|
ctrlAdminList->SetItemText(0, 2, GetAdminLVName(lpPktAdminListAck->m_szLevel));
|
|
ctrlAdminList->SetItemText(0, 3, CONV_CLISTR(lpPktAdminListAck->m_szIP));
|
|
ctrlAdminList->SetItemText(0, 4, CONV_CLISTR(lpPktAdminListAck->m_szDate));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 블록된 계정 리스트 ACK
|
|
bool CClientDispatch::PktSearchBlockAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktSearchBlockAck* lpBlockedListAck =
|
|
static_cast<PktAdminMgr::PktSearchBlockAck*>(lpPktBase);
|
|
|
|
CDialog* lpBlockManageDlg = static_cast<CDialog*>(GET_WINDOW(IDD_BLOCKEDLISTDLG));
|
|
|
|
if (NULL != lpBlockManageDlg)
|
|
{
|
|
CListCtrl* lpListCtrl = static_cast<CListCtrl*>(lpBlockManageDlg->GetDlgItem(IDC_BLOCKEDLIST));
|
|
|
|
int nInsertRow = lpListCtrl->GetItemCount();
|
|
|
|
CString strFormat;
|
|
|
|
strFormat.Format(_T("%d"), lpBlockedListAck->m_nidx);
|
|
lpListCtrl->InsertItem(0, strFormat);
|
|
|
|
CCharacterDoc::GetInstance().GetServerName((unsigned long)lpBlockedListAck->m_cServerGroup, strFormat);
|
|
lpListCtrl->SetItemText(0, 1, strFormat);
|
|
|
|
strFormat.Format(_T("%u"), lpBlockedListAck->m_dwUID);
|
|
lpListCtrl->SetItemText(0, 2, strFormat);
|
|
|
|
lpListCtrl->SetItemText(0, 3, lpBlockedListAck->m_szClientID);
|
|
|
|
lpListCtrl->SetItemText(0, 4, lpBlockedListAck->m_szCharacterName);
|
|
|
|
strFormat.Format(_T("%d"), lpBlockedListAck->m_cBlockTarget);
|
|
lpListCtrl->SetItemText(0, 5, strFormat);
|
|
|
|
strFormat.Format(_T("%d"), lpBlockedListAck->m_cBlockTerm);
|
|
lpListCtrl->SetItemText(0, 6, strFormat);
|
|
|
|
lpListCtrl->SetItemText(0, 7, lpBlockedListAck->m_szBlockStartTime);
|
|
|
|
lpListCtrl->SetItemText(0, 8, lpBlockedListAck->m_szBlockFinishTime);
|
|
|
|
lpListCtrl->SetItemText(0, 9, lpBlockedListAck->m_szAdminName);
|
|
|
|
lpListCtrl->SetItemText(0, 10, lpBlockedListAck->m_szDescription);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 검색 결과 Ack
|
|
bool CClientDispatch::PktSearchResultAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktSearchResultAck* lpPktResult =
|
|
static_cast<PktAdminMgr::PktSearchResultAck*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocInfo =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktResult->m_dwRequestKey);
|
|
|
|
if(NULL != lpCharDocInfo)
|
|
{
|
|
if(lpPktResult->m_Result == PktAdminMgr::PktSearchResultAck::Success)
|
|
{
|
|
CUserInfoDoc* Doc = static_cast <CUserInfoDoc*>(theApp.NewUserDocument());
|
|
Doc->SetUserInfo(lpCharDocInfo);
|
|
}
|
|
else if(lpPktResult->m_Result == PktAdminMgr::PktSearchResultAck::NoData)
|
|
{
|
|
if (CCharacterDoc::GetInstance().DeleteCharDocInfo(lpPktResult->m_dwRequestKey))
|
|
{
|
|
Report(GetLocalString("MSG_0072"), GENERAL);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 인벤토리 소지금 변경 Ack
|
|
bool CClientDispatch::PktInvenGold(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktInvenGold* lpPktInvenGold = static_cast<PktAdminMgr::PktInvenGold*>(lpPktBase);
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktInvenGold->m_dwRequest);
|
|
|
|
if(NULL != lpCharDocument)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
if(NULL != lpCharacter)
|
|
{
|
|
lpCharacter->SetGold(lpPktInvenGold->m_dwGold);
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 검색 ack
|
|
bool CClientDispatch::PktSearchAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktSearchAck* lpPktSearchAck = static_cast<PktAdminMgr::PktSearchAck*>(lpPktBase);
|
|
|
|
char* In_CharPos = reinterpret_cast<char*>(lpPktSearchAck + 1);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDoc =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktSearchAck->m_dwRequestKey);
|
|
|
|
if(NULL != lpCharDoc)
|
|
{
|
|
CCharacterDoc::In_ServerCharacter lpServChar;
|
|
ZeroMemory(&lpServChar, sizeof(CCharacterDoc::In_ServerCharacter));
|
|
|
|
lpServChar.dwCharCount = lpPktSearchAck->m_CharCount;
|
|
lpServChar.dwServerGroup = lpPktSearchAck->m_dwServerGroup;
|
|
|
|
lpCharDoc->m_cOldServerGroup = lpPktSearchAck->m_cOldServerGroup;
|
|
|
|
for(int CharCount = 0; CharCount < lpPktSearchAck->m_CharCount; CharCount++)
|
|
{
|
|
int nPos = sizeof(CCharacterDoc::In_CharacterIndex) * CharCount;
|
|
CCharacterDoc::In_CharacterIndex* lpChar =
|
|
reinterpret_cast<CCharacterDoc::In_CharacterIndex*>(In_CharPos + nPos);
|
|
|
|
CopyMemory(lpServChar.CharIdx + CharCount, lpChar, sizeof(CCharacterDoc::In_CharacterIndex));
|
|
}
|
|
|
|
lpCharDoc->m_listTreeInfo.push_back(lpServChar);
|
|
}
|
|
else
|
|
{
|
|
// 로그창에 뛰워주던지 암튼 사용자가 알수있도록 하자.
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 정보요청 ACK
|
|
bool CClientDispatch::PktGetCharacterAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGetCharacterAck* lpPktGetCharacterAck =
|
|
static_cast<PktAdminMgr::PktGetCharacterAck*>(lpPktBase);
|
|
|
|
unsigned long dwUID = lpPktGetCharacterAck->m_dwUID;
|
|
unsigned long dwCID = lpPktGetCharacterAck->m_dwCID;
|
|
unsigned long dwRequestKey = lpPktGetCharacterAck->m_dwRequestKey;
|
|
|
|
CCharacterDoc::CharDocInfo* CharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(dwRequestKey);
|
|
|
|
char* In_DataBuffer = reinterpret_cast<char*>(lpPktGetCharacterAck + 1);
|
|
unsigned short uExtraPktLen = lpPktGetCharacterAck->GetLen() - sizeof(PktAdminMgr::PktGetCharacterAck);
|
|
bool bResult = true;
|
|
CModifyCharacter* lpModifyChar = CharDocument->m_ModifyCharacter;
|
|
CString strWindowTitle;
|
|
|
|
if(NULL == CharDocument)
|
|
{
|
|
Report(GetLocalString("MSG_0073"), FAILED);
|
|
return true;
|
|
}
|
|
|
|
switch(lpPktGetCharacterAck->m_cType)
|
|
{
|
|
case PktAdminMgr::PktGetCharacterAck::Type::CHAR_BASIC_DATA:
|
|
{
|
|
lpModifyChar = CharDocument->Createcharacter();
|
|
bResult = Parser.PARSE_CHAR_BASIC_DATA(lpModifyChar, In_DataBuffer);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::CHAR_EXTRA_DATA:
|
|
{
|
|
bResult = Parser.PARSE_CHAR_EXTRA_DATA(lpModifyChar, In_DataBuffer);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::CHAR_FRIEND_DATA:
|
|
{
|
|
bResult = Parser.PARSE_CHAR_FRIEND_DATA(lpModifyChar, In_DataBuffer, uExtraPktLen);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::CHAR_BAN_DATA:
|
|
{
|
|
bResult = Parser.PARSE_CHAR_BAN_DATA(lpModifyChar, In_DataBuffer, uExtraPktLen);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::STORE_12_DATA:
|
|
{
|
|
bResult = Parser.PARSE_STORE_12_DATA(lpModifyChar, In_DataBuffer);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::STORE_34_DATA:
|
|
{
|
|
bResult = Parser.PARSE_STORE_34_DATA(lpModifyChar, In_DataBuffer);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetCharacterAck::Type::FINISH_GET_DATA:
|
|
{
|
|
lpModifyChar->SetUID(lpPktGetCharacterAck->m_dwUID);
|
|
lpModifyChar->SetCID(lpPktGetCharacterAck->m_dwCID);
|
|
lpModifyChar->SetServerGroup(lpPktGetCharacterAck->m_dwServerGroup);
|
|
lpModifyChar->SetOldServerGroup(lpPktGetCharacterAck->m_cOldServerGroupID);
|
|
|
|
strWindowTitle.Format(GetLocalString("FORMAT_001"),
|
|
lpModifyChar->GetUID(), lpModifyChar->GetCID(), lpModifyChar->GetName());
|
|
|
|
CharDocument->m_ModifyDocument->SetTitle(strWindowTitle);
|
|
CharDocument->m_cCharacterState = CCharacterDoc::CharDocInfo::FINISH;
|
|
|
|
CharInfoParseFinish(CharDocument);
|
|
|
|
// 계정 국가까지 얻은 다음에 CharInfoParseFinish!
|
|
CPacketMgr::GetInstance()->SendPktUserNation(
|
|
lpModifyChar->GetClientKey(), lpModifyChar->GetServerGroup(),
|
|
lpModifyChar->GetUID(), lpModifyChar->GetCID());
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(!bResult)
|
|
{
|
|
TCHAR szReport[1024];
|
|
_sntprintf(szReport, sizeof(szReport), GetLocalString("ADDED_STRING_053"), lpPktGetCharacterAck->m_cType);
|
|
CharDocument->ReleaseCharacter();
|
|
CharDocument->m_cCharacterState = CCharacterDoc::CharDocInfo::EMPTY;
|
|
Report(szReport, FAILED);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 창고 동기화 ACK
|
|
bool CClientDispatch::PktSyncDeposit( PktBase* lpPktBase )
|
|
{
|
|
PktAdminMgr::PktSyncDeposit* lpPktSyncDeposit = static_cast< PktAdminMgr::PktSyncDeposit* >( lpPktBase );
|
|
char* lpDepositBuffer = reinterpret_cast< char* >( lpPktSyncDeposit + 1 );
|
|
CCharacterDoc::CharDocInfo* lpCharDocument = CCharacterDoc::GetInstance( ).GetCharDocInfo( lpPktSyncDeposit->m_dwRequestID );
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
|
|
if(NULL != lpCharacter)
|
|
{
|
|
Item::CDepositContainer& SyncContainer = lpCharacter->GetDeposit();
|
|
unsigned long dwCID = lpCharacter->GetCID();
|
|
|
|
switch(lpPktSyncDeposit->m_cType)
|
|
{
|
|
case PktAdminMgr::PktSyncDeposit::Tab12:
|
|
SyncContainer.GetTab(0)->ClearItems();
|
|
SyncContainer.GetTab(1)->ClearItems();
|
|
Parser.PARSE_STORE_12_DATA(lpCharacter, lpDepositBuffer);
|
|
break;
|
|
case PktAdminMgr::PktSyncDeposit::Tab34:
|
|
SyncContainer.GetTab(2)->ClearItems();
|
|
SyncContainer.GetTab(3)->ClearItems();
|
|
Parser.PARSE_STORE_34_DATA(lpCharacter, lpDepositBuffer);
|
|
break;
|
|
}
|
|
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0075"), FAILED);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 정보 파싱 완료
|
|
bool CClientDispatch::CharInfoParseFinish(CCharacterDoc::CharDocInfo *lpCharDocInfo)
|
|
{
|
|
CView* pView;
|
|
POSITION pos = lpCharDocInfo->m_ModifyDocument->GetFirstViewPosition();
|
|
|
|
while (pos != NULL)
|
|
{
|
|
pView = lpCharDocInfo->m_ModifyDocument->GetNextView(pos);
|
|
|
|
if((pView->IsKindOf(RUNTIME_CLASS(CCharSheetView)))) break;
|
|
}
|
|
|
|
CCharSheetView* pSheetView = static_cast<CCharSheetView*>(pView);
|
|
|
|
if (NULL != pSheetView && NULL != lpCharDocInfo->m_ModifyCharacter)
|
|
{
|
|
lpCharDocInfo->m_ModifyCharacter->CalculateStatusData(true);
|
|
pSheetView->SetCharSheetInfo(lpCharDocInfo->m_dwDocKey, lpCharDocInfo->m_ModifyCharacter);
|
|
|
|
lpCharDocInfo->m_bLoaded = true;
|
|
}
|
|
else
|
|
{
|
|
lpCharDocInfo->m_bLoaded = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 세션 닫기 ACK
|
|
bool CClientDispatch::PktCloseCharacterAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCloseCharacterAck* lpPktCloseCharacterAck =
|
|
static_cast<PktAdminMgr::PktCloseCharacterAck*>(lpPktBase);
|
|
|
|
Report(GetLocalString("MSG_0076"), SUCCESS);
|
|
|
|
return true;
|
|
}
|
|
|
|
// 아이템 생성 ACK
|
|
bool CClientDispatch::PktCreateItemAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCreateItemAck* lpPktCreateItem = static_cast<PktAdminMgr::PktCreateItemAck*>(lpPktBase);
|
|
CCharacterDoc::CharDocInfo* CharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktCreateItem->m_dwRequestKey);
|
|
|
|
if( NULL != CharDocument )
|
|
{
|
|
CModifyCharacter* lpModifyCharacter = CharDocument->m_ModifyCharacter;
|
|
|
|
unsigned long dwUID = lpPktCreateItem->m_dwUID;
|
|
unsigned long dwCID = lpPktCreateItem->m_dwCID;
|
|
|
|
if(NULL != lpModifyCharacter)
|
|
{
|
|
if((dwUID == lpModifyCharacter->GetUID()) && (dwCID == lpModifyCharacter->GetCID()))
|
|
{
|
|
Item::CItem* lpItem = Item::CItemFactory::GetInstance().CreateItem(lpPktCreateItem->m_PrototypeID);
|
|
if(NULL != lpItem)
|
|
{
|
|
lpItem->SetNumOrDurability(lpPktCreateItem->m_CreateItemInfo.m_cNumOrDurability);
|
|
Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);
|
|
if( NULL != lpEquipment )
|
|
{
|
|
static_cast<CModifyEquipment*>(lpEquipment)->AdjustData(lpPktCreateItem->m_CreateItemInfo);
|
|
}
|
|
|
|
static_cast< CModifyItem* >( lpItem )->SetUID( lpPktCreateItem->m_ItemID );
|
|
|
|
unsigned char cTakePos = lpPktCreateItem->m_CreateItemInfo.m_cTakePos;
|
|
unsigned char cXPos = lpPktCreateItem->m_CreateItemInfo.m_cXPos;
|
|
unsigned char cYPos = lpPktCreateItem->m_CreateItemInfo.m_cYPos;
|
|
unsigned char cZPos = lpPktCreateItem->m_CreateItemInfo.m_cZPos;
|
|
|
|
Item::ItemPos ItemPos = ItemData::MakeItemPos( cTakePos, cXPos, cYPos, cZPos );
|
|
|
|
lpModifyCharacter->GetInventory().SetAdminTool();
|
|
|
|
if (false == lpModifyCharacter->SetItem(ItemPos, lpItem))
|
|
{
|
|
MessageBox(NULL, _T("Error MountItem"), _T("Err"), MB_OK);
|
|
}
|
|
|
|
CharInfoParseFinish(CharDocument);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 아이템 정보변경 ACK
|
|
bool CClientDispatch::PktUpdateItemAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktUpdateItemAck* lpUpdateAck = static_cast<PktAdminMgr::PktUpdateItemAck*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpUpdateAck->m_dwRequestKey);
|
|
|
|
if(NULL != lpCharDocument)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
|
|
if(NULL != lpCharacter)
|
|
{
|
|
unsigned char cTakePos = lpUpdateAck->m_UpdataItemInfo.m_cTakePos;
|
|
unsigned char cXPos = lpUpdateAck->m_UpdataItemInfo.m_cXPos;
|
|
unsigned char cYPos = lpUpdateAck->m_UpdataItemInfo.m_cYPos;
|
|
unsigned char cZPos = lpUpdateAck->m_UpdataItemInfo.m_cZPos;
|
|
|
|
Item::ItemPos ItemPos = ItemData::MakeItemPos(cTakePos, cXPos, cYPos, cZPos);
|
|
Item::CItem* lpItem = lpCharacter->GetItem(ItemPos);
|
|
|
|
if(NULL != lpItem)
|
|
{
|
|
lpItem->SetNumOrDurability(lpUpdateAck->m_UpdataItemInfo.m_cNumOrDurability);
|
|
|
|
Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);
|
|
if(NULL != lpEquipment)
|
|
{
|
|
static_cast<CModifyEquipment*>(lpEquipment)->AdjustData(lpUpdateAck->m_UpdataItemInfo);
|
|
}
|
|
}
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 아이템 삭제 ACK
|
|
bool CClientDispatch::PktRemoveItemAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktRemoveItemAck* lpRemoveItem = static_cast<PktAdminMgr::PktRemoveItemAck*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpRemoveItem->m_dwRequestKey);
|
|
|
|
if(NULL != lpCharDocument)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
|
|
if(NULL != lpCharacter)
|
|
{
|
|
unsigned char cTaskPos = lpRemoveItem->m_cTakePos;
|
|
unsigned char cXPos = lpRemoveItem->m_cXPos;
|
|
unsigned char cYPos = lpRemoveItem->m_cYPos;
|
|
unsigned char cZPos = lpRemoveItem->m_cZPos;
|
|
unsigned __int64 ItemUID = lpRemoveItem->m_ItemUID;
|
|
unsigned short PrototypeID = lpRemoveItem->m_ItemPrototypeID;
|
|
|
|
Item::ItemPos ItemPos = ItemData::MakeItemPos(cTaskPos, cXPos, cYPos, cZPos);
|
|
Item::CItem* lpItem = lpCharacter->GetItem(ItemPos);
|
|
|
|
if(NULL != lpItem)
|
|
{
|
|
if((lpItem->GetUID() == ItemUID) && (lpItem->GetPrototypeID() == PrototypeID))
|
|
{
|
|
lpCharacter->GetInventory().SetAdminTool();
|
|
|
|
if (true == lpCharacter->RemoveItem(ItemPos))
|
|
{
|
|
DELETE_ITEM(lpItem);
|
|
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0077"), FAILED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0078"), FAILED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0079"), FAILED);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 스킬 변경 ACK
|
|
bool CClientDispatch::PktSkillEditAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktSkillEdit* lpPktSkillEditAck = static_cast<PktAdminMgr::PktSkillEdit*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktSkillEditAck->m_dwRequest);
|
|
|
|
if(NULL != lpCharDocument)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDocument->m_ModifyCharacter;
|
|
|
|
if(NULL != lpCharacter)
|
|
{
|
|
unsigned char cResult = PktAdminMgr::PktSkillEdit::FAILED;
|
|
|
|
unsigned short wSkillID = lpPktSkillEditAck->m_wSkillID;
|
|
char cLevel = lpPktSkillEditAck->m_SkillLevel;
|
|
char cLockCount = lpPktSkillEditAck->m_SkillLockCount;
|
|
|
|
switch(lpPktSkillEditAck->m_cType)
|
|
{
|
|
case PktAdminMgr::PktSkillEdit::Create:
|
|
cResult = lpCharacter->AppendSkill(wSkillID, cLevel, cLockCount);
|
|
break;
|
|
case PktAdminMgr::PktSkillEdit::Edit:
|
|
cResult = lpCharacter->AppendSkill(wSkillID, cLevel, cLockCount);
|
|
break;
|
|
case PktAdminMgr::PktSkillEdit::Delete:
|
|
cResult = lpCharacter->DeleteSkill(wSkillID, cLevel, cLockCount);
|
|
break;
|
|
}
|
|
|
|
if(cResult = PktAdminMgr::PktSkillEdit::SUCCESS)
|
|
{
|
|
CharInfoParseFinish(lpCharDocument);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0080"), FAILED);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktCancelExecuteQuest(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCancelExecuteQuest* lpPktCancelExecuteQuest =
|
|
static_cast<PktAdminMgr::PktCancelExecuteQuest*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDoc =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktCancelExecuteQuest->m_dwRequestKey);
|
|
|
|
if (NULL != lpCharDoc)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDoc->m_ModifyCharacter;
|
|
|
|
if (true == lpCharacter->CancelQuest(lpPktCancelExecuteQuest->m_wQuestID, true))
|
|
{
|
|
CharInfoParseFinish(lpCharDoc);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0185"), FAILED);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktDeleteHistoryQuest(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktDeleteHistoryQuest* lpPktDeleteHistoryQuest =
|
|
static_cast<PktAdminMgr::PktDeleteHistoryQuest*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDoc =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktDeleteHistoryQuest->m_dwRequestKey);
|
|
|
|
if (NULL != lpCharDoc)
|
|
{
|
|
CModifyCharacter* lpCharacter = lpCharDoc->m_ModifyCharacter;
|
|
|
|
if (true == lpCharacter->DeleteHistoryQuest(lpPktDeleteHistoryQuest->m_wQuestID))
|
|
{
|
|
CharInfoParseFinish(lpCharDoc);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0185"), FAILED);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktUserNation(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktUserNation* lpPktUserNation =
|
|
static_cast<PktAdminMgr::PktUserNation*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDoc =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktUserNation->m_dwRequestKey);
|
|
|
|
if (NULL != lpCharDoc)
|
|
{
|
|
lpCharDoc->m_ModifyCharacter->SetUserNation(lpPktUserNation->m_cNation);
|
|
|
|
CharInfoParseFinish(lpCharDoc);
|
|
|
|
Report(GetLocalString("MSG_0074"), SUCCESS);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 캐릭터 이름변경 ACK
|
|
bool CClientDispatch::PktChangeNameAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktChangeName* lpPktChangeName = static_cast<PktAdminMgr::PktChangeName*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDocument =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktChangeName->m_dwRequest);
|
|
|
|
if(NULL != lpCharDocument)
|
|
{
|
|
CCharacterDoc::In_CharacterIndex* lpCharIdx =
|
|
lpCharDocument->GetSrvChar(lpPktChangeName->m_dwServerGroup, lpPktChangeName->m_dwCID);
|
|
|
|
if(NULL != lpCharIdx)
|
|
{
|
|
CUserCharTreeView* lpTreeView;
|
|
|
|
POSITION Pos = lpCharDocument->m_ModifyDocument->GetFirstViewPosition();
|
|
lpTreeView = static_cast<CUserCharTreeView*>(lpCharDocument->m_ModifyDocument->GetNextView(Pos));
|
|
|
|
CTreeCtrl* lpTree = static_cast<CTreeCtrl*>(lpTreeView->GetDlgItem(IDC_CHARTREE));
|
|
HTREEITEM hItem = lpTree->GetSelectedItem();
|
|
|
|
if(NULL != hItem)
|
|
{
|
|
TCHAR szCharNode[255];
|
|
_sntprintf(szCharNode, sizeof(szCharNode), _T("%d %s"),
|
|
lpPktChangeName->m_dwCID, GetLocalString("MSG_0171"));
|
|
|
|
lpTree->SetItemText(hItem, szCharNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_MODIFYCHARNAMEDLG));
|
|
if(NULL != lpDialog)
|
|
{
|
|
lpDialog->EndDialog(true);
|
|
}
|
|
|
|
CString strKey;
|
|
switch(lpPktChangeName->m_dwUID) // 원래 UID인데 그냥 에러 타입 받는걸로 사용;
|
|
{
|
|
case PktCharNameChange::ERR_ALREADY_USE_NAME: strKey = _T("MSG_0172"); break;
|
|
case PktCharNameChange::ERR_CANNOT_FIND_CHARACTER: strKey = _T("MSG_0173"); break;
|
|
case PktCharNameChange::ERR_CANNOT_USE_NAME: strKey = _T("MSG_0174"); break;
|
|
case PktCharNameChange::ERR_INVALID_NAME: strKey = _T("MSG_0175"); break;
|
|
case PktCharNameChange::ERR_NAMECHANGE_ITEM: strKey = _T("MSG_0176"); break;
|
|
case PktCharNameChange::ERR_SERVER: strKey = _T("MSG_0177"); break;
|
|
default: strKey = _T("MSG_0178"); break;
|
|
}
|
|
Report(GetLocalString(strKey), FAILED);
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자 창고아이템 삭제 ACK
|
|
bool CClientDispatch::PktAdminStoreDeleteAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktAdminStoreDelete* lpPktAck = static_cast<PktAdminMgr::PktAdminStoreDelete*>(lpPktBase);
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_STATUS_DLGBAR));
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_ADMINSTORELIST));
|
|
|
|
if(NULL != lpList)
|
|
{
|
|
int ItemCount = lpList->GetItemCount();
|
|
|
|
TCHAR szStoreUID[100];
|
|
_sntprintf(szStoreUID, sizeof(szStoreUID), _T("%d"), lpPktAck->m_dwStoreUID);
|
|
|
|
for(int cnt = 0;cnt < ItemCount; cnt++)
|
|
{
|
|
CString strStoreUID = lpList->GetItemText(cnt, 0);
|
|
|
|
if(!_tcsicmp(strStoreUID, szStoreUID))
|
|
{
|
|
lpList->DeleteItem(cnt);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 관리자창고 아이템정보 가져오기 ACK
|
|
bool CClientDispatch::PktGetAdminStoreItemAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGetAdminStoreItemAck* lpPktAck =
|
|
static_cast<PktAdminMgr::PktGetAdminStoreItemAck*>(lpPktBase);
|
|
|
|
switch(lpPktAck->m_cType)
|
|
{
|
|
case PktAdminMgr::PktGetAdminStoreItem::EDIT:
|
|
{
|
|
AdminStoreItemModify(lpPktAck);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGetAdminStoreItem::CREATE:
|
|
{
|
|
AdminStoreGrabMode(lpPktAck);
|
|
}
|
|
break;
|
|
default:
|
|
Report(GetLocalString("MSG_0083"), FAILED);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// 운영창고의 아이템을 집기
|
|
void CClientDispatch::AdminStoreGrabMode(PktAdminMgr::PktGetAdminStoreItemAck* lpPktAck)
|
|
{
|
|
CItemManageDlg dlg(CItemManageDlg::CREATE_ADMINSTORE);
|
|
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_STATUS_DLGBAR));
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_ADMINSTORELIST));
|
|
|
|
if(NULL != lpList)
|
|
{
|
|
int ItemSelect = lpList->GetNextItem(-1, LVIS_SELECTED);
|
|
if(-1 != ItemSelect)
|
|
{
|
|
dlg.m_strNewItemName = lpList->GetItemText(ItemSelect, 3);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0084"), FAILED);
|
|
return;
|
|
}
|
|
}
|
|
|
|
g_stMyItemInfo.m_stItemInfo.AdminStore_In(lpPktAck->m_binItemInfo);
|
|
g_stMyItemInfo.m_nModeIndex = MyItemInfo::NONE;
|
|
g_stMyItemInfo.m_dwStoreUID = lpPktAck->m_dwStoreUID;
|
|
|
|
dlg.DoModal();
|
|
}
|
|
|
|
// 관리자 아이템창고 정보 수정
|
|
void CClientDispatch::AdminStoreItemModify(PktAdminMgr::PktGetAdminStoreItemAck* lpPktAck)
|
|
{
|
|
CItemManageDlg dlg(CItemManageDlg::EDIT_ADMINSTORE);
|
|
|
|
CDialog* lpDialog = static_cast<CDialog*>(GET_WINDOW(IDD_STATUS_DLGBAR));
|
|
CListCtrl* lpList = static_cast<CListCtrl*>(lpDialog->GetDlgItem(IDC_ADMINSTORELIST));
|
|
|
|
if(NULL != lpList)
|
|
{
|
|
int ItemSelect = lpList->GetNextItem(-1, LVIS_SELECTED);
|
|
if(-1 < ItemSelect)
|
|
{
|
|
dlg.m_strNewItemName = lpList->GetItemText(ItemSelect, 3);
|
|
}
|
|
else
|
|
{
|
|
Report(GetLocalString("MSG_0084"), FAILED);
|
|
return;
|
|
}
|
|
}
|
|
|
|
g_stMyItemInfo.m_stItemInfo.AdminStore_In(lpPktAck->m_binItemInfo);
|
|
g_stMyItemInfo.m_nModeIndex = MyItemInfo::EDIT_ADMINSTORE;
|
|
g_stMyItemInfo.m_dwStoreUID = lpPktAck->m_dwStoreUID;
|
|
|
|
dlg.DoModal();
|
|
}
|
|
|
|
bool CClientDispatch::PktGuildSearchAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGuildSearchAck* lpGuildSearchAck =
|
|
reinterpret_cast<PktAdminMgr::PktGuildSearchAck*>(lpPktBase);
|
|
|
|
CGuildSearchDlg* lpDialog = static_cast<CGuildSearchDlg*>(GET_WINDOW(IDD_GUILDSEARCH_DLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildSearchAck->m_dwGID);
|
|
lpDialog->m_ctrlGuildSearchList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpGuildSearchAck->m_nOldServerID);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 1, strForFormating);
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpGuildSearchAck->m_dwServerGroup, strForFormating);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetNationString((int)lpGuildSearchAck->m_dwNation));
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 3, strForFormating);
|
|
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 4, CONV_CLISTR(lpGuildSearchAck->m_szName));
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildSearchAck->m_dwFame);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 5, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildSearchAck->m_dwLevel);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 6, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildSearchAck->m_dwMemberNum);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 7, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildSearchAck->m_dwGold);
|
|
lpDialog->m_ctrlGuildSearchList.SetItemText(0, 8, strForFormating);
|
|
|
|
lpDialog->m_dwSearchCount = lpDialog->m_ctrlGuildSearchList.GetItemCount();
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktRequestGuildMemberListAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktRequestGuildMemberListAck* lpGuildMemberList =
|
|
reinterpret_cast<PktAdminMgr::PktRequestGuildMemberListAck*>(lpPktBase);
|
|
|
|
CGuildMainDlg* lpDialog = static_cast<CGuildMainDlg*>(GET_WINDOW(IDD_GUILDMAINDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildMemberList->m_dwCID);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpGuildMemberList->m_nPosition);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpGuildMemberList->m_nPositionInGuild);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpGuildMemberList->m_szCharName);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 3, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpGuildMemberList->m_nLevel);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 4, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildMemberList->m_dwFame);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 5, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpGuildMemberList->m_dwGold);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 6, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetClassString(lpGuildMemberList->m_nClass));
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 7, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpGuildMemberList->m_szLeaveGuildTime);
|
|
lpDialog->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(0, 8, strForFormating);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktGuildRestoreDataListAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGuildRestoreDataListAck* lpPktGuildRestoreDataListAck =
|
|
reinterpret_cast<PktAdminMgr::PktGuildRestoreDataListAck*>(lpPktBase);
|
|
|
|
CGuildRestoreDlg* lpDialog = static_cast<CGuildRestoreDlg*>(GET_WINDOW(IDD_GUILDRESTOREDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpPktGuildRestoreDataListAck->m_dwServerGroup, strForFormating);
|
|
lpDialog->m_ctrlRestoreGuildList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpPktGuildRestoreDataListAck->m_dwGID);
|
|
lpDialog->m_ctrlRestoreGuildList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpPktGuildRestoreDataListAck->m_szGuildName);
|
|
lpDialog->m_ctrlRestoreGuildList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpPktGuildRestoreDataListAck->m_dwGold);
|
|
lpDialog->m_ctrlRestoreGuildList.SetItemText(0, 3, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpPktGuildRestoreDataListAck->m_szDeleteDate);
|
|
lpDialog->m_ctrlRestoreGuildList.SetItemText(0, 4, strForFormating);
|
|
|
|
lpDialog->m_dwSearchCount = lpDialog->m_ctrlRestoreGuildList.GetItemCount();
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktFortSearchAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktFortSearchAck* lpFortSearchAck =
|
|
reinterpret_cast<PktAdminMgr::PktFortSearchAck*>(lpPktBase);
|
|
|
|
CFortInfoDlg* lpDialog = static_cast<CFortInfoDlg*>(GET_WINDOW(IDD_FORTINFODLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpFortSearchAck->m_dwServerGroup, strForFormating);
|
|
lpDialog->m_ctrlSearchedList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpFortSearchAck->m_dwCampID);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpFortSearchAck->m_dwGuildID);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 2, strForFormating);
|
|
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 3, CONV_CLISTR(lpFortSearchAck->m_szGuildName));
|
|
|
|
strForFormating.Format(_T("%u"), lpFortSearchAck->m_dwHP);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 4, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetZoneString(lpFortSearchAck->m_cZone));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 5, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpFortSearchAck->m_cChannel);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 6, strForFormating);
|
|
|
|
strForFormating = GetSiegeObjectTypeString((int)lpFortSearchAck->m_usObjectType);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 7, strForFormating);
|
|
|
|
strForFormating = GetStateString((int)lpFortSearchAck->m_cState);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 8, strForFormating);
|
|
|
|
strForFormating = GetSubStateString((int)lpFortSearchAck->m_usObjectType, (int)lpFortSearchAck->m_cSubState);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 9, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpFortSearchAck->m_cUpgradeStep);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 10, strForFormating);
|
|
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 11, CONV_CLISTR(lpFortSearchAck->m_szRemainTime));
|
|
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 12, CONV_CLISTR(lpFortSearchAck->m_szLastUseTime));
|
|
|
|
strForFormating.Format(_T("%s"), GetGuildTitleString(lpFortSearchAck->m_cRight));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 13, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpFortSearchAck->m_fPosX);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 14, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpFortSearchAck->m_fPosY);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 15, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpFortSearchAck->m_fPosZ);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 16, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpFortSearchAck->m_cMaterial);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 17, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpFortSearchAck->m_cSiegeCount);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 18, strForFormating);
|
|
|
|
lpDialog->m_dwSearchCount = lpDialog->m_ctrlSearchedList.GetItemCount();
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktMiningCampAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktMiningCampAck* lpMiningCampAck =
|
|
reinterpret_cast<PktAdminMgr::PktMiningCampAck*>(lpPktBase);
|
|
|
|
CString strForFormating;
|
|
CMiningCampDlg* lpDialog = static_cast<CMiningCampDlg*>(GET_WINDOW(IDD_MININGCAMPDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
strForFormating.Format(_T("%u"), lpMiningCampAck->m_dwCampID);
|
|
lpDialog->m_ctrlMiningCampList.InsertItem(0, strForFormating);
|
|
|
|
const Item::ItemInfo* ItemInfo = Item::CItemMgr::GetInstance().GetItemInfo(lpMiningCampAck->m_sMineralID);
|
|
strForFormating.Format(_T("%s"), CONV_CLISTR(ItemInfo->m_SpriteData.m_szName));
|
|
lpDialog->m_ctrlMiningCampList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpMiningCampAck->m_sAmount);
|
|
lpDialog->m_ctrlMiningCampList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), lpMiningCampAck->m_cFlag);
|
|
lpDialog->m_ctrlMiningCampList.SetItemText(0, 3, strForFormating);
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool CClientDispatch::PktShopCampAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktShopCampAck* lpShopCampAck =
|
|
reinterpret_cast<PktAdminMgr::PktShopCampAck*>(lpPktBase);
|
|
|
|
CString strForFormating;
|
|
CShopCampPage* lpDialog = static_cast<CShopCampPage*>(GET_WINDOW(IDD_SHOPCAMPPAGE));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
lpDialog->SetShopCampItem(lpShopCampAck);
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktCastleSearchAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCastleSearchAck* lpCastleSearchAck =
|
|
reinterpret_cast<PktAdminMgr::PktCastleSearchAck*>(lpPktBase);
|
|
|
|
CCastleSearchDlg* lpDialog = static_cast<CCastleSearchDlg*>(GET_WINDOW(IDD_CASTLESEARCHDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpCastleSearchAck->m_dwServerGroup, strForFormating);
|
|
lpDialog->m_ctrlSearchedList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_dwCastleID);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetNationString(lpCastleSearchAck->m_cNation));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d : %s"), lpCastleSearchAck->m_cZone, GetZoneString(lpCastleSearchAck->m_cZone));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 3, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_cChannel);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 4, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_cName);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 5, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_cSiegeCount);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 6, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_cInvincibleCount);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 7, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_wTotalSiegeCount);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 8, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_dwTotalTaxMoney);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 9, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetGuildTitleString(lpCastleSearchAck->m_cRight));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 10, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosInX);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 11, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosInY);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 12, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosInZ);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 13, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosOutX);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 14, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosOutY);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 15, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleSearchAck->m_fPosOutZ);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 16, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetJewelString(lpCastleSearchAck->m_wItemID));
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 17, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleSearchAck->m_cItemNum);
|
|
lpDialog->m_ctrlSearchedList.SetItemText(0, 18, strForFormating);
|
|
|
|
lpDialog->m_dwSearchCount = lpDialog->m_ctrlSearchedList.GetItemCount();
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktCastleCreatureAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktCastleCreatureAck* lpCastleCreatureAck =
|
|
reinterpret_cast<PktAdminMgr::PktCastleCreatureAck*>(lpPktBase);
|
|
|
|
CCastleCreatureDlg* lpDialog = static_cast<CCastleCreatureDlg*>(GET_WINDOW(IDD_CASTLECREATUREDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_dwCastleID);
|
|
lpDialog->m_ctrlCastleCreatureList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_dwCastleID);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_dwOwnerID);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 2, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_dwHP);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 3, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetSiegeObjectTypeString((int) lpCastleCreatureAck->m_wObjectType));
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 4, strForFormating);
|
|
|
|
strForFormating.Format(_T("%d"), (int) ( lpCastleCreatureAck->m_fDirection * RADIAN));
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 5, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetStateString((int) lpCastleCreatureAck->m_cState));
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 6, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), GetSubStateString((int) lpCastleCreatureAck->m_wObjectType , (int) lpCastleCreatureAck->m_cSubState));
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 7, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_cUpgradeStep);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 8, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpCastleCreatureAck->m_cUpgradeType);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 9, strForFormating);
|
|
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 10, CONV_CLISTR(lpCastleCreatureAck->m_szRemainTime));
|
|
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 11, CONV_CLISTR(lpCastleCreatureAck->m_szLastUseTime));
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleCreatureAck->m_fPosX);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 12, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleCreatureAck->m_fPosY);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 13, strForFormating);
|
|
|
|
strForFormating.Format(_T("%f"), lpCastleCreatureAck->m_fPosZ);
|
|
lpDialog->m_ctrlCastleCreatureList.SetItemText(0, 14, strForFormating);
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CClientDispatch::PktItemQtyControlAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktItemQtyControl* lpPktItemQtyControl =
|
|
reinterpret_cast<PktAdminMgr::PktItemQtyControl*>(lpPktBase);
|
|
|
|
CItemQuantityControlDlg* lpDialog =
|
|
static_cast<CItemQuantityControlDlg*>(GET_WINDOW(IDD_ITEMQUANTITYCONTROLDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
unsigned long dwServerGroup = 0;
|
|
|
|
CString strGroupName;
|
|
CString strForFormat;
|
|
|
|
lpDialog->m_ctrlServerGroupCb.GetLBText(lpDialog->m_ctrlServerGroupCb.GetCurSel(), strGroupName);
|
|
CCharacterDoc::GetInstance().GetServerIndex(strGroupName, dwServerGroup);
|
|
|
|
// 현재 열려있는 그룹의 상태 갱신
|
|
if(dwServerGroup == (unsigned long)lpPktItemQtyControl->m_cServerGroup)
|
|
{
|
|
const Item::ItemInfo* ItemInfo =
|
|
Item::CItemMgr::GetInstance().GetItemInfo((unsigned short)lpPktItemQtyControl->m_dwItemTypeID);
|
|
|
|
if(lpPktItemQtyControl->m_cType == PktAdminMgr::PktItemQtyControl::ADD)
|
|
{
|
|
strForFormat.Format(_T("%u"), lpPktItemQtyControl->m_dwItemTypeID);
|
|
if(-1 != SearchListCtrlCol(lpDialog->m_ctrlDropItemList, strForFormat, 0)) // 아이템 수정 Ack
|
|
{
|
|
lpDialog->m_strMessage.Format(_T("%s"), GetLocalString("MSG_0085"));
|
|
if(lpPktItemQtyControl->GetError() == 0)
|
|
{
|
|
int nIndex = lpDialog->m_ctrlDropItemList.GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
PktAdminMgr::PktItemQtyControl* lpItemData =
|
|
reinterpret_cast<PktAdminMgr::PktItemQtyControl*>
|
|
(lpDialog->m_ctrlDropItemList.GetItemData(nIndex));
|
|
|
|
*lpItemData = *lpPktItemQtyControl;
|
|
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0086"));
|
|
}
|
|
else
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0087"));
|
|
}
|
|
else // 아이템 추가 Ack
|
|
{
|
|
lpDialog->m_strMessage.Format(_T("%s"), GetLocalString("MSG_0088"));
|
|
if(lpPktItemQtyControl->GetError() == 0)
|
|
{
|
|
int nIndex = lpDialog->m_ctrlDropItemList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%u"), lpPktItemQtyControl->m_dwItemTypeID);
|
|
lpDialog->m_ctrlDropItemList.InsertItem(nIndex, strForFormat);
|
|
lpDialog->m_ctrlDropItemList.SetItemText(nIndex, 1,
|
|
CONV_CLISTR(ItemInfo->m_SpriteData.m_szName));
|
|
|
|
PktAdminMgr::PktItemQtyControl* lpItemData = new PktAdminMgr::PktItemQtyControl;
|
|
|
|
*lpItemData = *lpPktItemQtyControl;
|
|
|
|
lpDialog->m_ctrlDropItemList.SetItemData(
|
|
nIndex, reinterpret_cast<DWORD_PTR>(lpItemData));
|
|
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0086"));
|
|
}
|
|
else
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0087"));
|
|
}
|
|
|
|
lpDialog->m_strCurrentDropItemCount.Format(_T("%d"), lpDialog->m_ctrlDropItemList.GetItemCount());
|
|
}
|
|
else if(lpPktItemQtyControl->m_cType == PktAdminMgr::PktItemQtyControl::DEL)
|
|
{
|
|
lpDialog->m_strMessage.Format(_T("%s"), GetLocalString("MSG_0089"));
|
|
if(lpPktItemQtyControl->GetError() == 0)
|
|
{
|
|
int nIndex = lpDialog->m_ctrlDropItemList.GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
PktAdminMgr::PktItemQtyControl* lpItemData =
|
|
reinterpret_cast<PktAdminMgr::PktItemQtyControl*>
|
|
(lpDialog->m_ctrlDropItemList.GetItemData(nIndex));
|
|
|
|
delete lpItemData;
|
|
|
|
lpDialog->m_ctrlDropItemList.DeleteItem(nIndex);
|
|
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0086"));
|
|
}
|
|
else
|
|
lpDialog->m_strMessage.AppendFormat(_T(" %s"), GetLocalString("MSG_0087"));
|
|
|
|
lpDialog->m_strCurrentDropItemCount.Format(_T("%d"), lpDialog->m_ctrlDropItemList.GetItemCount());
|
|
}
|
|
else if(lpPktItemQtyControl->m_cType == PktAdminMgr::PktItemQtyControl::STATUS_ACK)
|
|
{
|
|
if(0 != lpDialog->m_ctrlDropItemList.GetItemCount())
|
|
{
|
|
strForFormat.Format(_T("%u"), lpPktItemQtyControl->m_dwItemTypeID);
|
|
|
|
int nSearchIndex = SearchListCtrlCol(lpDialog->m_ctrlDropItemList, strForFormat, 0);
|
|
if(-1 != nSearchIndex)
|
|
{
|
|
PktAdminMgr::PktItemQtyControl* lpItemData =
|
|
reinterpret_cast<PktAdminMgr::PktItemQtyControl*>
|
|
(lpDialog->m_ctrlDropItemList.GetItemData(nSearchIndex));
|
|
|
|
*lpItemData = *lpPktItemQtyControl;
|
|
}
|
|
else
|
|
{
|
|
int nIndex = lpDialog->m_ctrlDropItemList.GetItemCount();
|
|
|
|
CString strForFormat;
|
|
strForFormat.Format(_T("%u"), lpPktItemQtyControl->m_dwItemTypeID);
|
|
lpDialog->m_ctrlDropItemList.InsertItem(nIndex, strForFormat);
|
|
lpDialog->m_ctrlDropItemList.SetItemText(nIndex, 1,
|
|
CONV_CLISTR(ItemInfo->m_SpriteData.m_szName));
|
|
|
|
PktAdminMgr::PktItemQtyControl* lpItemData = new PktAdminMgr::PktItemQtyControl;
|
|
|
|
*lpItemData = *lpPktItemQtyControl;
|
|
|
|
lpDialog->m_ctrlDropItemList.SetItemData(
|
|
nIndex, reinterpret_cast<DWORD_PTR>(lpItemData));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int nIndex = lpDialog->m_ctrlDropItemList.GetItemCount();
|
|
|
|
CString strForFormat;
|
|
strForFormat.Format(_T("%u"), lpPktItemQtyControl->m_dwItemTypeID);
|
|
lpDialog->m_ctrlDropItemList.InsertItem(nIndex, strForFormat);
|
|
lpDialog->m_ctrlDropItemList.SetItemText(nIndex, 1,
|
|
CONV_CLISTR(ItemInfo->m_SpriteData.m_szName));
|
|
|
|
PktAdminMgr::PktItemQtyControl* lpItemData = new PktAdminMgr::PktItemQtyControl;
|
|
|
|
*lpItemData = *lpPktItemQtyControl;
|
|
|
|
lpDialog->m_ctrlDropItemList.SetItemData(
|
|
nIndex, reinterpret_cast<DWORD_PTR>(lpItemData));
|
|
}
|
|
lpDialog->m_strCurrentDropItemCount.Format(_T("%d"), lpDialog->m_ctrlDropItemList.GetItemCount());
|
|
}
|
|
else if(lpPktItemQtyControl->m_cType == PktAdminMgr::PktItemQtyControl::STATUS_ACK_END)
|
|
{
|
|
lpDialog->m_strCurrentDropItemCount.Format(_T("%d"), lpDialog->m_ctrlDropItemList.GetItemCount());
|
|
lpDialog->m_strMessage.Format(_T("%s"), GetLocalString("MSG_0090"));
|
|
}
|
|
else
|
|
lpDialog->m_strMessage.Format(_T("%s"), GetLocalString("MSG_0091"));
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktUserBillingLogAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktUserBillingLogAck* lpPktUserBillingLogAck =
|
|
reinterpret_cast<PktAdminMgr::PktUserBillingLogAck*>(lpPktBase);
|
|
|
|
CUserBillingLogDlg* lpDialog = static_cast<CUserBillingLogDlg*>(GET_WINDOW(IDD_USERBILLINGLOGDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
CString strForFormating;
|
|
|
|
strForFormating.Format(_T("%s"), lpPktUserBillingLogAck->m_szClientID);
|
|
lpDialog->m_ctrlUserBillingLogList.InsertItem(0, strForFormating);
|
|
|
|
strForFormating.Format(_T("%u"), lpPktUserBillingLogAck->m_dwUID);
|
|
lpDialog->m_ctrlUserBillingLogList.SetItemText(0, 1, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpPktUserBillingLogAck->m_szIP);
|
|
lpDialog->m_ctrlUserBillingLogList.SetItemText(0, 2, strForFormating);
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpPktUserBillingLogAck->m_sServerIndex, strForFormating);
|
|
lpDialog->m_ctrlUserBillingLogList.SetItemText(0, 3, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpPktUserBillingLogAck->m_szFirstLoginTime);
|
|
lpDialog->m_ctrlUserBillingLogList.SetItemText(0, 4, strForFormating);
|
|
|
|
strForFormating.Format(_T("%s"), lpPktUserBillingLogAck->m_szLogoutTime);
|
|
lpDialog->m_ctrlUserBillingLogList.SetItemText(0, 5, strForFormating);
|
|
|
|
lpDialog->m_dwSearchCount = lpDialog->m_ctrlUserBillingLogList.GetItemCount();
|
|
|
|
lpDialog->UpdateData(false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktGameAdminAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGameAdmin* lpPktGameAdmin =
|
|
reinterpret_cast<PktAdminMgr::PktGameAdmin*>(lpPktBase);
|
|
|
|
CGAdminManagementDlg* lpDialog = static_cast<CGAdminManagementDlg*>(GET_WINDOW(IDD_GADMINMANAGEMENTDLG));
|
|
|
|
if(NULL != lpDialog)
|
|
{
|
|
if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::ACK)
|
|
{
|
|
CString strForFormat;
|
|
int nInsertIndex = lpDialog->m_ctrlGAdminList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%u"), lpPktGameAdmin->m_dwUID);
|
|
lpDialog->m_ctrlGAdminList.InsertItem(nInsertIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktGameAdmin->m_nAdminLV);
|
|
lpDialog->m_ctrlGAdminList.SetItemText(nInsertIndex, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktGameAdmin->m_szStartIP);
|
|
lpDialog->m_ctrlGAdminList.SetItemText(nInsertIndex, 2, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktGameAdmin->m_szEndIP);
|
|
lpDialog->m_ctrlGAdminList.SetItemText(nInsertIndex, 3, strForFormat);
|
|
}
|
|
else if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::REFRESH)
|
|
{
|
|
lpDialog->ReFreshGameAdminList();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktConnectAllServerzAck(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktConnectAllServerz* lpPktConnectAllServerz =
|
|
reinterpret_cast<PktAdminMgr::PktConnectAllServerz*>(lpPktBase);
|
|
|
|
CQuickMenuDlgBar* lpDlgBar = static_cast<CQuickMenuDlgBar*>(GET_WINDOW(IDD_QUICKMENUDLGBAR));
|
|
|
|
if(NULL != lpDlgBar)
|
|
{
|
|
lpDlgBar->m_ctrlConnectedServerList.ResetContent();
|
|
lpDlgBar->m_ctrlCharSearchCombo2.ResetContent();
|
|
|
|
CString strServerGroupName;
|
|
for(int nIndex = 0; nIndex < PktAdminMgr::PktConnectAllServerz::SERVERZ_NUM; ++nIndex)
|
|
{
|
|
// 배열에 들어있는 값은 접속되어 있는 서버 인덱스 + 1 (주의!)
|
|
if(0 != lpPktConnectAllServerz->m_nConnectedServerIndex[nIndex])
|
|
{
|
|
CCharacterDoc::GetInstance().GetServerName(
|
|
lpPktConnectAllServerz->m_nConnectedServerIndex[nIndex] - 1, strServerGroupName);
|
|
|
|
// 중계서버 리스트 갱신
|
|
lpDlgBar->m_ctrlConnectedServerList.InsertString(0, strServerGroupName);
|
|
|
|
// 검색 콤보 갱신
|
|
lpDlgBar->m_ctrlCharSearchCombo2.InsertString(0, strServerGroupName);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktInterestedUserList(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktInterestedUser* lpPktInterestedUser =
|
|
reinterpret_cast<PktAdminMgr::PktInterestedUser*>(lpPktBase);
|
|
|
|
CInterestedUserDlg* lpDlg = static_cast<CInterestedUserDlg*>(GET_WINDOW(IDD_INTERESTEDUSERDLG));
|
|
|
|
if (NULL != lpDlg)
|
|
{
|
|
CString strForFormat;
|
|
int nInsertIndex = lpDlg->m_ctrlInterestUserList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%s"), lpPktInterestedUser->m_szAccount);
|
|
lpDlg->m_ctrlInterestUserList.InsertItem(nInsertIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktInterestedUser->m_szReason);
|
|
lpDlg->m_ctrlInterestUserList.SetItemText(nInsertIndex, 1, strForFormat);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktConnectionChk(PktBase* lpPktBase)
|
|
{
|
|
CConnectionInfoDlg dlg(reinterpret_cast<PktAdminMgr::PktConnectionChk*>(lpPktBase));
|
|
dlg.DoModal();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktConnectedUserList(PktBase* lpPktBase)
|
|
{
|
|
CQuickMenuDlgBar* lpDlgBar = static_cast<CQuickMenuDlgBar*>(GET_WINDOW(IDD_QUICKMENUDLGBAR));
|
|
|
|
if (NULL != lpDlgBar)
|
|
{
|
|
lpDlgBar->InterestedUserListSet(lpPktBase);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktDuplicatedItem(PktBase* lpPktBase)
|
|
{
|
|
CDuplicatedItemDlg* lpDlg = static_cast<CDuplicatedItemDlg*>(GET_WINDOW(IDD_DUPLICATEDITEMDLG));
|
|
|
|
PktAdminMgr::PktDuplicatedItem* lpData =
|
|
reinterpret_cast<PktAdminMgr::PktDuplicatedItem*>(lpPktBase);
|
|
|
|
if(NULL != lpDlg)
|
|
{
|
|
CString strForFormat;
|
|
|
|
CCharacterDoc::GetInstance().GetServerName(lpData->m_dwServerGroup, strForFormat);
|
|
lpDlg->SetDlgItemText(IDC_DUPLICATEDITEM_SELGROUP_EDIT, strForFormat);
|
|
|
|
int nInsertIndex = lpDlg->m_ctrlDItemList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%s"), lpData->m_szInsertTime);
|
|
lpDlg->m_ctrlDItemList.InsertItem(nInsertIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpData->m_szUpdateTime);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpData->m_dwUID);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 2, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpData->m_dwCID);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 3, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpData->m_szCharName);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 4, strForFormat);
|
|
|
|
strForFormat.Format(_T("0x%016I64X"), lpData->m_dwItemUID);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 5, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpData->m_nQty);
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 6, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), (lpData->m_bChk == true) ? _T("DO") : _T("DO NOT"));
|
|
lpDlg->m_ctrlDItemList.SetItemText(nInsertIndex, 7, strForFormat);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktItemDistributeAck(PktBase* lpPktBase)
|
|
{
|
|
CItemDistributeDlg* lpDlg = static_cast<CItemDistributeDlg*>(GET_WINDOW(IDD_ITEMDISTRIBUTEDLG));
|
|
|
|
if(NULL != lpDlg)
|
|
{
|
|
lpDlg->ReportResult(reinterpret_cast<PktAdminMgr::PktItemDistributeAck*>(lpPktBase));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktGuildRight(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGuildRight* lpPktGuildRight =
|
|
reinterpret_cast<PktAdminMgr::PktGuildRight*>(lpPktBase);
|
|
|
|
CGuildMainDlg* lpDlg = static_cast<CGuildMainDlg*>(GET_WINDOW(IDD_GUILDMAINDLG));
|
|
|
|
if(NULL != lpDlg)
|
|
{
|
|
for(int nRightIndex = 0; nRightIndex < GuildRight::MAX_USING_RIGHT; ++nRightIndex)
|
|
{
|
|
CString strForFormat;
|
|
|
|
strForFormat.Format(_T("%s"), GetGuildRightString(nRightIndex));
|
|
lpDlg->m_ctrlGuildRightList.InsertItem(nRightIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), GetGuildTitleString(lpPktGuildRight->m_aryRight[nRightIndex]));
|
|
lpDlg->m_ctrlGuildRightList.SetItemText(nRightIndex, 1, strForFormat);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktUnifiedCharInfo(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktUnifiedCharInfo* lpPktUnifiedCharInfo =
|
|
reinterpret_cast<PktAdminMgr::PktUnifiedCharInfo*>(lpPktBase);
|
|
|
|
CUnifiedCharInfoDlg* lpDialog = static_cast<CUnifiedCharInfoDlg*>(GET_WINDOW(IDD_UNIFIEDCHARINFODLG));
|
|
|
|
if (NULL == lpDialog)
|
|
{
|
|
ERRLOG1(g_Log, "통합 캐릭터 정보 창 얻기 실패. 리소스ID-%d", IDD_UNIFIEDCHARINFODLG);
|
|
return true;
|
|
}
|
|
|
|
CString strForFormat;
|
|
int nInsertIndex = lpDialog->m_ctrlUnifiedCharList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%u"), lpPktUnifiedCharInfo->m_dwUID);
|
|
lpDialog->m_ctrlUnifiedCharList.InsertItem(nInsertIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpPktUnifiedCharInfo->m_nOldServerGroup);
|
|
lpDialog->m_ctrlUnifiedCharList.SetItemText(nInsertIndex, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktUnifiedCharInfo->m_dwBeforeCID);
|
|
lpDialog->m_ctrlUnifiedCharList.SetItemText(nInsertIndex, 2, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktUnifiedCharInfo->m_dwNewCID);
|
|
lpDialog->m_ctrlUnifiedCharList.SetItemText(nInsertIndex, 3, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktUnifiedCharInfo->m_szBeforeCharName);
|
|
lpDialog->m_ctrlUnifiedCharList.SetItemText(nInsertIndex, 4, strForFormat);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktUnifiedGuildInfo(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktUnifiedGuildInfo* lpPktUnifiedGuildInfo =
|
|
reinterpret_cast<PktAdminMgr::PktUnifiedGuildInfo*>(lpPktBase);
|
|
|
|
CUnifiedGuildInfoDlg* lpDialog = static_cast<CUnifiedGuildInfoDlg*>(GET_WINDOW(IDD_UNIFIEDGUILDINFODLG));
|
|
|
|
if (NULL == lpDialog)
|
|
{
|
|
ERRLOG1(g_Log, "통합 길드 정보 창 얻기 실패. 리소스ID-%d", IDD_UNIFIEDGUILDINFODLG);
|
|
return true;
|
|
}
|
|
|
|
CString strForFormat;
|
|
int nInsertIndex = lpDialog->m_ctrlUnifiedGuildList.GetItemCount();
|
|
|
|
strForFormat.Format(_T("%u"), lpPktUnifiedGuildInfo->m_dwBeforeGID);
|
|
lpDialog->m_ctrlUnifiedGuildList.InsertItem(nInsertIndex, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), lpPktUnifiedGuildInfo->m_nOldServerGroupID);
|
|
lpDialog->m_ctrlUnifiedGuildList.SetItemText(nInsertIndex, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktUnifiedGuildInfo->m_dwNewGID);
|
|
lpDialog->m_ctrlUnifiedGuildList.SetItemText(nInsertIndex, 2, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktUnifiedGuildInfo->m_szBeforeGName);
|
|
lpDialog->m_ctrlUnifiedGuildList.SetItemText(nInsertIndex, 3, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), lpPktUnifiedGuildInfo->m_szNewGName);
|
|
lpDialog->m_ctrlUnifiedGuildList.SetItemText(nInsertIndex, 4, strForFormat);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktDetailCharInfo(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktDetailCharInfo* lpPktDetailCharInfo =
|
|
reinterpret_cast<PktAdminMgr::PktDetailCharInfo*>(lpPktBase);
|
|
|
|
CDetailCharInfo* lpDlg = static_cast<CDetailCharInfo*>(GET_WINDOW(IDD_DETAILCHARINFO));
|
|
|
|
if (NULL == lpDlg)
|
|
{
|
|
ERRLOG1(g_Log, "통합 캐릭터 상세 정보 창 얻기 실패. 리소스ID-%d", IDD_DETAILCHARINFO);
|
|
return true;
|
|
}
|
|
|
|
CString strForFormat;
|
|
strForFormat.Format(_T("%s"), lpPktDetailCharInfo->m_szCharName);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(0, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%s"), GetClassString((int)lpPktDetailCharInfo->m_sClass));
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(1, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktDetailCharInfo->m_dwFame);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(2, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktDetailCharInfo->m_dwMileage);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(3, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%d"), (unsigned int)lpPktDetailCharInfo->m_cLevel);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(4, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%u"), lpPktDetailCharInfo->m_dwGold);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(5, 1, strForFormat);
|
|
|
|
strForFormat.Format(_T("%I64u"), lpPktDetailCharInfo->m_i64Exp);
|
|
lpDlg->m_ctrlDetailCharInfoList.SetItemText(6, 1, strForFormat);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktShiftToUID(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktShiftToUID* lpPktShiftToUID =
|
|
reinterpret_cast<PktAdminMgr::PktShiftToUID*>(lpPktBase);
|
|
|
|
CQuickMenuDlgBar* lpDlgBar = static_cast<CQuickMenuDlgBar*>(GET_WINDOW(IDD_QUICKMENUDLGBAR));
|
|
|
|
if(NULL != lpDlgBar)
|
|
{
|
|
if (PktAdminMgr::PktShiftToUID::ACCOUNT_TO_UID == lpPktShiftToUID->m_cPktType)
|
|
{
|
|
lpDlgBar->SetDlgItemInt(IDC_Q_UID_EDIT, lpPktShiftToUID->m_dwUID, FALSE);
|
|
}
|
|
else if (PktAdminMgr::PktShiftToUID::UID_TO_ACCOUNT == lpPktShiftToUID->m_cPktType)
|
|
{
|
|
lpDlgBar->SetDlgItemText(IDC_Q_ACCOUNT_EDIT, lpPktShiftToUID->m_szAccount);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktStoreTabEdit(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktStoreTabEdit* lpPktStoreTabEdit =
|
|
reinterpret_cast<PktAdminMgr::PktStoreTabEdit*>(lpPktBase);
|
|
|
|
CCharacterDoc::CharDocInfo* lpCharDoc =
|
|
CCharacterDoc::GetInstance().GetCharDocInfo(lpPktStoreTabEdit->m_dwRequestKey);
|
|
|
|
if (NULL != lpCharDoc)
|
|
{
|
|
// Ack받을때는 m_dwServerGroup에다 셋팅했던 탭 플래그를 받아옴.
|
|
lpCharDoc->m_ModifyCharacter->GetDeposit().SetTabFlag(lpPktStoreTabEdit->m_dwServerGroup);
|
|
|
|
CharInfoParseFinish(lpCharDoc);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktAmountOfGold(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktAmountOfGold* lpPktAmountOfGold =
|
|
reinterpret_cast<PktAdminMgr::PktAmountOfGold*>(lpPktBase);
|
|
|
|
CAdminStoreDlgBar* lpDlg = static_cast<CAdminStoreDlgBar*>(GET_WINDOW(IDD_BOTTOM_DLGBAR));
|
|
|
|
lpDlg->SetGoldEditBox(lpPktAmountOfGold->m_i64Gold);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktGMLogMsg(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGMLogMsg* lpPktGMLogMsg =
|
|
reinterpret_cast<PktAdminMgr::PktGMLogMsg*>(lpPktBase);
|
|
|
|
if (PktAdminMgr::PktGMLogMsg::LOG_CONFIRM == lpPktGMLogMsg->m_cPktType)
|
|
{
|
|
CString strMsg;
|
|
if (0 == lpPktGMLogMsg->m_dwCID)
|
|
{
|
|
strMsg.Format("%s (UID: %u)", GetLocalString("ADDED_STRING_043"), lpPktGMLogMsg->m_dwUID);
|
|
Report(strMsg, NOTIFY);
|
|
}
|
|
else
|
|
{
|
|
strMsg.Format("%s (CID: %u)", GetLocalString("ADDED_STRING_044"), lpPktGMLogMsg->m_dwCID);
|
|
Report(strMsg, NOTIFY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CGMLogMsgDlg* lpDlg = static_cast<CGMLogMsgDlg*>(GET_WINDOW(IDD_GMLOGMSGDLG));
|
|
|
|
if (NULL == lpDlg)
|
|
{
|
|
ERRLOG0(g_Log, "GM 로그 창 얻기 실패. ID - IDD_GMLOGMSGDLG");
|
|
return true;
|
|
}
|
|
|
|
switch(lpPktGMLogMsg->m_cPktType)
|
|
{
|
|
case PktAdminMgr::PktGMLogMsg::LOG_SELECT:
|
|
{
|
|
lpDlg->InsertGMLogMsgList(lpPktGMLogMsg);
|
|
}
|
|
break;
|
|
case PktAdminMgr::PktGMLogMsg::LOG_REFRESH:
|
|
{
|
|
lpDlg->SetDlgItemText(IDC_GMLOG_ADDLOG_EDIT, "");
|
|
lpDlg->m_ctrlGMLogMsgList.DeleteAllItems();
|
|
|
|
CPacketMgr::GetInstance()->SendPktGMLogMsg(PktAdminMgr::PktGMLogMsg::LOG_SELECT,
|
|
lpPktGMLogMsg->m_dwServerGroup, lpPktGMLogMsg->m_dwUID, lpPktGMLogMsg->m_dwCID);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientDispatch::PktGuildMemberEdit(PktBase* lpPktBase)
|
|
{
|
|
PktAdminMgr::PktGuildMemberEdit* lpPktGuildMemberEdit =
|
|
reinterpret_cast<PktAdminMgr::PktGuildMemberEdit*>(lpPktBase);
|
|
|
|
CGuildMainDlg* lpDlg = static_cast<CGuildMainDlg*>(GET_WINDOW(IDD_GUILDMAINDLG));
|
|
|
|
if (NULL != lpDlg)
|
|
{
|
|
switch(lpPktGuildMemberEdit->GetError())
|
|
{
|
|
case PktBase::NO_SERVER_ERR:
|
|
{
|
|
CString strCID;
|
|
strCID.Format("%u", lpPktGuildMemberEdit->m_dwCID);
|
|
|
|
int nIndex = SearchListCtrlCol(lpDlg->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList, strCID, 0);
|
|
|
|
if (PktGuildPosition::TYPE_POSITION == lpPktGuildMemberEdit->m_cType)
|
|
{
|
|
CString strPosition;
|
|
strPosition.Format("%d", lpPktGuildMemberEdit->m_cPosition);
|
|
lpDlg->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.SetItemText(nIndex, 1, strPosition);
|
|
|
|
Report(GetLocalString("ADDED_STRING_095"), SUCCESS);
|
|
}
|
|
else if(PktGuildPosition::TYPE_MEMBERDELETE == lpPktGuildMemberEdit->m_cType)
|
|
{
|
|
lpDlg->m_pGuildInfoSheet->m_wndMemberPage.m_ctrlMemberList.DeleteItem(nIndex);
|
|
|
|
Report(GetLocalString("ADDED_STRING_094"), SUCCESS);
|
|
}
|
|
}
|
|
break;
|
|
case PktGuildPosition::FAIL_CONNECT_CHAR:
|
|
Report(GetLocalString("ADDED_STRING_087"), FAILED); break;
|
|
case PktGuildPosition::FAIL_DB_UPDATE:
|
|
Report(GetLocalString("ADDED_STRING_088"), FAILED); break;
|
|
case PktGuildPosition::FAIL_GUILD:
|
|
Report(GetLocalString("ADDED_STRING_089"), FAILED); break;
|
|
case PktGuildPosition::FAIL_MEMBER_DELETE:
|
|
Report(GetLocalString("ADDED_STRING_090"), FAILED); break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
CString CClientDispatch::GetBlockString(unsigned int nIndex)
|
|
{
|
|
switch(nIndex)
|
|
{
|
|
case 1: return _T("Account Block");
|
|
case 2: return _T("Character Block");
|
|
case 3: return _T("Character Detain");
|
|
case 4: return _T("Ban Chating");
|
|
case 5: return _T("Info Modify");
|
|
}
|
|
|
|
return _T("UNKNOWN");
|
|
}
|
|
|
|
CString CClientDispatch::GetGuildTitleString(unsigned int nIndex)
|
|
{
|
|
switch(nIndex)
|
|
{
|
|
case Guild::NONE: return _T("NONE");
|
|
case Guild::MASTER: return GetLocalString("GUILD_TITLE_01");
|
|
case Guild::MIDDLE_ADMIN: return GetLocalString("GUILD_TITLE_02");
|
|
case Guild::COMMON: return GetLocalString("GUILD_TITLE_03");
|
|
case Guild::LEAVE_WAIT: return GetLocalString("GUILD_TITLE_04");
|
|
case Guild::JOIN_WAIT: return GetLocalString("GUILD_TITLE_05");
|
|
}
|
|
|
|
return _T("UNKNOWN");
|
|
}
|
|
|
|
CString CClientDispatch::GetGuildRightString(unsigned int nIndex)
|
|
{
|
|
switch(nIndex)
|
|
{
|
|
case GuildRight::PUT_STOREHOUSE: return GetLocalString("GUILD_RIGHT_01");
|
|
case GuildRight::GET_STOREHOUSE: return GetLocalString("GUILD_RIGHT_02");
|
|
case GuildRight::USE_SAFE: return GetLocalString("GUILD_RIGHT_03");
|
|
case GuildRight::INVITE_MEMBER: return GetLocalString("GUILD_RIGHT_04");
|
|
case GuildRight::PERMIT_JOIN: return GetLocalString("GUILD_RIGHT_05");
|
|
case GuildRight::CHANGE_PASSWORD: return GetLocalString("GUILD_RIGHT_06");
|
|
//case GuildRight::SETUP_RELATION: return GetLocalString("GUILD_RIGHT_07");
|
|
case GuildRight::REGULATE_TEX: return GetLocalString("GUILD_RIGHT_08");
|
|
case GuildRight::KICK_MEMBER: return GetLocalString("GUILD_RIGHT_09");
|
|
case GuildRight::BOARD_ADMIN: return GetLocalString("GUILD_RIGHT_10");
|
|
case GuildRight::SETUP_MARK_N_LEVEL: return GetLocalString("GUILD_RIGHT_11");
|
|
case GuildRight::SETUP_MIDDLE: return GetLocalString("GUILD_RIGHT_12");
|
|
case GuildRight::DIVIDE_GOLD: return GetLocalString("GUILD_RIGHT_13");
|
|
case GuildRight::SETUP_POLICY: return GetLocalString("GUILD_RIGHT_14");
|
|
}
|
|
|
|
return _T("UNKNOWN");
|
|
}
|
|
|
|
bool CClientDispatch::PktResultCharInfoTime(PktBase* lpPktAck)
|
|
{
|
|
typedef PktAdminMgr::PktCharInfoTimeResultAck PktCharInfoTimeResultAck;
|
|
|
|
PktCharInfoTimeResultAck* lpPktResultAck =
|
|
reinterpret_cast<PktCharInfoTimeResultAck*>(lpPktAck);
|
|
|
|
CCharInfoTime* lpDlg = static_cast<CCharInfoTime*>(GET_WINDOW(IDD_CHARINFOTIMEDLG));
|
|
|
|
if (NULL != lpDlg)
|
|
{
|
|
switch(lpPktResultAck->GetError())
|
|
{
|
|
case PktBase::NO_SERVER_ERR:
|
|
lpDlg->m_szCreateTime.Format("%s", lpPktResultAck->m_CreateTime);
|
|
lpDlg->m_szUpdateTime.Format("%s", lpPktResultAck->m_UpdateTime);
|
|
|
|
lpDlg->UpdateData(FALSE);
|
|
Report(GetLocalString("ADDED_STRING_107"), SUCCESS);
|
|
break;
|
|
case PktBase::SERVER_ERROR:
|
|
Report(GetLocalString("ADDED_STRING_109"), CAUTION);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|