RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure repository to include all source folders

Browse Source 
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>
This commit is contained in:
tindevil
2025-11-29 20:17:20 +09:00
parent 5d3cd64a25
commit dd97ddec92
11602 changed files with 1446576 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4903
GameTools/GLOBALSCRIPT/Network/ClientSocket/ClientSocket.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

367
GameTools/GLOBALSCRIPT/Network/ClientSocket/ClientSocket.h Normal file
View File

@@ -0,0 +1,367 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket Class
//
// Last Update : 2003-01-10
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _ClientSocket
#define _ClientSocket
#include "NetBase.h"
#include "UDPList/UDPList.h" // Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>Ʈ
#include <Network/Packet/PacketStruct/FriendPacket.h>
#include <Network/Packet/PacketStruct/CharItemPacket.h>
#include <Network/Packet/PacketStruct/CharStatusPacket.h>
#include <Network/Packet/PacketStruct/CharAttackPacket.h>
#include <Network/Packet/PacketStruct/CharCommunityPacket.h>
#include <DB/DBDefine.h>
const unsigned long WM_CLIENT_SOCKET = RegisterWindowMessage("WM_CLIENT_SOCKET");
const unsigned long WM_UDP_SOCKET = RegisterWindowMessage("WM_UDP_SOCKET");
//////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
class ClientSocket : public NetBase
{
public:
enum CO_SRV { CO_GAME = 0, CO_AUTH = 1 };
enum ListType { ListType_Client = 1, ListType_Party = 2 };
enum ListOper { ListOper_Update = 1, ListOper_Insert = 2 };
enum BindPos { Bind_SavePos = 1 };
enum Hand { Hand_Weapon1 = 1, Hand_Weapon2 = 2 };
enum FameInfoType { FameInfoType_Fame = 1, FameInfoType_Merits = 2 };
enum Require { Require_HPInfo = 0, Require_UDPInfo = 1, Require_Shape = 2 };
enum ChatType
{
ChatType_Normal = 0, ChatType_Party = 1, ChatType_Friend = 2,
ChatType_Guild = 3, ChatType_Notify = 4, ChatType_ClientLog = 5,
ChatType_Stall = 6
};
enum CellOper
{
CellOper_Move = 0, CellOper_Login = 1,
CellOper_Logout = 1, CellOper_Respawn = 2
};
enum ItemPos
{
ItemPos_None = 0, ItemPos_Equip = 1, ItemPos_Inven = 2,
ItemPos_QSlot = 3, ItemPos_SSlot = 4, ItemPos_Temp = 6,
ItemPos_Upgrade = 7, ItemPos_Exchange = 8, ItemPos_Deposit = 9,
ItemPos_Stall = 10
};
enum PartyCmd
{
PartyCmd_Invite = 0, PartyCmd_Accept = 1, PartyCmd_Refuse = 2,
PartyCmd_Banish = 3, PartyCmd_Secession = 4, PartyCmd_Transfer = 5,
PartyCmd_Destroy = 6, PartyCmd_Login = 7, PartyCmd_Logout = 8,
PartyCmd_Delete = 9, PartyCmd_ReLogin = 10, PartyCmd_FindParty = 11,
PartyCmd_FindMember = 12
};
enum StateType
{
StateType_STR = 1, StateType_DEX = 2, StateType_CON = 3,
StateType_INT = 4, StateType_WIS = 5
};
enum Judge
{
Judge_Front = 0, Judge_Side = 1, Judge_Back = 2,
Judge_Guard = 3, Judge_Critical = 4, Judge_Heal = 5,
Judge_ManaHeal = 6, Judge_Chant = 7, Judge_Enchant = 8,
Judge_Disenchant = 9, Judge_Evade = 10, Judge_Resist = 11,
Judge_ManaShell = 12, Judge_Poisoned = 13
};
enum ExchangeCmd
{
ExchangeCmd_Propose = 0, ExchangeCmd_Accept = 1, ExchangeCmd_Refuse = 2,
ExchangeCmd_OK = 3, ExchangeCmd_Cancel = 4, ExchangeCmd_Exchange = 5,
ExchangeCmd_Quit = 6, ExchangeCmd_Lock = 7, ExchangeCmd_UnLock = 8
};
enum DuelCmd
{
DuelCmd_Propose = 0, DuelCmd_Ready = 1, DuelCmd_Refuse = 2,
DuelCmd_Logout = 3, DuelCmd_Dead = 4, DuelCmd_PartyPropose = 5,
DuelCmd_PartyReady = 6, DuelCmd_RequestPartyInfo = 7, DuelCmd_Cancel = 8
};
enum SpellType
{
SpellType_None = 0,
// Chant
SpellType_BattleSong = 1,
SpellType_MaintenanceChant = 2,
SpellType_AccelerationChant = 3,
SpellType_LifeAura = 4,
// Enchant
SpellType_Stealth = 17, SpellType_ManaShell = 18,
SpellType_Encourage = 19, SpellType_EnchantWeapon = 20,
SpellType_BrightArmor = 21, SpellType_HardenSkin = 22,
SpellType_Flexibility = 23, SpellType_Guard = 24,
SpellType_Hold = 25, SpellType_Stun = 26,
SpellType_Frozen = 27, SpellType_Poisoned = 28,
SpellType_LowerStrength = 29,
// Other
SpellType_Invincible = 30
};
enum StallCmd
{
StallCmd_Register = 0, StallCmd_ChangePrice = 1, StallCmd_Cancel = 2
};
enum AdminCmd
{
MoveZoneChar = 1, MoveZoneParty = 2, MoveChar = 3, MoveParty = 4,
RespawnChar = 5, RespawnParty = 6, KillChar = 7, KillParty = 8,
DuelInit = 9, CreateItem = 10, CreateMon = 11, InfoChar = 12
};
private:
HWND m_hMainWnd;
IN_ADDR m_RegAddress;
void* m_RegPointer;
SOCKADDR_IN m_PubUDPAddress;
SOCKADDR_IN m_PriUDPAddress;
SOCKADDR_IN m_UDPAgentAddress;
DWORD m_UpdateCount;
int m_ConnectServer;
public:
SOCKADDR_IN m_GSSUDPAddress;
UDPList* m_ClientList;
UDPList* m_PartyList;
UDPList* m_InstanceClientList;
///////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket <20>⺻ Ŭ<><C5AC><EFBFBD><EFBFBD> <20>޼ҵ<DEBC>
//
///////////////////////////////////////////////////////////////////////////////////////////////
public:
ClientSocket(HWND hWnd_In);
virtual ~ClientSocket(void);
inline IN_ADDR GetRegAddress(void) { return m_RegAddress; }
inline char* GetRegString(void) { return inet_ntoa(m_RegAddress); }
inline bool IsEmptyRegAddress(void) { return (0 == m_RegAddress.S_un.S_addr) ? true : false; }
inline void CrearRegAddress(void) { memset(&m_RegAddress, 0, sizeof(SOCKADDR_IN)); }
inline SOCKADDR_IN GetPubAddress(void) { return m_PubUDPAddress; }
inline SOCKADDR_IN GetPriAddress(void) { return m_PriUDPAddress; }
inline SOCKADDR_IN GetUDPAddress(void) { return m_UDPAgentAddress; }
inline int GetConnectServer() { return m_ConnectServer; }
DWORD InsertIntoAddressList(unsigned short List_In, DWORD CharID_In, SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In);
bool DeleteFromAddressList(unsigned short List_In, DWORD CharID_In);
bool DeleteFromAddressList(unsigned short List_In, SOCKADDR_IN Address_In);
bool IsExistToList(unsigned short List_In, DWORD CharID_In);
DWORD GetListCount(unsigned short List_In);
bool RegistInstanceUDPList(DWORD CharID_In);
void DeleteInstanceUDPList();
bool IsRealIP(void);
PEERTYPE GetPeerType(SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In);
bool UDPSendList(WSABUF &SendBuf_In, UDPList* lpList_In);
bool UDPSendList(WSABUF &SendBuf_In, UDPList* lpList_In, DWORD CharID_In);
bool UDPRecv(void);
bool ConnectToAuthServer(char *Address_In);
bool ConnectToGameServer(char *Address_In);
bool Disconnect(void);
bool SendSysPing(void);
bool CharMoveZone(char Zone_In, POS& NewPos_In);
DWORD HandleCharMoveZone(char *pBuffer_In, unsigned char *Zone_Out, unsigned short *lpChannelNum_Out);
bool ServerZone(char Zone_In, char Channel_In);
DWORD HandleServerZone(char *pBuffer_In, DWORD *ServerID_Out);
bool UserLogin(DWORD SessionID_In, DWORD UserID_In, DWORD ServerID_In, DWORD ClientVer_In);
bool CharSelect(DWORD UserID_In, DWORD CharID_In);
bool CharCreate(DWORD UserID_In, DWORD SlotNum_In, CHAR_CREATE &Create_In);
bool CharDelete(DWORD UserID_In, DWORD CharID_In, DWORD SlotNum_In);
DWORD HandleUserLogin(char *pBuffer_In, DWORD *UserID_Out, LPCHAR_VIEW CharRecode_Out);
DWORD HandleCharSelect(char *pBuffer_In, unsigned char *Zone_Out, unsigned short *lpChannelNum_Out);
DWORD HandleCharCreate(char *pBuffer_In, DWORD *CharID_Out, DWORD *SlotNum_Out, LPCHAR_VIEW lpCharView_Out);
DWORD HandleCharDelete(char *pBuffer_In, DWORD *UserID_Out, DWORD *SlotNum_Out);
bool CharLogin(DWORD UserID_In, DWORD CharID_In, DWORD SessionID_In);
bool CharLogout(DWORD CharID_In);
bool CharUpdateAddress(DWORD CharID_In);
bool CharAddressInfo(DWORD CharID_In, DWORD TargetID_In);
bool CharRequireInfo(DWORD SenderID_In, DWORD TargetID_In, unsigned char Cmd_In);
bool CharMove(DWORD CharID_In, LPPOS Pos_In, float Dir_In, unsigned short UAct_In, unsigned short LAct_In, char Level_In, DWORD ChantEf_In, DWORD EnchantEf_In);
bool CharMoveUpdate(DWORD CharID_In, bool SitMode_In, LPPOS Pos_In, float Dir_In);
bool CharChat(DWORD CharID_In, unsigned short Cmd_In, char* Message_In, int MessageSize_In);
bool CharWhisper(char* SenderName_In, char *RecverName_In, char* Message_In, int MessageSize_In);
bool CharAttack(DWORD CharID_In, LPPOS lpPos_In, float Dir_In, AtType &AtType_In, AtNode &AtNode_In);
bool CharAttackInfo(DWORD CharID_In, AtType &AtType_In, unsigned char DefenserNum_In, LPDefenserNode lpNode_In);
bool CharRespawn(DWORD CharID_In, unsigned char cCmd_In, POS& Pos_In);
bool CharShapeInfo(LPCHAR_VIEW lpCharView_In, unsigned char cSelectedHands_In, unsigned long dwStatusFlag_In, char *StallName_In);
bool CharShapeInfo(DWORD CharID_In, LPCHAR_VIEW lpCharView_In, unsigned char cSelectedHands_In, unsigned long dwStatusFlag_In, char *StallName_In);
bool CharPickUp(DWORD CharID_In, DWORD ObjectID_In, Item::ItemPos Index_In);
bool CharPullDown(DWORD CharID_In, Item::ItemPos Index_In, unsigned char cNum);
bool CharTakeItem(DWORD CharID_In, TakeType TakeType_In);
bool CharSwapItem(DWORD CharID_In, TakeType SrcType_In, TakeType DstType_In);
bool CharTradeItem(DWORD CharID_In, DWORD NPCID_In, unsigned short ItemID_In, TakeType TakeType_In);
bool CharRepairItem(DWORD NPCID_In, Item::ItemPos* lpIndex_In, DWORD Gold_In);
bool CharUseItem(DWORD SenderID_In, DWORD Recver_In, Item::ItemPos* lpIndex_In);
bool CharCastObject(DWORD SenderID_In, DWORD RecverID_In, CastObject &CastObject_In);
bool CharCastObjectInfo(DWORD SenderID_In, DWORD RecverID_In, CastObject &CastObject_In);
bool CharInstallSocket(DWORD CharID_In, Item::ItemPos* lpEquipIndex_In, Item::ItemPos* lpSocket_In);
bool CharSuicide(DWORD CharID_In);
bool CharBindPos(DWORD NPCID_In, unsigned char Cmd_In, LPPOS lpPos_In, char Zone_In);
bool CharIncreasePoint(DWORD CharID_In, unsigned char StateType_In);
bool CharClassUpgrade(DWORD CharID_In, unsigned char ClassID_In);
bool CharSkillLock(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In);
bool CharSkillUnLock(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In, Item::ItemPos* lpIndex_In);
bool CharSkillCreate(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In);
bool CharSkillErase(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In);
bool CharPartyCmd(DWORD SenderID_In, DWORD ReferenceID_In, DWORD PartyID_In, unsigned short Cmd_In);
bool CharPartyMemInfo(DWORD CharID_In, DWORD PartyID_In, unsigned char Class_In, char Level_In, unsigned short MaxHP_In, short CurHP_In, unsigned short MaxMP_In, short CurMP_In, DWORD Chant_In, DWORD Enchant_In);
bool CharPartyFind(DWORD CharID_In);
bool CharUpgradeItem(DWORD CharID_In, unsigned char MineralNum_In);
bool CharLevelUpInfo(DWORD CharID_In, unsigned char Level_In);
bool CharSplitItem(DWORD CharID_In, TakeType &TakeType_In);
bool CharQuickSlotMove(TakeType &TakeType_In);
bool CharSwitchHand(unsigned char SelectHand_In);
bool CharTakeItems(DWORD CharID_In, unsigned char TakeNum_In, LPTakeType lpTakeTypes_In);
bool CharTakeGold(DWORD CharID_In, unsigned char SrcPos_In, unsigned char DstPos_In, DWORD Gold_In);
bool CharExchangeCmd(DWORD SenderID_In, DWORD RecverID_In, unsigned char Cmd_In);
bool CharPartyData(DWORD CharID_In, unsigned short Cmd_In, unsigned short Len_In, void *Data_In);
bool CharControlOption(DWORD CharID_In, RejectOption &Reject_In);
bool CharDuelCmd(DWORD SenderID_In, DWORD RecverID_In, unsigned char Cmd_In);
bool CharFameInfo(DWORD CharID_In, unsigned char Cmd_In);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
bool CharStallOpen(DWORD CharID_In, char* StallName_In);
bool CharStallRegisterItem(DWORD CharID_In, TakeType TakeType_In, unsigned long Price_In, unsigned char Cmd_In);
bool CharStallEnter(DWORD CustomerID_In, DWORD Owner_In);
// ģ<><C4A3> <20><><EFBFBD><EFBFBD>
bool CharFriendAddRequest(char* szName_In, PktFriendAddReq::CMD addType);
bool CharFriendRemoveRequest(unsigned long dwCID, PktFriendRemoveReq::CMD removeType);
bool CharFriendEtcRequest(unsigned long dwCID, unsigned long dwData, PktFriendEtc::CMD etcType);
bool StoreLogin(char *Password_In, char PassSave_In);
bool StoreLogout(void);
bool StoreBuyTab(char TabNum_In);
bool StoreChangePass(char *Password_In, char *NewPassword_In);
bool CharAdmin(unsigned short Cmd_In, char* Name_In, char Zone_In, char Channel_In, unsigned short ProtoTypeID, POS& Pos_In);
DWORD HandleDeposit(char *pBuffer_In, unsigned char *Cmd_Out, DWORD *Gold_Out, char *PassSave_Out);
DWORD HandleCharLogin(char *pBuffer_In, char *Admin_Out, LPCHAR_INFOST lpCharInfo_Out, LPSKILL lpSkill_Out, LPQUICK lpQuick_Out, LPCHAR_POS lpPos_Out, DWORD *ServerTime_Out,
unsigned short *EquipSize_Out, char **lppEquipBuff_Out, unsigned short *InvenSize_Out, char **lppInvenBuff_Out, unsigned short *ExtraSize_Out, char **lppExtraBuff_Out, unsigned short *ExchangeSize_Out, char **lppExchangeBuff_Out);
DWORD HandleCharLogout(char *pBuffer_In, DWORD *CharID_Out);
DWORD HandleDepositUpdate(char *pBuffer_In, DWORD *Flag_Out, unsigned char *TabNum_Out, bool *Complete_Out, unsigned short *StoreSize_Out, char **lppStoreBuff_Out);
DWORD HandleCharUpdateAddress(char *pBuffer_In);
DWORD HandleCharAddressInfo(char *pBuffer_In, DWORD *CharID_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out);
DWORD HandleCharRequireInfo(char *pBuffer_In, DWORD *CharID_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out, unsigned char *Cmd_Out);
DWORD HandleCharMove(char *pBuffer_In, DWORD *CharID_Out, LPPOS Pos_Out, float *Dir_Out, unsigned short *UAct_Out, unsigned short *LAct_Out, char *Level_Out, DWORD *ChantEf_Out, DWORD *EnchantEf_Out, DWORD *PtCount_Out);
DWORD HandleCharChat(char *pBuffer_In, DWORD *CharID_Out, unsigned short *Cmd_Out, char *Message_Out);
DWORD HandleCharWhisper(char *pBuffer_In, char *SenderName_Out, char *RecverName_Out, char *Message_Out);
DWORD HandleCharCellLogin(char *pBuffer_In, DWORD *CharID_Out, LPPOS Pos_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out, unsigned char *Cmd_Out);
DWORD HandleCharCellLogout(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Cmd_Out);
DWORD HandleMonMove(char *pBuffer_In, DWORD *MonID_Out, LPPOS lpPos_Out, float *Dir_Out, float *Vec_Out, unsigned short *Act_Out, unsigned short *AniNum_Out);
DWORD HandleCharAttack(char *pBuffer_In, DWORD *CharID_Out, LPAtType lpAtType_Out, unsigned short *HP_Out, unsigned short *MP_Out, DWORD *RightIndex_Out, DWORD *RightValue_Out, DWORD *LeftIndex_Out, DWORD *LeftValue_Out, char *Judge_Out, unsigned char *DefenserNum_Out, LPDefenserNode *lppNode_Out);
DWORD HandleCharAttackInfo(char *pBuffer_In, DWORD *CharID_Out, LPAtType lpAtType_Out, unsigned char *DefenserNum_Out, LPDefenserNode *lppNode_Out);
DWORD HandleCharRespawn(char *pBuffer_In, DWORD *CharID_Out, unsigned short *HP_Out, unsigned short *MP_Out, LPPOS lpPos_Out, __int64 *Exp_Out);
DWORD HandleCharAttacked(char *pBuffer_In, DWORD *AtCharID_Out, AtType *AtType_Out, LPPOS lpAtPos_Out, float *AtDir_Out, unsigned short *Judge_Out, unsigned short *MyHP_Out, unsigned short *MyMP_Out, unsigned char *MyIndex_Out, unsigned char *MyValue_Out);
DWORD HandleCharAward(char *pBuffer_In, DWORD *CharID_Out, DWORD *Exp_Out);
DWORD HandleCharShapeInfo(char *pBuffer_In, LPCHAR_VIEW lpCharView_Out, unsigned char *cSelectedHands_Out, unsigned long *dwStatusFlag_Out, char *StallName_Out);
DWORD HandleCharPickUp(char *pBuffer_In, DWORD *CharID_Out, DWORD *ObjectID_Out, Item::ItemPos* lpIndex_Out, DWORD *Gold_Out, DWORD *Size_Out, unsigned char* cNum_Out, char **lppBuffer_Out);
DWORD HandleCharPickUpInfo(char *pBuffer_In, DWORD *CharID_Out, DWORD *ObjectID_Out);
DWORD HandleCharPullDown(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpIndex_Out, LPFieldObject lpFieldObject_Out);
DWORD HandleCharPullDownInfo(char *pBuffer_In, DWORD *CharID_Out, LPFieldObject lpFieldObject_Out);
DWORD HandleGameCellInfo(char *pBuffer_In, unsigned char *ObjectNum_Out, LPFieldObject *lppFieldObject_Out);
DWORD HandleCharTakeItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpTakeType_Out);
DWORD HandleCharSwapItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpSrcType_Out, LPTakeType lpDstType_Out);
DWORD HandleCharTradeItem(char *pBuffer_In, DWORD *CharID_Out, DWORD *NPCID_Out, unsigned char *Pos_Out, Item::ItemPos* lpIndex_Out, unsigned char *Num_Out, DWORD *Gold_Out, unsigned short *Size_Out, char **lppBuffer_Out);
DWORD HandleCharRepairItem(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpIndex_Out, DWORD *Gold_Out);
DWORD HandleCharUseItem(char *pBuffer_In, DWORD *SenderID_Out, DWORD *Recver_Out, Item::ItemPos* lpIndex_Out);
DWORD HandleCharCastObject(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, LPCastObject lpCastObject);
DWORD HandleCharCastObjectInfo(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, LPCastObject lpCastObject);
DWORD HandleCharInstallSocket(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpEquipIndex_Out, Item::ItemPos* lpSocket_Out, unsigned short *Size_Out, char **lppBuffer_Out);
DWORD HandleCharSuicide(char *pBuffer_In, DWORD *CharID_Out, LPPOS lpPos_Out);
DWORD HandleCharBindPos(char *pBuffer_In, DWORD *NPCID_Out, unsigned char *Cmd_Out, LPPOS lpPos_Out, char *Zone_Out);
DWORD HandleCharLevelUp(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Level_Out, LPChState lpChState_Out);
DWORD HandleCharIncreasePoint(char *pBuffer_In, DWORD *CharID_Out, LPChState lpChState_Out);
DWORD HandleCharClassUpgrade(char *pBuffer_In, DWORD *CharID_Out, unsigned short *ClassID_Out, LPChState lpState_Out, char *Index_Out, unsigned short *Skill_Out);
DWORD HandleCharSkillLock(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out);
DWORD HandleCharSkillUnLock(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out, Item::ItemPos* lpIndex_Out, unsigned long *Gold_Out);
DWORD HandleCharSkillCreate(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out);
DWORD HandleCharSkillErase(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out);
DWORD HandleCharPartyInfo(char *pBuffer_In, LPPARTY lpParty_Out);
DWORD HandleCharPartyCmd(char *pBuffer_In, LPAddressInfo SenderAddress_Out, char *SenderName_Out, DWORD *SenderID_Out, DWORD *ReferenceID_Out, DWORD *PartyID_Out, unsigned short *Cmd_Out);
DWORD HandleCharPartyCmdInfo(char *pBuffer_In, DWORD *MemberID_Out, DWORD *PartyID_Out, unsigned short *Cmd_Out);
DWORD HandleCharPartyMemInfo(char *pBuffer_In, DWORD *CharID_Out, DWORD *PartyID_Out, unsigned char *Class_Out, char *Level_Out, unsigned short *MaxHP_Out, unsigned short *CurHP_Out, unsigned short *MaxMP_Out, unsigned short *CurMP_Out, DWORD *Chant_Out, DWORD *Enchant_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out);
DWORD HandleCharPartyFind(char *pBuffer_In, DWORD *CharID_Out, unsigned char *MemberFindPartyNum_Out, unsigned char *PartyFindMemberNum_Out, LPMemberFindParty *lppMemberFindParty_Out, LPPartyFindMember *lppPartyFindMember_Out);
DWORD HandleCharHPRegen(char *pBuffer_In, DWORD *CharID_Out, unsigned short *HP_Out, unsigned short *MP_Out);
DWORD HandleCharUpgradeItem(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Size_Out, char **lppBuffer_Out);
DWORD HandleCharLevelUpInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Level_Out);
DWORD HandleCharSplitItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpTakeType_Out, unsigned char *Size_Out, char **lppBuffer_Out);
DWORD HandleCharQuickSlotMove(char *pBuffer_In, LPTakeType lpTakeType_Out);
DWORD HandleCharSwitchHand(char *pBuffer_In, unsigned char *SelectHand_Out);
DWORD HandleCharTakeItems(char *pBuffer_In, DWORD *CharID_Out, unsigned char *TakeNum_Out, LPTakeType *lppTakeTypes_Out);
DWORD HandleCharTakeGold(char *pBuffer_In, DWORD *CharID_Out, unsigned char *SrcPos_Out, unsigned char *DstPos_Out, DWORD *Gold_Out);
DWORD HandleCharExchangeCmd(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, unsigned char *Cmd_Out);
DWORD HandleCharExchangeItem(char *pBuffer_In, DWORD *CharID_Out, DWORD *Size_Out, Item::ItemPos* lpIndex_Out, unsigned char *Type_Out, unsigned char *Num_Out, char **lppBuffer_Out);
DWORD HandleCellBroadCasting(char *pBuffer_In, unsigned short *CharNum_Out, LPAddressInfo *lppAddress_Out);
DWORD HandleControlOption(char *pBuffer_In, DWORD *CharID_Out, LPRejectOption Reject_Out);
DWORD HandleCharDuelCmd(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, unsigned char *Cmd_Out);
DWORD HandleCharTeamBattleInfo(char *pBuffer_In, unsigned long *CharID_Out, char *ChallengerName_Out, unsigned char *Cmd_Out, unsigned char *MemberNum_Out, unsigned long *MemberID_Out, unsigned char *MemberLevel_Out);
DWORD HandleCharFameInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Cmd_Out, unsigned long *FameOrMerits_Out, unsigned char *RankingByRace_Out, unsigned char *RankingByClass_Out);
DWORD HandleCharSpellInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *SpellType_Out, unsigned short *EnchantLevel_Out, bool *OnOff_Out);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
DWORD HandleCharStallOpen(char *pBuffer_In, DWORD *CharID_Out, char* StallName_Out);
DWORD HandleCharStallRegisterItem(char *pBuffer_In, DWORD *CharID_Out, TakeType *TakeType_Out, unsigned long *Price_Out, unsigned char *Cmd_Out);
DWORD HandleCharStallEnter(char *pBuffer_In, DWORD *CustomerID_Out, DWORD *Owner_Out);
DWORD HandleCharStallItemInfo(char *pBuffer_In, unsigned long *StallSize_Out, char **lppStallBuff_Out, unsigned short *ItemNum_Out, unsigned long **StallPrice_Out);
// ģ<><C4A3> <20><><EFBFBD><EFBFBD>
DWORD HandleCharFriendDB(char *pBuffer_In, unsigned char* cDataType_Out, char **ppFriendListData_Out, DWORD *dwDataSize_Out);
DWORD HandleCharFriendAck(char *pBuffer_In, unsigned char* cCmd_Out, DWORD *dwCID_Out);
DWORD HandleCharFriendRegistered(char *pBuffer_In, char* szName_Out);
DWORD HandleCharEliteBonus(char *pBuffer_In, char *Nation_Out, unsigned char *Level_Out);
};
#endif

343
GameTools/GLOBALSCRIPT/Network/ClientSocket/LoginSocket.cpp Normal file
View File

@@ -0,0 +1,343 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket Class
//
///////////////////////////////////////////////////////////////////////////////////////////////
#include "LoginSocket.h"
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Network/Packet/PacketStruct/ServerPacket.h>
#include <Network/Packet/PacketStruct/ClientToAuthServer.h>
#include <Network/Packet/PacketStruct/ClientToLoginServer.h>
LoginSocket::LoginSocket(HWND hWnd_In):
m_hMainWnd(hWnd_In), m_ConnectServer(0)
{
m_RegAddress.S_un.S_addr = 0;
}
LoginSocket::~LoginSocket(void)
{
Disconnect();
}
bool LoginSocket::ConnectToLoginServer(char* Address_In)
{
Disconnect();
if(!Socket::CreateTCPSocket(&m_TCPSocket, m_hMainWnd, WM_LOGIN_SOCKET))
return false;
m_ConnectServer = CO_SRV::CO_LOGIN;
return Socket::Connect(m_TCPSocket, Socket::MakeSockAddr(Address_In, DemonLoginTCPPort), &m_pRecvDataBuffer);
}
bool LoginSocket::ConnectToAuthServer(void)
{
Disconnect();
if(!Socket::CreateTCPSocket(&m_TCPSocket, m_hMainWnd, WM_LOGIN_SOCKET))
return false;
m_ConnectServer = CO_SRV::CO_AUTH;
return Socket::Connect(m_TCPSocket, Socket::MakeSockAddr(m_RegAddress, DemonAuthTCPPort), &m_pRecvDataBuffer);
}
bool LoginSocket::Disconnect(void)
{
if(m_TCPSocket)
Socket::DeleteSocket(&m_TCPSocket, m_hMainWnd);
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><> <20><>Ŷ [ public ]
//
// Parameter :
//
// Return :
// <09><>Ŷ <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true, <20><><EFBFBD>н<EFBFBD> false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool LoginSocket::SendSysPing(void)
{
if(m_TCPSocket == NULL)
return false;
CPacket* lpBuffer = new CPacket(sizeof(PktSyP), CmdSysPing, 0);
LPPktSyP lpSyPAckPt = reinterpret_cast<LPPktSyP>(lpBuffer->GetBuf());
lpSyPAckPt->m_dwTickTime = GetTickCount();
lpBuffer->WrapPacket(true);
if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
{
lpBuffer->Release();
return false;
}
lpBuffer->Release();
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// GAS <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> [ public ]
// - GAS <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> <20><><EFBFBD>ڿ<EFBFBD>[In] ex) "Bono"
// 2st : <20><><EFBFBD><EFBFBD> <20>н<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ڿ<EFBFBD>[In] ex) "Bono"
// 3st : Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>[In]
//
// Return :
// <09><>Ŷ <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true, <20><><EFBFBD>н<EFBFBD> false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool LoginSocket::AuthAccount(char* UserID_In, char* UserPW_In, DWORD ClientVer_In, unsigned short CnFlag_In, unsigned short Flag_In)
{
if(m_TCPSocket == NULL || UserID_In == NULL || UserPW_In == NULL)
return false;
CPacket* lpBuffer = new CPacket(sizeof(PktAU), CmdAuthAccount, 0, CnFlag_In);
LPPktAU lpAUPt = reinterpret_cast<LPPktAU>(lpBuffer->GetBuf());
strncpy(lpAUPt->m_UserAccount, UserID_In, 16);
strncpy(lpAUPt->m_UserPassword, UserPW_In, 16);
lpAUPt->m_dwSessionID = GetDiskSerial('C');
lpAUPt->m_ClientVerInfo = ClientVer_In;
lpAUPt->m_cFlag = Flag_In;
lpBuffer->WrapPacket(true);
if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
{
lpBuffer->Release();
return false;
}
lpBuffer->Release();
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ŷ ó<><C3B3> [ public ]
// - AUAckPt ó<><C3B3>
//
// Parameter :
// 1st : <20><>Ŷ <20><><EFBFBD><EFBFBD>[In]
// 2st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[Out]
// 3st : <20>α<EFBFBD><CEB1><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü[Out]
//
// Return :
// <09><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD LoginSocket::HandleAuthAccount(char *pBuffer_In, DWORD *SessionID_Out, DWORD *UserID_Out)
{
LPPktAUAck lpAUAckPt = (LPPktAUAck)pBuffer_In;
if(lpAUAckPt == NULL || UserID_Out == NULL)
return WrongParameter;
*SessionID_Out = lpAUAckPt->m_dwSessionID;
*UserID_Out = lpAUAckPt->m_dwUserID;
if(lpAUAckPt->Error() != NoError)
return lpAUAckPt->Error();
return NoError;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// GAS <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> [ public ]
// - GAS <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>[In]
// 2st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>[In]
//
// Return :
// <09><>Ŷ <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true, <20><><EFBFBD>н<EFBFBD> false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool LoginSocket::ServerList(DWORD ClientVersion_In)
{
if(m_TCPSocket == NULL)
return false;
CPacket* lpBuffer = new CPacket(sizeof(PktSvL), CmdLoginServerList, 0, 0);
LPPktSvL lpSvLPt = reinterpret_cast<LPPktSvL>(lpBuffer->GetBuf());
lpSvLPt->m_ClientVerInfo = ClientVersion_In;
lpBuffer->WrapPacket(true);
if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
{
lpBuffer->Release();
return false;
}
lpBuffer->Release();
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ŷ ó<><C3B3> [ public ]
// - AUAckPt ó<><C3B3>
//
// Parameter :
// 1st : <20><>Ŷ <20><><EFBFBD><EFBFBD>[In]
// 2st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[Out]
// 3st : <20>α<EFBFBD><CEB1><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü[Out]
//
// Return :
// <09><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD LoginSocket::HandleServerList(char *pBuffer_In, DWORD *dwUserID_Out, SERVER_LIST* lpServerList_Out)
{
LPPktSvLAck lpSvLAckPt = (LPPktSvLAck)pBuffer_In;
if(lpSvLAckPt == NULL || dwUserID_Out == NULL)
return WrongParameter;
if(lpSvLAckPt->Error() != NoError)
return lpSvLAckPt->Error();
*dwUserID_Out = lpSvLAckPt->m_dwUserID;
CopyMemory(lpServerList_Out, &(lpSvLAckPt->m_ServerList), sizeof(SERVER_LIST));
return NoError;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// GAS <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> [ public ]
// - GAS <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>[In]
// 2st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>[In]
//
// Return :
// <09><>Ŷ <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true, <20><><EFBFBD>н<EFBFBD> false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool LoginSocket::ServerGroup(unsigned char Group_In)
{
if(m_TCPSocket == NULL)
return false;
CPacket* lpBuffer = new CPacket(sizeof(PktSG), CmdServerGroup, 0, 0);
LPPktSG lpSGPt = reinterpret_cast<LPPktSG>(lpBuffer->GetBuf());
lpSGPt->m_cGroup = Group_In;
lpBuffer->WrapPacket(true);
if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
{
lpBuffer->Release();
return false;
}
lpBuffer->Release();
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ ó<><C3B3> [ public ]
// - AUTSAck ó<><C3B3>
//
// Parameter :
// 1st : <20><>Ŷ <20><><EFBFBD><EFBFBD>[In]
// 2st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[Out]
//
// Return :
// <09><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD LoginSocket::HandleServerGroup(char *pBuffer_In, DWORD *dwServerID_Out)
{
LPPktSGAck lpSGAckPt = (LPPktSGAck)pBuffer_In;
if(lpSGAckPt == NULL || dwServerID_Out == NULL)
return WrongParameter;
if(lpSGAckPt->Error() != NoError)
return lpSGAckPt->Error();
*dwServerID_Out = lpSGAckPt->m_dwServerID;
m_RegAddress = lpSGAckPt->m_AuthAddress;
return NoError;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><>ġ <20>ּ<EFBFBD> [ public ]
// - <20><>ġ <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>[In]
//
// Return :
// <09><>Ŷ <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true, <20><><EFBFBD>н<EFBFBD> false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool LoginSocket::PatchAddress(DWORD ServerID_In)
{
if(m_TCPSocket == NULL)
return false;
CPacket* lpBuffer = new CPacket(sizeof(PktSPI), CmdSysPatchAddress, 0, 0);
LPPktSPI lpSPIPt = reinterpret_cast<LPPktSPI>(lpBuffer->GetBuf());
lpSPIPt->m_dwServerID = ServerID_In;
lpBuffer->WrapPacket(true);
if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
{
lpBuffer->Release();
return false;
}
lpBuffer->Release();
return true;
}
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><>ġ <20>ּ<EFBFBD> [ public ]
// - <20><>ġ <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : <20><>ġ <20>ּ<EFBFBD>[In]
//
// Return :
// <09><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD LoginSocket::HandlePatchAddress(char *pBuffer_In, DWORD *ClientVer_Out, char *PatchAddress_Out)
{
LPPktSPIAck lpSPIAckPt = (LPPktSPIAck)pBuffer_In;
if(lpSPIAckPt == NULL)
return WrongParameter;
if(lpSPIAckPt->Error() != NoError)
return lpSPIAckPt->Error();
*ClientVer_Out = lpSPIAckPt->m_dwClientVer;
strncpy(PatchAddress_Out, lpSPIAckPt->m_PatchAddress, PktSPIAck::PATCH_ADDRESS_LENGTH);
return NoError;
}

58
GameTools/GLOBALSCRIPT/Network/ClientSocket/LoginSocket.h Normal file
View File

@@ -0,0 +1,58 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// LoginSocket Class
//
// Last Update : 2002. 8.28
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _LoginSocket
#define _LoginSocket
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
struct SERVER_LIST;
#include "NetBase.h"
const unsigned long WM_LOGIN_SOCKET = RegisterWindowMessage("WM_LOGIN_SOCKET");
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
class LoginSocket : public NetBase
{
private:
HWND m_hMainWnd;
IN_ADDR m_RegAddress;
int m_ConnectServer;
public:
typedef enum AuthFlag { AuthFlag_RegDB = 0x8000, AuthFlag_Email = 0x4000 };
typedef enum CO_SRV { CO_LOGIN = 0, CO_AUTH = 1 };
LoginSocket(HWND hWnd_In);
virtual ~LoginSocket(void);
inline IN_ADDR GetRegAddress() { return m_RegAddress; }
inline char* GetRegString() { return inet_ntoa(m_RegAddress); }
inline int GetConnectServer() { return m_ConnectServer; }
bool ConnectToLoginServer(char* Address_In);
bool ConnectToAuthServer(void);
bool Disconnect(void);
bool SendSysPing(void);
bool AuthAccount(char* UserID_In, char* UserPW_In, DWORD ClientVer_In, unsigned short CnFlag_In, unsigned short Flag_In = 0);
bool ServerList(DWORD ClientVersion_In);
bool ServerGroup(unsigned char Group_In);
bool PatchAddress(DWORD ServerID_In);
DWORD HandleAuthAccount(char *pBuffer_In, DWORD *SessionID_Out, DWORD *UserID_Out);
DWORD HandleServerList(char *pBuffer_In, DWORD *UserID_Out, SERVER_LIST* lpServerList_Out);
DWORD HandleServerGroup(char *pBuffer_In, DWORD *ServerID_Out);
DWORD HandlePatchAddress(char *pBuffer_In, DWORD *ClientVer_Out, char *PatchAddress_Out);
};
#endif

92
GameTools/GLOBALSCRIPT/Network/ClientSocket/NetBase.cpp Normal file
View File

@@ -0,0 +1,92 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// NetBase Class
//
///////////////////////////////////////////////////////////////////////////////////////////////
#include "NetBase.h"
#include <Network/XORCrypt/XORCrypt.h>
NetBase::NetBase(void) :
m_TCPSocket(INVALID_SOCKET), m_UDPSocket(INVALID_SOCKET)
{
m_pSendDataBuffer.buf = m_pSendBuffer;
m_pSendDataBuffer.len = 0;
m_pRecvDataBuffer.buf = m_pRecvBuffer;
m_pRecvDataBuffer.len = 0;
m_pRecvUDPDataBuffer.buf = m_pRecvUDPBuffer;
m_pRecvUDPDataBuffer.len = 0;
}
NetBase::~NetBase(void)
{
SAFE_CLOSESOCK(m_TCPSocket);
SAFE_CLOSESOCK(m_UDPSocket);
}
int NetBase::Recv(void)
{
return SocketIO::Recv(m_TCPSocket, m_pRecvDataBuffer);
}
int NetBase::UDPRecv(LPSOCKADDR_IN Address_Out)
{
return SocketIO::RecvFrom(m_UDPSocket, m_pRecvUDPDataBuffer, Address_Out);
}
int NetBase::PutRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In)
{
return SocketIO::PutRecvBufferToPtBuffer(pBuffer_Out, BufferSize_In, m_pRecvDataBuffer, m_pRecvBuffer, 0, 0);
}
int NetBase::PutUDPRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In)
{
return SocketIO::PutRecvBufferToPtBuffer(pBuffer_Out, BufferSize_In, m_pRecvUDPDataBuffer, m_pRecvUDPBuffer, 0, 0);
}
void NetBase::PutSendBuffer(bool Crypt_In)
{
CXORCrypt& Crypt = CXORCrypt::GetInstance();
DWORD dwCodePage = Crypt.GetCodePage();
LPPktBase lpBasePt = (LPPktBase)m_pSendDataBuffer.buf;
int Len = lpBasePt->GetLen();
// <20><><EFBFBD>ڵ<EFBFBD> <20><>Ŷ
if(Crypt_In)
{
Crypt.EncodePacket(m_pSendDataBuffer.buf + PktBaseSize, Len - PktBaseSize, dwCodePage);
lpBasePt->SetCodePage(dwCodePage);
lpBasePt->SetCrypt();
}
// <20><><EFBFBD>ڵ<EFBFBD> <20>ش<EFBFBD>
Crypt.EncodeHeader(m_pSendDataBuffer.buf + 1, PktBaseSize - 1, 0, 0);
m_pSendDataBuffer.len += Len;
m_pSendDataBuffer.buf += Len;
}
bool NetBase::FlushSendBuffer(void)
{
WSABUF SendBuf = { m_pSendDataBuffer.len, m_pSendBuffer };
CheckServerState();
if(m_pSendDataBuffer.len <= 0)
return true;
if(!Send(m_TCPSocket, SendBuf))
{
m_pSendDataBuffer.buf = m_pSendBuffer;
m_pSendDataBuffer.len = 0;
return false;
}
m_pSendDataBuffer.buf = m_pSendBuffer;
m_pSendDataBuffer.len = 0;
return true;
}

77
GameTools/GLOBALSCRIPT/Network/ClientSocket/NetBase.h Normal file
View File

@@ -0,0 +1,77 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// NetBase Class
//
// Last Update : 2002. 8. 28
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _NetBase
#define _NetBase
#include "Packet.h"
#include "Socket/SocketIO.h"
const unsigned int DemonLoginTCPPort = 10101; // Client Login TCP Port
const unsigned int DemonGameTCPPort = 10104; // Client Game TCP Port
const unsigned int DemonAuthTCPPort = 10110; // Client Auth TCP Port
const unsigned int DemonClientUDPPort = 20002; // Client UDP Port
const unsigned short NoError = 0x0000; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const unsigned short WrongParameter = 0x4001; // <20>߸<EFBFBD><DFB8><EFBFBD> <20><><EFBFBD><EFBFBD>
const unsigned short ExceptionError = 0x4002; // <20><><EFBFBD><EFBFBD> <20><> <20>߻<EFBFBD>
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
class NetBase : public SocketIO
{
public:
WSABUF m_pSendDataBuffer;
char m_pSendBuffer[BufferSize];
WSABUF m_pRecvDataBuffer;
char m_pRecvBuffer[BufferSize];
WSABUF m_pRecvUDPDataBuffer;
char m_pRecvUDPBuffer[BufferSize];
SOCKET m_TCPSocket;
SOCKET m_UDPSocket;
public:
NetBase(void);
~NetBase(void);
inline int GetUseSendBuffer(void) { return m_pSendDataBuffer.len; }
inline int GetUseRecvBuffer(void) { return static_cast<int>((m_pRecvDataBuffer.buf - m_pRecvBuffer) + m_pRecvDataBuffer.len); }
inline int GetUseRecvUDPBuffer(void) { return static_cast<int>((m_pRecvUDPDataBuffer.buf - m_pRecvUDPBuffer) + m_pRecvUDPDataBuffer.len); }
int Recv(void);
int UDPRecv(LPSOCKADDR_IN Address_Out);
int PutRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In);
int PutUDPRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In);
char* GetSendBuffer(void) { return m_pSendDataBuffer.buf; }
void PutSendBuffer(bool Crypt_In);
bool FlushSendBuffer(void);
public:
inline DWORD GetDiskSerial(char Drv_In)
{
unsigned long VolumeSerial = 0;
char Root[10] = "";
sprintf(Root, "%c:\\", Drv_In);
if(!GetVolumeInformation(Root, 0, 0, &VolumeSerial, 0, 0, 0, 0))
return 0;
return VolumeSerial;
}
};
#endif

108
GameTools/GLOBALSCRIPT/Network/ClientSocket/Packet.cpp Normal file
View File

@@ -0,0 +1,108 @@
#include "stdafx.h"
#include "Packet.h"
#include <Network/Packet/PacketBase.h>
#include <Network/XORCrypt/XORCrypt.h>
#include <algorithm>
CMemoryPool::CMemoryPool(size_t nPerAllocateSize, size_t nPerAllocateNum)
: m_nPerAllocateSize(nPerAllocateSize), m_nPerAllocateNum(nPerAllocateNum)
{
for(size_t nCount = 0; nCount < m_nPerAllocateNum; ++nCount)
{
m_Pool.push_back(new char[m_nPerAllocateSize]);
}
}
struct FnPoolDeleteArray
{
bool operator () (char* lpPtr)
{
if(NULL != lpPtr)
{
delete [] lpPtr;
}
return true;
}
};
CMemoryPool::~CMemoryPool()
{
CCSLock::Syncronize sync(m_PoolLock);
std::for_each(m_Pool.begin(), m_Pool.end(), FnPoolDeleteArray());
}
void* CMemoryPool::Alloc(size_t size)
{
CCSLock::Syncronize sync(m_PoolLock);
if(m_Pool.empty())
{
for(size_t nCount = 0; nCount < m_nPerAllocateNum; ++nCount)
{
m_Pool.push_back(new char[m_nPerAllocateSize]);
}
}
char* lpResult = m_Pool.back();
m_Pool.pop_back();
return lpResult;
}
void CMemoryPool::Free(void* ptr)
{
CCSLock::Syncronize sync(m_PoolLock);
m_Pool.push_back(reinterpret_cast<char*>(ptr));
}
CMemoryPool CPacket::ms_PacketPool(sizeof(CPacket), 20);
CPacket::CPacket()
: m_Len(0), m_nRefCount(1), m_bWrap(false)
{
}
CPacket::CPacket(unsigned short Len_In, unsigned char Cmd_In, unsigned short State_In, unsigned short Error_In)
: m_Len(0), m_nRefCount(1), m_bWrap(false)
{
((PktBase* )m_Buffer)->InitPtHead(Len_In, Cmd_In, State_In, Error_In);
}
CPacket::CPacket(unsigned short Len_In, unsigned char Cmd_In, unsigned long Tick_In)
: m_Len(0), m_nRefCount(1), m_bWrap(false)
{
((PktBase* )m_Buffer)->InitPtHead(Len_In, Cmd_In, Tick_In);
}
CPacket::~CPacket()
{
}
bool CPacket::WrapPacket(bool Crypt_In)
{
CXORCrypt& Crypt = CXORCrypt::GetInstance();
DWORD dwCodePage = Crypt.GetCodePage();
PktBase* lpBasePt = (PktBase* )m_Buffer;
m_Len = lpBasePt->GetLen();
if(m_bWrap)
return false;
// <20><><EFBFBD>ڵ<EFBFBD> <20><>Ŷ
if(Crypt_In)
{
Crypt.EncodePacket(m_Buffer + PktBaseSize, m_Len - PktBaseSize, dwCodePage);
lpBasePt->SetCodePage(dwCodePage);
lpBasePt->SetCrypt();
}
// <20><><EFBFBD>ڵ<EFBFBD> <20>ش<EFBFBD>
Crypt.EncodeHeader(m_Buffer + 1, PktBaseSize - 1, 0, 0);
return m_bWrap = true;
}

80
GameTools/GLOBALSCRIPT/Network/ClientSocket/Packet.h Normal file
View File

@@ -0,0 +1,80 @@
#ifndef _CPacket
#define _CPacket
#define WIN32_LEAN_AND_MEAN
#include <Winsock2.h>
#include <windows.h>
#include <new>
#include <vector>
#include <Thread/Lock.h>
#include "Socket/SocketIO.h"
class CMemoryPool
{
public:
CMemoryPool(size_t nPerAllocateSize, size_t PerAllocateNum);
~CMemoryPool();
void* Alloc(size_t size);
void Free(void* ptr);
private:
CCSLock m_PoolLock;
CACHE_PAD(PoolLockPadding, sizeof(CCSLock));
size_t m_nPerAllocateSize;
size_t m_nPerAllocateNum;
std::vector<char*> m_Pool;
};
class CPacket
{
protected:
volatile LONG m_nRefCount;
char m_Buffer[BufferSize];
unsigned short m_Len;
bool m_bWrap;
public:
CPacket();
CPacket(unsigned short Len_In, unsigned char Cmd_In, unsigned short State_In, unsigned short Error_In);
CPacket(unsigned short Len_In, unsigned char Cmd_In, unsigned long Tick_In);
~CPacket();
WSABUF GetWSABuf() {
WSABUF WSABuf = { m_Len, m_Buffer };
return WSABuf;
}
char * GetBuf(void) { return m_Buffer; };
inline LONG AddRef() { return InterlockedIncrement(&m_nRefCount); }
inline LONG Release();
bool WrapPacket(bool Crypt_In);
static CMemoryPool ms_PacketPool;
static void* operator new(size_t size) { return ms_PacketPool.Alloc(size); }
static void operator delete(void *ptr) { ms_PacketPool.Free(ptr); }
};
typedef CPacket* LPCPacket;
inline LONG CPacket::Release()
{
LONG nRefCount = InterlockedDecrement(&m_nRefCount);
if(0 == nRefCount)
{
delete this;
}
return nRefCount;
}
#endif

284
GameTools/GLOBALSCRIPT/Network/ClientSocket/Socket/Socket.cpp Normal file
View File

@@ -0,0 +1,284 @@
#include "Socket.h"
void Socket::InitWinsock(void)
{
WSADATA WsaData;
WSAStartup(MAKEWORD( 2, 2), &WsaData);
}
void Socket::ReleaseWinsock(void)
{
WSACleanup();
}
SOCKADDR_IN Socket::MakeSockAddr(char *IP_In, int Port_In)
{
SOCKADDR_IN Address = {0,};
Address.sin_family = AF_INET;
Address.sin_addr.s_addr = (NULL == IP_In) ? htonl(INADDR_ANY) : inet_addr(IP_In);
Address.sin_port = (0 == Port_In) ? 0 : htons(Port_In);
return Address;
}
SOCKADDR_IN Socket::MakeSockAddr(IN_ADDR Addr, int Port_In)
{
SOCKADDR_IN Address = {0,};
Address.sin_family = AF_INET;
Address.sin_addr = Addr;
Address.sin_port = (0 == Port_In) ? 0 : htons(Port_In);
return Address;
}
bool Socket::CreateTCPSocket(SOCKET *Socket_Out, HWND hWnd_In, unsigned int Msg_In)
{
BOOL KeepAlive = TRUE;
linger Linger;
Linger.l_onoff = 1;
Linger.l_linger = 0;
if(Socket_Out == NULL)
return false;
if((*Socket_Out = socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) == SOCKET_ERROR)
return false;
if(setsockopt(*Socket_Out, SOL_SOCKET, SO_KEEPALIVE, (char *)&KeepAlive, sizeof(BOOL)) == SOCKET_ERROR)
return false;
if(setsockopt(*Socket_Out, SOL_SOCKET, SO_LINGER, (char *)&Linger, sizeof(linger)) == SOCKET_ERROR)
return false;
if(WSAAsyncSelect(*Socket_Out, hWnd_In, Msg_In, FD_READ | FD_CONNECT | FD_CLOSE) == SOCKET_ERROR)
return false;
return true;
}
bool Socket::CreateUDPSocket(SOCKET *Socket_Out, SOCKADDR_IN Address_In, HWND hWnd_In, unsigned int Msg_In)
{
BOOL ReUseAddr = TRUE;
if(Socket_Out == NULL)
return false;
if((*Socket_Out = socket(AF_INET, SOCK_DGRAM, 0)) == SOCKET_ERROR)
return false;
if(bind(*Socket_Out, (sockaddr *)&Address_In, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
return false;
if(setsockopt(*Socket_Out, SOL_SOCKET, SO_REUSEADDR, (char *)&ReUseAddr, sizeof(BOOL)) == SOCKET_ERROR)
return false;
if(WSAAsyncSelect(*Socket_Out, hWnd_In, Msg_In, FD_READ) == SOCKET_ERROR)
return false;
return true;
}
bool Socket::DeleteSocket(SOCKET *Socket_In, HWND hWnd_In)
{
if(Socket_In == NULL)
return false;
WSAAsyncSelect(*Socket_In, hWnd_In, 0, 0);
SAFE_CLOSESOCK(*Socket_In);
return true;
}
bool Socket::GetNATAddress(SOCKET Socket_In, SOCKADDR_IN *Address_Out, bool AllowVirtual)
{
int AddressSize = sizeof(SOCKADDR_IN);
if(getsockname(Socket_In, (struct sockaddr *)Address_Out, &AddressSize) != SOCKET_ERROR)
{
char HostName[256];
if(!gethostname(HostName, 255))
{
PHOSTENT pHost = gethostbyname(HostName);
if(NULL == pHost)
{
return false;
}
IN_ADDR& Addr = Address_Out->sin_addr;
for(int Count = 0;pHost->h_addr_list[Count]; ++Count)
{
memcpy(&(Addr.S_un.S_addr), pHost->h_addr_list[Count], sizeof(IN_ADDR));
if(!AllowVirtual)
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE>
// 10.0.0.0 ~ 10.255.255.255
// 172.16.0.0 ~ 172.31.255.255
// 192.168.0.0 ~ 192.168.255.255
if((unsigned char)10 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
else if((unsigned char)172 == Addr.S_un.S_un_b.s_b1)
{
if(Addr.S_un.S_un_b.s_b2 >= (unsigned char)16 && Addr.S_un.S_un_b.s_b2 <= (unsigned char)31)
{
continue;
}
}
else if((unsigned char)192 == Addr.S_un.S_un_b.s_b1)
{
if((unsigned char)168 == Addr.S_un.S_un_b.s_b2)
{
continue;
}
}
}
// <20>߸<EFBFBD><DFB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// 169.X.X.X <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD> ( SyGate )
// 0.X.X.X
if((unsigned char)169 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
else if((unsigned char)0 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
return true;
}
if(0 != Count)
return true;
}
return false;
}
return false;
}
bool Socket::GetHostName(char *Name_Out, int Size)
{
if(!gethostname(Name_Out, Size))
return true;
return false;
}
bool Socket::GetHostIP(IN_ADDR &Addr, bool AllowVirtual)
{
char HostName[256];
if(!gethostname(HostName, 255))
{
PHOSTENT pHost = gethostbyname(HostName);
if(NULL == pHost)
{
return false;
}
for(int Count = 0;pHost->h_addr_list[Count]; ++Count)
{
memcpy(&(Addr.S_un.S_addr), pHost->h_addr_list[Count], sizeof(IN_ADDR));
if(!AllowVirtual)
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE>
// 10.0.0.0 ~ 10.255.255.255
// 172.16.0.0 ~ 172.31.255.255
// 192.168.0.0 ~ 192.168.255.255
if((unsigned char)10 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
else if((unsigned char)172 == Addr.S_un.S_un_b.s_b1)
{
if(Addr.S_un.S_un_b.s_b2 >= (unsigned char)16 && Addr.S_un.S_un_b.s_b2 <= (unsigned char)31)
{
continue;
}
}
else if((unsigned char)192 == Addr.S_un.S_un_b.s_b1)
{
if((unsigned char)168 == Addr.S_un.S_un_b.s_b2)
{
continue;
}
}
}
// <20>߸<EFBFBD><DFB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// 169.X.X.X <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD> ( SyGate )
// 0.X.X.X
if((unsigned char)169 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
else if((unsigned char)0 == Addr.S_un.S_un_b.s_b1)
{
continue;
}
return true;
}
if(0 != Count)
return true;
}
return false;
}
bool Socket::GetHostIP(IN_ADDR &Addr, char *Domain)
{
PHOSTENT pHost = gethostbyname(Domain);
if(NULL == pHost)
{
return false;
}
memcpy(&(Addr.S_un.S_addr), pHost->h_addr_list[0], sizeof(IN_ADDR));
return true;
}
bool Socket::IsWrongIP(IN_ADDR &Addr)
{
if((unsigned char)169 == Addr.S_un.S_un_b.s_b1)
{
if((unsigned char)254 == Addr.S_un.S_un_b.s_b2)
{
return true;
}
}
if((unsigned char)0 == Addr.S_un.S_un_b.s_b1)
return true;
return false;
}
bool Socket::IsEmptyAddr(IN_ADDR &Addr)
{
if((unsigned char)0 == Addr.S_un.S_un_b.s_b1)
{
return true;
}
return true;
}
bool Socket::Connect(SOCKET Socket_In, SOCKADDR_IN Address_In, WSABUF *WSABuf_In)
{
if(WSAConnect(Socket_In, (sockaddr *)&Address_In, sizeof(SOCKADDR_IN), 0, WSABuf_In, 0, 0) == SOCKET_ERROR)
{
DWORD dwError = GetLastError();
if(ERROR_IO_PENDING != dwError && WSAEWOULDBLOCK != (int)dwError)
return false;
}
return true;
}

33
GameTools/GLOBALSCRIPT/Network/ClientSocket/Socket/Socket.h Normal file
View File

@@ -0,0 +1,33 @@
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <iphlpapi.h>
#include <windows.h>
#define SelectEvent(dwError) WSAGETSELECTEVENT(dwError)
#define SelectError(dwError) WSAGETSELECTERROR(dwError)
#define SAFE_CLOSESOCK(p) { if (INVALID_SOCKET != (p)) { closesocket(p); (p) = INVALID_SOCKET; } }
namespace Socket
{
void InitWinsock(void);
void ReleaseWinsock(void);
SOCKADDR_IN MakeSockAddr(IN_ADDR Addr, int Port_In);
SOCKADDR_IN MakeSockAddr(char *IP_In, int Port_In);
bool CreateTCPSocket(SOCKET *Socket_Out, HWND hWnd_In, unsigned int Msg_In);
bool CreateUDPSocket(SOCKET *Socket_Out, SOCKADDR_IN Address_In, HWND hWnd_In, unsigned int Msg_In);
bool DeleteSocket(SOCKET *Socket_In, HWND hWnd_In);
bool GetNATAddress(SOCKET Socket_In, SOCKADDR_IN *Address_Out, bool AllowVirtual);
bool GetHostName(char *Name_Out, int Size);
bool GetHostIP(IN_ADDR &Addr, bool AllowVirtual);
bool GetHostIP(IN_ADDR &Addr, char *Domain);
bool IsWrongIP(IN_ADDR &Addr);
bool IsEmptyAddr(IN_ADDR &Addr);
bool Connect(SOCKET Socket_In, SOCKADDR_IN Address_In, WSABUF *WSABuf_In);
};

191
GameTools/GLOBALSCRIPT/Network/ClientSocket/Socket/SocketIO.cpp Normal file
View File

@@ -0,0 +1,191 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// SocketIO Class
//
///////////////////////////////////////////////////////////////////////////////////////////////
#include "SocketIO.h"
#include <Network/XORCrypt/XORCrypt.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>
SocketIO::SocketIO(void)
: m_ServerState(ServerInfo::SS_SMOOTH), m_PacketCount(0), m_Crypt(CXORCrypt::GetInstance())
{
Socket::InitWinsock();
}
SocketIO::~SocketIO(void)
{
Socket::ReleaseWinsock();
}
int SocketIO::Send(SOCKET Socket_In, WSABUF SendData_In)
{
int send_byte;
send_byte = send(Socket_In, (char *)SendData_In.buf, SendData_In.len, 0);
if(send_byte == SOCKET_ERROR || (int)SendData_In.len != send_byte)
return 0;
return send_byte;
}
int SocketIO::SendTo(SOCKET Socket_In, SOCKADDR_IN Addreess_In, WSABUF SendData_In)
{
int AddressSize = sizeof(SOCKADDR_IN);
int send_byte = 0;
send_byte = sendto(Socket_In, (char *)SendData_In.buf, SendData_In.len, 0, (struct sockaddr *)&Addreess_In, AddressSize);
if(send_byte == SOCKET_ERROR || (int)SendData_In.len != send_byte)
return 0;
return send_byte;
}
int SocketIO::Recv(SOCKET Socket_In, WSABUF &RecvData_In)
{
DWORD recv_byte;
if((recv_byte = recv(Socket_In, RecvData_In.buf, BufferSize, 0)) != SOCKET_ERROR)
{
RecvData_In.len = recv_byte;
return recv_byte;
}
return 0;
}
int SocketIO::RecvFrom(SOCKET Socket_In, WSABUF &RecvData_In, LPSOCKADDR_IN Address_Out)
{
int AddressSize = sizeof(SOCKADDR_IN);
DWORD recv_byte;
if((recv_byte = recvfrom(Socket_In, RecvData_In.buf, BufferSize, 0, (struct sockaddr *)Address_Out, &AddressSize)) != SOCKET_ERROR)
{
RecvData_In.len = recv_byte;
return recv_byte;
}
return 0;
}
int SocketIO::PutRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In, WSABUF &RecvData_In, char *RecvBuffer_In, unsigned short PageVer_In, unsigned char PageNum_In)
{
LPPktBase lpPktBase = NULL;;
if(pBuffer_Out == NULL || RecvData_In.len == 0)
return false;
try
{
lpPktBase = (LPPktBase)RecvData_In.buf;
if(lpPktBase->GetStartBit() != StartBit)
{
// <20><>Ŷ <20><><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD>
if(RecvData_In.buf != RecvBuffer_In)
{
// <20><><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> ( <20><>Ŷ <20><><EFBFBD><EFBFBD> )
RecvData_In.len = static_cast<u_long>((RecvData_In.buf - RecvBuffer_In) + RecvData_In.len);
RecvData_In.buf = RecvBuffer_In;
}
else
{
// <20><><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߸<EFBFBD><DFB8><EFBFBD> <20><>Ŷ ( <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> )
RecvData_In.len = 0;
RecvData_In.buf = RecvBuffer_In;
return 0;
}
}
lpPktBase = (LPPktBase)RecvData_In.buf;
if(lpPktBase->GetStartBit() == StartBit)
{
// <20><><EFBFBD>ڵ<EFBFBD> <20>ش<EFBFBD>
if(RecvData_In.len < PktBaseSize)
{
// <20>߸<EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD> )
RecvData_In.buf = RecvData_In.buf + RecvData_In.len;
RecvData_In.len = 0;
return 0;
}
m_Crypt.DecodeHeader((char *)lpPktBase + 1, PktBaseSize - 1, PageVer_In, PageNum_In);
unsigned short PacketLength = lpPktBase->GetLen();
if(PktMinLen <= PacketLength && PacketLength <= PktMaxLen)
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ
if(PacketLength <= RecvData_In.len)
{
if(lpPktBase->IsCrypt())
{
m_Crypt.DecodePacket((char *)lpPktBase + PktBaseSize, PacketLength - PktBaseSize, lpPktBase->GetCodePage());
}
if(lpPktBase->IsCompress())
{
// <20><><EFBFBD><EFBFBD> <20><>Ŷ ó<><C3B3>
DWORD Len = BufferSize_In;
CopyMemory(pBuffer_Out, (char *)lpPktBase, PktBaseSize);
CMiniLZOCompress::Decompress((char *)lpPktBase + PktBaseSize, PacketLength - PktBaseSize, pBuffer_Out + PktBaseSize, &Len);
lpPktBase->SetLen((unsigned short)Len + PktBaseSize);
}
else
{
// <20><> <20><><EFBFBD><EFBFBD> <20><>Ŷ ó<><C3B3>
CopyMemory(pBuffer_Out, (char *)lpPktBase, PacketLength);
}
RecvData_In.len = RecvData_In.len - PacketLength;
if(RecvData_In.len)
{
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
CopyMemory((char *)lpPktBase, (char *)lpPktBase + PacketLength, RecvData_In.len);
}
return PacketLength;
}
else
{
m_Crypt.EncodeHeader((char *)lpPktBase + 1, PktBaseSize - 1, PageVer_In, PageNum_In);
// <20>߸<EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD> )
RecvData_In.buf = RecvData_In.buf + RecvData_In.len;
RecvData_In.len = 0;
return 0;
}
}
else
{
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ
RecvData_In.buf = RecvBuffer_In;
RecvData_In.len = 0;
return 0;
}
}
else
{
// <20>߸<EFBFBD><DFB8><EFBFBD> <20><>Ŷ ( <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> )
RecvData_In.buf = RecvBuffer_In;
RecvData_In.len = 0;
return 0;
}
}
catch(...)
{
return 0;
}
return 0;
}

95
GameTools/GLOBALSCRIPT/Network/ClientSocket/Socket/SocketIO.h Normal file
View File

@@ -0,0 +1,95 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// SocketIO Class
//
// Last Update : 2002. 8. 28
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _SocketIO
#define _SocketIO
#include "Socket.h"
#include <Network/Packet/PacketBase.h>
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
class CXORCrypt;
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
const unsigned int BufferSize = 8192 * 100;
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
class SocketIO
{
private:
ServerInfo::ServerState m_ServerState;
unsigned long m_PacketCount;
CXORCrypt& m_Crypt;
public:
SocketIO(void);
virtual ~SocketIO(void);
int Send(SOCKET Socket_In, WSABUF SendData_In);
int SendTo(SOCKET Socket_In, SOCKADDR_IN Addreess_In, WSABUF SendData_In);
int Recv(SOCKET Socket_In, WSABUF &RecvData_In);
int RecvFrom(SOCKET Socket_In, WSABUF &RecvData_In, LPSOCKADDR_IN Address_Out);
int PutRecvBufferToPtBuffer(char *pBuffer_Out, int BufferSize_In, WSABUF &RecvData_In, char *RecvBuffer_In, unsigned short PageVer_In, unsigned char PageNum_In);
inline char* InsertPtCount(char *Buffer_In);
inline unsigned long ExtractPtCount(char *Buffer_In);
inline bool CheckServerState();
};
inline char* SocketIO::InsertPtCount(char *Buffer_In)
{
((PktBase* )Buffer_In)->SetServerInfo(m_PacketCount);
if(++m_PacketCount >= 0xFFFFFFF0)
m_PacketCount = 0;
return Buffer_In;
}
inline unsigned long SocketIO::ExtractPtCount(char *Buffer_In)
{
PktBase* lpBasePt = (PktBase* )Buffer_In;
return lpBasePt->GetServerInfo();
}
inline bool SocketIO::CheckServerState()
{
if(m_ServerState == ServerInfo::SS_SMOOTH)
return true;
else if(m_ServerState == ServerInfo::SS_LOADED)
{
Sleep(25);
return true;
}
else if(m_ServerState == ServerInfo::SS_BUSY)
{
Sleep(100);
return true;
}
else if(m_ServerState == ServerInfo::SS_VERYBUSY)
{
Sleep(300);
return true;
}
return false;
}
#endif

475
GameTools/GLOBALSCRIPT/Network/ClientSocket/UDPList/T_List.h Normal file
View File

@@ -0,0 +1,475 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ø<EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _TList
#define _TList
#pragma warning(disable:4786) // don't warn about browse name overflow.
#define LPLIST LIST*
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD>ø<EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> class TList
{
public:
LIST* m_pListHead;
LIST* m_pListTail;
LIST* m_pGarbageTop;
int m_ListCount;
int m_GarbageLength;
int m_GarbageCount;
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20>⺻ Ŭ<><C5AC><EFBFBD><EFBFBD> <20>޼ҵ<DEBC>
//
///////////////////////////////////////////////////////////////////////////////////////////////
public:
TList(void);
~TList(void);
inline bool IsListEmpty(void)
{
if(m_pListHead == NULL)
return true;
return false;
}
inline int GetListCount(void)
{
return m_ListCount;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20>޼ҵ<DEBC>
//
///////////////////////////////////////////////////////////////////////////////////////////////
LIST* Create(void);
bool Delete(LIST* pDelete_In);
bool InsertToList(LIST* pInsert_In);
bool DeleteFromList(LIST* pDelete_In);
bool DeleteAllFromList(void);
bool IsExistHandleFromList(LIST* pFind_In);
LIST* GetHandleWithCount(int Count_In);
///////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ݷ<EFBFBD><DDB7><EFBFBD> <20><><EFBFBD><EFBFBD> <20>޼ҵ<DEBC>
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool PushItemToGarbage(LIST* pPush_In);
LIST* PopItemFromGarbage(void);
bool SetGarbageStackLength(int StackLength_In);
bool ClearGarbageStack(void);
};
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// TList <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> [ public ]
// - <20>ɹ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʱ<EFBFBD>ȭ
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> TList<LIST>::TList(void)
{
m_pListHead = NULL;
m_pListTail = NULL;
m_pGarbageTop = NULL;
m_ListCount = 0;
m_GarbageLength = 0;
m_GarbageCount = 0;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// TList <20>Ҹ<EFBFBD><D2B8><EFBFBD> [ public ]
// - <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> TList<LIST>::~TList(void)
{
if(m_pListHead != NULL)
DeleteAllFromList();
if(m_pGarbageTop != NULL)
ClearGarbageStack();
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// Create [ public ]
// - <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> LPLIST TList<LIST>::Create(void)
{
LPLIST pList = NULL;
if(m_GarbageCount)
{
if((pList = PopItemFromGarbage()) != NULL)
{
pList->pNext = NULL;
return pList;
}
}
pList = new LIST;
pList->pNext = NULL;
return pList;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// Delete [ public ]
// - <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::Delete(LPLIST pDelete_In)
{
if(pDelete_In == NULL)
return false;
if(PushItemToGarbage(pDelete_In))
return true;
delete pDelete_In;
return true;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// InsertToList [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>߰<EFBFBD>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::InsertToList(LPLIST pInsert_In)
{
if(pInsert_In == NULL)
return false;
if(m_pListHead == NULL)
{
m_pListHead = pInsert_In;
m_pListTail = m_pListHead;
m_ListCount++;
return true;
}
m_pListTail->pNext = pInsert_In;
m_pListTail = pInsert_In;
m_ListCount++;
return true;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// DeleteFromList [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::DeleteFromList(LPLIST pDelete_In)
{
LPLIST pPosition;
if(pDelete_In == NULL)
return false;
if(m_pListHead == pDelete_In)
{
m_pListHead = m_pListHead->pNext;
if(Delete(pDelete_In))
{
m_ListCount--;
}
return true;
}
else
{
for(pPosition = m_pListHead; pPosition; pPosition = pPosition->pNext)
{
if(pPosition->pNext == pDelete_In)
{
if(m_pListTail == pDelete_In)
m_pListTail = pPosition;
pPosition->pNext = pDelete_In->pNext;
if(Delete(pDelete_In))
{
m_ListCount--;
}
return true;
}
}
}
return false;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// DeleteAllFromList [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::DeleteAllFromList(void)
{
LPLIST pDelete;
while(m_pListHead)
{
pDelete = m_pListHead;
m_pListHead = m_pListHead->pNext;
if(!Delete(pDelete))
return false;
}
m_ListCount = 0;
m_pListTail = m_pListHead;
return true;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// IsExistHandleFromList [ public ]
// - <20><><EFBFBD><EFBFBD>Ʈ Ȯ<><C8AE>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::IsExistHandleFromList(LPLIST pFind_In)
{
LPLIST pPosition = m_pListHead;
while(pPosition)
{
if(pFind_In == pPosition)
return true;
pPosition = pPosition->pNext;
}
return false;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// GetHandleWithCount [ public ]
// - ī<><C4AB>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : ī<><C4AB>Ʈ
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> LPLIST TList<LIST>::GetHandleWithCount(int Count_In)
{
LPLIST pList;
int Counter;
for(Counter = 0, pList = NULL; Counter <= Count_In && pList; Counter++, pList = pList->pNext);
return pList;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// SetGarbageStackLength [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::SetGarbageStackLength(int StackLength_In)
{
LPLIST pList;
int Counter;
m_GarbageLength = StackLength_In;
if(m_GarbageCount > m_GarbageLength)
{
for(Counter = m_GarbageCount; Counter > m_GarbageLength; Counter--)
if(pList = PopItemFromGarbage())
{
delete pList;
}
else
break;
}
else
{
for(Counter = m_GarbageCount; Counter < m_GarbageLength; Counter++)
{
pList = new LIST;
if(!PushItemToGarbage(pList))
break;
}
}
if(m_GarbageCount == StackLength_In)
return true;
return false;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
//
// ClearGarbageStack [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::ClearGarbageStack(void)
{
LPLIST pDelete;
if(m_pGarbageTop == NULL)
return false;
while(m_pGarbageTop)
{
pDelete = m_pGarbageTop;
m_pGarbageTop = m_pGarbageTop->pNext;
delete pDelete;
}
m_GarbageCount = 0;
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
// PushItemToGarbage [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>߰<EFBFBD>
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Succeed, <20>߸<EFBFBD><DFB8><EFBFBD> <20><><EFBFBD><EFBFBD> Parameter, <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD><DFBB><EFBFBD> Exception
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> bool TList<LIST>::PushItemToGarbage(LPLIST pPush_In)
{
if(pPush_In == NULL || m_GarbageCount >= m_GarbageLength)
return false;
if(m_pGarbageTop == NULL)
{
pPush_In->pNext = NULL;
m_pGarbageTop = pPush_In;
}
else
{
pPush_In->pNext = m_pGarbageTop;
m_pGarbageTop = pPush_In;
}
m_GarbageCount++;
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
// PopItemFromGarbage [ public ]
// - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Parameter :
//
// Return:
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Parameter, <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD><DFBB><EFBFBD> Exception
//
///////////////////////////////////////////////////////////////////////////////////////////////
template <class LIST> LPLIST TList<LIST>::PopItemFromGarbage(void)
{
LPLIST pPop;
if(m_pGarbageTop == NULL)
return NULL;
pPop = m_pGarbageTop;
m_pGarbageTop = m_pGarbageTop->pNext;
m_GarbageCount--;
return pPop;
}
#endif

14
GameTools/GLOBALSCRIPT/Network/ClientSocket/UDPList/UDPList.cpp Normal file
View File

@@ -0,0 +1,14 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// UDPList
//
///////////////////////////////////////////////////////////////////////////////////////////////
#include "UDPList.h"
UDPList::UDPList(void)
{
}
UDPList::~UDPList(void)
{
}

144
GameTools/GLOBALSCRIPT/Network/ClientSocket/UDPList/UDPList.h Normal file
View File

@@ -0,0 +1,144 @@
///////////////////////////////////////////////////////////////////////////////////////////////
//
// UDPList
//
///////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _CSocketHandleList
#define _CSocketHandleList
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <winsock.h>
#include "T_List.h"
typedef enum _PEERTYPE
{
Not_Defined = 0, // <20><><EFBFBD><EFBFBD> <20>ȵ<EFBFBD>
REAL_IP, // <20><><EFBFBD><EFBFBD> IP
NAT_Friendly, // <20><><EFBFBD><EFBFBD> IP (<28><><EFBFBD><EFBFBD> NAT)
NAT_Different // <20><><EFBFBD><EFBFBD> IP (<28>ٸ<EFBFBD> NAT)
} PEERTYPE;
typedef struct _UDP_LIST
{
DWORD CharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
PEERTYPE PeerType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
SOCKADDR_IN PublicAddress; // <20>ּ<EFBFBD> Public
SOCKADDR_IN PrivateAddress; // <20>ּ<EFBFBD> Private
DWORD MoveTick; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ð<EFBFBD>
_UDP_LIST* pNext;
}UDP_LIST, *LPUDP_LIST;
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
///////////////////////////////////////////////////////////////////////////////////////////////
class UDPList : public TList<UDP_LIST>
{
public:
UDPList(void);
~UDPList(void);
inline DWORD InsertIntoAddressList(DWORD CharID_In, SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In, PEERTYPE PeerType_In);
inline bool DeleteFromAddressList(DWORD CharID_In);
inline bool DeleteFromAddressList(SOCKADDR_IN Address_In);
inline LPUDP_LIST SearchFromAddressList(DWORD CharID_In);
inline LPUDP_LIST SearchFromAddressList(SOCKADDR_IN Address_In);
};
inline DWORD UDPList::InsertIntoAddressList(DWORD CharID_In, SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In, PEERTYPE PeerType_In)
{
LPUDP_LIST lpList = SearchFromAddressList(CharID_In);
if(lpList != NULL)
{
lpList->CharID = CharID_In;
lpList->PublicAddress = PubAddress_In;
lpList->PrivateAddress = PriAddress_In;
lpList->PeerType = PeerType_In;
return 1;
}
lpList = Create();
if(lpList != NULL)
{
lpList->CharID = CharID_In;
lpList->PublicAddress = PubAddress_In;
lpList->PrivateAddress = PriAddress_In;
lpList->PeerType = PeerType_In;
InsertToList(lpList);
return 2;
}
return 0;
}
inline bool UDPList::DeleteFromAddressList(DWORD CharID_In)
{
LPUDP_LIST lpList = SearchFromAddressList(CharID_In);
if(lpList != NULL)
{
DeleteFromList(lpList);
return true;
}
return false;
}
inline bool UDPList::DeleteFromAddressList(SOCKADDR_IN Address_In)
{
LPUDP_LIST lpList = SearchFromAddressList(Address_In);
if(lpList != NULL)
{
DeleteFromList(lpList);
return true;
}
return false;
}
inline LPUDP_LIST UDPList::SearchFromAddressList(DWORD CharID_In)
{
LPUDP_LIST lpList;
lpList = m_pListHead;
while(lpList)
{
if(lpList->CharID == CharID_In)
return lpList;
lpList = lpList->pNext;
}
return NULL;
}
inline LPUDP_LIST UDPList::SearchFromAddressList(SOCKADDR_IN Address_In)
{
LPUDP_LIST lpList;
lpList = m_pListHead;
while(lpList)
{
if(lpList->PrivateAddress.sin_addr.S_un.S_addr == Address_In.sin_addr.S_un.S_addr && lpList->PrivateAddress.sin_port == Address_In.sin_port)
return lpList;
if(lpList->PublicAddress.sin_addr.S_un.S_addr == Address_In.sin_addr.S_un.S_addr && lpList->PublicAddress.sin_port == Address_In.sin_port)
return lpList;
lpList = lpList->pNext;
}
return NULL;
}
#endif

2
GameTools/GLOBALSCRIPT/Network/Packet/PacketBase.cpp Normal file
View File

@@ -0,0 +1,2 @@
#include "stdafx.h"
#include "PacketBase.h"

143
GameTools/GLOBALSCRIPT/Network/Packet/PacketBase.h Normal file
View File

@@ -0,0 +1,143 @@
#ifndef _PACKET_BASE
#define _PACKET_BASE
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>۸<EFBFBD> <20><><EFBFBD><EFBFBD>
//
// SS_SMOOTH : <20><>Ȱ<EFBFBD><C8B0> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
// SS_LOADED : <20>ణ<EFBFBD><E0B0A3> <20><><EFBFBD>ϰ<EFBFBD> <20>ֽ<EFBFBD>. (50 % of bufferring)
// SS_BUSY : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ϰ<EFBFBD> <20>ֽ<EFBFBD>. (70 % of bufferring)
// SS_VERYBUSY : <20>ؽ<EFBFBD><D8BD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28><>Ŷ <20>ս<EFBFBD><D5BD><EFBFBD> <20>ʷ<EFBFBD><CAB7><EFBFBD> <20><> <20>ֽ<EFBFBD>.)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
union ServerInfo
{
enum ServerState
{
SS_SMOOTH, SS_LOADED, SS_BUSY, SS_VERYBUSY
};
struct sSrvState
{
unsigned short wError; // <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
unsigned short wSrvState; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
sSrvState SrvState;
unsigned long dwServerInfo;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
// <20>⺻ <20><>Ŷ
#pragma pack(1)
struct PktBase
{
typedef unsigned char StartType;
typedef unsigned char CMDType;
typedef unsigned short LengthType;
protected:
StartType m_StartBit;
CMDType m_Cmd;
LengthType m_Len; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD>
unsigned long m_CodePage;
ServerInfo m_SrvInfo;
public:
inline void InitPtHead(unsigned short Len_In, unsigned char Cmd_In,
unsigned short State_In, unsigned short Error_In);
inline void InitPtHead(unsigned short Len_In, unsigned char Cmd_In, unsigned long Tick_In);
inline unsigned short Error(void) { return m_SrvInfo.SrvState.wError; }
inline void SetError(unsigned short Error) { m_SrvInfo.SrvState.wError = Error; }
inline unsigned short GetError(void) { return m_SrvInfo.SrvState.wError; }
inline StartType GetStartBit(void) { return m_StartBit; }
inline void SetCodePage(unsigned long Code) { m_CodePage = Code; }
inline unsigned long GetCodePage(void) { return m_CodePage; }
inline void SetServerInfo(unsigned long Info) { m_SrvInfo.dwServerInfo = Info; }
inline unsigned long GetServerInfo(void) { return m_SrvInfo.dwServerInfo; }
inline CMDType GetCmd(void) { return m_Cmd; }
inline bool IsCrypt(void);
inline void SetCrypt(void);
inline bool IsCompress(void);
inline void SetCompress(void);
inline LengthType GetUncompressLen(void);
inline void SetLen(LengthType Len);
inline LengthType GetLen(void);
};
typedef PktBase* LPPktBase;
#pragma pack()
const unsigned int PktBaseSize = sizeof(PktBase);
const PktBase::StartType StartBit = 0xFF; // <20><><EFBFBD><EFBFBD> <20><>Ʈ
const PktBase::LengthType Crypt = 0x8000; // <20><>ȣȭ <20><><EFBFBD><EFBFBD> - 1000B
const PktBase::LengthType Compress = 0x4000; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> - 0100B
const PktBase::LengthType LengthHdr = 0xC000; // 1100B
const PktBase::LengthType LengthMask = 0x3FFF; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EEB3BB> <20><><EFBFBD><EFBFBD>ũ <20><>. <20><><EFBFBD><EFBFBD> 14<31><34>Ʈ. <20>ִ<EFBFBD> 16383byte.
const PktBase::LengthType PktMinLen = sizeof(PktBase);
const PktBase::LengthType PktMaxLen = 16383;
inline bool PktBase::IsCrypt(void) { return ((m_Len & Crypt) == Crypt) ? true : false; }
inline void PktBase::SetCrypt(void) { m_Len |= Crypt; }
inline bool PktBase::IsCompress(void) { return ((m_Len & Compress) == Compress) ? true : false; }
inline void PktBase::SetCompress(void) { m_Len |= Compress; }
inline PktBase::LengthType PktBase::GetUncompressLen(void) { return PktMaxLen; }
inline void PktBase::SetLen(PktBase::LengthType Len) { m_Len = (m_Len & LengthHdr) | Len; }
inline PktBase::LengthType PktBase::GetLen(void) { return m_Len & LengthMask; }
//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ŷ <20>ش<EFBFBD> <20>ʱ<EFBFBD>ȭ
//
// Parameter :
// 1st : <20><><EFBFBD><EFBFBD>[In]
// 2st : Ŀ<>ǵ<EFBFBD>[In]
// 3st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>[In]
// 4st : <20><><EFBFBD><EFBFBD>[In]
//
// Return :
//
///////////////////////////////////////////////////////////////////////////////////////////////
inline void PktBase::InitPtHead(unsigned short Len_In, unsigned char Cmd_In,
unsigned short State_In, unsigned short Error_In)
{
m_StartBit = StartBit;
m_Cmd = Cmd_In;
m_Len = Len_In;
m_CodePage = 0;
m_SrvInfo.SrvState.wSrvState = State_In;
m_SrvInfo.SrvState.wError = Error_In;
}
inline void PktBase::InitPtHead(unsigned short Len_In, unsigned char Cmd_In, unsigned long Tick_In)
{
m_StartBit = StartBit;
m_Cmd = Cmd_In;
m_Len = Len_In;
m_CodePage = 0;
m_SrvInfo.dwServerInfo = Tick_In;
}
#endif

141
GameTools/GLOBALSCRIPT/Network/Packet/PacketCommand.h Normal file
View File

@@ -0,0 +1,141 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ŷ Ŀ<>ǵ<EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _PACKET_COMMAND_H_
#define _PACKET_COMMAND_H_
#include "PacketBase.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Ŀ<>ǵ<EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
const PktBase::CMDType CmdNull = 0x00;
const PktBase::CMDType CmdAuthAccount = 0x01; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdServerGroup = 0x02; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdUserLogin = 0x03; // <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
const PktBase::CMDType CmdUserKill = 0x04; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharSelect = 0x05; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharCreate = 0x06; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharDelete = 0x07; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharLogin = 0x08; // ij<><C4B3><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
const PktBase::CMDType CmdCharSuicide = 0x09; // ij<><C4B3><EFBFBD><EFBFBD> <20>ڻ<EFBFBD>
const PktBase::CMDType CmdCharRespawn = 0x0A; // ij<><C4B3><EFBFBD><EFBFBD> <20><>Ȱ
const PktBase::CMDType CmdCharMove = 0x0B; // ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD> (P2P)
const PktBase::CMDType CmdCharMoveUpdate = 0x0C; // ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
const PktBase::CMDType CmdCharChat = 0x0D; // ij<><C4B3><EFBFBD><EFBFBD> ä<><C3A4> (P2P)
const PktBase::CMDType CmdCharAttack = 0x0E; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharCastObject = 0x0F; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharUseSkill = 0x10; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharTakeItem = 0x11; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharSwapItem = 0x12; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharRepairItem = 0x13; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharUseItem = 0x14; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharTradeItem = 0x15; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ŷ<EFBFBD>
const PktBase::CMDType CmdCharSkillLock = 0x16; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ų <20><>
const PktBase::CMDType CmdCharSkillCreate = 0x17; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharSkillErase = 0x18; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharClassUpgrade = 0x19; // ij<><C4B3><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD>
const PktBase::CMDType CmdCharShapeInfo = 0x1A; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (P2P)
const PktBase::CMDType CmdCharIncreasePoint = 0x1B; // ij<><C4B3><EFBFBD><EFBFBD> <20>ɷ<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharBindPosition = 0x1C; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>ε<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharRequireInfo = 0x1D; // ij<><C4B3><EFBFBD><EFBFBD> <20>ش<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û
const PktBase::CMDType CmdCharUpdateAddress = 0x1E; // ij<><C4B3><EFBFBD><EFBFBD> UDP <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
const PktBase::CMDType CmdCharPartyCmd = 0x1F; // ij<><C4B3><EFBFBD><EFBFBD> <20><>Ƽ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharPartyMemInfo = 0x20; // ij<><C4B3><EFBFBD><EFBFBD> <20><>Ƽ <20>ɹ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (P2P)
const PktBase::CMDType CmdCharExchangeCmd = 0x21; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȯ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdSysConnectAgent = 0x22; // <20>ý<EFBFBD><C3BD><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD> (UDP <20>߰<EFBFBD>) # <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdSysPacketTransmit = 0x23; // <20>ý<EFBFBD><C3BD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD> (UDP <20>߰<EFBFBD>) # <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharLogout = 0x24; // ij<><C4B3><EFBFBD><EFBFBD> <20>α<EFBFBD> <20>ƿ<EFBFBD>
const PktBase::CMDType CmdDBGetData = 0x25; // DB <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdDBUpdateData = 0x26; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ DB <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdAgentParty = 0x27; // DB <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>Ƽ
const PktBase::CMDType CmdSysServerLogin = 0x28; // <20>ý<EFBFBD><C3BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
const PktBase::CMDType CmdServerZone = 0x29; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdGameCellInfo = 0x2A; // <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>)
const PktBase::CMDType CmdCharInfo = 0x2B; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> # <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharAddressInfo = 0x2C; // ij<><C4B3><EFBFBD><EFBFBD> UDP <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharCellLogin = 0x2D; // ij<><C4B3><EFBFBD><EFBFBD> <20><> <20>α<EFBFBD><CEB1><EFBFBD>
const PktBase::CMDType CmdCharCellLogout = 0x2E; // ij<><C4B3><EFBFBD><EFBFBD> <20><> <20>α׾ƿ<D7BE>
const PktBase::CMDType CmdMonMove = 0x2F; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
const PktBase::CMDType CmdCharAttackInfo = 0x30; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (P2P)
const PktBase::CMDType CmdCharAttacked = 0x31; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharAward = 0x32; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharItemInfo = 0x33; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharPickUp = 0x34; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharPullDown = 0x35; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharPickUpInfo = 0x36; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharPullDownInfo = 0x37; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharCastObjectInfo = 0x38; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharInstallSocket = 0x39; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ
const PktBase::CMDType CmdCharLevelUp = 0x3A; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
const PktBase::CMDType CmdCharPartyInfo = 0x3B; // ij<><C4B3><EFBFBD><EFBFBD> <20><>Ƽ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharUpgradeItem = 0x3C; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD>
const PktBase::CMDType CmdCharHPRegen = 0x3D; // ij<><C4B3><EFBFBD><EFBFBD> HP <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharLevelUpInfo = 0x3E; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharSplitItem = 0x3F; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>ø<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ΰ<EFBFBD><CEB0><EFBFBD> <20>ɰ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>)
const PktBase::CMDType CmdUpdateUIDTable = 0x40; // UID <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
const PktBase::CMDType CmdCharQuickSlotMove = 0x41; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
const PktBase::CMDType CmdCharSwitchHand = 0x42; // <20><> <20>ٲٱ<D9B2>
const PktBase::CMDType CmdSysMngerRegistry = 0x43; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdSysMngerRequest = 0x44; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û
const PktBase::CMDType CmdSysMngerResponse = 0x45; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڷ<EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharTakeItems = 0x46; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD>)
const PktBase::CMDType CmdCharTakeGold = 0x47; // ij<><C4B3><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharExchangeItem = 0x48; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȯ
const PktBase::CMDType CmdCellBroadCasting = 0x49; // <20><> <20><><EFBFBD>ε<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD>
const PktBase::CMDType CmdSysPatchAddress = 0x4A; // <20><>ġ <20>ּ<EFBFBD>
const PktBase::CMDType CmdCharPartyCmdInfo = 0x4B; // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdServerLog = 0x4C; // <20>α<EFBFBD> <20><><EFBFBD><EFBFBD> (???)
const PktBase::CMDType CmdCharWhisper = 0x4D; // ij<><C4B3><EFBFBD><EFBFBD> <20>ӼӸ<D3BC>
const PktBase::CMDType CmdSysServerVerUpdate = 0x4E; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
const PktBase::CMDType CmdSysMng = 0x4F; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><>Ŷ (<28>ӽ<EFBFBD> (???)
const PktBase::CMDType CmdSysChannelUpdate = 0x50; // <20><><EFBFBD><EFBFBD> ä<><C3A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
const PktBase::CMDType CmdCharPartyFind = 0x51; // <20><>Ƽ ã<><C3A3>
const PktBase::CMDType CmdCharPartyMemData = 0x52; // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharControlOption = 0x53; // ij<><C4B3><EFBFBD><EFBFBD> <20>ɼ<EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharDuelCmd = 0x54; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharFameInfo = 0x55; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdLoginServerList = 0x56; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ #!! <20><>ȣ <20><><EFBFBD><EFBFBD> <20>Ұ<EFBFBD> !!#
const PktBase::CMDType CmdCharSpellInfo = 0x57; // ij<><C4B3><EFBFBD><EFBFBD> æƮ&<26><>æƮ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharSkillUnLock = 0x58; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ų <20><> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdSysPing = 0x59; // <20><><EFBFBD><EFBFBD> <20><> <20><>Ŷ
const PktBase::CMDType CmdCharMoveZone = 0x5A; // <20><> <20>̵<EFBFBD>
const PktBase::CMDType CmdAgentZone = 0x5B; // <20><> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdDeposit = 0x5C; // â<><C3A2> ó<><C3B3> <20><>Ŷ(Client <--> GameServer)
const PktBase::CMDType CmdDepositUpdate = 0x5D; // â<><C3A2> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>Ŷ(GameServer <--> DBAgent)
const PktBase::CMDType CmdCharStallOpen = 0x5E; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharStallRegisterItem = 0x5F; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharStallEnter = 0x60; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharStallItemInfo = 0x61; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharAdminCmd = 0x62; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const PktBase::CMDType CmdCharTeamBattleInfo = 0x63; // <20><><EFBFBD><EFBFBD>Ʋ <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdFriendAddRequest = 0x64; // ģ<><C4A3> <20>߰<EFBFBD>
const PktBase::CMDType CmdFriendRemoveRequest = 0x65; // ģ<><C4A3> <20><><EFBFBD><EFBFBD>
const PktBase::CMDType CmdFriendEtcRequest = 0x66; // ģ<><C4A3> <20><>Ÿ
const PktBase::CMDType CmdFriendAck = 0x67; // ģ<><C4A3> Ack
const PktBase::CMDType CmdFriendDB = 0x68; // ģ<><C4A3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><> ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>)
const PktBase::CMDType CmdEliteBonus = 0x69; // <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ʽ<EFBFBD>
const PktBase::CMDType CmdFinalPacketNum = 0x6A; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ <20><>ȣ
#endif

58
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/AddressPacket.h Normal file
View File

@@ -0,0 +1,58 @@
#ifndef _ADDRESS_PACKET_H_
#define _ADDRESS_PACKET_H_
// AddressPacket.h
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
// UDP <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ ( Update Address )
// : Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE> <20>α<EFBFBD><CEB1><EFBFBD> <20>Ŀ<EFBFBD> UDP<44><50> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ѹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>.
// : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE> <20><>Ŷ<EFBFBD><C5B6><EFBFBD><EFBFBD> <20>ܺ<EFBFBD> UDP <20>ּҸ<D6BC> <20><><EFBFBD>´<EFBFBD>.
typedef struct PktUA* LPPktUA;
struct PktUA : public PktBase
{
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// UDP <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ Ack
typedef struct PktUAAck* LPPktUAAck;
struct PktUAAck : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>ü
typedef struct AddressInfo* LPAddressInfo;
struct AddressInfo
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
AddressInfo() : m_dwCharID(0)
{
memset(&m_PublicAddress, 0, sizeof(m_PublicAddress));
memset(&m_PrivateAddress, 0, sizeof(m_PrivateAddress));
}
AddressInfo(const SOCKADDR_IN& PublicAddress, const SOCKADDR_IN& PrivateAddress, const unsigned long dwCharID)
: m_PublicAddress(PublicAddress), m_PrivateAddress(PrivateAddress), m_dwCharID(dwCharID) { }
};
// UDP <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ ( Address Info )
// - <20><><EFBFBD>巹<EFBFBD><E5B7B9> <20><><EFBFBD><EFBFBD>ü
typedef struct PktAI* LPPktAI;
struct PktAI : public PktBase
{
AddressInfo m_AddressInfo;
};
#pragma pack()
#endif

135
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/AuthServerToDBAgentServer.h Normal file
View File

@@ -0,0 +1,135 @@
#ifndef _AUTHSERVER_TO_DBAGENT_SERVER_PACKET_H_
#define _AUTHSERVER_TO_DBAGENT_SERVER_PACKET_H_
#include <winsock2.h>
#include <windows.h>
#include <DB/DBDefine.h>
#include "DataPacket.h"
#pragma pack(1)
// ---------------------------------------------------------
// <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><>û AuthServer -> DBAgentServer
typedef struct PktULD* LPPktULD;
struct PktULD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
IN_ADDR m_Address;
};
// <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD> DBAgentServer -> AuthServer
typedef struct PktULDAck* LPPktULDAck;
struct PktULDAck : public PktDD
{
unsigned long m_dwUserID;
CHAR_VIEW m_CharView[3];
};
// <20><><EFBFBD><EFBFBD> <20>α׾ƿ<D7BE> AuthServer -> DBAgentServer
typedef struct PktULoD *LPPktULoD;
struct PktULoD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> DBAgentServer -> AuthServer
typedef struct PktSSD *LPPktSSD;
struct PktSSD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û AuthServer -> DBAgentServer
typedef struct PktCCD* LPPktCCD;
struct PktCCD : public PktDD
{
unsigned long m_dwUserID;
unsigned long m_dwSlot;
unsigned long m_dwGold;
POS m_Pos;
CHAR_CREATE m_CharCreate;
unsigned short m_wSkill;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> DBAgentServer -> AuthServer
typedef struct PktCCDAck* LPPktCCDAck;
struct PktCCDAck : public PktDD
{
unsigned long m_dwCharID;
unsigned long m_dwSlot;
CHAR_VIEW m_CharView;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktCSD* LPPktCSD;
struct PktCSD : public PktDD
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
};
typedef struct PktCSDAck* LPPktCSDAck;
struct PktCSDAck : public PktDD
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned char m_cZone;
unsigned short m_wChannelNum[MAX_CHANNEL_NUM];
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktCDD* LPPktCDD;
struct PktCDD : public PktDD
{
unsigned long m_dwUserID;
unsigned long m_dwSlotNum;
unsigned long m_dwCharID;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktCCID* LPPktCCID;
struct PktCCID : public PktDD
{
unsigned long m_dwCharID;
unsigned long m_dwSize;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// ij<><C4B3><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktCLiD* LPPktCLiD;
struct PktCLiD : public PktDD
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSerial;
};
// ---------------------------------------------------------
#pragma pack()
#endif

55
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharAdminPacket.h Normal file
View File

@@ -0,0 +1,55 @@
#ifndef _CHAR_ADMIN_PACKET_H_
#define _CHAR_ADMIN_PACKET_H_
// CharAdminPacket.h
#include <winsock2.h>
#include <windows.h>
#include <Network/Packet/PacketBase.h>
#include <DB/DBdefine.h>
#pragma pack(1)
typedef struct PktAdmin* LPPktAdmin;
struct PktAdmin : public PktBase
{
enum { MAX_NAME_LEN = 16 };
enum CMD
{
NONE = 0, // <09><EFBFBD><EEBFB5> <20><><EFBFBD><EFBFBD>
MOVE_ZONE_C = 1, // ij<><C4B3><EFBFBD><EFBFBD> <20><> <20>̵<EFBFBD>
MOVE_ZONE_P = 2, // <09><>Ƽ <20><> <20>̵<EFBFBD>
MOVE_C = 3, // ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD>
MOVE_P = 4, // <09><>Ƽ <20>̵<EFBFBD>
RESPAWN_C = 5, // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
RESPAWN_P = 6, // <09><>Ƽ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
KILL_C = 7, // ij<><C4B3><EFBFBD><EFBFBD> ų
KILL_P = 8, // <09><>Ƽ ų
DUELINIT = 9, // <09><><EFBFBD><EFBFBD> <20>ʱ<EFBFBD>ȭ
CREATEITEM = 10, // <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
CREATEMON = 11, // <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
INFO_C = 12 // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
unsigned short m_usCmd; // <20><EFBFBD><EEBFB5> <20><><EFBFBD><EFBFBD>
char m_stName[MAX_NAME_LEN]; // <20≯<EFBFBD>
union
{
struct ZoneInfo
{
char m_cZone; // <20><> <20><>ȣ
char m_cChannel; // ä<><C3A4> <20><>ȣ
} m_ZoneInfo;
unsigned short m_usProtoTypeID; // Ÿ<><C5B8> <20><><EFBFBD>̵<EFBFBD>
};
POS m_Position; // <20><>ġ
};
#pragma pack()
#endif

181
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharAttackPacket.h Normal file
View File

@@ -0,0 +1,181 @@
#ifndef _CHAR_ATTACK_PACKET_H_
#define _CHAR_ATTACK_PACKET_H_
// CharAttackPacket.h
#include <DB/DBDefine.h>
#include <Network/Packet/PacketBase.h>
#include "CharAttackPacketStruct.h"
#pragma pack(1)
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktAt* LPPktAt;
struct PktAt : public PktBase
{
POS m_Postion; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><>ġ
float m_fDir; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwCharID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
AtType m_AtType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
AtNode m_AtNode; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ Ack (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktAtAck* LPPktAtAck;
struct PktAtAck : public PktBase
{
enum PktAtAckErr
{
NO_SERVER_ERR = 0,
SERVER_ERROR = 1,
FAIL_ATTACK = 2,
FAIL_ALREADY_DEAD = 2
};
unsigned long m_dwCharID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
AtType m_AtType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
unsigned short m_wHP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> HP
unsigned short m_wMP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> MP
unsigned char m_cJudge; // <20>÷<EFBFBD><C3B7><EFBFBD>
unsigned char m_cDefenserNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
unsigned char m_cRightHandValue; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ҵ<EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>)
unsigned char m_cLeftHandValue; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ҵ<EFBFBD>(<28>޼<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>)
unsigned char m_cRightHandIndex; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>)
unsigned char m_cLeftHandIndex; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD>(<28>޼<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>)
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktAtInfo* LPPktAtInfo;
struct PktAtInfo : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
AtType m_AtType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
unsigned char m_cDefenserNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktAted* LPPktAted;
struct PktAted : public PktBase
{
POS m_Postion; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
float m_fDir; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwCharID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> ID
AtType m_AtType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
unsigned short m_wMyHP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> HP
unsigned short m_wMyMP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> MP
unsigned char m_cJudge; // <20><><EFBFBD><EFBFBD> <20><>
unsigned char m_cMyWeaponIndex; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ҿ<EFBFBD>)
unsigned char m_cMyWeaponValue; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ҵ<EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ҿ<EFBFBD>)
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20><><EFBFBD><EFBFBD>, 1 = <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD>, 3 = <20>α׾ƿ<D7BE>, 4 = <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20><><EFBFBD><EFBFBD>, 1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD>Ϳ<EFBFBD><CDBF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û,
// 3 = <20>ź<EFBFBD> <20>ɼ<EFBFBD><C9BC><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktDuC* LPPktDuC;
struct PktDuC : public PktBase
{
enum DuelCmd
{
DUC_PROPOSE = 0, DUC_READY = 1, DUC_REFUSE = 2,
DUC_LOGOUT = 3, DUC_DEAD = 4, DUC_PARTY_PROPOSE = 5,
DUC_PARTY_READY = 6, DUC_REQUEST_PARTY_INFO = 7, DUC_CANCEL = 8
};
enum PktDuCError
{
NO_SERVER_ERR = 0, SERVER_ERROR = 1, FAIL_DUELING_CHAR = 2,
FAIL_REJECT = 3, FAIL_NOT_LEADER = 4, FAIL_NOT_PARTY = 5
};
unsigned long m_dwSenderID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwRecverID; // <20>޴<EFBFBD><DEB4><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cCmd; // <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD>Ʋ <20><><EFBFBD><EFBFBD>
typedef struct PktTBInfo* LPPktTBInfo;
struct PktTBInfo : public PktBase
{
enum DuelCmd
{
DUC_PROPOSE = 0, DUC_READY = 1, DUC_REFUSE = 2,
DUC_LOGOUT = 3, DUC_DEAD = 4, DUC_PARTY_PROPOSE = 5,
DUC_PARTY_READY = 6, DUC_REQUEST_PARTY_INFO = 7
};
unsigned long m_dwCharID;
char m_strChallengerName[CHAR_INFOST::MAX_NAME_LEN];
unsigned char m_cCmd;
unsigned char m_cMemberNum;
};
// ij<><C4B3><EFBFBD><EFBFBD> æƮ&<26><>æƮ <20><><EFBFBD><EFBFBD>
typedef struct PktSpInfo* LPPktSpInfo;
struct PktSpInfo : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_nEnchantLevel; // <20>ֹ<EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned char m_cSpellType; // <20>ֹ<EFBFBD> Ÿ<><C5B8> ( namespace Skill::SpellType<70><65><EFBFBD><EFBFBD> )
bool m_bOnOff; // <20><><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
typedef struct PktRs* LPPktRs;
struct PktRs : public PktBase
{
enum RespawnCmd
{
RS_NORMAL = 0, RS_SELECT = 1
};
unsigned long m_dwCharID;
unsigned char m_cCmd;
POS m_Position;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ack
typedef struct PktRsAck* LPPktRsAck;
struct PktRsAck : public PktBase
{
POS m_Position; // <20><><EFBFBD><EFBFBD> <20><>ġ
__int64 m_dlExp; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_wHP; // HP
unsigned short m_wMP; // MP
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3>
typedef struct PktAw* LPPktAw;
struct PktAw : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned long m_dwExp; // <20><><EFBFBD><EFBFBD>ġ
};
#pragma pack()
#endif

54
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharAttackPacketStruct.h Normal file
View File

@@ -0,0 +1,54 @@
#ifndef _CHAR_ATTACK_PACKET_STRUCT_H_
#define _CHAR_ATTACK_PACKET_STRUCT_H_
#pragma pack(1)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü )
typedef struct AtNode *LPAtNode;
struct AtNode
{
enum { MAX_DEFENDER_NUM = 10 };
unsigned char m_wDefenserNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
unsigned long m_dwDefenser[MAX_DEFENDER_NUM]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cDefenserJudge[MAX_DEFENDER_NUM]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct AtType* LPAtType;
struct AtType
{
enum { SkillBitMask = 0x8000 };
enum Attack
{
Normal = 0,
Move = 1,
ComboLast = 2,
Bow = 3,
CrossBow = 4
};
unsigned short m_wType; // <20><><EFBFBD><EFBFBD> Ÿ<><C5B8> (<28>Ǵ<EFBFBD> <20><>ų ID)
char m_cSkillLevel; // <20><>ų <20><><EFBFBD><EFBFBD> (-127 ~ 128)
unsigned char m_cSkillLockCount : 4; // <20><>ų <20><>ī<EFBFBD><C4AB>Ʈ (0~5)
unsigned char m_cAtCount : 4; // <20><><EFBFBD><EFBFBD> ī<><C4AB>Ʈ (0~15)
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct DefenserNode* LPDefenserNode;
struct DefenserNode
{
unsigned long m_dwCharID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_wMaxHP; // <20>ִ<EFBFBD> HP
unsigned short m_sCurrHP; // <20><><EFBFBD><EFBFBD> HP
unsigned short m_wMaxMP; // <20>ִ<EFBFBD> MP
unsigned short m_sCurrMP; // <20><><EFBFBD><EFBFBD> MP
unsigned short m_wDamage; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
unsigned char m_cJudge; // <20><><EFBFBD><EFBFBD> <20><>
};
#pragma pack()
#endif

329
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharCommunityPacket.h Normal file
View File

@@ -0,0 +1,329 @@
#ifndef _CHAR_COMMUNITY_PACKET_H_
#define _CHAR_COMMUNITY_PACKET_H_
// CharCommunityPacket.h
// DBDefine<6E>ʿ<EFBFBD>.
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#include <Network/Packet/PacketStruct/CharItemPacketStruct.h>
#include "AddressPacket.h"
#include "CharCommunityPacketStruct.h"
#pragma pack(1)
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
typedef struct PktPI* LPPktPI;
struct PktPI : public PktBase
{
PARTY m_Party;
};
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20>ʴ<EFBFBD>, 1 = <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD>
// 3 = <20><><EFBFBD><EFBFBD>, 4 = Ż<><C5BB>, 5 = <20>絵
// 6 = <20>ı<EFBFBD>, 7 = <20>α<EFBFBD><CEB1><EFBFBD>, 8 = <20>α׾ƿ<D7BE>
// 9 = <20><><EFBFBD><EFBFBD>(ij<><C4B3><EFBFBD><EFBFBD>), 10 = <20><><EFBFBD>α<EFBFBD><CEB1><EFBFBD>,
// 11 = <20><>Ƽã<C6BC><C3A3>, 12 = <20><><EFBFBD><EFBFBD>ã<EFBFBD><C3A3>
//
// <20><><EFBFBD><EFBFBD> :
// 1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20>̹<EFBFBD> <20><>Ƽ<EFBFBD><C6BC> <20><><EFBFBD>ԵǾ<D4B5> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>, 3 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// 4 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 5 = Ż<><C5BB> <20><><EFBFBD><EFBFBD>, 6 = <20>絵 <20><><EFBFBD><EFBFBD>, 7 = <20><>Ƽ <20>ο<EFBFBD> <20>ʰ<EFBFBD>,
// 8 = <20>ʴ<EFBFBD> <20><><EFBFBD><EFBFBD>, 9 = <20>ź<EFBFBD> <20>ɼ<EFBFBD><C9BC><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>
//
typedef struct PktPC* LPPktPC;
struct PktPC : public PktBase
{
enum PartyCmd
{
PC_INVITE = 0, PC_ACCEPT = 1, PC_REFUSE = 2,
PC_BANISH = 3, PC_SECESSION = 4, PC_TRANSFER = 5,
PC_DESTROY = 6, PC_LOGIN = 7, PC_LOGOUT = 8,
PC_DELETE = 9, PC_RELOGIN = 10, PC_FINDPARTY = 11,
PC_FINDMEMBER = 12
};
enum PktPCError
{
SERVER_ERROR = 1, CHAR_JOINED = 2, FAIL_ACCEPT = 3,
FAIL_BANISH = 4, FAIL_SECESSION = 5, FAIL_TRANSFER = 6,
OVER_MEMBER = 7, FAIL_INVITE = 8, FAIL_REJECT = 9
};
unsigned long m_dwPartyID; // <20><>Ƽ <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwSenderID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(<28><>ü)
unsigned long m_dwReferenceID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(<28><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>)
unsigned short m_wCmd; // <20><><EFBFBD><EFBFBD>
};
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD> Ack
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20>ʴ<EFBFBD>, 1 = <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD>
// 3 = <20><><EFBFBD><EFBFBD>, 4 = Ż<><C5BB>, 5 = <20>絵
// 6 = <20>ı<EFBFBD>, 7 = <20>α<EFBFBD><CEB1><EFBFBD>, 8 = <20>α׾ƿ<D7BE>
// 9 = <20><><EFBFBD><EFBFBD>(ij<><C4B3><EFBFBD><EFBFBD>)
//
// <20><><EFBFBD><EFBFBD> :
// 1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20>̹<EFBFBD> <20><>Ƽ<EFBFBD><C6BC> <20><><EFBFBD>ԵǾ<D4B5> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>, 3 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// 4 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 5 = Ż<><C5BB> <20><><EFBFBD><EFBFBD>, 6 = <20>絵 <20><><EFBFBD><EFBFBD>, 7 = <20><>Ƽ <20>ο<EFBFBD> <20>ʰ<EFBFBD>
//
typedef struct PktPCAck* LPPktPCAck;
struct PktPCAck : public PktBase
{
enum PartyCmd
{
PC_INVITE = 0, PC_ACCEPT = 1, PC_REFUSE = 2,
PC_BANISH = 3, PC_SECESSION = 4, PC_TRANSFER = 5,
PC_DESTROY = 6, PC_LOGIN = 7, PC_LOGOUT = 8,
PC_DELETE = 9
};
enum PktPCErrorAck
{
SERVER_ERROR = 1, CHAR_JOINED = 2, FAIL_ACCEPT = 3,
FAIL_BANISH = 4, FAIL_SECESSION = 5, FAIL_TRANSFER = 6,
OVER_MEMBER = 7, FAIL_INVITE = 8
};
AddressInfo m_SenderAddressInfo; // Sender<65><72> <20>ּ<EFBFBD>
char m_strSenderName[CHAR_INFOST::MAX_NAME_LEN]; // Sender<65><72> <20≯<EFBFBD>
unsigned long m_dwPartyID; // <20><>Ƽ <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwSenderID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(<28><>ü)
unsigned long m_dwReferenceID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(<28><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>)
unsigned char m_cCmd; // <20><><EFBFBD><EFBFBD>
};
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20>ʴ<EFBFBD>, 1 = <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD>
// 3 = <20><><EFBFBD><EFBFBD>, 4 = Ż<><C5BB>, 5 = <20>絵
// 6 = <20>ı<EFBFBD>, 7 = <20>α<EFBFBD><CEB1><EFBFBD>, 8 = <20>α׾ƿ<D7BE>
// 9 = <20><><EFBFBD><EFBFBD>(ij<><C4B3><EFBFBD><EFBFBD>)
//
// <20><><EFBFBD><EFBFBD> :
// 1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20>̹<EFBFBD> <20><>Ƽ<EFBFBD><C6BC> <20><><EFBFBD>ԵǾ<D4B5> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>, 3 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// 4 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 5 = Ż<><C5BB> <20><><EFBFBD><EFBFBD>, 6 = <20>絵 <20><><EFBFBD><EFBFBD>, 7 = <20><>Ƽ <20>ο<EFBFBD> <20>ʰ<EFBFBD>
//
typedef struct PktPCInfo* LPPktPCInfo;
struct PktPCInfo : public PktBase
{
enum PartyCmd
{
PC_INVITE = 0, PC_ACCEPT = 1, PC_REFUSE = 2,
PC_BANISH = 3, PC_SECESSION = 4, PC_TRANSFER = 5,
PC_DESTROY = 6, PC_LOGIN = 7, PC_LOGOUT = 8,
PC_DELETE = 9
};
enum PktPCInfoError
{
SERVER_ERROR = 1, CHAR_JOINED = 2, FAIL_ACCEPT = 3,
FAIL_BANISH = 4, FAIL_SECESSION = 5, FAIL_TRANSFER = 6,
OVER_MEMBER = 7, FAIL_INVITE = 8
};
unsigned long m_dwPartyID; // <20><>Ƽ ID
unsigned long m_dwMemberID; // <20><><EFBFBD><EFBFBD> ID
unsigned char m_cCmd; // <20><><EFBFBD><EFBFBD>
};
// <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktMD* LPPktMD;
struct PktMD : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_wCmd; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned short m_wLen; // <20><><EFBFBD><EFBFBD>
};
// <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktPM* LPPktPM;
struct PktPM : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwPartyID; // <20><>Ƽ <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwChant; // æƮ <20><><EFBFBD><EFBFBD>
unsigned long m_dwEnchant; // <20><>æƮ <20><><EFBFBD><EFBFBD>
unsigned short m_wMaxHP; // <20>ִ<EFBFBD> HP
unsigned short m_sCurrHP; // <20><><EFBFBD><EFBFBD> HP
unsigned short m_wMaxMP; // <20>ִ<EFBFBD> MP
unsigned short m_sCurrMP; // <20><><EFBFBD><EFBFBD> MP
unsigned char m_cClass; // ij<><C4B3><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD>
unsigned char m_cLevel; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><>Ƽ ã<><C3A3>
typedef struct PktPF* LPPktPF;
struct PktPF : public PktBase
{
unsigned long m_dwCharID;
};
// <20><>Ƽ ã<><C3A3> Ack
typedef struct PktPFAck* LPPktPFAck;
struct PktPFAck : public PktBase
{
enum { MAX_LIST = 30, MAX_DIFF_LEVEL_VIEW = 5 };
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cMemberFindPartyNum; // <20><>Ƽ ã<><C3A3> <20><><EFBFBD><EFBFBD>Ʈ <20><>
unsigned char m_cPartyFindMemberNum; // <20><>Ƽ<EFBFBD><C6BC> ã<><C3A3> <20><><EFBFBD><EFBFBD>Ʈ <20><>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD>嵵) <20><><EFBFBD><EFBFBD>
typedef struct PktFI* LPPktFI;
struct PktFI : public PktBase
{
enum InfoKind
{
NONE = 0,
FAME = 1,
MERITS = 2
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cInfoKind; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD>嵵) <20><><EFBFBD><EFBFBD> Ack
typedef struct PktFIAck* LPPktFIAck;
struct PktFIAck : public PktBase
{
enum InfoKind
{
NONE = 0,
FAME = 1,
MERITS = 2
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwFameOrMerits; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28>Ǵ<EFBFBD> <20><><EFBFBD>嵵)
unsigned char m_cRankingByRace; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned char m_cRankingByClass; // Ŭ<><C5AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned char m_cInfoKind; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20>ɼ<EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktCOp* LPPktCOp;
struct PktCOp : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
RejectOption m_RejectOption; // <20>ź<EFBFBD> <20>ɼ<EFBFBD> <20><>Ʈ<EFBFBD>V
};
// ij<><C4B3><EFBFBD><EFBFBD> ä<><C3A4> <20><>Ŷ.
typedef struct PktCt* LPPktCt;
struct PktCt : public PktBase
{
enum PktCtCmd
{
NORMAL = 0, PARTY = 1,
FRIEND = 2, GUILD = 3,
NOTICE = 4, CLIENT_LOG = 5,
STALL = 6,
PktCtMaxSize = 180
};
unsigned long m_dwCharID;
unsigned short m_sCmd;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>ӻ<EFBFBD><D3BB><EFBFBD> <20><>Ŷ.
typedef struct PktWh* LPPktWh;
struct PktWh : public PktBase
{
enum
{
SERVER_ERROR = 1,
FAIL_CHAR_LOGOUT = 2,
FAIL_REJECT = 3,
FAIL_ENEMY = 4,
PktWhMaxSize = 180
};
char m_SenderName[CHAR_INFOST::MAX_NAME_LEN];
char m_RecverName[CHAR_INFOST::MAX_NAME_LEN];
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ.
typedef struct PktStO* LPPktStO;
struct PktStO : public PktBase
{
enum { MAX_STALL_NAME_LEN = 32 };
unsigned long m_dwCharID;
char m_StallName[MAX_STALL_NAME_LEN];
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ.
typedef struct PktStRI* LPPktStRI;
struct PktStRI : public PktBase
{
enum PktStRICmd
{
SC_REGISTER = 0,
SC_CHANGEPRICE = 1,
SC_CANCEL = 2
};
enum PktStRIEErr
{
SUCCESS = 0,
SERVER_ERROR = 1,
FAIL_NOT_ITEM = 2
};
unsigned long m_dwCharID;
TakeType m_TakeType;
unsigned long m_dwPrice;
unsigned char m_cCmd;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ.
typedef struct PktStE* LPPktStE;
struct PktStE : public PktBase
{
enum PktStEErr
{
SUCCESS = 0,
SERVER_ERROR = 1,
FAIL_FULL_STALL = 2,
FAIL_ENTER = 3,
FAIL_LEAVE = 4
};
unsigned long m_dwCustomerID;
unsigned long m_dwOwnerID;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ.
typedef struct PktStIInfo* LPPktStIInfo;
struct PktStIInfo : public PktBase
{
unsigned long m_dwItemSize;
unsigned short m_wItemNum;
};
#pragma pack()
#endif

52
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharCommunityPacketStruct.h Normal file
View File

@@ -0,0 +1,52 @@
#ifndef _CHAR_COMMUNITY_PACKET_STRUCT_H_
#define _CHAR_COMMUNITY_PACKET_STRUCT_H_
#pragma pack(1)
#include <DB/DBDefine.h>
// <20><>Ƽ ã<><C3A3> <20><><EFBFBD><EFBFBD>ü
typedef struct MemberFindParty* LPMemberFindParty;
struct MemberFindParty
{
char m_strName[CHAR_INFOST::MAX_NAME_LEN]; // <20≯<EFBFBD>
unsigned char m_cLevel; // <20><><EFBFBD><EFBFBD>
unsigned char m_cClass; // Ŭ<><C5AC><EFBFBD><EFBFBD>
};
// <20><>Ƽ<EFBFBD><C6BC> ã<><C3A3> <20><><EFBFBD><EFBFBD>ü
typedef struct PartyFindMember* LPPartyFindMember;
struct PartyFindMember
{
char m_strLeaderName[CHAR_INFOST::MAX_NAME_LEN]; // <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>
unsigned char m_cAverageLevel; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned char m_cMemberNum; // <20><><EFBFBD><EFBFBD> <20><>
};
// <20>ź<EFBFBD> <20>ɼ<EFBFBD>
typedef struct RejectOption* LPRejectOption;
struct RejectOption
{
union
{
struct RejectStruct
{
unsigned short m_Party : 1;
unsigned short m_Exchange : 1;
unsigned short m_Duel : 1;
unsigned short m_Whisper : 1;
unsigned short m_Remainder : 12;
};
RejectStruct Reject;
unsigned short m_wReject;
};
RejectOption() : m_wReject(0) { }
RejectOption(unsigned short wReject) : m_wReject(wReject) { }
};
#pragma pack()
#endif

451
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharItemPacket.h Normal file
View File

@@ -0,0 +1,451 @@
#ifndef _CHAR_ITEM_PACKET_H_
#define _CHAR_ITEM_PACKET_H_
// CharItemPacket.h
// ItemStructure.h<><68> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20><>. (<28><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, )
#include <Item/ItemStructure.h>
#include <Network/Packet/PacketBase.h>
#include "CharItemPacketStruct.h"
#pragma pack(1)
// <20><><EFBFBD><EFBFBD> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktPU* LPPktPU;
struct PktPU : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwObjectID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>̵<EFBFBD>
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
};
// <20><><EFBFBD><EFBFBD> <20><>Ŷ Ack
typedef struct PktPUAck* LPPktPUAck;
struct PktPUAck : public PktBase
{
enum ObjectType { Item = 0, Gold = 1 };
enum PktPUAckError
{
SERVER_ERROR = 1,
FAIL_GET_CELL = 2,
FAIL_GET_ITEM = 3,
FAIL_PICKUP_INVEN = 4
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwObjectID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwSize; // Objectũ<74><C5A9>(Ȥ<><C8A4> <20><> <20><>)
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_cType; // Object<63><74><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȥ<><C8A4> <20><>)
unsigned char m_cNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktPUInfo PktPUInfo, *LPPktPUInfo;
struct PktPUInfo : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwObjectID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>̵<EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktPD* LPPktPD;
struct PktPD : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ <20><> <20>ε<EFBFBD><CEB5><EFBFBD>
unsigned char m_cNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ack
typedef struct PktPDAck* LPPktPDAck;
struct PktPDAck : public PktBase
{
enum PktPDAckError
{
SERVER_ERROR = 1,
FAIL_GET_CELL = 2,
FAIL_DROP_INVEN = 3,
FAIL_DROP_FIELD = 4,
FAIL_ZERO_ITEM = 5
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
FieldObject m_FieldObject; // FieldObject
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ <20><> <20>ε<EFBFBD><CEB5><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktPDInfo* LPPktPDInfo;
struct PktPDInfo : public PktBase
{
unsigned long m_dwCharID;
FieldObject m_FieldObject;
};
// <20><> <20><><EFBFBD><EFBFBD>
typedef struct PktCeInfo* LPPktCeInfo;
struct PktCeInfo : public PktBase
{
unsigned char m_cObjectNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktTI* LPPktTI;
struct PktTI : public PktBase
{
enum PktTIError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
TakeType m_TakeType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
};
// <20><> ó<><C3B3> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktTG* LPPktTG;
struct PktTG : public PktBase
{
enum PktTGError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2,
GOLD_OVERFLOW = 3
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwGold; // <20><> <20>׼<EFBFBD>
unsigned char m_cSrcPos : 4; // Src<72><63>ġ - TakeType <20><><EFBFBD><EFBFBD>
unsigned char m_cDstPos : 4; // Dst<73><74>ġ - TakeType <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktTIs* LPPktTIs;
struct PktTIs : public PktBase
{
enum PktTlsError
{
SERVER_ERROR = 1
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_TakeNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktSwI* LPPktSwI;
struct PktSwI : public PktBase
{
enum PktSwlError
{
SERVER_ERROR = 1,
FAIL_SRC_MOVE = 2,
FAIL_DST_MOVE = 3,
CANT_SWAP = 4
};
unsigned long m_dwCharID; // - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
TakeType m_SwapSrc; // - <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
TakeType m_SwapDst; // - <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ŷ<EFBFBD> <20><>Ŷ
typedef struct PktTr* LPPktTr;
struct PktTr : public PktBase
{
enum PktTrError
{
NO_SERVER_ERR = 0,
SERVER_ERROR = 1,
FAIL_DROP_INVEN = 2,
WRONG_NPC = 3,
FAIL_ITEM_BUY = 4,
FAIL_PUT_INVEN = 5
};
unsigned long m_dwCustomerID; // <20>մ<EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwOwnerID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> (NPC <20>Ǵ<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD>)
unsigned short m_wBuyItemID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID (0<≯<EFBFBD> <20>ȱ<EFBFBD>)
TakeType m_TakeType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ŷ<EFBFBD> <20><>Ŷ Ack (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktTrAck* LPPktTrAck;
struct PktTrAck : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwNPCID; // <20><><EFBFBD><EFBFBD> NPC <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwGold; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
unsigned short m_wSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>(0 = <20>ȱ<EFBFBD>, 0<><30> <20>ƴϸ<C6B4> <20><><EFBFBD><EFBFBD>)
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_cNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktRpI* LPPktRpI;
struct PktRpI : public PktBase
{
enum Pos
{
EQUIPMENT = 1,
INVENTORY = 2,
EQUIPMENT_ALL = 3,
INVENTORY_ALL = 4,
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwGold; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktUI* LPPktUI;
struct PktUI : public PktBase
{
enum PktUIAck
{
SERVER_ERROR = 1,
USE_FAILED = 2
};
unsigned long m_dwSender; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwRecver; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ ( <20><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD> )
typedef struct PktCO* LPPktCO;
struct PktCO : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwReceiverID; // <20>޴<EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ (Cast Object)
typedef struct PktCOInfo* LPPktCOInfo;
struct PktCOInfo : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwReceiverID; // <20>޴<EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD> <20><>ġ <20><>Ŷ
typedef struct PktIS* LPPktIS;
struct PktIS : public PktBase
{
unsigned long m_dwCharID;
Item::ItemPos m_equipPos; // <20><><EFBFBD><EFBFBD> <20><>ġ
Item::ItemPos m_gemPos; // <20><><EFBFBD><EFBFBD> <20><>ġ
};
// <20><><EFBFBD><EFBFBD> <20><>ġ <20><>Ŷ Ack (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktISAck* LPPktISAck;
struct PktISAck : public PktBase
{
unsigned long m_dwCharID;
Item::ItemPos m_equipPos; // <20><><EFBFBD><EFBFBD> <20><>ġ
Item::ItemPos m_gemPos; // <20><><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_wSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
};
// <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
typedef struct PktUgI* LPPktUgI;
struct PktUgI : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cMineralNum; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ack (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü)
typedef struct PktUgIAck* LPPktUgIAck;
struct PktUgIAck : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ø<EFBFBD> <20><>û (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktSplt* LPPktSplt;
struct PktSplt : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
TakeType m_TakeType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
// ( Src : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, Dst : <20><><EFBFBD><EFBFBD><EFBFBD><20><><EFBFBD><EFBFBD> <20>ڸ<EFBFBD>(<28>׻<EFBFBD> <20><><EFBFBD><EFBFBD> <20>־<EFBFBD><D6BE><EFBFBD> <20><>),
// Num : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ø<EFBFBD> Ack (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>) (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü (<28><><EFBFBD><EFBFBD><EFBFBD><20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>))
typedef struct PktSpItAck* LPPktSpItAck;
struct PktSpItAck : public PktBase
{
enum PktSpltAckError
{
SERVER_ERROR = 1,
FAIL_SPLIT = 2
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
TakeType m_TakeType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü
unsigned char m_cSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
};
// <20><> <20><><EFBFBD><EFBFBD> <20>̵<EFBFBD> (<28><><EFBFBD><EFBFBD> <20>ʿ<EFBFBD>)
typedef struct PktQSM* LPPktQSM;
struct PktQSM : public PktBase
{
enum PktQSMError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2
};
TakeType m_TakeType;
};
// <20><><EFBFBD><EFBFBD>ġ <20>ڵ<EFBFBD>
typedef struct PktSwH* LPPktSwH;
struct PktSwH : public PktBase
{
unsigned char m_cSelect; // <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> ( 1 = <20><><EFBFBD><EFBFBD>1 & <20><><EFBFBD><EFBFBD>1, 2 = <20><><EFBFBD><EFBFBD>2 & <20><><EFBFBD><EFBFBD>2 )
};
// <20><>ȯ <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20><><EFBFBD><EFBFBD>, 1 = <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD>, 3 = Ȯ<><C8AE>, 4 = Ȯ<><C8AE> <20><><EFBFBD><EFBFBD>, 5 = <20>ŷ<EFBFBD> <20><><EFBFBD><EFBFBD>, 6 = <20>ŷ<EFBFBD> <20><><EFBFBD><EFBFBD>
//
// <20><><EFBFBD><EFBFBD> :
// 0 = <20><><EFBFBD><EFBFBD>, 1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20>̹<EFBFBD> <20><>ȯ<EFBFBD><C8AF><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD>Ϳ<EFBFBD><CDBF><EFBFBD> <20><>ȯ <20><>û,
// 3 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ȯ<><C8AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¿<EFBFBD><C2BF><EFBFBD> <20>ŷ<EFBFBD> <20><><EFBFBD><EFBFBD>, 4 = <20>ź<EFBFBD> <20>ɼ<EFBFBD><C9BC><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
typedef struct PktExC* LPPktExC;
struct PktExC : public PktBase
{
enum ExchageCmd
{
EXC_PROPOSE = 0, EXC_ACCEPT = 1, EXC_REFUSE = 2,
EXC_OK = 3, EXC_CANCEL = 4, EXC_EXCHANGE = 5,
EXC_QUIT = 6, EXC_LOCK = 7, EXC_UNLOCK = 8
};
enum PktExCError
{
NO_SERVER_ERR = 0, SERVER_ERROR = 1, FAIL_EXCHANGING_CHAR = 2,
FAIL_NOT_ALL_OK = 3, FAIL_REJECT = 4
};
unsigned long m_dwSenderID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwRecverID; // <20>޴<EFBFBD><DEB4><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cCmd; // <20><><EFBFBD><EFBFBD>
};
// <20><>ȯ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (+ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü)
typedef struct PktExI* LPPktExI;
struct PktExI : public PktBase
{
enum Type
{
Item = 0,
Gold = 1,
Remove = 2
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned long m_dwSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>(Ȥ<><C8A4> <20><> <20><>)
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
unsigned char m_cType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> = 0, <20><> = 1)
unsigned char m_cNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(stack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
};
namespace Deposit
{
enum Const { PASSWORD_LENGTH = 4 };
};
// â<><C3A2> <20><>Ŷ (GameServer <--> DBAgent)
// <20>α<EFBFBD><CEB1>νÿ<CEBD>, PktDBUpdate<74><65> <20><><EFBFBD><EFBFBD> <20><>, PktDepositUpdateDB<44><42> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ش<EFBFBD>.
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> m_bUpdateComplete<74><65> true<75><65> Set<65><74> <20>ش<EFBFBD>.
// <20><><EFBFBD><EFBFBD> <20>߿<EFBFBD><DFBF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>÷<EFBFBD> Update<74><65> <20>Ѵ<EFBFBD>.
typedef struct PktDepositUpdateDB* LPPktDepositUpdateDB;
struct PktDepositUpdateDB : public PktBase
{
enum TabFlag
{
ITEM_TAB1 = ( 1 << 0 ),
ITEM_TAB2 = ( 1 << 1 ),
ITEM_TAB3 = ( 1 << 2 ),
ITEM_TAB4 = ( 1 << 3 ),
USED_DEPOSIT = ( 1 << 30), // 0 : â<><C3A2> <20><><EFBFBD><EFBFBD> X, 1 : â<><C3A2> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
SAVED_PASSWORD = ( 1 << 31) // 0 : NOSAVE 1 : SAVE
};
enum TabNum
{
TAB_12 = 0,
TAB_34 = 1,
};
unsigned long m_dwUID; // ij<><C4B3><EFBFBD><EFBFBD> UID
unsigned long m_dwCID; // ij<><C4B3><EFBFBD><EFBFBD> CID
unsigned long m_dwTabFlag; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¸<EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD><EFBFBD> bitset
unsigned short m_usDataSize; // <20><>(Ȥ<><C8A4> <20><>ȣ) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>. <20><>ȣ<EFBFBD><C8A3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Deposit::PASSWORD_LENGTH<54><48> <20><><EFBFBD>ƾ<EFBFBD> <20>Ѵ<EFBFBD>.
unsigned char m_cTabNum; // password<72><64> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> PASSWORD_TABNUM<55><4D>
bool m_bUpdateComplete; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>Ϸ<EFBFBD><CFB7>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD>, true<75><65> set.
};
// â<><C3A2> <20><>Ŷ (Client <--> GameServer)
struct PktDeposit : public PktBase
{
enum CMD
{
LOGIN = 1, // Ack<63><6B><EFBFBD><EFBFBD>(Ack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) (Client<->GameServer) szData[0]~[3]<5D><> password, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 1byte (0, 1)
BUY_TAB = 2, // Ack<63><6B><EFBFBD><EFBFBD>(Ack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) (Client<->GameServer) szData[0]<5D><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ȣ<EFBFBD><C8A3> <20>־<EFBFBD> <20><>
RETURN_TAB = 3, // Ack<63><6B><EFBFBD><EFBFBD>(Ack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) (Client<->GameServer) szData[0]<5D><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ȣ<EFBFBD><C8A3> <20>־<EFBFBD> <20><>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
LOGOUT = 4, // Ack<63><6B><EFBFBD><EFBFBD> (Client->GameServer) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
CHANGE_PASS = 5, // Ack<63><6B><EFBFBD><EFBFBD> (Client->GameServer) szData[0]~[3]<5D><> password. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>¿<EFBFBD><C2BF><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
SAVED_PASS = 6, // Ack<63><6B><EFBFBD><EFBFBD> (GameServer -> Client) <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1>ν<EFBFBD> <20><>. szData[0]~[3]<5D><> Gold, [4]<5D><> <20><>ȣ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 1byte (0, 1)
PASSWORD = 7, // AgentServer -> GameServer (CID, Password), GameServer -> AgentServer (UID, Password)
GOLD = 8 // AgentServer -> GameServer (CID, Gold), GameServer -> AgentServer (UID, Gold)
};
enum DepositError
{
SERVER_ERROR = 1,
INSUFFICIENT_MONEY = 2,
AUTH_FAILED = 3,
INVALID_ARGUMENT = 4
};
enum { MIN_DATA_SIZE = Deposit::PASSWORD_LENGTH + 4 };
unsigned char m_cCmd;
char m_szData[MIN_DATA_SIZE];
};
#pragma pack()
#endif

58
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharItemPacketStruct.h Normal file
View File

@@ -0,0 +1,58 @@
#ifndef _CHAR_ITEM_PACKET_STRUCT_H_
#define _CHAR_ITEM_PACKET_STRUCT_H_
#include <DB/DBDefine.h>
#include <Item/ItemStructure.h>
#pragma pack(1)
// <20>ʵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>ü
typedef struct FieldObject* LPFieldObject;
struct FieldObject
{
enum CheckBit { Gold = 0x80000000 };
POS m_Pos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
unsigned long m_dwOID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>̵<EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȥ<><C8A4> Object )
unsigned long m_dwTypeID; // Ÿ<><C5B8> <20><><EFBFBD>̵<EFBFBD> (<28><><EFBFBD><EFBFBD> 1<><31>Ʈ <20><><EFBFBD≯<EFBFBD> <20><>)
unsigned long m_dwStatusFlag; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> chant, enchant <20><><EFBFBD><EFBFBD> Flag
unsigned char m_cNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
};
// TakeType
typedef struct TakeType* LPTakeType;
struct TakeType
{
enum TakeSource
{
TS_NONE = 0, TS_EQUIP = 1,
TS_INVEN = 2, TS_QSLOT = 3,
TS_SSLOT = 4, TS_TEMP = 6,
TS_UPGRADE = 7, TS_EXCHANGE = 8,
TS_DEPOSIT = 9, TS_STALL = 10
};
Item::ItemPos m_srcPos;
Item::ItemPos m_dstPos;
unsigned char m_cNum;
TakeType() : m_cNum(0) { }
TakeType(Item::ItemPos srcPos, Item::ItemPos dstPos, unsigned char cNum)
: m_srcPos(srcPos), m_dstPos(dstPos), m_cNum(cNum) { }
};
// ij<><C4B3>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>ü (Cast Object)
typedef struct CastObject* LPCastObject;
struct CastObject
{
POS m_DstPos; // <20><><EFBFBD><EFBFBD> <20><>ġ
unsigned long m_dwTargetID; // Ÿ<><C5B8> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_wTypeID; // <20><><EFBFBD>̵<EFBFBD> ( <20><><EFBFBD>ϰ<EFBFBD><CFB0><EFBFBD> <20>ݾ<EFBFBD> )
unsigned char m_cObjectType; // <20><><EFBFBD><EFBFBD> ( 0 = ij<><C4B3>Ʈ, <20><><EFBFBD><EFBFBD> <20><>, 2 = <20><> )
unsigned char m_cObjectLevel; // <20><><EFBFBD><EFBFBD>
};
#pragma pack()
#endif

66
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharLoginOutPacket.h Normal file
View File

@@ -0,0 +1,66 @@
#ifndef _CHAR_LOGIN_OUT_PACKET_H_
#define _CHAR_LOGIN_OUT_PACKET_H_
// CharLoginOutPacket.h
#include <winsock2.h>
#include <windows.h>
#include <Network/Packet/PacketBase.h>
#include "CharLoginOutPacketStruct.h"
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
class CSession;
#pragma pack(1)
typedef struct PktDBUpdate* LPPktDBUpdate;
struct PktDBUpdate : public PktBase
{
unsigned __int64 m_dlItemSerial; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD>
unsigned long m_dwSessionID; // <20><><EFBFBD><EFBFBD> ID
unsigned long m_dwUserID; // <20><><EFBFBD><EFBFBD> ID
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
CSession* m_lpSession; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
IN_ADDR m_Address; // <20>ּ<EFBFBD>
unsigned short m_TypeCode; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ Ÿ<><C5B8>
unsigned short m_usUpdate[DBUpdateData::MAX_UPDATE_DB]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> (Char Login)
typedef struct PktCLi* LPPktCLi;
struct PktCLi : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSessionID;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> Ack (1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
typedef struct PktCLiAck* LPPktCLiAck;
struct PktCLiAck : public PktBase
{
SOCKADDR_IN m_GSSUDPAddr;
unsigned long m_dwServerTime;
unsigned char m_cAdmin;
unsigned short m_usUpdate[DBUpdateData::MAX_UPDATE_DB];
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>α׾ƿ<D7BE> (Char Logout)
typedef struct PktCLo* LPPktCLo;
struct PktCLo : public PktBase
{
unsigned long m_dwCharID;
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>α׾ƿ<D7BE> (Char Logout)
typedef struct PktCLoAck* LPPktCLoAck;
struct PktCLoAck : public PktBase
{
unsigned long m_dwCharID;
};
#pragma pack()
#endif

30
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharLoginOutPacketStruct.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef _CHAR_LOGIN_OUT_PACKET_STRUCT_
#define _CHAR_LOGIN_OUT_PACKET_STRUCT_
namespace DBUpdateData
{
enum UpdateList
{
STATUS_UPDATE = 0, POSITION_UPDATE = 1,
SKILL_UPDATE = 2, QUICKSLOT_UPDATE = 3,
ITEM_EQUIP_UPDATE = 4, ITEM_INVEN_UPDATE = 5,
ITEM_EXTRA_UPDATE = 6, ITEM_EXCHANGE_UPDATE = 7,
MAX_UPDATE_DB = 8
};
enum UpdateType
{
LOGIN = 0, LOGOUT = 1,
UPDATE = 2, ADMIN_LOGIN = 3,
ZONEMOVE = 4
};
enum Limit
{
MAX_DBUPDATE_SIZE = 8000
};
};
#endif

93
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharMovePacket.h Normal file
View File

@@ -0,0 +1,93 @@
#ifndef _CHAR_MOVE_PACKET_H_
#define _CHAR_MOVE_PACKET_H_
// CharMovePacket.h
#include <Network/Packet/PacketBase.h>
#include <DB/DBdefine.h>
#pragma pack(1)
// ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD> <20><>Ŷ (CharMove)
typedef struct PktMV* LPPktMV;
struct PktMV : public PktBase
{
POS m_Position; // ij<><C4B3><EFBFBD><EFBFBD> <20><>ġ
float m_fDir; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned long m_dwChantEf; // Chant Effect
unsigned long m_dwEnchantEf; // Enchant Effect
unsigned short m_wUAct; // <20>׼<EFBFBD> <20><>ȣ
unsigned short m_wLAct; // <20>׼<EFBFBD> <20><>ȣ
unsigned char m_wLevel; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>Ŷ ( Char Move Update )
typedef struct PktMU* LPPktMU;
struct PktMU : public PktBase
{
POS m_Position; // <20><>ġ
float m_fDir; // <20><><EFBFBD><EFBFBD>
unsigned long m_dwTick; // Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ ƽ
bool m_bSitMode; // <20>ɱ<EFBFBD> (true = <20>ɾ<EFBFBD> <20><><EFBFBD><EFBFBD>.)
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>Ŷ Ack ( Char Move Update )
typedef struct PktMUAck* LPPktMUAck;
struct PktMUAck : public PktBase
{
unsigned long m_dwTick; // Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ ƽ (ó<><C3B3> <20>ð<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
unsigned char m_cFlag; // - <20>÷<EFBFBD><C3B7><EFBFBD> (0 = <20>̵<EFBFBD>, 1 = <20><><EFBFBD>̵<EFBFBD>)
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ( Monster Move )
typedef struct PktMM* LPPktMM;
struct PktMM : public PktBase
{
POS m_Position; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
float m_fDir; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
float m_fVec; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ӵ<EFBFBD>
unsigned long m_dwMonID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_wAct; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ൿ
unsigned short m_wAniNum; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD> Ƚ<><C8BD>
};
namespace CellCommand
{
enum Type
{
CELL_MOVE = 0,
CELL_LOGIN = 1,
RESPAWN = 2
};
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><> <20>α<EFBFBD><CEB1><EFBFBD> <20><>Ŷ (Char Cell Login)
typedef struct PktCCLi* LPPktCCLi;
struct PktCCLi : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
POS m_Pos;
unsigned long m_dwCharID;
unsigned char m_cCmd; // see namespace CellCommand
};
// ij<><C4B3><EFBFBD><EFBFBD> <20><> <20>α׾ƿ<D7BE> <20><>Ŷ ( Char Cell Logout )
typedef struct PktCCLo* LPPktCCLo;
struct PktCCLo : public PktBase
{
unsigned long m_dwCharID;
unsigned char m_cCmd; // see namespace CellCommand
};
// <20><> <20><><EFBFBD>ε<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> + Address<73><73><EFBFBD><EFBFBD>ü
typedef struct PktCB PktCB, *LPPktCB;
struct PktCB : public PktBase
{
unsigned short m_sCharNum; // <20><> ij<><C4B3><EFBFBD><EFBFBD> <20><>
};
#pragma pack()
#endif

0
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharPacketStruct.h Normal file
View File

181
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharStatusPacket.h Normal file
View File

@@ -0,0 +1,181 @@
#ifndef _CHAR_STATUS_PACKET_H_
#define _CHAR_STATUS_PACKET_H_
// CharStatusPacket.h
#include <Network/Packet/PacketBase.h>
#include <DB/DBdefine.h>
#include <Item/ItemStructure.h>
#include "CharStatusPacketStruct.h"
#pragma pack(1)
// ij<><C4B3><EFBFBD><EFBFBD> <20>ڻ<EFBFBD>
typedef struct PktSC* LPPktSC;
struct PktSC : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>ڻ<EFBFBD> Ack
typedef struct PktSCAck PktSCAck, *LPPktSCAck;
struct PktSCAck : public PktBase
{
POS m_Pos;
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
};
// <20><><EFBFBD>ε<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
typedef struct PktBP* LPPktBP;
struct PktBP : public PktBase
{
POS m_Pos; // <20><><EFBFBD>ε<EFBFBD><CEB5><EFBFBD> <20><>ġ
char m_cZone; // <20><><EFBFBD>ε<EFBFBD><CEB5><EFBFBD> <20><>
unsigned long m_dwNPCID; // <20><><EFBFBD>ε<EFBFBD><CEB5><EFBFBD> NPC ID
unsigned char m_cCmd; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (0 = <20><><EFBFBD>̺<EFBFBD> <20><>ġ, 1 = <20><>ġ <20>̵<EFBFBD>)
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktLU* LPPktLU;
struct PktLU : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cLevel; // <20><><EFBFBD><EFBFBD>
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktLUInfo* LPPktLUInfo;
struct PktLUInfo : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cLevel; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
// <20>ɷ<EFBFBD>ġ <20><><EFBFBD><EFBFBD>
typedef struct PktIP* LPPktIP;
struct PktIP : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned char m_cStateType; // <20>ɷ<EFBFBD>ġ Ÿ<><C5B8>
};
// <20>ɷ<EFBFBD>ġ <20><><EFBFBD><EFBFBD> Ack
typedef struct PktIPAck* LPPktIPAck;
struct PktIPAck : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
};
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD>
typedef struct PktCU* LPPktCU;
struct PktCU : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned char m_cClass; // Ŭ<><C5AC><EFBFBD><EFBFBD> <20><>ȣ
};
// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD>׷<EFBFBD><D7B7>̵<EFBFBD> Ack
typedef struct PktCUAck* LPPktCUAck;
struct PktCUAck : public PktBase
{
ChState m_State; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned short m_wSkill; // <20><>ų ID
unsigned char m_cIndex; // <20><>ų <20>ε<EFBFBD><CEB5><EFBFBD>
unsigned char m_cClass; // Ŭ<><C5AC><EFBFBD><EFBFBD> <20><>ȣ
};
// <20><>ų (<28><><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><>/<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
typedef struct PktSk* LPPktSk;
struct PktSk : public PktBase
{
enum PktSkError
{
SERVER_ERROR = 1, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
FAIL_NOT_SKILL = 2, // <20><>ų <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
FAIL_NOT_ENOUGH_SLOT = 4, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
FAIL_NON_LEVEL = 3, FAIL_ALREADY_LOCK = 4, // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
FAIL_FULL_LOCK = 3, FAIL_NOT_ENOUGH_LEVEL = 4, // <20><> <20><><EFBFBD><EFBFBD>
FAIL_NON_LOCK = 3, // <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
};
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> ID
unsigned short m_wSkill; // <20><>ų <20><>ȣ
unsigned char m_cIndex; // <20><>ų <20><>ġ
};
// <20><>ų <20><> <20><><EFBFBD><EFBFBD>
typedef struct PktSkUL* LPPktSkUL;
struct PktSkUL : public PktSk
{
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ġ
};
// <20><>ų <20><> <20><><EFBFBD><EFBFBD> Ack
typedef struct PktSkULAck* LPPktSkULAck;
struct PktSkULAck : public PktSk
{
unsigned long m_dwGold; // <20>Һ<EFBFBD> <20>ݾ<EFBFBD>
Item::ItemPos m_itemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ġ
};
// HP <20><><EFBFBD><EFBFBD> <20><>Ŷ ( Char HP Regen )
typedef struct PktHP* LPPktHP;
struct PktHP : public PktBase
{
unsigned long m_dwCharID; // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned short m_sHP; // <20><><EFBFBD><EFBFBD> hp
unsigned short m_sMP; // <20><><EFBFBD><EFBFBD> mp
};
// <20><><EFBFBD><EFBFBD> <20><>û ( Require Info )
// - P2P<32><50> <20>ٸ<EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ÿ<EFBFBD><C3BF><EFBFBD> <20>ּҳ<D6BC><D2B3><EFBFBD><EFBFBD><EFBFBD> <20>߰<EFBFBD> <20>Ǹ<EFBFBD>,
// <09>ش<EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> <20>ǰڴ<C7B0>.
typedef struct PktRI* LPPktRI;
struct PktRI : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // <20>ش<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
unsigned char m_cCmd; // Ŀ<>ǵ<EFBFBD> (0 : HP, MP <20><><EFBFBD><EFBFBD>, 1 : UDP <20>ּ<EFBFBD>, 2 : <20><><EFBFBD><EFBFBD>)
};
// ij<><C4B3><EFBFBD><EFBFBD> <20>Ѹ<EFBFBD><D1B8><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktSI* LPPktSI;
struct PktSI : public PktBase
{
enum { MAX_STALL_NAME_LEN = 32 };
enum WEAPON_HAND
{
WEAPON_HAND1 = 1,
WEAPON_HAND2 = 2
};
CHAR_VIEW m_CharView; // ij<><C4B3><EFBFBD><EFBFBD> <20>Ѹ<EFBFBD><D1B8><EFBFBD>
unsigned long m_dwStatusFlag; // ij<><C4B3><EFBFBD>Ϳ<EFBFBD> <20>ɷ<EFBFBD> <20>ִ<EFBFBD> chant, enchant Flag
unsigned char m_cSelectedHands; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> (1 = <20><><EFBFBD><EFBFBD>1 & <20><><EFBFBD><EFBFBD>1, 2 = <20><><EFBFBD><EFBFBD>2 & <20><><EFBFBD><EFBFBD>2)
char m_StallName[MAX_STALL_NAME_LEN]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD>
};
// <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ʽ<EFBFBD>
typedef struct PktEB* LPPktEB;
struct PktEB : public PktBase
{
EliteBonus m_EliteBonus;
};
#pragma pack()
#endif

31
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/CharStatusPacketStruct.h Normal file
View File

@@ -0,0 +1,31 @@
#ifndef _CHAR_STATUS_PACKET_STRUCT_H_
#define _CHAR_STATUS_PACKET_STRUCT_H_
#pragma pack(1)
// ij<><C4B3><EFBFBD><EFBFBD> <20>ɷ<EFBFBD>ġ
typedef struct ChState* LPChState;
struct ChState
{
unsigned short m_wIP;
unsigned short m_wSTR;
unsigned short m_wDEX;
unsigned short m_wCON;
unsigned short m_wINT;
unsigned short m_wWIS;
};
typedef struct EliteBonus* LPEliteBonus;
struct EliteBonus
{
enum { MAX_BONUS_LEVEL = 5 };
char m_cNation;
unsigned char m_cLevel;
EliteBonus() : m_cNation(0), m_cLevel(0) { }
};
#pragma pack()
#endif

207
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/ClientToAuthServer.h Normal file
View File

@@ -0,0 +1,207 @@
#ifndef _CLIENT_TO_AUTH_SERVER_PACKET_H_
#define _CLIENT_TO_AUTH_SERVER_PACKET_H_
#include <DB/DBDefine.h>
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û (Client to AuthServer)
// - <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20>н<EFBFBD><D0BD><EFBFBD><EFBFBD><EFBFBD>
// - Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
//
// : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD>´<EFBFBD>.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktAU* LPPktAU;
struct PktAU : public PktBase
{
enum { NAME_LEN = 16 };
char m_UserAccount[NAME_LEN];
char m_UserPassword[NAME_LEN];
unsigned long m_ClientVerInfo;
unsigned short m_cFlag;
unsigned long m_dwSessionID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (AuthServer to Client)
// - <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20>н<EFBFBD><D0BD><EFBFBD><EFBFBD><EFBFBD>
// - Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
//
// : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD>´<EFBFBD>.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktAUAck* LPPktAUAck;
struct PktAUAck : public PktBase
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> (Client to AuthServer)
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> ť <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// : <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20>Ŀ<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>´<EFBFBD>.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktULi* LPPktULi;
struct PktULi : public PktBase
{
DWORD m_dwSessionID;
DWORD m_dwUserID;
DWORD m_dwServerID;
DWORD m_dwCheckSum;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> Ack (AuthServer to Client)
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// (1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktULiAck* LPPktULiAck;
struct PktULiAck : public PktBase
{
enum { SERVER_ERROR = 1, FAIL_GET_DATA = 2 };
unsigned long m_dwUserID;
CHAR_VIEW m_CharView[3];
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ( Char Select )
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
//
// : ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ش<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ϳ<EFBFBD> <20>ּҸ<D6BC> <20>Ѱ<EFBFBD> <20>޴´<DEB4>.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCS* LPPktCS;
struct PktCS : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ack
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> ť <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// - GSS <20><><EFBFBD><EFBFBD> <20>ּ<EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCSAck* LPPktCSAck;
struct PktCSAck : public PktBase
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned char m_cZone;
unsigned short m_wChannelNum[MAX_CHANNEL_NUM];
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ( Char Create )
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><>ȣ
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// - <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD>)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCC* LPPktCC;
struct PktCC : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwSlotNum;
CHAR_CREATE m_CreateChar;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ack
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><>ȣ
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//
// (1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 3 = <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> ij<><C4B3><EFBFBD><EFBFBD> <20≯<EFBFBD>, 4 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>,
// 5 = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>, 6 = <20>߸<EFBFBD><DFB8><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCCAck* LPPktCCAck;
struct PktCCAck : public PktBase
{
unsigned long m_dwCharID;
unsigned long m_dwSlotNum;
CHAR_VIEW m_CharView;
enum
{
SERVER_ERROR = 1, FAIL_INSERT_DATA = 2,
EXIST_CHAR_NAME = 3, EXIST_SLOT = 4,
WRONG_CHAR_NAME = 5, WRONG_CHAR_DATA = 6
};
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ( Char Delete )
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><>ȣ
// - <20><>Ƽ <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCD* LPPktCD;
struct PktCD : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSlotNum;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ack
// - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
// - <20><><EFBFBD><EFBFBD> <20><>ȣ
//
// (1 = <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, 2 = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCDAck* LPPktCDAck;
struct PktCDAck : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwSlotNum;
enum { SERVER_ERROR = 1, FAIL_DELETE_DATA =2 };
};
#pragma pack()
#endif

76
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/ClientToLoginServer.h Normal file
View File

@@ -0,0 +1,76 @@
#ifndef _CLIENT_TO_LOGIN_SERVER_PACKET_H_
#define _CLIENT_TO_LOGIN_SERVER_PACKET_H_
#include "ServerInfo.h"
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
// -----------------------------------------------------------------------------
// <20>α<EFBFBD><CEB1><EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><>Ŷ.
// -----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><>û <20><>Ŷ : Launcher to LoginServer
typedef struct PktSvL* LPPktSvL;
struct PktSvL : public PktBase
{
unsigned long m_ClientVerInfo;
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><>Ŷ : LoginServer to Launcher
typedef struct PktSvLAck* LPPktSvLAck;
struct PktSvLAck : public PktBase
{
unsigned long m_dwUserID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
SERVER_LIST m_ServerList; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ
};
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û <20><>Ŷ : Launcher to LoginServer
typedef struct PktSG* LPPktSG;
struct PktSG : public PktBase
{
char m_cGroup;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ : LoginServer to Launcher
typedef struct PktSGAck* LPPktSGAck;
struct PktSGAck : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_AuthAddress;
};
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>û <20><>Ŷ(OLD) : Launcher to LoginServer
typedef struct PktAUO* LPPktAUO;
struct PktAUO : public PktBase
{
enum { NAME_LEN = 16 };
char m_UserAccount[NAME_LEN];
char m_UserPassword[NAME_LEN];
unsigned long m_ClientVerInfo;
unsigned short m_cFlag;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ : LoginServer to Launcher
typedef struct PktAUOAck* LPPktAUOAck;
struct PktAUOAck : public PktBase
{
unsigned long m_dwUserID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
SERVER_LIST m_ServerList; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ
};
// -----------------------------------------------------------------------------
#pragma pack()
#endif

50
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/DataPacket.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef _DATA_PACKET_H_
#define _DATA_PACKET_H_
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
typedef struct PktDD* LPPktDD;
struct PktDD : public PktBase
{
unsigned long m_dwUID;
unsigned short m_wCmd;
enum SubCommands
{
SCmdUserLogin = 0x0001, // <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
SCmdUserLogout = 0x0002, // <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
SCmdUserMove = 0x0003, // <20><><EFBFBD><EFBFBD> <20><> <20>̵<EFBFBD>
SCmdCharCreate = 0x0021, // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdCharDelete = 0x0022, // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdCharCreateItem = 0x0023, // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SCmdCharSelect = 0x0024, // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdCreateParty = 0x0031, // <20><>Ƽ <20><><EFBFBD><EFBFBD>
SCmdDeleteParty = 0x0032, // <20><>Ƽ <20><><EFBFBD><EFBFBD>
SCmdGetPartyInfo = 0x0033, // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdInsertPartyMem = 0x0034, // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>
SCmdDeletePartyMem = 0x0035, // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdLoginPartyMem = 0x0036, // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD>
SCmdLogoutPartyMem = 0x0037, // <20><>Ƽ <20><><EFBFBD><EFBFBD> <20>α׾ƿ<D7BE>
SCmdTransferLeader = 0x0038, // <20><><EFBFBD><EFBFBD> <20>絵
SCmdStartSession = 0x0041, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SCmdServerZone = 0x0043, // <20><><EFBFBD><EFBFBD> <20><>
SCmdCharMoveZone = 0x0044 // ij<><C4B3><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
};
inline void InitPtSubCmd(unsigned long dwUID, unsigned short Cmd_In);
};
inline void PktDD::InitPtSubCmd(unsigned long dwUID, unsigned short Cmd_In)
{
m_dwUID = dwUID;
m_wCmd = Cmd_In;
}
#pragma pack()
#endif

215
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/FriendPacket.h Normal file
View File

@@ -0,0 +1,215 @@
#ifndef _CHAR_FRIEND_PACKET_H_
#define _CHAR_FRIEND_PACKET_H_
// CharFriendPacket.h
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
/*
struct PktFriendAddReq : public PktBase CMD : 0x64
struct PktFriendRemoveReq : public PktBase CMD : 0x65
struct PktFriendEtc : public PktBase CMD : 0x66
struct PktFriendAck : public PktBase CMD : 0x67
struct PktFriendDB : public PktBase CMD : 0x68
ģ<><C4A3> <20><><EFBFBD><EFBFBD> Operations
<Client->GameServer>
ģ<><C4A3> <20><><EFBFBD><EFBFBD> : PktFriendAddReq
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendAddReq
ģ<><C4A3> <20><><EFBFBD><EFBFBD> : PktFriendRemoveReq
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendRemoveReq
<20>׷<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendEtc(Ack<63><6B><EFBFBD><EFBFBD>)
<GameServer->Client>
ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ <20>ֱ<EFBFBD> : PktFriendDB
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20>߱<EFBFBD> : PktFriendDB
ģ<><C4A3> <20><><EFBFBD><EFBFBD> Ack : PktFriendAck
ģ<><C4A3> <20><><EFBFBD><EFBFBD> Ack : PktFriendAck
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> Ack : PktFriendAck
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> Ack : PktFriendAck
ģ<><C4A3> <20>α<EFBFBD><CEB1><EFBFBD> : PktFriendAck
ģ<><C4A3> <20>α׾ƿ<D7BE> : PktFriendAck
ģ<><C4A3> <20><><EFBFBD>ϴ<EFBFBD><CFB4><EFBFBD> : PktFriendAddReq
<GameServer->DBAgent>
ģ<><C4A3> <20><><EFBFBD><EFBFBD> : PktFriendDB
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendDB
ģ<><C4A3> <20><><EFBFBD><EFBFBD> : PktFriendDB
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendDB
<20>׷<EFBFBD> <20><><EFBFBD><EFBFBD> : PktFriendDB
<DBAgent->GameServer>
ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ <20>ֱ<EFBFBD> : PktFriendDB
<20>ź<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20>ֱ<EFBFBD> : PktFriendDB
*/
struct FriendInfo
{
private:
enum StatusMask
{
IS_LOGINED = 0x00000001,
GROUP = 0x000000F0
};
public:
enum { MAX_NAME = 16 };
unsigned long m_dwStatusFlag;
char m_szName[MAX_NAME];
bool IsLogined() { return (0 != (m_dwStatusFlag & IS_LOGINED)); }
void SetLoginStatus(bool bLogined)
{
if(bLogined) { m_dwStatusFlag |= IS_LOGINED; }
else { m_dwStatusFlag &= ~IS_LOGINED; }
}
unsigned long GetGroup() { return ((m_dwStatusFlag & GROUP) >> 4); }
bool SetGroup(unsigned long dwGroup)
{
if(0xF < dwGroup) { return false; }
m_dwStatusFlag = (m_dwStatusFlag & (~GROUP)) | (dwGroup << 4);
return true;
}
};
struct BanInfo
{
enum { MAX_NAME = 16 };
char m_szName[MAX_NAME];
};
// <20>߰<EFBFBD> <20><>Ŷ
struct PktFriendAddReq : public PktBase
{
enum { MAX_NAME = 16 };
enum CMD
{
ADD_FRIEND_REQ = 0, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> (Client->GameServer), m_szName<6D><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD>.
BAN_FRIEND_REQ = 1, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> (Client->GameServer), m_szName<6D><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD>.
ADDED_INFO = 2 // ģ<><C4A3><EFBFBD><EFBFBD> <20><><EFBFBD>ϵ<EFBFBD> (GameServer->Client), m_szName<6D><65> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD>.
};
char m_szName[MAX_NAME]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>.
unsigned char m_cCmd;
};
// <20><><EFBFBD><EFBFBD> <20><>Ŷ
struct PktFriendRemoveReq : public PktBase
{
enum CMD
{
REMOVE_FRIEND_REQ = 0, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> (Client->GameServer), m_dwCID<49><44> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CID.
REMOVE_BAN_REQ = 1, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (Client->GameServer), m_dwCID<49><44> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CID.
};
unsigned long m_dwCID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CID;
unsigned char m_cCmd;
};
// <20><>Ÿ <20><>Ŷ
struct PktFriendEtc : public PktBase
{
enum CMD
{
SETGROUP = 0, // <20>׷<EFBFBD> <20><><EFBFBD><EFBFBD> (Client->GameServer),
// m_dwCID<49><44> <20>׷<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CID, m_dwData<74><61> <20>ٲ<EFBFBD> <20>׷<EFBFBD> <20><>ȣ
};
unsigned long m_dwCID;
unsigned long m_dwData;
unsigned char m_cCmd;
};
// ģ<><C4A3> <20><><EFBFBD><EFBFBD> <20><>Ŷ ( Client <--> GameServer )
struct PktFriendAck : public PktBase
{
enum CMD
{
ADD_FRIEND_ACK = 0, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> Ack (GameServer->Client)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : SERVER_ERROR (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
// NOT_LOGINED (<28>α<EFBFBD><CEB1>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ϸ<EFBFBD> <20><>)
// REJECTED (<28>ź<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD>)
// LIST_FULL (ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><> <20><> <20><><EFBFBD><EFBFBD>)
REMOVE_FRIEND_ACK = 1, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> Ack (GameServer->Client)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : SERVER_ERROR (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
ADD_BAN_ACK = 2, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> Ack (GameServer->Client)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : SERVER_ERROR (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
// NOT_LOGINED (<28>α<EFBFBD><CEB1>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ϸ<EFBFBD> <20><>)
// LIST_FULL (ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><> <20><> <20><><EFBFBD><EFBFBD>)
REMOVE_BAN_ACK = 3, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> Ack (GameServer->Client)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : SERVER_ERROR (<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
FRIEND_LOGIN = 4, // ģ<><C4A3> <20>α<EFBFBD><CEB1><EFBFBD> (GameServer->Client), m_dwCID<49><44> <20>α<EFBFBD><CEB1><EFBFBD><EFBFBD><EFBFBD> ģ<><C4A3><EFBFBD><EFBFBD> CID
FRIEND_LOGOUT = 5 // ģ<><C4A3> <20>α׾ƿ<D7BE> (GameServer->Client), m_dwCID<49><44> <20>α׾ƿ<D7BE><C6BF><EFBFBD> ģ<><C4A3><EFBFBD><EFBFBD> CID
};
enum FriendERROR
{
SERVER_ERROR = 1,
NOT_LOGINED = 2,
REJECTED = 3,
LIST_FULL = 4
};
unsigned long m_dwCID;
unsigned char m_cCmd;
};
// ģ<><C4A3> <20><><EFBFBD><EFBFBD> <20><>Ŷ
struct PktFriendDB : public PktBase
{
enum CMD
{
ADD_FRIEND = 0, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> (GameServer->DBAgent) Owner<65><72> Reference<63><65> <20><><EFBFBD><EFBFBD>.
REMOVE_FRIEND = 1, // ģ<><C4A3> <20><><EFBFBD><EFBFBD> (GameServer->DBAgent) Owner<65><72> Reference<63><65> <20><><EFBFBD><EFBFBD>.
ADD_BAN = 2, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> (GameServer->DBAgent) Owner<65><72> Reference<63><65> <20><><EFBFBD><EFBFBD>.
REMOVE_BAN = 3, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD> (GameServer->DBAgent) Owner<65><72> Reference<63><65> <20><><EFBFBD><EFBFBD>.
SETGROUP = 4, // <20>׷<EFBFBD> <20><><EFBFBD><EFBFBD> (GameServer->DBAgent)
// Owner<65><72> Reference<63><65> m_dwData<74><61> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>׷<EFBFBD><D7B7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
FRIEND_LIST = 5, // ģ<><C4A3> <20><><EFBFBD><EFBFBD>Ʈ (DBAgent->GameServer, GameServer->Client)
// CIDTable<6C><65><EFBFBD><EFBFBD> SerializeOut<75><74> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20>ڿ<EFBFBD> <20>ٴ´<D9B4>.
// Reference<63><65> <20>ǹ<EFBFBD> <20><><EFBFBD><EFBFBD>. m_dwData<74><61> <20>ڿ<EFBFBD> <20>ٴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>.
BAN_LIST = 6, // <20>ź<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ (DBAgent->GameServer, GameServer->Client)
// CIDTable<6C><65><EFBFBD><EFBFBD> SerializeOut<75><74> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20>ڿ<EFBFBD> <20>ٴ´<D9B4>.
// Reference<63><65> <20>ǹ<EFBFBD> <20><><EFBFBD><EFBFBD>. m_dwData<74><61> <20>ڿ<EFBFBD> <20>ٴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>.
};
unsigned long m_dwOwnerUID; // <20><><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> UID
unsigned long m_dwOwnerCID; // <20><><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> CID
unsigned long m_dwReferenceCID; // <20><><EFBFBD><EFBFBD> <20>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> CID
unsigned long m_dwData; // Data
unsigned char m_cCmd;
};
#pragma pack()
#endif

81
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/PartyPacket.h Normal file
View File

@@ -0,0 +1,81 @@
#ifndef _PARTY_INFO_PACKET_H_
#define _PARTY_INFO_PACKET_H_
#include "DataPacket.h"
#pragma pack(1)
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktPID* LPPktPID;
struct PktPID : public PktDD
{
unsigned long m_dwCharID;
unsigned long m_dwPartyID;
};
typedef struct PktPIDAck* LPPktPIDAck;
struct PktPIDAck : public PktDD
{
PARTY m_Party;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCPD* LPPktCPD;
struct PktCPD : public PktDD
{
DWORD m_dwLeaderID;
DWORD m_dwMemberID;
};
typedef struct PktCPDAck* LPPktCPDAck;
struct PktCPDAck : public PktDD
{
PARTY m_Party;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktDPD* LPPktDPD;
struct PktDPD : public PktDD
{
unsigned long m_dwPartyID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// <20><>Ƽ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//
// Sender(Send/Recv) Reference(Send/Recv)
// <09><><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> : CID/CID 0/SID
// <09><><EFBFBD><EFBFBD> <20>α׾ƿ<D7BE> : CID/CID 0/<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(0 <20>ϰ<EFBFBD><CFB0><EFBFBD> <20><><EFBFBD><EFBFBD> <20>絵 <20><><EFBFBD><EFBFBD>)
// <09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : CID/CID CID/CID
// <09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : CID/CID CID/<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>(0 <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>絵 <20><><EFBFBD><EFBFBD>)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktPMD* LPPktPMD;
struct PktPMD : public PktDD
{
unsigned long m_dwPartyID;
unsigned long m_dwSenderID;
unsigned long m_dwReferenceID;
};
#pragma pack()
#endif

104
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/ServerInfo.h Normal file
View File

@@ -0,0 +1,104 @@
#ifndef _LOGIN_SERVER_INFO_
#define _LOGIN_SERVER_INFO_
#include <winsock2.h>
#include <windows.h>
#include <algorithm>
#pragma pack(1)
// -----------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü<EFBFBD><C3BC>
typedef union SERVER_ID* LPSERVER_ID;
union SERVER_ID
{
enum Zone { ZONE1 = 1, ZONE2 = 2, BATTLE_GROUND = 3 };
typedef struct SID* LPSID;
struct SID
{
char Type;
char Group;
char Channel;
char ID;
};
SID sID;
DWORD dwID;
// 2002-12-24 cppis <20><> <20>߰<EFBFBD>
inline char GetChannel(void) { return sID.Channel; }
inline char GetZone(void) { return sID.ID; }
};
typedef struct SERVER* LPSERVER_GROUP;
struct SERVER_GROUP
{
enum { CHANNEL_NUM = 2, SERVER_NAME = 15 };
char m_Group; // <20><><EFBFBD><EFBFBD> <20>׷<EFBFBD>
char m_Name[SERVER_NAME]; // <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>
unsigned short m_ChannelNum; // ä<><C3A4> <20><><EFBFBD><EFBFBD>
long m_ClientNum[CHANNEL_NUM]; // <20><><EFBFBD><EFBFBD> <20><> <20><>
};
typedef struct SERVER* LPSERVER_LIST;
struct SERVER_LIST
{
enum { SERVER_NUM = 10 };
unsigned short m_ServerNum; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
SERVER_GROUP m_ServerGroup[SERVER_NUM]; // <20><><EFBFBD><EFBFBD> <20>׷<EFBFBD>
};
#pragma pack()
typedef struct RylServerInfo* LPRylServerInfo;
struct RylServerInfo
{
enum
{
GROUP_NAME_LENGTH = 120,
PATCH_ADDRESS_LENGTH = 100
};
SERVER_ID m_ServerUID;
IN_ADDR m_ServerAddress;
unsigned long m_dwClientVer;
unsigned long m_dwChecksum;
size_t m_nGroupNameLen;
size_t m_nPatchAddressLen;
char m_szGroupName[GROUP_NAME_LENGTH];
char m_szPatchAddress[PATCH_ADDRESS_LENGTH];
unsigned short m_dwChannelClientNum[SERVER_GROUP::CHANNEL_NUM];
unsigned short m_usChannelNum;
RylServerInfo::RylServerInfo()
: m_dwClientVer(0), m_dwChecksum(0),
m_nPatchAddressLen(0), m_usChannelNum(0)
{
m_ServerUID.dwID = 0;
m_ServerAddress.S_un.S_addr = 0;
m_szPatchAddress[0] = '\0';
strncpy(m_szGroupName, "UnKnown", GROUP_NAME_LENGTH);
m_nGroupNameLen = strlen(m_szGroupName);
std::fill_n(m_dwChannelClientNum, int(SERVER_GROUP::CHANNEL_NUM), 0);
}
};
#endif

195
GameTools/GLOBALSCRIPT/Network/Packet/PacketStruct/ServerPacket.h Normal file
View File

@@ -0,0 +1,195 @@
#ifndef _DBAGENT_TO_LOGIN_
#define _DBAGENT_TO_LOGIN_
#include <DB/DBDefine.h>
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#pragma pack(1)
// <20><> <20><>Ŷ ( Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ -> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 5<>ʸ<EFBFBD><CAB8><EFBFBD>.. <20><><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ŵ<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20>ʿ<EFBFBD><CABF><EFBFBD> Ping<6E><67> <20>ش<EFBFBD>. )
typedef struct PktSyP* LPPktSyP;
struct PktSyP : public PktBase
{
unsigned long m_dwTickTime;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><>û <20><>Ŷ
typedef struct PktSL* LPPktSL;
struct PktSL : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_Address;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktSLAck* LPPktSLAck;
struct PktSLAck : public PktBase
{
enum { PATCH_ADDRESS_LENGTH = 100 };
unsigned long m_dwServerID;
__int64 m_dlItemUID;
unsigned long m_dwClientVer;
unsigned long m_dwCheckSum;
char m_PatchAddress[PATCH_ADDRESS_LENGTH];
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
typedef struct PktSVU* LPPktSVU;
struct PktSVU : public PktBase
{
enum { PATCH_ADDRESS_LENGTH = 100 };
unsigned long m_dwServerID;
IN_ADDR m_ServerAddr;
unsigned long m_dwClientVer;
unsigned long m_dwCheckSum;
char m_PatchAddress[PATCH_ADDRESS_LENGTH];
};
// ä<><C3A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
typedef struct PktSCInfo* LPPktSCInfo;
struct PktSCInfo : public PktBase
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned long m_dwServerID;
unsigned char m_wChannelNum;
unsigned short m_dwChannelClientNum[MAX_CHANNEL_NUM];
};
// ---------------------------------------------------------------------------
// <20><>ġ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
// <20><>ġ <20><><EFBFBD><EFBFBD> <20><>û <20><>Ŷ
typedef struct PktSPI* LPPktSPI;
struct PktSPI : public PktBase
{
unsigned long m_dwServerID;
};
// <20><>ġ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ
typedef struct PktSPIAck* LPPktSPIAck;
struct PktSPIAck : public PktBase
{
enum { PATCH_ADDRESS_LENGTH = 100 };
unsigned long m_dwClientVer;
char m_PatchAddress[PATCH_ADDRESS_LENGTH];
};
// ---------------------------------------------------------------------------
// Zone <20><><EFBFBD><EFBFBD> <20><>Ŷ
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktSZ* LPPktSZ;
struct PktSZ : public PktBase
{
unsigned short m_cChannel;
unsigned char m_cZone;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ack
typedef struct PktSZAck* LPPktSZAck;
struct PktSZAck : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_GameAddress;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
typedef struct PktSZMv* LPPktSZMv;
struct PktSZMv : public PktBase
{
POS m_NewPos;
char m_cZone;
};
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ack
typedef struct PktSZMvAck* LPPktSZMvAck;
struct PktSZMvAck : public PktBase
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned short m_wChannelNum[MAX_CHANNEL_NUM];
unsigned char m_cZone;
};
typedef struct PktSZMvD* LPPktSZMvD;
struct PktSZMvD : public PktDD
{
unsigned long m_dwUserID;
char m_cZone;
POS m_NewPos;
};
typedef struct PktSZMvDAck* LPPktSZMvDAck;
struct PktSZMvDAck : public PktDD
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned char m_cZone;
unsigned short m_wChannelNum[MAX_CHANNEL_NUM];
};
// <20><><EFBFBD><EFBFBD> <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>
typedef struct PktSA* LPPktSA;
struct PktSA : public PktDD
{
unsigned long m_dwUserID; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>
char m_cZone; // <20><> <20><>ȣ
char m_cChannel; // ä<><C3A4> <20><>ȣ
};
// <20><><EFBFBD><EFBFBD> <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD> Ack
typedef struct PktSAAck* LPPktSAAck;
struct PktSAAck : public PktDD
{
unsigned long m_dwServerID;
IN_ADDR m_GameAddress;
};
// ---------------------------------------------------------------------------
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
typedef struct PktUUT *LPPktUUT;
struct PktUUT : public PktBase {
enum {
UpdateUIDTableNone = 0, // <20><><EFBFBD><EFBFBD>
UpdateUIDTableLogin = 1, // <20>α<EFBFBD><CEB1><EFBFBD>
UpdateUIDTableLogout = 2 // <20>α׾ƿ<D7BE>
};
unsigned char m_cCmd;
unsigned long m_dwSessionID;
unsigned long m_dwServerID;
unsigned long m_dwUserID;
unsigned long m_dwCharID;
};
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̱<EFBFBD>.
typedef struct PktUK* LPPktUK;
struct PktUK : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwServerID;
};
#pragma pack()
#endif

191
GameTools/GLOBALSCRIPT/Network/XORCrypt/XORCrypt.cpp Normal file
View File

@@ -0,0 +1,191 @@
// XORCrypt.cpp: implementation of the CXORCrypt class.
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "XORCrypt.h"
#include <ctime>
#include <cstdlib>
CXORCrypt CXORCrypt::ms_this;
CXORCrypt::CXORCrypt()
{
InitCodePage();
}
CXORCrypt::~CXORCrypt()
{
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// XORF [ public ] - XOR <20><><EFBFBD><EFBFBD>. # <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>, 3st : <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Return:
void CXORCrypt::XORF(char *Start_In, int Length_In, unsigned short PageVer,
unsigned char PageNum1, unsigned char PageNum2)
{
for (int Counter = 0; Counter < Length_In; ++Counter)
{
*Start_In = *Start_In ^ BitFields[PageVer][PageNum1][Counter % BIT_COUNT];
*Start_In = *Start_In ^ BitFields[PageVer][PageNum2][Counter % BIT_COUNT];
++Start_In;
}
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// XORB [ public ] - XOR <20><><EFBFBD><EFBFBD>. # <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>, 3st : <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Return:
void CXORCrypt::XORB(char *Start_In, int Length_In, unsigned short PageVer,
unsigned char PageNum1, unsigned char PageNum2)
{
for (int Counter = 0; Counter < Length_In; ++Counter)
{
*Start_In = *Start_In ^ BitFields[PageVer][PageNum2][Counter % BIT_COUNT];
*Start_In = *Start_In ^ BitFields[PageVer][PageNum1][Counter % BIT_COUNT];
++Start_In;
}
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// InitCODE_PAGE [ public ] - <20><>ȣ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʱ<EFBFBD>ȭ <20>Ѵ<EFBFBD>
// Parameter :
// Return:
void CXORCrypt::InitCodePage(void)
{
int CODE_PAGENums = CODE_PAGE * 10;
srand((unsigned)time(NULL));
for (int Counter = 0; Counter < CODE_PAGENums; ++Counter)
{
m_CodePage[Counter] = rand() % CODE_PAGE;
if(Counter > 1)
{
if (m_CodePage[Counter] == m_CodePage[Counter - 1])
{
--Counter;
}
}
}
m_CodePageCount = rand() % (CODE_PAGE * 10);
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// GetCODE_PAGE [ public ] - <20><>ȣ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>´<EFBFBD>
// Parameter :
// Return:
unsigned long CXORCrypt::GetCodePage(void)
{
if(0xffffff00 < m_CodePageCount)
{
m_CodePageCount = 0;
}
m_CodePageCount = (m_CodePageCount + 2) % (CODE_PAGE * 10);
return (((unsigned long)PAGE_VERSION << 16) & 0xffff0000) |
(((unsigned long)m_CodePage[m_CodePageCount] << 8) & 0x0000ff00) |
((unsigned long)m_CodePage[m_CodePageCount - 1] & 0x000000ff);
}
unsigned long CXORCrypt::GetCodePage(unsigned short PageVer_In)
{
if(0xffffff00 < m_CodePageCount)
{
m_CodePageCount = 0;
}
m_CodePageCount = (m_CodePageCount + 2) % (CODE_PAGE * 10);
return (((unsigned long)PageVer_In << 16) & 0xffff0000) |
(((unsigned long)m_CodePage[m_CodePageCount] << 8) & 0x0000ff00) |
((unsigned long)m_CodePage[m_CodePageCount - 1] & 0x000000ff);
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// InnerEncodeS [ public ] - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣȭ : <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> XOR <20><><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>. # Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><>
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>, 3st : <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Return:
bool CXORCrypt::EncodePacket(char *Start_In, int Length_In, unsigned long CodePage_In)
{
unsigned short PageVer = 0;
unsigned char PageNum1 = 0, PageNum2 = 0;
PageVer = (unsigned short)(((CodePage_In & 0xffff0000) >> 16) & 0x0000ffff);
PageNum1 = (unsigned char)(((CodePage_In & 0xff00) >> 8) & 0x00ff);
PageNum2 = (unsigned char)(CodePage_In & 0x00ff);
if(PageVer < 0 || PageVer > 1)
return false;
if(PageNum1 < 0 || PageNum1 >= CODE_PAGE || PageNum2 < 0 || PageNum2 >= CODE_PAGE)
return false;
XORF(Start_In, Length_In, PageVer, PageNum1, PageNum2);
return true;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// InnerEncodeS [ public ] - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣȭ : <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> XOR <20><><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>. # <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>, 3st : <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Return:
bool CXORCrypt::DecodePacket(char *Start_In, int Length_In, unsigned long CodePage_In)
{
unsigned short PageVer = 0;
unsigned char PageNum1 = 0, PageNum2 = 0;
PageVer = (unsigned short)(((CodePage_In & 0xffff0000) >> 16) & 0x0000ffff);
PageNum1 = (unsigned char)(((CodePage_In & 0xff00) >> 8) & 0x00ff);
PageNum2 = (unsigned char)(CodePage_In & 0x00ff);
if(PageVer < 0 || PageVer > 1)
return false;
if(PageNum1 < 0 || PageNum1 >= CODE_PAGE || PageNum2 < 0 || PageNum2 >= CODE_PAGE)
return false;
XORB(Start_In, Length_In, PageVer, PageNum1, PageNum2);
return true;
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// EncodeHeader [ public ] - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣȭ : <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> XOR <20><><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>
// Return:
void CXORCrypt::EncodeHeader(char *Start_In, int Length_In, unsigned short PageVer_In, unsigned char PageNum_In)
{
for(int Counter = 0; Counter < Length_In; ++Counter)
{
*Start_In = *Start_In ^ BitFields[PageVer_In][PageNum_In][Counter % BIT_COUNT];
*Start_In = (((*Start_In & 0x80) >> 7) & 0x01) | ((*Start_In << 1) & 0xFE);
++Start_In;
}
}
//Interface////////////////////////////////////////////////////////////////////////////////////
// DecodeHeader [ public ] - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣȭ : <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> XOR <20><><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>. # <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// Parameter : 1st : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, 2st : <20><><EFBFBD><EFBFBD>
// Return:
void CXORCrypt::DecodeHeader(char *Start_In, int Length_In, unsigned short PageVer_In, unsigned char PageNum_In)
{
for(int Counter = 0; Counter < Length_In; ++Counter)
{
*Start_In = (((*Start_In & 0x01) << 7) & 0x80) | ((*Start_In >> 1) & 0x7F);
*Start_In = *Start_In ^ BitFields[PageVer_In][PageNum_In][Counter % BIT_COUNT];
++Start_In;
}
}

58
GameTools/GLOBALSCRIPT/Network/XORCrypt/XORCrypt.h Normal file
View File

@@ -0,0 +1,58 @@
#ifndef _CXOR_CRYPT_H_
#define _CXOR_CRYPT_H_
#pragma once
#include <Pattern/Singleton.h>
class CXORCrypt : public CSingleton<CXORCrypt>
{
public:
enum
{
PAGE_VERSION = 0,
BIT_COUNT = 40,
CODE_PAGE = 10,
};
private:
static const unsigned char BitFields[][CODE_PAGE][BIT_COUNT];
unsigned char m_CodePage[CODE_PAGE * 10];
unsigned long m_CodePageCount;
void InitCodePage(void);
void XORF(char *Start_In, int Length_In, unsigned short PageVer, unsigned char PageNum1, unsigned char PageNum2);
void XORB(char *Start_In, int Length_In, unsigned short PageVer, unsigned char PageNum1, unsigned char PageNum2);
// To make Singleton Class.
CXORCrypt();
static CXORCrypt ms_this;
public:
~CXORCrypt();
// interface of encoder, decoder
unsigned long GetCodePage(void);
unsigned long GetCodePage(unsigned short PageVer_In);
inline unsigned short GetPageVer(unsigned long CodePage_In);
bool EncodePacket(char *Start_In, int Length_In, unsigned long CodePage_In);
bool DecodePacket(char *Start_In, int Length_In, unsigned long CodePage_In);
void EncodeHeader(char *Start_In, int HeaderLen_In, unsigned short PageVer_In, unsigned char PageNum_In);
void DecodeHeader(char *Start_In, int HeaderLen_In, unsigned short PageVer_In, unsigned char PageNum_In);
};
inline unsigned short CXORCrypt::GetPageVer(unsigned long CodePage_In)
{
return (unsigned short)(((CodePage_In & 0xffff0000) >> 16) & 0x0000ffff);
}
#endif

213
GameTools/GLOBALSCRIPT/Network/XORCrypt/XORCryptoCodeList.cpp Normal file
View File

@@ -0,0 +1,213 @@
#include "stdafx.h"
#include "XORCrypt.h"
const unsigned char CXORCrypt::BitFields[][CODE_PAGE][BIT_COUNT] =
{
///////////////////////////////////////////////////////////////////////
//Code Version 0
{
// Code Page 1
0x82, 0x53, 0x43, 0x4C, 0x2B,
0x0D, 0x37, 0xD7, 0xD9, 0xD8,
0x1B, 0x6D, 0xA0, 0xC3, 0x2B,
0xEE, 0x45, 0x88, 0x1A, 0xA6,
0x18, 0x1D, 0x9D, 0x38, 0x2A,
0x55, 0x03, 0x1D, 0xCD, 0xA6,
0x73, 0x07, 0xED, 0x8D, 0xC5,
0xDB, 0xA3, 0xBD, 0xB6, 0xD5,
// Code Page 2
0x34, 0xB5, 0xB2, 0x3D, 0x7D,
0x43, 0x8C, 0xC0, 0x21, 0x25,
0xCD, 0xB6, 0x53, 0x76, 0xCE,
0x5D, 0xD4, 0x87, 0xCA, 0x84,
0x81, 0xCB, 0x5E, 0x04, 0xBA,
0x69, 0x3E, 0x65, 0xDE, 0x21,
0x8A, 0x63, 0x62, 0x71, 0x90,
0x87, 0x0A, 0x52, 0x28, 0x44,
// Code Page 3
0xA3, 0x49, 0xDC, 0xEA, 0x09,
0xB7, 0x01, 0xA4, 0xA1, 0x11,
0x11, 0x8E, 0x80, 0x35, 0x5B,
0xDD, 0x38, 0xD5, 0x4E, 0x36,
0x0C, 0xA2, 0xBB, 0x05, 0x36,
0x57, 0x2E, 0x98, 0xBE, 0x88,
0x3C, 0x28, 0x43, 0x63, 0xA0,
0xE9, 0xE1, 0x6D, 0x51, 0xCB,
// Code Page 4
0x4D, 0x62, 0x84, 0x43, 0x89,
0xC7, 0x89, 0x83, 0x65, 0x29,
0x53, 0x95, 0x7C, 0xC0, 0xA1,
0x0C, 0xDB, 0xD7, 0x04, 0xD8,
0x6A, 0xD1, 0x73, 0x1D, 0x21,
0x67, 0x86, 0x8D, 0xA4, 0xA0,
0x34, 0xBD, 0x31, 0x20, 0x61,
0x0E, 0xE9, 0x63, 0xB4, 0xC0,
// Code Page 5
0xC7, 0x36, 0x1B, 0x41, 0x23,
0x9C, 0xD1, 0x8C, 0x25, 0x53,
0x42, 0x2E, 0x45, 0x6D, 0x42,
0x7B, 0x4E, 0x5B, 0xEB, 0x24,
0x33, 0x74, 0x52, 0x28, 0xC6,
0x2A, 0xC3, 0x16, 0x60, 0xA5,
0x45, 0x35, 0xDB, 0x9A, 0x54,
0x97, 0xE2, 0xEE, 0x9B, 0xDE,
// Code Page 6
0xE0, 0xC3, 0x84, 0x41, 0xED,
0x45, 0x4C, 0x69, 0xD9, 0x28,
0x55, 0x27, 0x8E, 0x3A, 0x3C,
0x8E, 0x84, 0x97, 0x14, 0xE6,
0x58, 0x51, 0x26, 0x0D, 0xE2,
0x9E, 0x66, 0x7C, 0x0D, 0x01,
0x7D, 0x17, 0x4C, 0x08, 0xDD,
0x97, 0x1C, 0x7B, 0xCE, 0x5D,
// Code Page 7
0x54, 0x37, 0x7C, 0x0C, 0x8E,
0x27, 0x7A, 0x78, 0x2E, 0xE6,
0x6D, 0x25, 0x62, 0x62, 0x98,
0x20, 0x2E, 0x23, 0x15, 0x61,
0x7D, 0x97, 0x50, 0x07, 0x20,
0x7A, 0x04, 0x29, 0x62, 0x90,
0x6B, 0xE9, 0xE6, 0x22, 0x72,
0x38, 0x56, 0xC9, 0x06, 0x2E,
// Code Page 8
0x3B, 0x47, 0x08, 0x2D, 0x21,
0x42, 0x07, 0x69, 0x4A, 0x57,
0x8B, 0x79, 0xE7, 0x56, 0x27,
0x23, 0x24, 0x85, 0x47, 0x74,
0x75, 0x85, 0xA9, 0xEB, 0x10,
0xCB, 0x17, 0x85, 0x4B, 0x5E,
0x20, 0x78, 0xD0, 0x7D, 0x86,
0x5E, 0x14, 0x7E, 0x64, 0x50,
// Code Page 9
0x69, 0x52, 0x4A, 0xBD, 0x8C,
0x9B, 0xD6, 0x63, 0xBD, 0x26,
0x86, 0x32, 0x95, 0xA4, 0x02,
0x9B, 0x01, 0x14, 0x49, 0x78,
0x88, 0x57, 0x3A, 0x01, 0x4A,
0xBC, 0x50, 0xCD, 0x31, 0x39,
0x71, 0x30, 0x5B, 0x9C, 0x4D,
0x21, 0x67, 0x82, 0xE8, 0x5C,
// Code Page 10
0x66, 0x10, 0xA9, 0x7D, 0xD2,
0x36, 0xE2, 0xB1, 0x28, 0x20,
0xD5, 0xE7, 0xD5, 0x0E, 0xD4,
0x0C, 0x2C, 0x77, 0x80, 0x0E,
0xA6, 0x37, 0xBE, 0x61, 0xAD,
0xD6, 0x17, 0x65, 0x13, 0x70,
0xAE, 0x40, 0x3B, 0x52, 0xEE,
0x53, 0x84, 0xEB, 0x04, 0x0D,
},
///////////////////////////////////////////////////////////////////////
//Code Version 1
{
// Code Page 1
0x49, 0x8C, 0x77, 0xC0, 0xC0,
0x64, 0x54, 0x0B, 0x22, 0xBD,
0x82, 0x93, 0x9A, 0x23, 0x8D,
0xE4, 0xC8, 0x9D, 0xB3, 0x50,
0x44, 0xB1, 0xE2, 0x9E, 0x15,
0x7A, 0xA1, 0x0C, 0x24, 0xE3,
0x1E, 0x0A, 0x0A, 0x73, 0x6A,
0xA5, 0x8B, 0x3A, 0x53, 0x33,
// Code Page 2
0xB0, 0xE6, 0xB7, 0x51, 0x70,
0xDA, 0xD6, 0x29, 0xAA, 0x10,
0xB5, 0x8A, 0x38, 0x37, 0x4E,
0x7A, 0x3B, 0x74, 0x7B, 0x63,
0x41, 0x7C, 0x21, 0x65, 0x5E,
0x26, 0x95, 0x44, 0x75, 0xA3,
0x74, 0xDD, 0xB4, 0x33, 0x9E,
0x54, 0x3C, 0x95, 0x5E, 0x34,
// Code Page 3
0x10, 0x19, 0x43, 0x64, 0x78,
0x2B, 0xA6, 0x60, 0x7D, 0xCD,
0xA9, 0x28, 0xB8, 0x85, 0x0E,
0x66, 0xC7, 0x3C, 0x28, 0xDC,
0xA1, 0x4D, 0x60, 0x9B, 0xC7,
0xD3, 0x74, 0x93, 0xE6, 0xC3,
0x97, 0x76, 0x12, 0xA4, 0xCB,
0xB9, 0x22, 0x51, 0xB9, 0x79,
// Code Page 4
0x5C, 0x68, 0xDB, 0xE6, 0x59,
0x57, 0x95, 0xCD, 0xAE, 0xCA,
0x67, 0xB8, 0x37, 0x90, 0xBA,
0x54, 0x98, 0x95, 0x73, 0x8E,
0x47, 0xC1, 0x40, 0xBA, 0x80,
0x26, 0x10, 0xAA, 0x60, 0x64,
0xD8, 0x69, 0xC7, 0x0D, 0x2B,
0x28, 0xA6, 0xBA, 0x01, 0x4A,
// Code Page 5
0xEE, 0x28, 0x65, 0xC4, 0x9D,
0x41, 0x8D, 0x91, 0x6C, 0x91,
0x7E, 0x80, 0xC3, 0xD1, 0xAE,
0xB6, 0x92, 0x41, 0x66, 0x13,
0x72, 0x20, 0x26, 0xA1, 0x72,
0x05, 0x29, 0x08, 0x88, 0x30,
0x40, 0x6D, 0x5A, 0x41, 0x01,
0x7A, 0xDB, 0x2C, 0xEE, 0xC3,
// Code Page 6
0x5C, 0x03, 0x38, 0xD8, 0x95,
0xE7, 0xB4, 0x67, 0x30, 0x51,
0x21, 0x68, 0x78, 0x89, 0x68,
0x0B, 0xE3, 0xB0, 0x28, 0xB3,
0xA9, 0x38, 0x18, 0xE4, 0x59,
0x43, 0xC9, 0x52, 0x75, 0x04,
0x15, 0x07, 0x97, 0x14, 0x07,
0x27, 0xDA, 0xE5, 0xD9, 0xDB,
// Code Page 7
0xDB, 0x08, 0x27, 0xA3, 0x64,
0xDC, 0x42, 0xE3, 0x3D, 0x0D,
0x26, 0xA2, 0xC3, 0x5E, 0x3E,
0xA7, 0x47, 0xE4, 0x1C, 0x73,
0x13, 0x99, 0x9E, 0xBA, 0xD3,
0x08, 0x73, 0x88, 0x03, 0x01,
0x24, 0x2E, 0x09, 0xBD, 0x3A,
0x6E, 0x3C, 0xB6, 0xA2, 0x22,
// Code Page 8
0xE7, 0x27, 0x60, 0x20, 0x85,
0xDA, 0xEA, 0x84, 0x86, 0x41,
0x67, 0x1C, 0x83, 0xBE, 0x7A,
0x61, 0x67, 0x01, 0x18, 0x30,
0xC6, 0x37, 0xBC, 0x51, 0xBC,
0x78, 0xA1, 0x53, 0x53, 0x58,
0x9B, 0x32, 0x05, 0x67, 0x6B,
0xC7, 0x3A, 0x7C, 0xA8, 0xE5,
// Code Page 9
0x70, 0x10, 0x29, 0x88, 0x94,
0xC0, 0xEE, 0x8D, 0x52, 0x20,
0xD9, 0xC3, 0x3C, 0xB3, 0x43,
0x74, 0x83, 0xC8, 0xC5, 0xAA,
0x90, 0x58, 0x0C, 0xD0, 0xBC,
0x2A, 0xED, 0x04, 0x05, 0x8E,
0x27, 0xDE, 0x9C, 0x37, 0x57,
0x2A, 0x93, 0x63, 0x1B, 0x9E,
// Code Page 10
0xC3, 0x52, 0xDB, 0xE9, 0x63,
0x9A, 0x87, 0x18, 0x6D, 0xBE,
0x1B, 0x37, 0x6A, 0xEA, 0x01,
0x02, 0x01, 0xB5, 0x74, 0x71,
0xA5, 0x9A, 0x9A, 0x3A, 0x11,
0x8B, 0x62, 0xD7, 0xB0, 0x06,
0x0C, 0xA0, 0x10, 0x09, 0x97,
0x5A, 0xEB, 0xEA, 0x18, 0xB8,
}
};