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

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 주소 서버 업데이트 ( Update Address )
// : 클라이언트가 로그인 후에 UDP로 서버로 한번 보내준다.
// : 서버는 클라이언트의 패킷으로 외부 UDP 주소를 얻는다.
typedef struct PktUA* LPPktUA;
struct PktUA : public PktBase
{
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// UDP 주소 서버 업데이트 Ack
typedef struct PktUAAck* LPPktUAAck;
struct PktUAAck : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// 주소 구조체
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 주소 정보 패킷 ( Address Info )
// - 어드레스 구조체
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)
// ---------------------------------------------------------
// 유저 로그인 요청 AuthServer -> DBAgentServer
typedef struct PktULD* LPPktULD;
struct PktULD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
IN_ADDR m_Address;
};
// 유저 로그인 응답 DBAgentServer -> AuthServer
typedef struct PktULDAck* LPPktULDAck;
struct PktULDAck : public PktDD
{
unsigned long m_dwUserID;
CHAR_VIEW m_CharView[3];
};
// 유저 로그아웃 AuthServer -> DBAgentServer
typedef struct PktULoD *LPPktULoD;
struct PktULoD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
// 세션 시작 DBAgentServer -> AuthServer
typedef struct PktSSD *LPPktSSD;
struct PktSSD : public PktDD
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// 캐릭터 생성 요청 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;
};
// 캐릭터 생성 응답 DBAgentServer -> AuthServer
typedef struct PktCCDAck* LPPktCCDAck;
struct PktCCDAck : public PktDD
{
unsigned long m_dwCharID;
unsigned long m_dwSlot;
CHAR_VIEW m_CharView;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// 캐릭터 선택 관련 (데이터)
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];
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// 캐릭터 삭제 관련 (데이터)
typedef struct PktCDD* LPPktCDD;
struct PktCDD : public PktDD
{
unsigned long m_dwUserID;
unsigned long m_dwSlotNum;
unsigned long m_dwCharID;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// 캐릭터 생성 아이템 관련 (데이터)
typedef struct PktCCID* LPPktCCID;
struct PktCCID : public PktDD
{
unsigned long m_dwCharID;
unsigned long m_dwSize;
};
// ---------------------------------------------------------
// ---------------------------------------------------------
// 캐릭터 로그인 관련 (데이터)
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, // 운영자 명령
MOVE_ZONE_C = 1, // 캐릭터 존 이동
MOVE_ZONE_P = 2, // 파티 존 이동
MOVE_C = 3, // 캐릭터 이동
MOVE_P = 4, // 파티 이동
RESPAWN_C = 5, // 캐릭터 리스폰
RESPAWN_P = 6, // 파티 리스폰
KILL_C = 7, // 캐릭터 킬
KILL_P = 8, // 파티 킬
DUELINIT = 9, // 듀얼 초기화
CREATEITEM = 10, // 아이템 드롭
CREATEMON = 11, // 몬스터 생성
INFO_C = 12 // 캐릭터 정보
};
unsigned short m_usCmd; // 운영자 명령
char m_stName[MAX_NAME_LEN]; // 이름
union
{
struct ZoneInfo
{
char m_cZone; // 존 번호
char m_cChannel; // 채널 번호
} m_ZoneInfo;
unsigned short m_usProtoTypeID; // 타입 아이디
};
POS m_Position; // 위치
};
#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)
// 캐릭터 공격 패킷
typedef struct PktAt* LPPktAt;
struct PktAt : public PktBase
{
POS m_Postion; // 공격자 캐릭터 위치
float m_fDir; // 공격자 방향
unsigned long m_dwCharID; // 공격자 캐릭터 아이디
AtType m_AtType; // 공격 타입
AtNode m_AtNode; // 방어자 정보
};
// 캐릭터 공격 패킷 Ack (가변 길이) + 방어자 노드
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; // 공격자 캐릭터 아이디
AtType m_AtType; // 공격 타입
unsigned short m_wHP; // 공격자 HP
unsigned short m_wMP; // 공격자 MP
unsigned char m_cJudge; // 플래그
unsigned char m_cDefenserNum; // 방어자 수
unsigned char m_cRightHandValue; // 사용한 무기 감소도(오른손, 내구도 감소 용)
unsigned char m_cLeftHandValue; // 사용한 무기 감소도(왼손, 내구도 감소 용)
unsigned char m_cRightHandIndex; // 사용한 무기 인덱스(오른손, 내구도 감소 용)
unsigned char m_cLeftHandIndex; // 사용한 무기 인덱스(왼손, 내구도 감소 용)
};
// 캐릭터 공격 정보 (가변 길이) + 방어자 노드
typedef struct PktAtInfo* LPPktAtInfo;
struct PktAtInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
AtType m_AtType; // 공격 타입
unsigned char m_cDefenserNum; // 방어자 수
};
// 캐릭터 공격 받음 패킷
typedef struct PktAted* LPPktAted;
struct PktAted : public PktBase
{
POS m_Postion; // 공격자 위치
float m_fDir; // 공격자 방향
unsigned long m_dwCharID; // 공격자 캐릭터 ID
AtType m_AtType; // 공격 타입
unsigned short m_wMyHP; // 방어자 HP
unsigned short m_wMyMP; // 방어자 MP
unsigned char m_cJudge; // 판정 값
unsigned char m_cMyWeaponIndex; // 방어자 무기 인덱스(내구도 감소용)
unsigned char m_cMyWeaponValue; // 방어자 무기 감소도(내구도 감소용)
};
// 듀얼 명령
//
// 명령 :
// 0 = 제안, 1 = 수락, 2 = 거절, 3 = 로그아웃, 4 = 사망
//
// 에러 :
// 0 = 성공, 1 = 서버 에러, 2 = 이미 듀얼중인 캐릭터에게 듀얼 신청,
// 3 = 거부 옵션이 켜진 상태
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; // 보낸이 아이디
unsigned long m_dwRecverID; // 받는이 아이디
unsigned char m_cCmd; // 명령
};
// 팀배틀 정보
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;
};
// 캐릭터 챈트&인챈트 정보
typedef struct PktSpInfo* LPPktSpInfo;
struct PktSpInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_nEnchantLevel; // 주문 레벨
unsigned char m_cSpellType; // 주문 타입 ( namespace Skill::SpellType참조 )
bool m_bOnOff; // 켜짐/꺼짐
};
// 캐릭터 리스폰
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;
};
// 캐릭터 리스폰 Ack
typedef struct PktRsAck* LPPktRsAck;
struct PktRsAck : public PktBase
{
POS m_Position; // 현재 위치
__int64 m_dlExp; // 현재 경험점
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wHP; // HP
unsigned short m_wMP; // MP
};
// 어워드 처리
typedef struct PktAw* LPPktAw;
struct PktAw : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwExp; // 경험치
};
#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)
// 방어자 정보 ( 차후 서버에서 처리 시 없어질 구조체 )
typedef struct AtNode *LPAtNode;
struct AtNode
{
enum { MAX_DEFENDER_NUM = 10 };
unsigned char m_wDefenserNum; // 방어자 수
unsigned long m_dwDefenser[MAX_DEFENDER_NUM]; // 방어자 아이디
unsigned char m_cDefenserJudge[MAX_DEFENDER_NUM]; // 방어자 판정
};
// 공격 정보
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; // 공격 타입 (또는 스킬 ID)
char m_cSkillLevel; // 스킬 레벨 (-127 ~ 128)
unsigned char m_cSkillLockCount : 4; // 스킬 락카운트 (0~5)
unsigned char m_cAtCount : 4; // 공격 카운트 (0~15)
};
// 방어자 노드
typedef struct DefenserNode* LPDefenserNode;
struct DefenserNode
{
unsigned long m_dwCharID; // 방어자 캐릭터 아이디
unsigned short m_wMaxHP; // 최대 HP
unsigned short m_sCurrHP; // 현재 HP
unsigned short m_wMaxMP; // 최대 MP
unsigned short m_sCurrMP; // 현재 MP
unsigned short m_wDamage; // 데미지 값
unsigned char m_cJudge; // 판정 값
};
#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필요.
#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)
// 파티 생성
typedef struct PktPI* LPPktPI;
struct PktPI : public PktBase
{
PARTY m_Party;
};
// 파티 명령
//
// 명령 :
// 0 = 초대, 1 = 가입, 2 = 거절
// 3 = 퇴장, 4 = 탈퇴, 5 = 양도
// 6 = 파괴, 7 = 로그인, 8 = 로그아웃
// 9 = 삭제(캐릭터), 10 = 재로그인,
// 11 = 파티찾기, 12 = 멤버찾기
//
// 에러 :
// 1 = 서버 에러, 2 = 이미 파티에 가입되어 있는 경우, 3 = 가입 실패
// 4 = 퇴장 실패, 5 = 탈퇴 실패, 6 = 양도 실패, 7 = 파티 인원 초과,
// 8 = 초대 실패, 9 = 거부 옵션을 켠 상태
//
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; // 파티 아이디
unsigned long m_dwSenderID; // 캐릭터 아이디(주체)
unsigned long m_dwReferenceID; // 참조 아이디(대상 캐릭터/서버 아이디)
unsigned short m_wCmd; // 명령
};
//
// 파티 명령 Ack
//
// 명령 :
// 0 = 초대, 1 = 가입, 2 = 거절
// 3 = 퇴장, 4 = 탈퇴, 5 = 양도
// 6 = 파괴, 7 = 로그인, 8 = 로그아웃
// 9 = 삭제(캐릭터)
//
// 에러 :
// 1 = 서버 에러, 2 = 이미 파티에 가입되어 있는 경우, 3 = 가입 실패
// 4 = 퇴장 실패, 5 = 탈퇴 실패, 6 = 양도 실패, 7 = 파티 인원 초과
//
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의 주소
char m_strSenderName[CHAR_INFOST::MAX_NAME_LEN]; // Sender의 이름
unsigned long m_dwPartyID; // 파티 아이디
unsigned long m_dwSenderID; // 캐릭터 아이디(주체)
unsigned long m_dwReferenceID; // 참조 아이디(대상 캐릭터/서버 아이디)
unsigned char m_cCmd; // 명령
};
//
// 파티 정보
//
// 명령 :
// 0 = 초대, 1 = 가입, 2 = 거절
// 3 = 퇴장, 4 = 탈퇴, 5 = 양도
// 6 = 파괴, 7 = 로그인, 8 = 로그아웃
// 9 = 삭제(캐릭터)
//
// 에러 :
// 1 = 서버 에러, 2 = 이미 파티에 가입되어 있는 경우, 3 = 가입 실패
// 4 = 퇴장 실패, 5 = 탈퇴 실패, 6 = 양도 실패, 7 = 파티 인원 초과
//
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; // 파티 ID
unsigned long m_dwMemberID; // 멤버 ID
unsigned char m_cCmd; // 명령
};
// 파티 멤버 데이터 (+ 가변길이 데이터)
typedef struct PktMD* LPPktMD;
struct PktMD : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wCmd; // 서브 명령
unsigned short m_wLen; // 길이
};
// 파티 멤버 정보
typedef struct PktPM* LPPktPM;
struct PktPM : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwPartyID; // 파티 아이디
unsigned long m_dwChant; // 챈트 상태
unsigned long m_dwEnchant; // 인챈트 상태
unsigned short m_wMaxHP; // 최대 HP
unsigned short m_sCurrHP; // 현재 HP
unsigned short m_wMaxMP; // 최대 MP
unsigned short m_sCurrMP; // 현재 MP
unsigned char m_cClass; // 캐릭터 클래스
unsigned char m_cLevel; // 캐릭터 레벨
};
// 파티 찾기
typedef struct PktPF* LPPktPF;
struct PktPF : public PktBase
{
unsigned long m_dwCharID;
};
// 파티 찾기 Ack
typedef struct PktPFAck* LPPktPFAck;
struct PktPFAck : public PktBase
{
enum { MAX_LIST = 30, MAX_DIFF_LEVEL_VIEW = 5 };
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cMemberFindPartyNum; // 파티 찾기 리스트 수
unsigned char m_cPartyFindMemberNum; // 파티원 찾기 리스트 수
};
// 캐릭터 명성(공헌도) 정보
typedef struct PktFI* LPPktFI;
struct PktFI : public PktBase
{
enum InfoKind
{
NONE = 0,
FAME = 1,
MERITS = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cInfoKind; // 정보 종류
};
// 캐릭터 명성(공헌도) 정보 Ack
typedef struct PktFIAck* LPPktFIAck;
struct PktFIAck : public PktBase
{
enum InfoKind
{
NONE = 0,
FAME = 1,
MERITS = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwFameOrMerits; // 현재 명성(또는 공헌도)
unsigned char m_cRankingByRace; // 종족별 순위
unsigned char m_cRankingByClass; // 클래스별 순위
unsigned char m_cInfoKind; // 정보 종류
};
// 옵션 조정
typedef struct PktCOp* LPPktCOp;
struct PktCOp : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
RejectOption m_RejectOption; // 거부 옵션 비트셑
};
// 캐릭터 채팅 패킷.
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;
};
// 캐릭터 속삭임 패킷.
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];
};
// 캐릭터 노점상 개설 패킷.
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];
};
// 캐릭터 노점상 물건 등록 패킷.
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;
};
// 캐릭터 노점상 입장 패킷.
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;
};
// 캐릭터 노점상 아이템 정보 패킷.
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>
// 파티 찾기 구조체
typedef struct MemberFindParty* LPMemberFindParty;
struct MemberFindParty
{
char m_strName[CHAR_INFOST::MAX_NAME_LEN]; // 이름
unsigned char m_cLevel; // 레벨
unsigned char m_cClass; // 클래스
};
// 파티원 찾기 구조체
typedef struct PartyFindMember* LPPartyFindMember;
struct PartyFindMember
{
char m_strLeaderName[CHAR_INFOST::MAX_NAME_LEN]; // 리더 이름
unsigned char m_cAverageLevel; // 평균 레벨
unsigned char m_cMemberNum; // 멤버 수
};
// 거부 옵션
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을 포함해야 함. (집기, 떨구기, )
#include <Item/ItemStructure.h>
#include <Network/Packet/PacketBase.h>
#include "CharItemPacketStruct.h"
#pragma pack(1)
// 집기 패킷 (응답 필요)
typedef struct PktPU* LPPktPU;
struct PktPU : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwObjectID; // 오브젝트 아이디
Item::ItemPos m_itemPos; // 아이템 위치
};
// 집기 패킷 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; // 캐릭터 아이디
unsigned long m_dwObjectID; // 오브젝트 아이디
unsigned long m_dwSize; // Object크기(혹은 돈 양)
Item::ItemPos m_itemPos; // 아이템이 놓일 위치
unsigned char m_cType; // Object종류(아이템 혹은 돈)
unsigned char m_cNum; // 아이템 개수
};
// 집기 정보
typedef struct PktPUInfo PktPUInfo, *LPPktPUInfo;
struct PktPUInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 정보
unsigned long m_dwObjectID; // 오브젝트 아이디
};
// 떨구기 (응답 필요)
typedef struct PktPD* LPPktPD;
struct PktPD : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_itemPos; // 아이템 위치 및 인덱스
unsigned char m_cNum; // 아이템 개수
};
// 떨구기 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; // 캐릭터 아이디
FieldObject m_FieldObject; // FieldObject
Item::ItemPos m_itemPos; // 아이템 위치 및 인덱스
};
// 떨구기 정보
typedef struct PktPDInfo* LPPktPDInfo;
struct PktPDInfo : public PktBase
{
unsigned long m_dwCharID;
FieldObject m_FieldObject;
};
// 셀 정보
typedef struct PktCeInfo* LPPktCeInfo;
struct PktCeInfo : public PktBase
{
unsigned char m_cObjectNum; // 오브젝트 개수
};
// 아이템 처리 패킷 (응답 필요)
typedef struct PktTI* LPPktTI;
struct PktTI : public PktBase
{
enum PktTIError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
};
// 돈 처리 패킷 (응답 필요)
typedef struct PktTG* LPPktTG;
struct PktTG : public PktBase
{
enum PktTGError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2,
GOLD_OVERFLOW = 3
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 돈 액수
unsigned char m_cSrcPos : 4; // Src위치 - TakeType 참조
unsigned char m_cDstPos : 4; // Dst위치 - TakeType 참조
};
// 아이템 처리 패킷 (응답 필요)
typedef struct PktTIs* LPPktTIs;
struct PktTIs : public PktBase
{
enum PktTlsError
{
SERVER_ERROR = 1
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_TakeNum; // 아이템 집기 숫자
};
// 아이템 스왑 패킷
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; // - 캐릭터 아이디
TakeType m_SwapSrc; // - 스왑 소스 아이템 집기 구조체
TakeType m_SwapDst; // - 스왑 대상 아이템 집기 구조체
};
// 아이템 거래 패킷
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; // 손님 아이디
unsigned long m_dwOwnerID; // 상점 주인 아이디 (NPC 또는 캐릭터)
unsigned short m_wBuyItemID; // 사려고 하는 아이템 종류 ID (0이면 팔기)
TakeType m_TakeType; // 아이템 집기 구조체
};
// 아이템 거래 패킷 Ack (+ 가변길이 아이템)
typedef struct PktTrAck* LPPktTrAck;
struct PktTrAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwNPCID; // 상점 NPC 아이디
unsigned long m_dwGold; // 현재 소지금
unsigned short m_wSize; // 아이템 크기(0 = 팔기, 0이 아니면 사기)
Item::ItemPos m_itemPos; // 아이템 위치
unsigned char m_cNum; // 아이템 갯수
};
// 아이템의 수리 패킷 (응답 필요)
typedef struct PktRpI* LPPktRpI;
struct PktRpI : public PktBase
{
enum Pos
{
EQUIPMENT = 1,
INVENTORY = 2,
EQUIPMENT_ALL = 3,
INVENTORY_ALL = 4,
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 수리 비용
Item::ItemPos m_itemPos; // 수리 아이템 위치
};
// 아이템의 사용 패킷 (응답 필요)
typedef struct PktUI* LPPktUI;
struct PktUI : public PktBase
{
enum PktUIAck
{
SERVER_ERROR = 1,
USE_FAILED = 2
};
unsigned long m_dwSender; // 사용자 아이디
unsigned long m_dwRecver; // 대상자 아이디
Item::ItemPos m_itemPos; // 사용 아이템 위치
};
// 오브젝트 던지기 패킷 ( 응답 필요 )
typedef struct PktCO* LPPktCO;
struct PktCO : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // 던지는 사람
unsigned long m_dwReceiverID; // 받는 사람
};
// 오브젝트 던지기 패킷 (Cast Object)
typedef struct PktCOInfo* LPPktCOInfo;
struct PktCOInfo : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // 던지는 사람
unsigned long m_dwReceiverID; // 받는 사람
};
// 소켓 설치 패킷
typedef struct PktIS* LPPktIS;
struct PktIS : public PktBase
{
unsigned long m_dwCharID;
Item::ItemPos m_equipPos; // 장비 위치
Item::ItemPos m_gemPos; // 보석 위치
};
// 소켓 설치 패킷 Ack (+ 소켓이 설치된 장비 아이템)
typedef struct PktISAck* LPPktISAck;
struct PktISAck : public PktBase
{
unsigned long m_dwCharID;
Item::ItemPos m_equipPos; // 장비 위치
Item::ItemPos m_gemPos; // 보석 위치
unsigned char m_wSize; // 아이템 크기
};
// 업그레이드 아이템
typedef struct PktUgI* LPPktUgI;
struct PktUgI : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cMineralNum; // 광물 숫자
};
// 업그레이드 아이템 Ack (+ 아이템 구조체)
typedef struct PktUgIAck* LPPktUgIAck;
struct PktUgIAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cSize; // 아이템 크기
};
// 아이템 스플릿 요청 (응답 필요)
typedef struct PktSplt* LPPktSplt;
struct PktSplt : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
// ( Src : 나눌 아이템, Dst : 나누어서 놓을 자리(항상 비어 있어야 함),
// Num : 나눌 아이템 개수)
};
// 아이템 스플릿 Ack (응답 필요) (+ 가변길이 아이템 구조체 (나누어서 생긴 아이템 정보))
typedef struct PktSpItAck* LPPktSpItAck;
struct PktSpItAck : public PktBase
{
enum PktSpltAckError
{
SERVER_ERROR = 1,
FAIL_SPLIT = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
unsigned char m_cSize; // 아이템 크기
};
// 퀵 슬롯 이동 (응답 필요)
typedef struct PktQSM* LPPktQSM;
struct PktQSM : public PktBase
{
enum PktQSMError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2
};
TakeType m_TakeType;
};
// 스위치 핸드
typedef struct PktSwH* LPPktSwH;
struct PktSwH : public PktBase
{
unsigned char m_cSelect; // 선택 핸드 ( 1 = 무기1 & 방패1, 2 = 무기2 & 방패2 )
};
// 교환 명령
//
// 명령 :
// 0 = 제안, 1 = 수락, 2 = 거절, 3 = 확인, 4 = 확인 취소, 5 = 거래 성립, 6 = 거래 취소
//
// 에러 :
// 0 = 성공, 1 = 서버 에러, 2 = 이미 교환중인 캐릭터에게 교환 신청,
// 3 = 양쪽 모두 확인하지 않은 상태에서 거래 성립, 4 = 거부 옵션이 켜진 상태
//
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; // 보낸이 아이디
unsigned long m_dwRecverID; // 받는이 아이디
unsigned char m_cCmd; // 명령
};
// 교환 아이템 (+ 아이템 구조체)
typedef struct PktExI* LPPktExI;
struct PktExI : public PktBase
{
enum Type
{
Item = 0,
Gold = 1,
Remove = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwSize; // 아이템 데이터 크기(혹은 돈 양)
Item::ItemPos m_itemPos; // 아이템 위치
unsigned char m_cType; // 아이템 종류(아이템 = 0, 돈 = 1)
unsigned char m_cNum; // 아이템 개수(stack아이템인 경우, 개수만 보냄)
};
namespace Deposit
{
enum Const { PASSWORD_LENGTH = 4 };
};
// 창고 패킷 (GameServer <--> DBAgent)
// 로그인시에, PktDBUpdate를 보낸 후, PktDepositUpdateDB를 여러개 준다.
// 마지막 패킷에 m_bUpdateComplete를 true로 Set해 준다.
// 게임 중에는 게임 서버가 수시로 Update를 한다.
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 : 창고 사용 X, 1 : 창고 사용함.
SAVED_PASSWORD = ( 1 << 31) // 0 : NOSAVE 1 : SAVE
};
enum TabNum
{
TAB_12 = 0,
TAB_34 = 1,
};
unsigned long m_dwUID; // 캐릭터 UID
unsigned long m_dwCID; // 캐릭터 CID
unsigned long m_dwTabFlag; // 현재 탭의 구입 상태를 나타내는 bitset
unsigned short m_usDataSize; // 탭(혹은 암호) 데이터 크기. 암호인 경우는 Deposit::PASSWORD_LENGTH와 같아야 한다.
unsigned char m_cTabNum; // password인 경우는 PASSWORD_TABNUM임
bool m_bUpdateComplete; // 업데이트가 완료되는 경우, true로 set.
};
// 창고 패킷 (Client <--> GameServer)
struct PktDeposit : public PktBase
{
enum CMD
{
LOGIN = 1, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]~[3]는 password, 그 다음에 암호 저장 여부 1byte (0, 1)
BUY_TAB = 2, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]에 사용할 탭 번호를 넣어 줌
RETURN_TAB = 3, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]에 사용할 탭 번호를 넣어 줌, 아직 구현되지 않음
LOGOUT = 4, // Ack있음 (Client->GameServer) 데이터 없음.
CHANGE_PASS = 5, // Ack있음 (Client->GameServer) szData[0]~[3]는 password. 인증된 상태에서만 가능.
SAVED_PASS = 6, // Ack없음 (GameServer -> Client) 게임 로그인시 줌. szData[0]~[3]는 Gold, [4]는 암호 저장 여부 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)
// 필드 오브젝트 구조체
typedef struct FieldObject* LPFieldObject;
struct FieldObject
{
enum CheckBit { Gold = 0x80000000 };
POS m_Pos; // 아이템 위치
unsigned long m_dwOID; // 오브젝트 아이디 ( 몬스터 혹은 Object )
unsigned long m_dwTypeID; // 타입 아이디 (상위 1비트 셋이면 돈)
unsigned long m_dwStatusFlag; // 몬스터 chant, enchant 상태 Flag
unsigned char m_cNum; // 아이템 수
};
// 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) { }
};
// 캐스트 오브젝트 구조체 (Cast Object)
typedef struct CastObject* LPCastObject;
struct CastObject
{
POS m_DstPos; // 목적 위치
unsigned long m_dwTargetID; // 타겟 아이디
unsigned short m_wTypeID; // 아이디 ( 돈일경우 금액 )
unsigned char m_cObjectType; // 종류 ( 0 = 캐스트, 어텍 류, 2 = 돈 )
unsigned char m_cObjectLevel; // 레벨
};
#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"
// 전방 참조
class CSession;
#pragma pack(1)
typedef struct PktDBUpdate* LPPktDBUpdate;
struct PktDBUpdate : public PktBase
{
unsigned __int64 m_dlItemSerial; // 가장 마지막으로 업데이트한 아이템 시리얼
unsigned long m_dwSessionID; // 세션 ID
unsigned long m_dwUserID; // 유저 ID
unsigned long m_dwCharID; // 캐릭터 ID
CSession* m_lpSession; // 세션 포인터
IN_ADDR m_Address; // 주소
unsigned short m_TypeCode; // 업데이트 타입
unsigned short m_usUpdate[DBUpdateData::MAX_UPDATE_DB]; // 업데이트 데이터 크기
};
// 캐릭터 로그인 (Char Login)
typedef struct PktCLi* LPPktCLi;
struct PktCLi : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSessionID;
};
// 캐릭터 로그인 Ack (1 = 서버 에러, 2 = 데이터 얻기 실패)
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];
};
// 캐릭터 로그아웃 (Char Logout)
typedef struct PktCLo* LPPktCLo;
struct PktCLo : public PktBase
{
unsigned long m_dwCharID;
};
// 캐릭터 로그아웃 (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)
// 캐릭터 이동 패킷 (CharMove)
typedef struct PktMV* LPPktMV;
struct PktMV : public PktBase
{
POS m_Position; // 캐릭터 위치
float m_fDir; // 캐릭터 방향
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwChantEf; // Chant Effect
unsigned long m_dwEnchantEf; // Enchant Effect
unsigned short m_wUAct; // 액션 번호
unsigned short m_wLAct; // 액션 번호
unsigned char m_wLevel; // 캐릭터 레벨
};
// 캐릭터 이동 업데이트 패킷 ( Char Move Update )
typedef struct PktMU* LPPktMU;
struct PktMU : public PktBase
{
POS m_Position; // 위치
float m_fDir; // 방향
unsigned long m_dwTick; // 클라이언트 틱
bool m_bSitMode; // 앉기 (true = 앉아 있음.)
};
// 캐릭터 이동 업데이트 패킷 Ack ( Char Move Update )
typedef struct PktMUAck* LPPktMUAck;
struct PktMUAck : public PktBase
{
unsigned long m_dwTick; // 클라이언트 틱 (처리 시간 퍼포 측정)
unsigned char m_cFlag; // - 플래그 (0 = 이동, 1 = 셀이동)
};
// 몬스터 움직임 ( Monster Move )
typedef struct PktMM* LPPktMM;
struct PktMM : public PktBase
{
POS m_Position; // 몬스터 위치
float m_fDir; // 몬스터 방향
float m_fVec; // 몬스터 속도
unsigned long m_dwMonID; // 몬스터 아이디
unsigned short m_wAct; // 몬스터 행동
unsigned short m_wAniNum; // 몬스터 이동 횟수
};
namespace CellCommand
{
enum Type
{
CELL_MOVE = 0,
CELL_LOGIN = 1,
RESPAWN = 2
};
};
// 캐릭터 셀 로그인 패킷 (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
};
// 캐릭터 셀 로그아웃 패킷 ( Char Cell Logout )
typedef struct PktCCLo* LPPktCCLo;
struct PktCCLo : public PktBase
{
unsigned long m_dwCharID;
unsigned char m_cCmd; // see namespace CellCommand
};
// 셀 브로드 캐스팅 + Address구조체
typedef struct PktCB PktCB, *LPPktCB;
struct PktCB : public PktBase
{
unsigned short m_sCharNum; // 셀 캐릭터 수
};
#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)
// 캐릭터 자살
typedef struct PktSC* LPPktSC;
struct PktSC : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 캐릭터 자살 Ack
typedef struct PktSCAck PktSCAck, *LPPktSCAck;
struct PktSCAck : public PktBase
{
POS m_Pos;
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 바인드 포지션
typedef struct PktBP* LPPktBP;
struct PktBP : public PktBase
{
POS m_Pos; // 바인드할 위치
char m_cZone; // 바인드할 존
unsigned long m_dwNPCID; // 바인드할 NPC ID
unsigned char m_cCmd; // 포지션 명령 (0 = 세이브 위치, 1 = 위치 이동)
};
// 레벨업 패킷
typedef struct PktLU* LPPktLU;
struct PktLU : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cLevel; // 레벨
};
// 레벨업 정보 패킷
typedef struct PktLUInfo* LPPktLUInfo;
struct PktLUInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cLevel; // 캐릭터 레벨
};
// 능력치 증가
typedef struct PktIP* LPPktIP;
struct PktIP : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned char m_cStateType; // 능력치 타입
};
// 능력치 증가 Ack
typedef struct PktIPAck* LPPktIPAck;
struct PktIPAck : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // 캐릭터 ID
};
// 클래스 업그레이드
typedef struct PktCU* LPPktCU;
struct PktCU : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned char m_cClass; // 클래스 번호
};
// 클래스 업그레이드 Ack
typedef struct PktCUAck* LPPktCUAck;
struct PktCUAck : public PktBase
{
ChState m_State; // 캐릭터 상태
unsigned long m_dwCharID; // 캐릭터 ID
unsigned short m_wSkill; // 스킬 ID
unsigned char m_cIndex; // 스킬 인덱스
unsigned char m_cClass; // 클래스 번호
};
// 스킬 (생성/지우기/락/락해제)
typedef struct PktSk* LPPktSk;
struct PktSk : public PktBase
{
enum PktSkError
{
SERVER_ERROR = 1, // 서버 에러
FAIL_NOT_SKILL = 2, // 스킬 관련 공통 에러
FAIL_NOT_ENOUGH_SLOT = 4, // 생성 에러
FAIL_NON_LEVEL = 3, FAIL_ALREADY_LOCK = 4, // 지우기 에러
FAIL_FULL_LOCK = 3, FAIL_NOT_ENOUGH_LEVEL = 4, // 락 에러
FAIL_NON_LOCK = 3, // 락 해제 에러
};
unsigned long m_dwCharID; // 캐릭터 ID
unsigned short m_wSkill; // 스킬 번호
unsigned char m_cIndex; // 스킬 위치
};
// 스킬 락 해제
typedef struct PktSkUL* LPPktSkUL;
struct PktSkUL : public PktSk
{
Item::ItemPos m_itemPos; // 망각의 돌 위치
};
// 스킬 락 해제 Ack
typedef struct PktSkULAck* LPPktSkULAck;
struct PktSkULAck : public PktSk
{
unsigned long m_dwGold; // 소비 금액
Item::ItemPos m_itemPos; // 망각의 돌 위치
};
// HP 리젠 패킷 ( Char HP Regen )
typedef struct PktHP* LPPktHP;
struct PktHP : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_sHP; // 현재 hp
unsigned short m_sMP; // 현재 mp
};
// 정보 요청 ( Require Info )
// - P2P로 다른 클라이언트에게 직접 보낼 시에는 주소내용이 추가 되며,
// 해당 클라이언트 아이디는 보내는 이의 캐릭터 아이디가 되겠다.
typedef struct PktRI* LPPktRI;
struct PktRI : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // 해당 캐릭터 아이디
unsigned char m_cCmd; // 커맨드 (0 : HP, MP 정보, 1 : UDP 주소, 2 : 모양)
};
// 캐릭터 겉모습 정보
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; // 캐릭터 겉모습
unsigned long m_dwStatusFlag; // 캐릭터에 걸려 있는 chant, enchant Flag
unsigned char m_cSelectedHands; // 현재 사용중인 손 (1 = 무기1 & 방패1, 2 = 무기2 & 방패2)
char m_StallName[MAX_STALL_NAME_LEN]; // 노점상 이름
};
// 엘리트 보너스
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¸¯ÅÍ ´É·ÂÄ¡
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)
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 사용자 인증 요청 (Client to AuthServer)
// - 계정 이름
// - 계정 패스워드
// - 클라이언트 버젼
//
// : 사용자 계정으로 로그인하여 유저 아이디와 로그인 가능한 서버 리스트드을 얻는다.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 사용자 인증 응답 (AuthServer to Client)
// - 계정 이름
// - 계정 패스워드
// - 클라이언트 버젼
//
// : 사용자 계정으로 로그인하여 유저 아이디와 로그인 가능한 서버 리스트드을 얻는다.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktAUAck* LPPktAUAck;
struct PktAUAck : public PktBase
{
unsigned long m_dwSessionID;
unsigned long m_dwUserID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 유저 로그인 (Client to AuthServer)
// - 유저 아이디
// - 서버 아이디
// - 예약 큐 포인터
// : 유저 로그인 후에 캐릭터 셀렉트 관련 정보를 얻어온다.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktULi* LPPktULi;
struct PktULi : public PktBase
{
DWORD m_dwSessionID;
DWORD m_dwUserID;
DWORD m_dwServerID;
DWORD m_dwCheckSum;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 유저 로그인 Ack (AuthServer to Client)
// - 유저 아이디
// - 캐릭터 정보
//
// (1 = 서버 에러, 2 = 데이터 얻기 실패)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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];
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 선택 ( Char Select )
// - 유저 아이디
// - 캐릭터 아이디
//
// : 캐릭터 선택 후 해당 캐릭터의 서버의 예약 포인터와 주소를 넘겨 받는다.
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCS* LPPktCS;
struct PktCS : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 선택 Ack
// - 유저 아이디
// - 캐릭터 아이디
// - 예약 큐 포인터
// - GSS 서버 주소
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCSAck* LPPktCSAck;
struct PktCSAck : public PktBase
{
enum { MAX_CHANNEL_NUM = 2 };
unsigned char m_cZone;
unsigned short m_wChannelNum[MAX_CHANNEL_NUM];
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 생성 ( Char Create )
// - 유저 아이디
// - 슬롯 번호
// - 캐릭터 생성 데이터
// - 복장 (셔츠, 부츠, 무기)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCC* LPPktCC;
struct PktCC : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwSlotNum;
CHAR_CREATE m_CreateChar;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 생성 Ack
// - 캐릭터 아이디
// - 슬롯 번호
// - 캐릭터 데이터
//
// (1 = 서버 에러, 2 = 데이터 생성 실패, 3 = 존재하는 캐릭터 이름, 4 = 비어 있지 않은 슬롯,
// 5 = 적당하지 않은 이름, 6 = 잘못된 생성 데이터)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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
};
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 삭제 ( Char Delete )
// - 유저 아이디
// - 캐릭터 아이디
// - 슬롯 번호
// - 파티 아이디
// - 길드 아이디
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktCD* LPPktCD;
struct PktCD : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSlotNum;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 캐릭터 삭제 Ack
// - 유저 아이디
// - 슬롯 번호
//
// (1 = 서버 에러, 2 = 데이터 삭제 실패)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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)
// -----------------------------------------------------------------------------
// 로그인 클라이언트 패킷.
// -----------------------------------------------------------------------------
// 서버 리스트 요청 패킷 : Launcher to LoginServer
typedef struct PktSvL* LPPktSvL;
struct PktSvL : public PktBase
{
unsigned long m_ClientVerInfo;
};
// 서버 리스트 응답 패킷 : LoginServer to Launcher
typedef struct PktSvLAck* LPPktSvLAck;
struct PktSvLAck : public PktBase
{
unsigned long m_dwUserID; // 유저 아이디
SERVER_LIST m_ServerList; // 서버 리스트
};
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// 서버군 선택 요청 패킷 : Launcher to LoginServer
typedef struct PktSG* LPPktSG;
struct PktSG : public PktBase
{
char m_cGroup;
};
// 서버군 선택 응답 패킷 : LoginServer to Launcher
typedef struct PktSGAck* LPPktSGAck;
struct PktSGAck : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_AuthAddress;
};
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// 사용자 인증 요청 패킷(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;
};
// 사용자 인증 응답 패킷 : LoginServer to Launcher
typedef struct PktAUOAck* LPPktAUOAck;
struct PktAUOAck : public PktBase
{
unsigned long m_dwUserID; // 유저 아이디
SERVER_LIST m_ServerList; // 서버 리스트
};
// -----------------------------------------------------------------------------
#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, // 유저 로그인
SCmdUserLogout = 0x0002, // 유저 로그인
SCmdUserMove = 0x0003, // 유저 존 이동
SCmdCharCreate = 0x0021, // 캐릭터 생성
SCmdCharDelete = 0x0022, // 캐릭터 삭제
SCmdCharCreateItem = 0x0023, // 캐릭터 생성 아이템
SCmdCharSelect = 0x0024, // 캐릭터 선택
SCmdCreateParty = 0x0031, // 파티 생성
SCmdDeleteParty = 0x0032, // 파티 삭제
SCmdGetPartyInfo = 0x0033, // 파티 정보 얻기
SCmdInsertPartyMem = 0x0034, // 파티 멤버 추가
SCmdDeletePartyMem = 0x0035, // 파티 멤버 삭제
SCmdLoginPartyMem = 0x0036, // 파티 멤버 로그인
SCmdLogoutPartyMem = 0x0037, // 파티 멤버 로그아웃
SCmdTransferLeader = 0x0038, // 리더 양도
SCmdStartSession = 0x0041, // 세션 시작
SCmdServerZone = 0x0043, // 서버 존
SCmdCharMoveZone = 0x0044 // 캐릭터 존이동
};
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
친구 관련 Operations
<Client->GameServer>
친구 등록 : PktFriendAddReq
거부 등록 : PktFriendAddReq
친구 삭제 : PktFriendRemoveReq
거부 삭제 : PktFriendRemoveReq
그룹 설정 : PktFriendEtc(Ack없음)
<GameServer->Client>
친구 리스트 주기 : PktFriendDB
거부 리스트 추기 : PktFriendDB
친구 등록 Ack : PktFriendAck
친구 삭제 Ack : PktFriendAck
거부 등록 Ack : PktFriendAck
거부 삭제 Ack : PktFriendAck
친구 로그인 : PktFriendAck
친구 로그아웃 : PktFriendAck
친구 등록당함 : PktFriendAddReq
<GameServer->DBAgent>
친구 등록 : PktFriendDB
거부 등록 : PktFriendDB
친구 제거 : PktFriendDB
거부 제거 : PktFriendDB
그룹 세팅 : PktFriendDB
<DBAgent->GameServer>
친구 리스트 주기 : PktFriendDB
거부 리스트 주기 : 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];
};
// 추가 패킷
struct PktFriendAddReq : public PktBase
{
enum { MAX_NAME = 16 };
enum CMD
{
ADD_FRIEND_REQ = 0, // 친구 등록 (Client->GameServer), m_szName는 등록할 사람의 이름.
BAN_FRIEND_REQ = 1, // 거부 등록 (Client->GameServer), m_szName은 등록할 사람의 이름.
ADDED_INFO = 2 // 친구가 등록됨 (GameServer->Client), m_szName은 나를 등록한 사람의 이름.
};
char m_szName[MAX_NAME]; // 등록한 사람 이름.
unsigned char m_cCmd;
};
// 제거 패킷
struct PktFriendRemoveReq : public PktBase
{
enum CMD
{
REMOVE_FRIEND_REQ = 0, // 친구 제거 (Client->GameServer), m_dwCID는 제거할 사람의 CID.
REMOVE_BAN_REQ = 1, // 거부 등록 제거 (Client->GameServer), m_dwCID는 제거할 사람의 CID.
};
unsigned long m_dwCID; // 대상자 CID;
unsigned char m_cCmd;
};
// 기타 패킷
struct PktFriendEtc : public PktBase
{
enum CMD
{
SETGROUP = 0, // 그룹 등록 (Client->GameServer),
// m_dwCID는 그룹 세팅할 사람의 CID, m_dwData는 바뀔 그룹 번호
};
unsigned long m_dwCID;
unsigned long m_dwData;
unsigned char m_cCmd;
};
// 친구 관련 패킷 ( Client <--> GameServer )
struct PktFriendAck : public PktBase
{
enum CMD
{
ADD_FRIEND_ACK = 0, // 친구 등록 Ack (GameServer->Client)
// 가능한 에러 : SERVER_ERROR (서버 에러)
// NOT_LOGINED (로그인되지 않은 캐릭터를 등록하려 함)
// REJECTED (거부 리스트에 있음)
// LIST_FULL (친구 리스트가 꽉 차 있음)
REMOVE_FRIEND_ACK = 1, // 친구 제거 Ack (GameServer->Client)
// 가능한 에러 : SERVER_ERROR (서버 에러)
ADD_BAN_ACK = 2, // 거부 등록 Ack (GameServer->Client)
// 가능한 에러 : SERVER_ERROR (서버 에러)
// NOT_LOGINED (로그인되지 않은 캐릭터를 등록하려 함)
// LIST_FULL (친구 리스트가 꽉 차 있음)
REMOVE_BAN_ACK = 3, // 거부 제거 Ack (GameServer->Client)
// 가능한 에러 : SERVER_ERROR (서버 에러)
FRIEND_LOGIN = 4, // 친구 로그인 (GameServer->Client), m_dwCID는 로그인한 친구의 CID
FRIEND_LOGOUT = 5 // 친구 로그아웃 (GameServer->Client), m_dwCID는 로그아웃한 친구의 CID
};
enum FriendERROR
{
SERVER_ERROR = 1,
NOT_LOGINED = 2,
REJECTED = 3,
LIST_FULL = 4
};
unsigned long m_dwCID;
unsigned char m_cCmd;
};
// 친구 관련 패킷
struct PktFriendDB : public PktBase
{
enum CMD
{
ADD_FRIEND = 0, // 친구 등록 (GameServer->DBAgent) Owner가 Reference를 등록.
REMOVE_FRIEND = 1, // 친구 제거 (GameServer->DBAgent) Owner가 Reference를 제거.
ADD_BAN = 2, // 거부 등록 (GameServer->DBAgent) Owner가 Reference를 등록.
REMOVE_BAN = 3, // 거부 제거 (GameServer->DBAgent) Owner가 Reference를 제거.
SETGROUP = 4, // 그룹 세팅 (GameServer->DBAgent)
// Owner가 Reference를 m_dwData에 들어 있는 그룹으로 세팅.
FRIEND_LIST = 5, // 친구 리스트 (DBAgent->GameServer, GameServer->Client)
// CIDTable에서 SerializeOut한 데이터가 뒤에 붙는다.
// Reference는 의미 없음. m_dwData는 뒤에 붙는 데이터의 크기.
BAN_LIST = 6, // 거부 리스트 (DBAgent->GameServer, GameServer->Client)
// CIDTable에서 SerializeOut한 데이터가 뒤에 붙는다.
// Reference는 의미 없음. m_dwData는 뒤에 붙는 데이터의 크기.
};
unsigned long m_dwOwnerUID; // 등록 하는 사람 UID
unsigned long m_dwOwnerCID; // 등록 하는 사람 CID
unsigned long m_dwReferenceCID; // 등록 되는 사람 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)
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 파티 정보
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 파티 생성
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 파티 삭제
//
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct PktDPD* LPPktDPD;
struct PktDPD : public PktDD
{
unsigned long m_dwPartyID;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 파티 멤버 정보
//
// Sender(Send/Recv) Reference(Send/Recv)
// 멤버 로그인 : CID/CID 0/SID
// 멤버 로그아웃 : CID/CID 0/리더 아이디(0 일경우 리더 양도 없음)
// 멤버 가입 : CID/CID CID/CID
// 멤버 삭제 : CID/CID CID/리더 아이디(0 일 경우 리더 양도 없음)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
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)
// -----------------------------------------------------------------------------
// 서버 정보 관련 구조체들
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 가 추가
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; // 서버 그룹
char m_Name[SERVER_NAME]; // 서버 이름
unsigned short m_ChannelNum; // 채널 숫자
long m_ClientNum[CHANNEL_NUM]; // 접속 자 수
};
typedef struct SERVER* LPSERVER_LIST;
struct SERVER_LIST
{
enum { SERVER_NUM = 10 };
unsigned short m_ServerNum; // 서버 숫자
SERVER_GROUP m_ServerGroup[SERVER_NUM]; // 서버 그룹
};
#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)
// 핑 패킷 ( 클라이언트 -> 서버로 5초마다.. 서버 - 서버간 통신도, 연결하는 쪽에서 Ping을 준다. )
typedef struct PktSyP* LPPktSyP;
struct PktSyP : public PktBase
{
unsigned long m_dwTickTime;
};
// 서비스 로그인 요청 패킷
typedef struct PktSL* LPPktSL;
struct PktSL : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_Address;
};
// 서비스 로그인 응답 패킷
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];
};
// 서비스 버전 업데이트 정보
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];
};
// 채널 업데이트 정보
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];
};
// ---------------------------------------------------------------------------
// 패치 정보 관련 패킷
// 패치 정보 요청 패킷
typedef struct PktSPI* LPPktSPI;
struct PktSPI : public PktBase
{
unsigned long m_dwServerID;
};
// 패치 서버 응답 패킷
typedef struct PktSPIAck* LPPktSPIAck;
struct PktSPIAck : public PktBase
{
enum { PATCH_ADDRESS_LENGTH = 100 };
unsigned long m_dwClientVer;
char m_PatchAddress[PATCH_ADDRESS_LENGTH];
};
// ---------------------------------------------------------------------------
// Zone 관련 패킷
// 서버존 선택
typedef struct PktSZ* LPPktSZ;
struct PktSZ : public PktBase
{
unsigned short m_cChannel;
unsigned char m_cZone;
};
// 서버존 선택 Ack
typedef struct PktSZAck* LPPktSZAck;
struct PktSZAck : public PktBase
{
unsigned long m_dwServerID;
IN_ADDR m_GameAddress;
};
// 서버존 이동
typedef struct PktSZMv* LPPktSZMv;
struct PktSZMv : public PktBase
{
POS m_NewPos;
char m_cZone;
};
// 서버존 선택 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];
};
// 서버 주소 얻기
typedef struct PktSA* LPPktSA;
struct PktSA : public PktDD
{
unsigned long m_dwUserID; // 유저 아이디
char m_cZone; // 존 번호
char m_cChannel; // 채널 번호
};
// 서버 주소 얻기 Ack
typedef struct PktSAAck* LPPktSAAck;
struct PktSAAck : public PktDD
{
unsigned long m_dwServerID;
IN_ADDR m_GameAddress;
};
// ---------------------------------------------------------------------------
// 유저 관련
// 유저 테이블 업데이트
typedef struct PktUUT *LPPktUUT;
struct PktUUT : public PktBase {
enum {
UpdateUIDTableNone = 0, // 없음
UpdateUIDTableLogin = 1, // 로그인
UpdateUIDTableLogout = 2 // 로그아웃
};
unsigned char m_cCmd;
unsigned long m_dwSessionID;
unsigned long m_dwServerID;
unsigned long m_dwUserID;
unsigned long m_dwCharID;
};
// 유저 죽이기.
typedef struct PktUK* LPPktUK;
struct PktUK : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwServerID;
};
#pragma pack()
#endif