#pragma once #include "DNProtocol.h" #include "DNUserData.h" #include #if !defined( PRE_TEST_PACKETMODULE ) #if defined(_GAMESERVER) || defined(_VILLAGESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) #include "../EngineUtil/EtMathWrapperD3D.h" #endif #endif // #if !defined( PRE_TEST_PACKETMODULE ) #include "../../GameCommon/DNNotifierCommon.h" #include "DNCommonDef.h" #if defined(_SERVER) #include "DNServerDef.h" #endif #pragma pack(push, 1) //-------------------------------------------------------------- // 패킷구조체 (헤더 + 데이터) //-------------------------------------------------------------- struct DNTPacketHeader { unsigned short iLen; unsigned char cMainCmd; unsigned char cSubCmd; }; struct DNTPacketCompHeader { unsigned short nLen; unsigned char cSeq; unsigned char cMainCmd; unsigned char cSubCmd; }; struct DNTPacket { unsigned short iLen; unsigned char cMainCmd; unsigned char cSubCmd; char buf[1024*40]; }; struct DNTCompPacket { DNTPacketCompHeader header; char buf[1024*40]; }; struct DNGAME_PACKET { unsigned short datasize; unsigned char header; //tcp packet과 inteface 공유를 위하여 헤더를 늘립니다. main_cmd와 같음 unsigned char sub_header; //sub_cmd와 같음 unsigned short checksum; unsigned char seq; //tcp udp seq char data[1024*4]; }; /* Security Association per Client */ struct ClientSA { DWORD _attr1; DWORD _attr2; }; struct DNEncryptPacketSeq { USHORT nLen; BYTE cSeq; union { struct { char Buf[1024*50]; }; DNTPacket Packet; }; }; #if defined(_GAMESERVER) //External PacketMessage Process (udp = Internal, tcp = external)(고냥 의미만~) struct _STORE_BUFFER_HEADER { unsigned short iBufSize; unsigned short iSize; unsigned int nAccountDBID; int iMainCmd; int iSubCmd; BYTE cMsgType; //eStoreExternalType USHORT nMasterID; #if defined( PRE_WORLDCOMBINE_PARTY ) int iWorldSetID; #endif // #if defined( PRE_WORLDCOMBINE_PARTY ) //bool bIsDataMsg; }; #endif struct DNDoorsPacketHeader { unsigned short datasize; unsigned short protocol; }; struct DNDoorsPacket { DNDoorsPacketHeader header; char data[8192 - sizeof(DNDoorsPacketHeader)]; }; //-------------------------------------------------------------- // 여러곳에서 쓰는(?) 기타 구조체 //-------------------------------------------------------------- struct TDatabaseVersion { enum { MaxDatabaseNameLen = 128, }; TDatabaseVersion() { iVersion = -1; memset( wszName, 0, sizeof(wszName) ); } int iVersion; WCHAR wszName[MaxDatabaseNameLen]; }; struct SPartyMemberInfo { UINT nSessionID; int nExp; BYTE cLevel; BYTE cPvPLevel; BYTE cJobArray[JOBMAX]; char cClassID; int nMapIndex; WCHAR wszCharacterName[NAMELENMAX]; int nHairID; int nFaceID; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; USHORT wFatigue; USHORT wStdRebirthCoin; USHORT wCashRebirthCoin; int nHelmetID; int nEarringID; BYTE cMemberIndex; //0번부터 시작 UINT uiPvPUserState; #if defined( PRE_WORLDCOMBINE_PARTY ) int nWorldSetID; //월드아이디 #endif #if defined( PRE_ADD_NEWCOMEBACK ) bool bCheckComebackAppellation; #endif }; struct TKeySetting { enum { Max1 = 29, #if defined(PRE_ADD_SKILLSLOT_EXTEND) Max2 = 49, #else // #if defined(PRE_ADD_SKILLSLOT_EXTEND) Max2 = 39, #endif // #if defined(PRE_ADD_SKILLSLOT_EXTEND) }; BYTE cVersion; BYTE arrKey1[Max1]; BYTE arrKey2[Max2]; TKeySetting() { cVersion = 0; memset( arrKey1, 0, Max1 ); memset( arrKey2, 0, Max2 ); } }; struct TPadSetting { enum { #if defined(PRE_ADD_SKILLSLOT_EXTEND) Max = 50, #else // #if defined(PRE_ADD_SKILLSLOT_EXTEND) Max = 40, #endif // #if defined(PRE_ADD_SKILLSLOT_EXTEND) }; BYTE cVersion; BYTE arrKey1[Max]; BYTE arrKey2[Max]; BYTE arrKey3[Max]; BYTE arrKey4[Max]; TPadSetting() { cVersion = 0; memset( arrKey1, 255, Max ); memset( arrKey2, 255, Max ); memset( arrKey3, 255, Max ); memset( arrKey4, 255, Max ); } }; struct TSwapMemberIndex { UINT nSessionID; BYTE cIndex; }; //GameOptions 20바이트 struct TGameOptions { //비트쉬프트 없이 바로 사용하기 위하여....db에 연속된메모리 형태로 저장이 되므로 변경시 참고해주세요. 꼬이면 골치 아파요. union { struct { //순서 바꾸지 말아주세요~ 추가는 하단으로 bool bUserName : 1; //다른유저이름표시 bool bPartyUserName : 1; //파티원이름표시 bool bMonsterName : 1; //몬스터이름표시 bool bStateBarInsideCount : 1; //상태바숫자표시 bool bMyHPBar : 1; //나의hp바표시 bool bPartyHPBar : 1; //파티 hpbar표시 bool bMonsterHPBar : 1; //몬스터바표시 bool bMyCombatInfo : 1; //전투정보표시 bool bPartyCombatInfo : 1; //파티원전투정보표시 bool bDamageDirMelee : 1; // 근접 피격방향 표시 bool bDamageDirRange : 1; // 원거리 피격방향 표시 bool bGuildName : 1; // 길드명 표시 bool bGameTip : 1; // 하단 슬라이드 게임팁 표시 bool bSimpleGuide : 1; // 간략 가이드 bool bPVPLevelMark : 1; // 콜로세움 계급 표시 bool bSkillCoolTimeCounter : 1; // 스킬 재사용 시간 표시 //추가시 DISPLAYOPTIONCOUNT 숫자를 추가 갯수만큼 올려주세요. }; char cDisplayOption[5]; //1bit*40 = 5Byte }; union { struct { //순서 바꾸지 말아주세요~ 추가는 하단으로 bool bDisplayGuildName : 1; //내 길드명을 남이 볼 수 있는지 bool bDisplayGender : 1; //내 성별을 남이 볼 수 있는지 bool bDisplayLevel : 1; //내 레벨을 남이 볼 수 있는지 //추가시 COMMDISPLAYOPTIONCOUNT 숫자를 추가 갯수만큼 올려주세요. }; char cCommunityDisplayOption[2]; //1bit*16 = 2byte }; union { struct { //순서 바꾸지 말아주세요~ 추가는 하단으로 //use eCommunityAcceptableOptionType BYTE cPartyInviteAcceptable : 2; BYTE cGuildInviteAcceptable : 2; BYTE cTradeRequestAcceptable : 2; BYTE cDuelRequestAcceptable : 2; BYTE cObserveStuffAcceptable : 2; BYTE cLadderInviteAcceptable : 2; BYTE cQuickPvPInviteAcceptable : 2; BYTE cPartyChatAcceptable : 2; // PRE_ADD_CHAT_RENEWAL //추가시 COMMOPTIONCOUNT 숫자를 추가 갯수만큼 올려주세요. }; char cCommunityOption[11]; //11byte }; union { struct { BYTE cDisplayOptionCount : 4; BYTE cCommunityDisplayOptionCount : 4; BYTE cCommunityOptionCount : 4; }; char cGameOptionCount[2]; //2byte }; void SetDefault() { bUserName = true; bPartyUserName = true; bMonsterName = true; bStateBarInsideCount = true; bMyHPBar = false; bPartyHPBar = false; bMonsterHPBar = true; bMyCombatInfo = true; bPartyCombatInfo = false; bDamageDirMelee = true; bDamageDirRange = true; bGuildName = true; bGameTip = true; bSimpleGuide = true; bPVPLevelMark = true; bSkillCoolTimeCounter = false; bDisplayGuildName = true; bDisplayGender = false; bDisplayLevel = true; cPartyInviteAcceptable = _CA_OPTIONTYPE_ACCEPT; cGuildInviteAcceptable = _CA_OPTIONTYPE_ACCEPT; cTradeRequestAcceptable = _CA_OPTIONTYPE_ACCEPT; cDuelRequestAcceptable = _CA_OPTIONTYPE_ACCEPT; cObserveStuffAcceptable = _CA_OPTIONTYPE_ACCEPT; cLadderInviteAcceptable = _CA_OPTIONTYPE_ACCEPT; cQuickPvPInviteAcceptable = _CA_OPTIONTYPE_ACCEPT; cPartyChatAcceptable = _CA_OPTIONTYPE_ACCEPT; cDisplayOptionCount = DISPLAYOPTIONCOUNT; cCommunityDisplayOptionCount = COMMDISPLAYOPTIONCOUNT; cCommunityOptionCount = COMMOPTIONCOUNT; } }; struct TProfile { BYTE cGender; WCHAR wszGreeting[PROFILEGREETINGLEN+1]; bool bOpenPublic; }; struct TItemInfo { BYTE cSlotIndex; TItem Item; }; struct TRepurchaseItemInfo { int iRepurchaseID; __time64_t tSellDate; int iSellPrice; TItem Item; }; struct TGuildWareSlot { BYTE cSlotIndex; INT64 nSerial; // 시리얼 }; struct TGuildWareHistory { int nIndex; // 인덱스 WCHAR wszCharacterName[NAMELENMAX]; // 캐릭터명 BYTE cInOut; // 입/출 short wCount; // 수량 0:Coin / +1:ItemCode int nContent; // 내역 cCount(수량)에 따라 용도가 달라진다 __time64_t EventDate; // 이벤트날짜 }; struct TEffectItemInfo { int iItemID; bool bEternityFlag; __time64_t ExpireDate; int iProperty[5]; INT64 biItemSerial; }; struct TQuestItemCnt // 인벤토리의 아이템 목록 추가 가능여부를 확인하기 위해 임시로 생성할 목적으로 선언 { public: int nItemID; short wCount; // 개수 public: void Set(int _nItemID, short _wCount) { nItemID = _nItemID; wCount = _wCount; } void Reset() { nItemID = 0; wCount = 0; } }; struct TInvenItemCnt // 인벤토리의 아이템 목록 추가 가능여부를 확인하기 위해 임시로 생성할 목적으로 선언 { public: int nItemID; short wCount; // 개수 bool bSoulbound; char cSealCount; public: void Set(int _nItemID, short _wCount, bool _bSoulbound, char _cSealCount ) { nItemID = _nItemID; wCount = _wCount; bSoulbound = _bSoulbound; cSealCount = _cSealCount; } void Reset() { nItemID = 0; wCount = 0; bSoulbound = false; cSealCount = 0; } }; struct TCommunityLocation { public: BYTE cServerLocation; // eLocationState int nChannelID; // 게임일경우 0 또는 -1 int nMapIdx; // 모를 경우 -1 public: TCommunityLocation() { Reset(); } void Reset() { cServerLocation = _LOCATION_NONE; nChannelID = 0; nMapIdx = 0; } bool IsSet() const { return(_LOCATION_NONE != cServerLocation); } }; struct TCommunityLocationEx:public TCommunityLocation { public: INT64 biCharacterDBID; void Reset( INT64 CharDBID ) { biCharacterDBID = CharDBID; TCommunityLocation::Reset(); } }; struct TGuildUID // 길드 UID { public: TGuildUID() { Reset(); } TGuildUID(const TGuildUID& pRhv) { ui64UID = pRhv.ui64UID; } TGuildUID(int nWorldID, UINT nDBID) { Set(nWorldID, nDBID); } void Set(int nSetWorldID, UINT nSetDBID) { nWorldID = nSetWorldID; nDBID = nSetDBID; } void Reset() { ui64UID = GUILDUID_DEF; } bool IsSet() const { return(GUILDUID_DEF != ui64UID); } operator UINT64() const { return ui64UID; } bool operator==(const TGuildUID& pRhv) const { return(ui64UID == pRhv.ui64UID); } bool operator!=(const TGuildUID& pRhv) const { return(ui64UID != pRhv.ui64UID); } bool operator==(UINT64 pUid) const { return(ui64UID == pUid); } bool operator!=(UINT64 pUid) const { return(ui64UID != pUid); } bool operator<(const TGuildUID& pRhv) const { return(ui64UID < pRhv.ui64UID); } // for stdext::hash_map등. public: union { UINT64 ui64UID; // 길드 UID struct { int nWorldID; // 월드 ID UINT nDBID; // 길드 DBID }; }; }; struct TGuildView // 길드 시각정보 { public: TGuildView() { Reset(); } void Set(const TGuildView& pGuildView) { Set(pGuildView.GuildUID, pGuildView.wszGuildName); wWarSchduleID = pGuildView.wWarSchduleID; cTeamColorCode = pGuildView.cTeamColorCode; wGuildMark = pGuildView.wGuildMark; wGuildMarkBG = pGuildView.wGuildMarkBG; wGuildMarkBorder = pGuildView.wGuildMarkBorder; } void Set(const TGuildUID pGuildUID, LPCWSTR lpwszGuildName) { GuildUID = pGuildUID; if (lpwszGuildName) ::wcsncpy_s(wszGuildName, _countof(wszGuildName), lpwszGuildName, _countof(wszGuildName)); else wszGuildName[0] = L'\0'; } void Reset() { GuildUID.Reset(); wszGuildName[0] = L'\0'; wWarSchduleID = 0; cTeamColorCode = 0; wGuildMark = 0; wGuildMarkBG = 0; wGuildMarkBorder = 0; } bool IsSet() const { return(GuildUID.IsSet()); } bool operator==(const TGuildView& pRhv) const { return((pRhv.GuildUID == GuildUID)); } bool operator!=(const TGuildView& pRhv) const { return(!(this->operator==(pRhv))); } public: TGuildUID GuildUID; // 길드 UID (월드 ID + 길드 DBID) WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 (일단 길드 창설 이후에는 이름은 변경되지 않는것을 전제로 함) short wWarSchduleID; BYTE cTeamColorCode; // 0:없음 / 1:청팀 / 2:홍팀 short wGuildMark; // 길드마크 문양 short wGuildMarkBG; // 길드마크 배경 short wGuildMarkBorder; // 길드마크 테두리 }; struct TGuildSelfView : public TGuildView // 길드 시각정보 (개인) // P.S.> 절대 다중상속 하면 않됨 { public: TGuildSelfView() { Reset(); } TGuildSelfView(const TGuildView& pGuildView, BYTE btGuildRole) { Set(pGuildView, btGuildRole); } TGuildSelfView(const TGuildSelfView& pGuildSelfView) { Set(pGuildSelfView); } void Reset() { btGuildRole = GUILDROLE_TYPE_CNT; TGuildView::Reset(); } void Set(const TGuildView& pGuildView, BYTE cGuildRole) { btGuildRole = cGuildRole; TGuildView::Set(pGuildView); } void Set(const TGuildSelfView& pGuildSelfView) { btGuildRole = pGuildSelfView.btGuildRole; TGuildView::Set(pGuildSelfView); } bool operator==(const TGuildSelfView& pRhv) const { // 상등 비교 시 부모 클래스 (길드 자체) 멤버만 인정 ? return(TGuildView::operator==(pRhv) && pRhv.btGuildRole == btGuildRole); } bool operator!=(const TGuildSelfView& pRhv) const { return(!(this->operator==(pRhv))); } public: BYTE btGuildRole; // 길드 직책 }; struct TGuildRewardItem { int nItemID; // 아이템아이디 int nItemType; // 타입 short nEffectValue; // 효과값 #if defined( PRE_ADD_GUILDREWARDITEM ) int nEffectValue2; // 효과값2 #endif bool bEternity; // 영구 여부 __time64_t m_tExpireDate; // 기간 }; struct TGuild // 길드 정보 { public: TGuild() { Reset(); } void Reset() { GuildView.Reset(); ui64GuildMoney = 0; wGuildLevel = 1; wszGuildNotice[0] = L'\0'; ::memset(iGuildMedal, 0, sizeof(iGuildMedal)); wGuildSize = 0; wGuildWareSize = 0; ::memset(&OpenDate, 0, sizeof(OpenDate)); ::memset(wszGuildRoleName, 0, sizeof(wszGuildRoleName)); ::memset(wGuildRoleAuth, 0, sizeof(wGuildRoleAuth)); ::memset(nRoleMaxItem, 0, sizeof(nRoleMaxItem)); ::memset(nRoleMaxCoin, 0, sizeof(nRoleMaxCoin)); nGuildWarFinalCount = 0; nGuildWarFinalWinCount = 0; iTotalGuildExp = 0; iDailyStagePoint = 0; iDailyMissionPoint = 0; iWarPoint = 0; ::memset(GuildRewardItem, 0, sizeof(GuildRewardItem)); #if defined( PRE_ADD_GUILD_EASYSYSTEM ) ::memset(wszGuildHomePage, 0, sizeof(wszGuildHomePage)); #endif } bool IsSet() const { return(GuildView.IsSet()); } bool CheckAuth(eGuildRoleType pGuildRoleType, eGuildAuthType pGuildAuthType) const { if (wGuildRoleAuth[pGuildRoleType] & (static_cast(1) << pGuildAuthType)) { return true; } return false; } public: TGuildView GuildView; // 길드 시각정보 INT64 ui64GuildMoney; // 길드 자금 short wGuildLevel; // 길드 레벨 WCHAR wszGuildNotice[GUILDNOTICE_MAX+1]; // 길드 공지 int iGuildMedal[GUILDMEDAL_TYPE_CNT]; // 길드 메달 short wGuildSize; // 길드 추가/전체 수용인원 short wGuildWareSize; // 길드 창고 최대수 __time64_t OpenDate; // 길드 창설일 WCHAR wszGuildRoleName[GUILDROLE_TYPE_CNT][GUILDROLENAME_MAX+1];// 길드 역할별 이름 int wGuildRoleAuth[GUILDROLE_TYPE_CNT]; // 길드 역할별 권한 INT nRoleMaxItem[GUILDROLE_TYPE_CNT]; // 길드 역할별 창고 아이템 횟수제한 (인덱스) INT nRoleMaxCoin[GUILDROLE_TYPE_CNT]; // 길드 역할별 최대 출금액 (인덱스) short nGuildWarFinalCount; // 길드전 본선 진출 횟수 short nGuildWarFinalWinCount; // 길드전 본선 우승 횟수 int iTotalGuildExp; // 길드 경험치 int iDailyStagePoint; // 스테이지 포인트 int iDailyMissionPoint; // 미션 포인트 int iWarPoint; // 길드전 포인트 TGuildRewardItem GuildRewardItem[GUILDREWARDEFFECT_TYPE_CNT]; // 길드보상 적용 효과 WCHAR wszGuildHomePage[GUILDHISTORYTEXT_MAX+1]; // 길드 홈페이지 char cGuildType; // 참조 BeginnerGuild }; struct TGuildMember // 길드원 정보 { public: TGuildMember() { Reset(); } void Set(UINT nMemberADBID, INT64 nMemberCDBID, LPCWSTR lpwszMemberCharacterName, char cMemberJob, char cMemberLevel, BYTE cMemberGuildRole, __time64_t tMemberJoinDate = 0, long nMemberUseGuildCommonPoint = 0, long nMemberTotGuildCommonPoint = 0, LPCWSTR lpwszGuildMemberIntroduce = NULL, __time64_t tLastLogoutDate = 0, BYTE cMemberServerLocation = 0, int nMemberChannelID = 0, int nMemberMapIdx = 0) { nAccountDBID = nMemberADBID; nCharacterDBID = nMemberCDBID; ::wcsncpy_s(wszCharacterName, _countof(wszCharacterName), lpwszMemberCharacterName, _countof(wszCharacterName)); nJob = cMemberJob; cLevel = cMemberLevel; btGuildRole = cMemberGuildRole; JoinDate = tMemberJoinDate; iUseGuildCommonPoint = nMemberUseGuildCommonPoint; iTotGuildCommonPoint = nMemberTotGuildCommonPoint; if (lpwszGuildMemberIntroduce) { ::wcsncpy_s(wszGuildMemberIntroduce, _countof(wszGuildMemberIntroduce), lpwszGuildMemberIntroduce, _countof(wszGuildMemberIntroduce)); } LastLogoutDate = tLastLogoutDate; Location.cServerLocation = cMemberServerLocation; Location.nChannelID = nMemberChannelID; Location.nMapIdx = nMemberMapIdx; } void Reset() { nCharacterDBID = 0; btGuildRole = GUILDROLE_TYPE_CNT; iUseGuildCommonPoint = 0; iTotGuildCommonPoint = 0; wszGuildMemberIntroduce[0] = L'\0'; JoinDate = 0; nAccountDBID = 0; wszCharacterName[0] = L'\0'; nJob = 0; cLevel = 0; LastLogoutDate = 0; Location.cServerLocation = _LOCATION_NONE; Location.nChannelID = 0; Location.nMapIdx = 0; nDelMembNo = 0; TakeWareItemCount = 0; WithdrawCoin = 0; WareVeriosnDate = 0; bOpenWareStatus = false; LastWareUseDate = 0; } bool IsSet() const { return(0 != nCharacterDBID); } public: // 길드원 DB 정보 INT64 nCharacterDBID; // 캐릭터 DBID BYTE btGuildRole; // 길드 역할 long iUseGuildCommonPoint; // 길드 일반 포인트 (사용) long iTotGuildCommonPoint; // 길드 일반 포인트 (기여) WCHAR wszGuildMemberIntroduce[GUILDMEMBINTRODUCE_MAX+1]; // 길드원 자기소개 __time64_t JoinDate; // 길드 가입 날짜 // 캐릭터 DB 정보 UINT nAccountDBID; // 계정 DBID WCHAR wszCharacterName[NAMELENMAX]; // 캐릭터 이름 TP_JOB nJob; // 전직직업 CHAR cLevel; // 레벨 __time64_t LastLogoutDate; // 최종 로그아웃 날짜 // 캐릭터 실시간 정보 TCommunityLocation Location; // 현재 위치 (로그인 여부도 본 멤버의 상태로 체크) int TakeWareItemCount; // 금일 아이템을 꺼내기 횟수 INT64 WithdrawCoin; // 금일 인출한 금액 __time64_t WareVeriosnDate; // 창고 접근 버젼 bool bOpenWareStatus; // 창고 오픈 상태 __time64_t LastWareUseDate; // 창고에 마지막으로 사용한 날짜 // 서버 관리 BYTE nDelMembNo; // 캐릭터 삭제 관리번호 }; struct TGuildHistory // 길드 히스토리 정보 (인스턴스) { INT64 biIndex; // 길드 히스토리 인덱스 __time64_t RegDate; // 길드 히스토리 등록일 BYTE btHistoryType; // 길드 히스토리 타입 (eGuildHistoryType) int nInt1; int nInt2; INT64 biInt64; WCHAR Text[GUILDHISTORYTEXT_MAX+1]; }; // 길드모집게시판 등록 길드정보 struct TGuildRecruitInfo { TGuildUID GuildUID; // 길드 UID (월드 ID + 길드 DBID) WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 short wGuildMark; // 길드마크 문양 short wGuildMarkBG; // 길드마크 배경 short wGuildMarkBorder; // 길드마크 테두리 WCHAR wszGuildRecruitNotice[GUILDRECRUITINTRODUCE+1]; // 길드모집게시판 소개글 short wGuildLevel; // 길드 레벨 short wGuildMemberPresentSize; // 현재 길드원 수 short wGuildMemberMaxSize; // 최대 길드원 수 #if defined( PRE_ADD_GUILD_EASYSYSTEM ) BYTE cPurposeCode; // 길드 목적(1:친목 2:전투 3:네스트 4:콜로세움 WCHAR wszGuildHomePage[GUILDHISTORYTEXT_MAX+1]; //길드 홈페이지 WCHAR wszGuildMasterName[NAMELENMAX+1]; // 길드 마스터명 #endif }; // 길드모집게시판을 통해서 길드가입신청을 한 유저목록 struct TGuildRecruitCharacter { INT64 nCharacterDBID; // 캐릭터 DBID WCHAR wszCharacterName[NAMELENMAX+1]; // 캐릭터 이름 TP_JOB nJob; // 전직직업 BYTE cLevel; // 레벨 }; #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM ) struct TNpcReputation { int iNpcID; int iFavorPoint; int iMalicePoint; TNpcReputation() :iNpcID(0),iFavorPoint(0),iMalicePoint(0) { } TNpcReputation( int NpcID, int FavorPoint, int MalicePoint ) :iNpcID(NpcID),iFavorPoint(FavorPoint),iMalicePoint(MalicePoint) { } void Set( int NpcID, int FavorPoint, int MalicePoint ) { iNpcID = NpcID; iFavorPoint = FavorPoint; iMalicePoint = MalicePoint; } }; #endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM ) struct TUnionReputePointInfo { INT64 iUnionPoint[NpcReputation::UnionType::Etc]; void SetUnionReputePoint( BYTE cType, INT64 iPoint ) { if (NpcReputation::UnionType::Commercial > cType || cType >= NpcReputation::UnionType::Etc) return; iUnionPoint[cType] = iPoint; } INT64 GetUnionReputePoint( BYTE cType ) const { if (NpcReputation::UnionType::Commercial > cType || cType >= NpcReputation::UnionType::Etc) return 0; return iUnionPoint[cType]; } bool DelUnionReputePoint (BYTE cType, INT64 iPoint) { if (NpcReputation::UnionType::Commercial > cType || cType >= NpcReputation::UnionType::Etc) return false; if (iUnionPoint[cType] < iPoint) return false; iUnionPoint[cType] -= iPoint; return true; } }; struct SCUnionPoint { INT64 biUnionPoint[NpcReputation::UnionType::Etc]; }; struct SCUnionMembershipList // SC_REPUTATION / SC_UNIONMEMBERSHIPLIST { int nItemID[NpcReputation::UnionType::Etc]; int nLeftUseTime[NpcReputation::UnionType::Etc]; }; struct SCBuyUnionMembershipResult // SC_REPUTATION / SC_REFRESHUNIONMEMBERSHIP { BYTE cType; int nItemID; int nLeftUseTime; // 남은 사용시간 (분단위) }; struct TMasterInfo { INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; BYTE cLevel; BYTE cJobCode; BYTE cGenderCode; int iRespectPoint; WCHAR wszSelfIntrodution[MasterSystem::Max::SelfIntrotuctionLen]; int iGraduateCount; }; struct TPupilInfo { INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; BYTE cLevel; BYTE cJob; int iFavorPoint; __time64_t tLastConnectDate; TPupilInfo() { biCharacterDBID = 0; cLevel = 0; cJob = 0; iFavorPoint = 0; tLastConnectDate = 0; memset( wszCharName, 0, sizeof(wszCharName) ); } }; struct TPupilInfoWithLocation:public TPupilInfo { TCommunityLocation Location; TPupilInfoWithLocation() { Location.Reset(); } TPupilInfoWithLocation( TPupilInfo& data ) { Location.Reset(); biCharacterDBID = data.biCharacterDBID; cLevel = data.cLevel; cJob = data.cJob; iFavorPoint = data.iFavorPoint; tLastConnectDate = data.tLastConnectDate; memcpy( wszCharName, data.wszCharName, sizeof(wszCharName) ); } }; struct TMasterAndClassmateInfo { MasterSystem::MasterClassmateKind::eCode Code; INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; __time64_t tLastConnectDate; TMasterAndClassmateInfo() { Code = MasterSystem::MasterClassmateKind::Max; biCharacterDBID = 0; tLastConnectDate = 0; memset( wszCharName, 0, sizeof(wszCharName) ); } }; struct TMasterAndClassmateInfoWithLocation:public TMasterAndClassmateInfo { TCommunityLocation Location; TMasterAndClassmateInfoWithLocation() { Location.Reset(); } TMasterAndClassmateInfoWithLocation( TMasterAndClassmateInfo& data ) { Location.Reset(); Code = data.Code; biCharacterDBID = data.biCharacterDBID; tLastConnectDate = data.tLastConnectDate; memcpy( wszCharName, data.wszCharName, sizeof(wszCharName) ); } }; struct TClassmateInfo { INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; BYTE cJob; BYTE cLevel; BYTE cMasterCount; WCHAR wszMasterCharName[MasterSystem::Max::MasterCount][NAMELENMAX]; TClassmateInfo() { biCharacterDBID = 0; cJob = 0; cLevel = 0; cMasterCount = 0; memset( wszCharName, 0, sizeof(wszCharName) ); memset( wszMasterCharName, 0, sizeof(wszMasterCharName) ); } }; struct TClassmateInfoWithLocation:public TClassmateInfo { TCommunityLocation Location; TClassmateInfoWithLocation() { Location.Reset(); } TClassmateInfoWithLocation( TClassmateInfo& data ) { Location.Reset(); biCharacterDBID = data.biCharacterDBID; cJob = data.cJob; cLevel = data.cLevel; cMasterCount = data.cMasterCount; memcpy( wszCharName, data.wszCharName, sizeof(wszCharName) ); for( UINT i=0 ; i((0.34f*iPvPLadderGradePoint))+450; } else { iLP = static_cast(1511.26f/static_cast((1+40.f*pow(2.f,(-0.00412f*iPvPLadderGradePoint))))); } switch( cPvPLadderCode ) { case LadderSystem::MatchType::_1vs1: { iLP = static_cast(iLP*0.72f); break; } case LadderSystem::MatchType::_2vs2: { #ifdef PRE_ADD_2vs2_LADDER iLP = static_cast(iLP*0.89f); #else iLP = static_cast(iLP*0.84f); #endif break; } #if defined(PRE_ADD_DWC) case LadderSystem::MatchType::_3vs3_DWC: case LadderSystem::MatchType::_3vs3_DWC_PRACTICE: #endif case LadderSystem::MatchType::_3vs3: { #ifdef PRE_ADD_2vs2_LADDER iLP = static_cast(iLP*0.95f); #else iLP = static_cast(iLP*0.90f); #endif break; } } return iLP; } }; struct TPvPLadderScoreInfo { int iPvPLadderPoint; BYTE cMaxKillJobCode; BYTE cMaxDeathJobCode; BYTE cLadderTypeCount; TPvPLadderMatchTypeScore LadderScore[LadderSystem::MatchType::MaxCount]; void SetLadderScoreForCheat( LadderSystem::MatchType::eCode Type, int iLadderPoint, int iGradePoint, int iHiddenGradePoint ) { iPvPLadderPoint = iLadderPoint; bool bEmpty = true; for( int i=0 ; i iTop ) iTop = LadderScore[i].iPvPLadderGradePoint; } return iTop; } int GetHiddenGradePoint( LadderSystem::MatchType::eCode Type ) const { for( int i=0 ; i iTop ) iTop = iVal; } return iTop; } void UseLadderPoint( int iPoint ) { if( iPvPLadderPoint < iPoint ) { _ASSERT(0); return; } iPvPLadderPoint -= iPoint; } }; struct TPvPLadderJobScore { BYTE cJobCode; int iWin; int iLose; int iDraw; }; struct TPvPLadderScoreInfoByJob { BYTE cJobCount; TPvPLadderJobScore LadderScoreByJob[JOB_KIND_MAX]; }; struct TPvPLadderRanking { INT64 biCharacterDBID; int iRank; int iPvPLadderGradePoint; WCHAR wszCharName[NAMELENMAX]; BYTE cJobCode; int iWin,iLose,iDraw; }; struct TPvPGhoulScores { int nPoint[GhoulMode::PointType::Max]; }; struct TPeriodResetItem { BYTE cType; int iValue; __time64_t tDate; }; #if defined( PRE_ADD_DWC ) struct TDWCChannelInfo { int nChannelID; // DWC 대회 회차 정보 __time64_t tStartDate; // 시작시간 __time64_t tEndDate; // 종료 시간 BYTE cStatus; // DWC::DWCStatus int nLadderTime[2]; // DWC 래더 매칭 시간, 총 2회의 매칭 시간을 설정할 수 있음 BYTE cLimitCharacterLevel; // DWC 캐릭터 생성하기 위한 보유 캐릭터 레벨 조건 }; #endif // #if defined( PRE_ADD_DWC ) //-------------------------------------------------------------- // 패킷관련 //-------------------------------------------------------------- //------------------------------------------------- // Client <-> Login //------------------------------------------------- /* CS_CHECKLOGIN -> SC_CHECKLOGIN CS_SERVERLIST -> SC_SERVERLIST CS_SELECTSERVER -> SC_CHARLIST CS_SELECTCHAR -> SC_CHANNELLIST CS_SELECTCHANNEL -> 마을로!! */ struct CSCheckVersion // CS_LOGIN / CS_CHECKVERSION { BYTE cNation; BYTE cVersion; bool bCheck; USHORT nMajorVersion; USHORT nMinorVersion; char Stampila[4]; #if defined (_KR) BYTE szMID[MACHINEIDMAX]; DWORD dwGRC; #endif // _KR }; struct SCCheckVersion // SC_LOGIN / SC_CHECKVERISON { int nRet; char szServerVersion[SERVERVERSIONMAX]; TDatabaseVersion MembershipDBVersion; TDatabaseVersion WorldDBVersion; }; struct CSCheckLoginKR // CS_LOGIN / CS_CHECKLOGIN_KR { WCHAR wszPassPort[1024]; WCHAR wszVirtualIp[IPLENMAX]; }; struct CSCheckLoginKRAZ // CS_LOGIN / CS_CHECKLOGIN_KRAZ { WCHAR wszKeyID[128]; WCHAR wszRequestTime[30]; // 19(YYYY-MM-DD HH:NN:SS) + 6(공백->\_3, :->\_7 로 대체) WCHAR wszVirtualIp[IPLENMAX]; }; struct CSCheckLoginCH // CS_LOGIN / CS_CHECKLOGIN_CH { WCHAR wszVirtualIp[IPLENMAX]; char szPassport[SNDAOAPASSPORTMAX + 1]; }; struct CSCheckLoginJP // CS_LOGIN / CS_CHECKLOGIN_JP { INT64 nMemberID; WCHAR wszVirtualIp[IPLENMAX]; char szAuthString[4096]; Partner::Type::eType PartnerType; }; struct CSCheckLoginTW // CS_LOGIN / CS_CHECKLOGIN_TW { char szAccountName[IDLENMAX]; #ifdef RLKT_ADD_MD5_AUTH char szPassword[32];//md5. #else char szPassword[PASSWORDLENMAX]; #endif char szVirtualIp[IPLENMAX]; }; struct CSCheckLoginUS // CS_LOGIN / CS_CHECKLOGIN_US { #ifdef PRE_ADD_STEAM_USERCOUNT bool bSteamUser; #endif //#ifdef PRE_ADD_STEAM_USERCOUNT WCHAR wszPassPort[1024]; WCHAR wszVirtualIp[IPLENMAX]; }; struct CSCheckLoginSG // CS_LOGIN / CS_CHECKLOGIN_SG { char szLoginID[CHERRYLOGINIDMAX]; char szPassWord[PASSWORDLENMAX]; char szVirtualIp[IPLENMAX]; #if defined (PRE_MOD_SG_WITH_MACADDR) char szMacAddress[MACADDRLENMAX]; #endif //#if defined (PRE_MOD_SG_WITH_MACADDR) }; struct CSCheckLoginTH // CS_LOGIN / CS_CHECKLOGIN_TH { char szAccountName[IDLENMAX]; char szPassword[PASSWORDLENMAX]; char szDomain[DOMAINLENMAX]; char szVirtualIp[IPLENMAX]; }; struct CSCheckLoginTHOTP //CS_LOGIN / CS_CHECKLOGIN_TH_OTP { char szOTPResponse[AsiaAuth::Common::OTPLenMax + 1]; }; struct SCOTRPResult //CS_LOGIN / SC_ASIASOFT_RET_OTP { int nRetCode; }; struct CSCheckLoginID //CS_LGIN / CS_CHECKLOGIN_ID { char szAccountName[IDLENMAX]; char szPassword[PASSWORDLENMAX]; char szVirtualIp[IPLENMAX]; char szMacAddress[MACADDRLENMAX]; char szKey[KREONKEYMAX]; int nReturnError; }; struct CSCheckLoginRU // CS_LOGIN / CS_CHECKLOING_RU { char szAccountName[IDLENMAX]; char szOTPHash[MAILRUOTPMAX]; // 65.. char szVirtualIp[IPLENMAX]; }; struct CSCheckLoginEU // CS_LOGIN / CS_CHECKLOGIN_EU { char szAccountName[IDLENMAX]; char szPassword[PASSWORDLENMAX]; char szVirtualIp[IPLENMAX]; char cSelectedLanguage; }; struct CSCheckLogin // CS_LOGIN / CS_CHECKLOGIN { WCHAR wszUserId[IDLENMAX]; #ifdef RLKT_ADD_MD5_AUTH unsigned char wszPassword[32]; //md5 #else WCHAR wszPassword[PASSWORDLENMAX]; #endif WCHAR wszVirtualIp[IPLENMAX]; #ifdef PRE_ADD_MULTILANGUAGE char cSelectedLanguage; #endif //#ifdef PRE_ADD_MULTILANGUAGE }; struct SCCheckLogin // SC_LOGIN / SC_CHECKLOGIN { UINT nSessionID; int nRet; #if !defined(PRE_MOD_SELECT_CHAR) BYTE cCharCountMax; BYTE cGender; #endif // #if defined(PRE_MOD_SELECT_CHAR) __time64_t _tServerTime; TGameOptions GameOption; #ifdef PRE_ADD_COMEBACK bool bComebackUser; #endif //#ifdef PRE_ADD_COMEBACK #if defined( PRE_ADD_GAMEQUIT_REWARD ) bool bReConnectNewbieReward; // 예) 신규 유저 재접 보상 수령 대상자(NewbieReward: true/RegTime: 생성시간) __time64_t _tAccountRegistTime; // 신규 유저 보상 시간이 남은 경우(NewbieReward: false/RegTime: 생성시간), 보상 대상 아닌경우(false/0) #endif // #if defined( PRE_ADD_GAMEQUIT_REWARD ) #ifdef PRE_ADD_DOORS bool bMobileAuthentication; #endif //PRE_ADD_DOORS #if defined(_CH) || defined(_KRAZ) WCHAR wszAccountName[IDLENMAX]; #endif // #if defined(_CH) || defined(_KRAZ) #if defined(_CH) char szInfoURL[SNDAOAPASSPORTMAX]; #endif }; struct TServerListData { BYTE cWorldID; WCHAR wszServerName[WORLDNAMELENMAX]; UINT nWorldMaxUser; UINT nWorldCurUser; bool bOnline; bool bOnTop; BYTE cMyCharCount; }; struct SCServerList // SC_LOGIN / SC_SERVERLIST { BYTE cServerCount; TServerListData ServerListData[WORLDCOUNTMAX]; }; struct CSSelectServer // CS_LOGIN / CS_SELECTSERVER { char cWorldID; }; struct TCharListData { #if defined( PRE_ADD_TOTAL_LEVEL_SKILL ) BYTE cWorldSetID; #endif #if defined(PRE_MOD_SELECT_CHAR) BYTE cWorldID; #endif // #if defined(PRE_MOD_SELECT_CHAR) WCHAR wszCharacterName[NAMELENMAX]; #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) BYTE cLevel; BYTE cJob; int nMapID; int nEquipArray[EQUIPMAX]; int nDefaultBody; // 처음 생성시에 설정한 equip int nDefaultLeg; int nDefaultHand; int nDefaultFoot; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; INT64 biUniqueID; // nexon 메신저에서 쓰는 용도(?) int nCashEquipArray[CASHEQUIPMAX]; bool bDeleteFlag; __time64_t DeleteDate; #if defined(PRE_CHARLIST_SORTING) __time64_t LastLoginDate; __time64_t CreateDate; #endif // #if defined(PRE_CHARLIST_SORTING) #if defined( PRE_ADD_NEWCOMEBACK ) bool bCombackEffectItem; #endif #if defined( PRE_ADD_DWC ) //[debug] 董珂빔쫠侶몸俚쌘 //#if 0 BYTE cAccountLevel; // DWC 캐릭터 = 40 //#endif #endif // #if defined( PRE_ADD_DWC ) }; struct SCCharList // SC_LOGIN / SC_CHARLIST { int nRet; #if defined(PRE_CHARLIST_SORTING) BYTE cCharacterSortCode; // Login::CharacterSortCode #endif // #if defined(PRE_CHARLIST_SORTING) BYTE cAccountLevel; BYTE cCharCountMax; BYTE cCharCount; // 몇개인지 TCharListData CharListData[CHARCOUNTMAX]; }; struct CSSelectChar // CS_LOGIN / CS_SELECTCHAR { #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) int nSeed; int nValue[SecondAuth::Common::PWMaxLength]; // 2차 인증 비밀번호 값 #ifdef PRE_ADD_23829 bool bSetIgnoreAuthNotify; #endif }; struct CSCreateChar // CS_LOGIN / CS_CREATECHAR { #if defined(PRE_MOD_SELECT_CHAR) BYTE cWorldID; #endif // #if defined(PRE_MOD_SELECT_CHAR) WCHAR wszCharacterName[NAMELENMAX]; int nEquipArray[EQUIPMAX]; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; BYTE cClass; bool isDarkClass; }; struct SCCreateChar // SC_LOGIN / SC_CREATECHAR { WCHAR wszCharacterName[NAMELENMAX]; int nRet; char cDailyCreateMaxCount; // 최대 개수 }; struct CSDeleteChar // CS_LOGIN / CS_DELETECHAR { #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) int nSeed; int nValue[SecondAuth::Common::PWMaxLength]; }; struct SCDeleteChar // SC_LOGIN / SC_DELETECHAR { #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) int nRet; BYTE cFailCount; }; struct sChannelInfo { UINT nChannelID; USHORT nChannelIdx; //for UI UINT nMapIdx; USHORT nCurrentUserCount; USHORT nMaxUserCount; int nChannelAttribute; int nMeritBonusID; BYTE cMinLevel; BYTE cMaxLevel; BYTE cVillageID; bool bVisibility; char szIP[IPLENMAX]; USHORT nPort; int nLimitLevel; bool bShow; USHORT nDependentMapID; int nServerID; CHAR cThreadID; #if defined(PRE_ADD_CHANNELNAME) WCHAR wszLanguageName[CHANNELLANGUAGEMAX]; #endif // #if defined(PRE_ADD_CHANNELNAME) }; struct TMeritInfo { int nID; int nMinLevel; int nMaxLevel; int nMeritType; int nExtendValue; }; struct SCChannelList // SC_LOGIN / SC_CHANNELLIST { int nRet; BYTE cFailCount; BYTE cCount; sChannelInfo Info[VILLAGECHANNELMAX]; }; struct CSSelectChannel // SC_LOGIN / SC_SELECTCHANNEL { int nChannelID; }; struct SCTutorialMapInfo // SC_LOGIN / SC_TUTORIALMAPINFO { int nMapIndex; char cGateNo; }; struct SCWaitUser // SC_LOGIN / SC_WAITUSER { BYTE cWorldID; UINT nWaitUserCount; ULONG nEstimateTime; }; struct SCCHeckBlock // SC_LOGIN / SC_CHECKBLOCK { __time64_t ServerDate; __time64_t StartDate; __time64_t EndDate; WCHAR wszBlockReason[RESTRAINTREASONMAX]; BYTE cType; int iReasonID; }; struct CSReviveChar { #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) }; struct SCReviveChar { #if defined(PRE_MOD_SELECT_CHAR) INT64 biCharacterDBID; #else // #if defined(PRE_MOD_SELECT_CHAR) BYTE cCharIndex; #endif // #if defined(PRE_MOD_SELECT_CHAR) int nRet; }; struct CSCharacterSortCode // CS_LOGIN / CS_CHARACTERSORTCODE { BYTE cCharacterSortCode; }; #if defined( PRE_ADD_DWC ) struct CSCreateDWCChar // CS_LOGIN / CS_CREATEDWCCHAR { BYTE cJobCode; // 기존에 생성 되어있는 캐릭터 중에서 하나를 지정해서 이름을 생성 함 #if defined( PRE_MOD_SELECT_CHAR ) INT64 biSelectCharacterDBID; #else // #if defined( PRE_MOD_SELECT_CHAR ) BYTE cSelectCharIndex; #endif // #if defined( PRE_MOD_SELECT_CHAR ) }; struct SCCreateDWCChar // SC_LOGIN / SC_CREATEDWCCHAR { int nRet; }; #endif // #if defined( PRE_ADD_DWC ) //------------------------------------------------- // SYSTEM (CS_SYSTEM, SC_SYSTEM) //------------------------------------------------- struct SCVillageInfo // SC_SYSTEM / SC_VILLAGEINFO { UINT nSessionID; char szVillageIp[IPLENMAX]; USHORT wVillagePort; short nRet; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 }; struct CSConnectVillage // CS_SYSTEM / CS_CONNECTVILLAGE { UINT nSessionID; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 WCHAR wszVirtualIp[IPLENMAX]; // nexon pcbang #ifdef _KR BYTE szMID[MACHINEIDMAX]; DWORD dwGRC; #endif //#ifdef _KR }; struct SCDetachMessage //SC_SYSTEM / SC_DETACHCONNECTION_MSG { int nRetCode; #if defined(PRE_MOD_DUPLICATION_LOGIN_MES) bool bDisConnectByClient; #endif // #if defined(PRE_MOD_DUPLICATION_LOGIN_MES) }; struct SCZeroPopulation //SC_SYSTEM / SC_ZEROPOPULATION { bool bZeroPopulation; }; struct SCConnectVillage // SC_SYSTEM / SC_CONNECTVILLAGE { short nRet; char szServerVersion[SERVERVERSIONMAX]; int nChannelAttr; BYTE cWithoutLoading; }; struct CSVillageReady // CS_SYSTEM / CS_VILLAGEREADY { bool boFirst; bool boChannelMove; }; struct SCGameInfo // SC_SYSTEM / SC_GAMEINFO { GameTaskType::eType GameTaskType; BYTE cReqGameIDType; ULONG nGameServerIP; USHORT nGameServerPort; USHORT nGameServerTcpPort; int nRet; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 }; struct CSConnectRequest // CS_SYSTEM / CS_CONNECT_REQUEST { UINT nSessionID; ULONG nAddrIP; USHORT nPort; }; struct SCConnectedResult // SC_SYSTEM / SC_CONNECTED_RESULT { UINT nSessionID; //그냥 ㅎㅎㅎ 님하 오케위~ char szServerVersion[SERVERVERSIONMAX]; }; struct CSReady2Recieve // CS_SYSTEM / CS_READY_2_RECIEVE { UINT nSessionID; //혹시나 해서 WCHAR wszVirtualIp[IPLENMAX]; // nexon pcbang }; struct CSIntendedDisconnect // CS_SYSTEM / CS_INTENDED_DISCONNECT { }; struct CSConnectGame // CS_SYSTEM / CS_CONNECTGAME { UINT nSessionID; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 #ifdef _KR BYTE szMID[MACHINEIDMAX]; DWORD dwGRC; #endif //#ifdef _KR }; struct CCPeerConnectRequest // CS_SYSTEM / CC_PEER_CONNECT_REQUEST { UINT nSessionID[2]; char cState; //0 = Connect Request, 1 = Connected, 2 = Disconnected }; struct SCPeerConnectRequest // SC_SYSTEM / SC_PEER_CONNECT_REQUEST { //님들하 뉘들끼리 연결좀 하삼~ ULONG nDestAddrIP; USHORT nDestAddrPort; UINT nSessionID[2]; }; struct CSReconnectLogin // CS_SYSTEM / CS_RECONNECTLOGIN { UINT nSessionID; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 #ifdef _KR BYTE szMID[MACHINEIDMAX]; DWORD dwGRC; #endif //#ifdef _KR #if defined(_ID) char szVirtualIp[IPLENMAX]; char szMacAddress[MACADDRLENMAX]; char szKey[KREONKEYMAX]; #endif // #if defined(_ID) }; struct CSAbandonStage // CS_SYSTEM / CS_ABANDONSTAGE { bool bIsPartyOut; //파티에서 나가는 것이면 트루, 그냥 포기면 팔스 bool bIntenedDisconnect; }; struct SCReconnectLogin // SC_SYSTEM / SC_RECONNECTLOGIN { int nRet; UINT nAccountDBID; // 계정 DBID INT64 biCertifyingKey; // 인증키 }; struct SCCountDownMsg // SC_SYSTEM / SC_COUNTDOWNMSG { BYTE cIsStart; // 1:start 0:stop int nCountTime; UINT nCode; // 사용할 uistringnum BYTE msgboxType; // 0:prefix 1:number_only 2:progress }; struct SCFCMState // SC_SYSTEM / SC_CHN_FCM { int nOnlineMin; }; #if defined(_GPK) const int GPKCODELENMAX = 1024 * 6; struct SCGPKCode // SC_SYSTEM / SC_CHN_GPKCODE { int nCodeLen; BYTE Code[GPKCODELENMAX]; }; const char GPKDATALENMAX = 64; struct CSGPKData // CS_SYSTEM / CS_CHN_GPKDATA { char Data[GPKDATALENMAX]; }; struct SCGPKData // SC_SYSTEM / SC_CHN_GPKDATA { char Data[GPKDATALENMAX]; }; const int GPKAUTHLENMAX = 128; struct CSGPKAuthData // SC_SYSTEM / SC_CHN_GPKAUTHDATA { int nLen; unsigned char Data[GPKAUTHLENMAX]; }; struct SCGPKAuthData // CS_SYSTEM / CS_CHN_GPKAUTHDATA { int nLen; unsigned char Data[GPKAUTHLENMAX]; }; #endif // _CH #if defined(PRE_ADD_VIP) struct CSVIPAutomaticPay // CS_SYSTEM / CS_VIPAUTOMATICPAY, // VIP자동결제 { bool bAutomaticPay; }; struct SCVIPAutomaticPay // SC_SYSTEM / SC_VIPAUTOMATICPAY, // VIP자동결제 { bool bAutomaticPay; }; #endif // #if defined(PRE_ADD_VIP) struct CSTCPPing { DWORD dwTick; }; typedef CSTCPPing SCTCPPing; struct SCFieldPing { DWORD dwTick; }; struct SCServiceClose //SC_SYSTEM / SC_SERVICECLOSE //서비스클로우즈 알리미~ { __time64_t _tNow; //서버센드된시각 __time64_t _tOderedTime; //서비스매니저에 명령되어진 시각(혹시나 필요할까 해서) __time64_t _tCloseTime; //서비스클로즈 예정시각 }; //------------------------------------------------- // CHAR (CS_CHAR, SC_CHAR) //------------------------------------------------- struct CSLoockUser // CS_CHAR / CS_LOOKUSER { WCHAR wszCharacterName[NAMELENMAX]; }; struct SCLoockUser // SC_CHAR / SC_LOOKUSER { }; struct SCMapInfo // SC_CHAR / SC_MAPINFO { int nMapIndex; BYTE cMapArrayIndex; BYTE cEnviIndex; BYTE cEnviArrayIndex; int nChannelID; short wChannelIdx; TMeritInfo MeritInfo; }; struct SCPvPInfo { TPvPGroup PvP; }; struct SCPvPMemberIndex //SC_PVP_MEMBERINDEX { USHORT nTeam; int nRetCode; BYTE cCount; TSwapMemberIndex Index[PARTYMAX]; }; struct SCPvPMemberGrade //SC_PVP_MEMBERGRADE { int nRetCode; UINT uiUserState; UINT nSessionID; }; struct SCPvPTryAcquirePoint //SC_PVP_TRYACQUIREPOINT { int nAreaID; int nRetCode; }; struct SCPvPTryAcquireSkill //SC_PVP_TRYACQUIRESKILL { int nSkillID; int nLevel; int nRetCode; }; struct SCPvPInitSkill //SC_PVP_INITSKILL { int nRetCode; }; struct SCPvPUseSkill //SC_PVP_USESKILL { UINT nSessionID; //사용한사람 왠지 필요할꺼 같아서 int nSkillID; int nRetCode; }; struct SCPvPSwapSkillIndex //SC_PVP_SWAPSKILLINDEX { char cFrom; char cTo; int nRetCode; }; //#if defined(_GAMESERVER) || defined(_VILLAGESERVER) || defined(_WINDOWS) #if defined(_GAMESERVER) || defined(_VILLAGESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct SCEnter // SC_CHAR / SC_ENTER { UINT nSessionID; UINT nVehicleObjectID; WCHAR wszCharacterName[NAMELENMAX]; char cAccountLevel; // 계정권한 (eAccountLevel) BYTE cPartyState; BYTE cClassID; BYTE cJobArray[JOBMAX]; BYTE cLevel; int nExp; INT64 nCoin; // 전체 가지고 있는 코인이기 때문에 int64로 BYTE cRebirthCoin; BYTE cPCBangRebirthCoin; USHORT wRebirthCashCoin; EtVector3 Position; float fRotate; USHORT wSkillPoint[DualSkill::Type::MAX]; int nDefaultBody; // 처음 생성시에 설정한 equip int nDefaultLeg; int nDefaultHand; int nDefaultFoot; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; short nAppellation; short nCoverAppellation; USHORT wFatigue; USHORT wWeekFatigue; USHORT wPCBangFatigue; USHORT wEventFatigue; USHORT wMaxEventFatigue; #if defined(PRE_ADD_VIP) bool bVIP; BYTE cVIPRebirthCoin; USHORT wVIPFatigue; // 남은 피로도 int nVIPPoint; // 포인트 __time64_t tVIPExpirationDate; // 만료일 bool bVIPAutomaticPay; // 자동결제 여부 #endif // #if defined(PRE_ADD_VIP) TPvPGroup sPvPInfo; char cViewCashEquipBitmap[VIEWCASHEQUIPMAX_BITSIZE]; TGuildSelfView GuildSelfView; // 길드 시각정보 (개인) char cCurrentGuildWarEventStep; // 현재 길드전 스텝 short wCurrentGuldWarScheduleID; // 현재 진행되는 길드전 차수 char cSkillPage; // 현재 활성화 되어있는 스킬페이지 char cAge; #if defined( PRE_ADD_NAMEDITEM_SYSTEM ) int nNamedItemID; #endif #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeed; #endif // PRE_ADD_NEW_MONEY_SEED }; struct SCEnterUser // SC_CHAR / SC_ENTERUSER { UINT nSessionID; UINT nVehicleObjectID; WCHAR wszCharacterName[NAMELENMAX]; char cAccountLevel; // 계정권한 bool bHide; BYTE cPartyState; BYTE cClassID; BYTE cLevel; BYTE cPvPLevel; BYTE cJob; EtVector3 Position; float fRotate; bool bBattleMode; int nDefaultBody; // 처음 생성시에 설정한 equip int nDefaultLeg; int nDefaultHand; int nDefaultFoot; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; short nAppellation; short nCoverAppellation; TGuildSelfView GuildSelfView; // 길드 시각정보 (개인) char cViewCashEquipBitmap[VIEWCASHEQUIPMAX_BITSIZE]; #if defined(PRE_ADD_VIP) bool bVIP; #endif // #if defined(PRE_ADD_VIP) bool bIsPartyLeader; TVehicle VehicleEquip; TVehicle PetEquip; char cCount; char cCashCount; char cGlyphCount; #if defined(PRE_ADD_TALISMAN_SYSTEM) char cTalismanCount; #endif int nSourceItemID; #if defined( PRE_ADD_NAMEDITEM_SYSTEM ) int nNamedItemID; #endif #if defined ( PRE_ADD_BESTFRIEND) INT64 biBestFriendItemSerial; WCHAR wszBestFriendName[NAMELENMAX]; #endif #if defined(PRE_ADD_TRANSFORM_POTION) int nTransformID; #endif //#if defined(PRE_ADD_TRANSFORM_POTION) #if defined(PRE_ADD_DWC) WCHAR wszDWCTeamName[GUILDNAME_MAX]; #endif #if defined(PRE_ADD_TALISMAN_SYSTEM) TItemInfo EquipArray[EQUIPMAX+CASHEQUIPMAX+GLYPHMAX+TALISMAN_MAX]; // 이게 항상 맨 끝이어야합니다. #else TItemInfo EquipArray[EQUIPMAX+CASHEQUIPMAX+GLYPHMAX]; // 이게 항상 맨 끝이어야합니다. #endif }; struct SCEnterNpc // SC_CHAR / SC_ENTERNPC { UINT nNpcObjectID; UINT nNpcID; EtVector3 Position; float fRotate; }; #endif struct SCLeaveUser // SC_CHAR / SC_LEAVEUSER { UINT nSessionID; char cLeaveType; // eLeaveType char cAccountLevel; // 계정권한 }; struct SCLeaveNpc // SC_CHAR / SC_LEAVENPC { UINT nObjectID; }; struct SCEnterPropNpc { UINT nNpcObjectID; int nPropUniqueID; }; struct SCLeavePropNpc { int nPropUniqueID; }; struct TQuickSlotEx: TQuickSlot { BYTE cIndex; }; struct SCQuickSlotList // SC_CHAR / SC_QUICKSLOTLIST { BYTE cSlotCount; TQuickSlotEx QuickSlot[QUICKSLOTMAX]; }; struct CSAddQuickSlot // SC_CHAR / SC_ADDQUICKSLOT { BYTE cSlotIndex; // 단축슬롯창 index BYTE cSlotType; // eQuickSlotType 참조 INT64 nID; // 해당 ID (아이템아이디 혹은 스킬아이디 혹은 탈것 아이템 시리얼) }; struct SCAddQuickSlot // SC_CHAR / SC_ADDQUICKSLOT { BYTE cSlotIndex; // 단축슬롯창 index BYTE cSlotType; // eQuickType 참조 int nID; // 해당 ID (아이템아이디 혹은 스킬아이디) int nRet; }; struct CSDelQuickSlot // SC_CHAR / CS_DELQUICKSLOT { BYTE cSlotIndex; }; struct SCDelQuickSlot // SC_CHAR / SC_DELQUICKSLOT { BYTE cSlotIndex; int nRet; }; struct CSCloseUIWindow { eWindowState WindowState; // eWindowState }; struct SCFatigue // SC_CHAR / SC_FATIGUE { UINT iResult; UINT nSessionID; short wFatigue; // 현재값 short wWeekFatigue; // 주간 현재값 short wPCBangFatigue; // 피씨방 현재값 short wEventFatigue; #if defined(PRE_ADD_VIP) short wVIPFatigue; // VIP 현재값 #endif // #if defined(PRE_ADD_VIP) }; struct SCHide // SC_CHAR / SC_HIDE { UINT nSessionID; bool bHide; }; struct TShutdownData { char cType; // eShutdownType short nYear; char nMonth; char nDay; char nHour; }; struct SCPCBang // SC_CHAR / SC_PCBANG { char cPCBangGrade; #if defined(_KR) char cAuthorizeType; int nArgument; int nShutdownTime; #endif // #if defined(_KR) #if defined(_KRAZ) TShutdownData Shutdown; #endif // #if defined(_KRAZ) }; struct SCNestClear // SC_CHAR / SC_NESTCLEAR { char cCount; TNestClearData NestClear[NESTCLEARMAX]; }; struct SCUpdateNestClear // SC_CHAR / SC_UPDATENESTCLEAR { TNestClearData Update; }; struct SCMaxLevelCharacterCount { int iCount; }; struct SCCommonVariableList { BYTE cCount; CommonVariable::Data List[CommonVariable::Type::Max]; }; struct SCModCommonVariable { CommonVariable::Data Data; }; #if defined( PRE_ADD_NOTIFY_ITEM_COMPOUND ) struct CSCompoundNotify { int nItemID; int nItemOption; }; #endif #if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD) struct CSStageClearBonusRewardSelect // CS_CHAR / CS_STAGECLEAR_BONUSREWARD_SELECT { UINT nPropID; int nItemID; }; struct SCStageClearBonusRewardSelect // SC_CHAR / SC_STAGECLEAR_BONUSREWARD_SELECT { int nResult; }; #endif // #if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD) //------------------------------------------------- // ACTOR (CS_ACTOR, SC_ACTOR) //------------------------------------------------- struct CSActorMessage // CS_ACTOR / CS_ACTOR_MSG { UINT nSessionID; char cBuf[128]; }; struct SCActorMessage // SC_ACTOR / SC_ACTOR_MSG { UINT nSessionID; char cBuf[128]; }; //------------------------------------------------- // ACTOR BUNDLE (CS_ACTORBUNDLE, SC_ACTORBUNDLE) //------------------------------------------------- struct SCActorBundleMessage { UINT nSessionID; char cBuf[256]; }; struct CSActorBundleMessage { UINT nSessionID; char cBuf[256]; }; struct SCActorShadowMessage { UINT nSessionID; char cBuf[256]; }; //------------------------------------------------- // PROP (CS_PROP, SC_PROP) //------------------------------------------------- struct CSPropMessage // CS_PROP / CS_PROP_MSG { UINT nUniqueID; char cBuf[128]; }; struct SCPropMessage // SC_PROP / SC_PROP_MSG { UINT nUniqueID; char cBuf[128]; }; //------------------------------------------------- // PARTY (CS_PARTY, SC_PARTY) //------------------------------------------------- #ifdef PRE_MOD_SYNCPACKET const int MAX_SEND_SYNCPLAYER = 4; #else //#ifdef PRE_MOD_SYNCPACKET const int MAX_SEND_SYNCPLAYER = 8; #endif //#ifdef PRE_MOD_SYNCPACKET struct CSCreateParty // CS_PARTY / CS_CREATEPARTY { #if defined( PRE_PARTY_DB ) ePartyType PartyType; int iBitFlag; int iPassword; #else BYTE cRaidParty; //일단은 5인이상 8인이하의 파티를 지칭함 1:true, otherwise:false BYTE cIsJobDice; BYTE cUserLvLimitMax; #endif // #if defined( PRE_PARTY_DB ) BYTE cPartyMemberMax; TPARTYITEMLOOTRULE ItemLootRule; //ePartyItemLootRule 참조 TITEMRANK ItemRank; //아이템랭크(루트룰기획참조) BYTE cUserLvLimitMin; //민맥스값이 있단다. int nTargetMapIdx; TDUNGEONDIFFICULTY Difficulty; #if defined( PRE_PARTY_DB ) WCHAR wszPartyName[PARTYNAMELENMAX]; #else BYTE cUseVoice; //zero is nouse otherwise use BYTE cNameLen; BYTE cPassWordLen; WCHAR wszBuf[PARTYNAMELENMAX + PARTYPASSWORDMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct SCCreateParty // SC_PARTY / SC_CREATEPARTY { int nRetCode; TPARTYID PartyID; ePartyType PartyType; BYTE cIsAutoCreate; //자동생성 여부 0: 일반생성 1자동생성 }; struct CSDestroyParty // CS_PARTY / CS_DESTROYPARTY { TPARTYID PartyIndex; }; struct CSInvitePartyMember //CS_PARTY / CS_PARTYINVITE { BYTE cInviteMemberSize; WCHAR wszBuf[NAMELENMAX]; }; struct CSInviteDenied { TPARTYID PartyIdx; BYTE cIsOpenBlind; //대화중이거나 창이 열려있는 경우 BYTE cInviterNameLen; WCHAR wszBuf[NAMELENMAX]; }; struct CSPartyMemberInfo //CS_PARTY / CS_PARTYMEMBER_INFO { TPARTYID PartyID; }; struct CSPartyInviteOverServerResult //CS_PARTY / CS_PARTYINVITE_OVERSERVER_RESULT { int nGameServerID; //from WCHAR wszInviterName[NAMELENMAX]; int nRetCode; //0 invite agreed otherwise denied }; struct CSPartyMemberKick //CS_PARTY / CS_PARTYMEMBER_KICK { UINT nSessionID; char cKickKind; //0일반 1영구 }; struct CSPartyLeaderSwap //CS_PARTY / CS_PARTYLEADER_SWAP { UINT nSessionID; }; struct CSJoinGetReversionItem //CS_PARTY / CS_JOINGETREVERSEITEM { bool bJoin; }; struct CSMemberAbsent //CS_PARTY / CS_ABSENT { BYTE cAbsentFlag; // 0 absent, 1 present }; struct CSVerifyDungeon //CS_PARTY / CS_VERIFYTARGETDUNGEON { int nMapIdx; BYTE cDifficulty; }; struct CSPartyAskJoin //CS_PARTY / CS_PARTYASKJOIN { WCHAR wszPartyLeaderName[NAMELENMAX]; }; struct CSPartyAskJoinDecision //CS_PARTY / CS_PARTYASKJOINDECISION { BYTE cRet; //0 denied, 1 agree WCHAR wszPartyAsker[NAMELENMAX]; //대상자 }; struct CSPartySwapMemberIndex //CS_PARTY / CS_SWAPMEMBERINDEX { BYTE cCount; TSwapMemberIndex Index[PARTYMAX]; }; struct SCPartySwapMemberIndex //SC_SWAPMEMBERINDEX { int nRetCode; BYTE cCount; TSwapMemberIndex Index[PARTYMAX]; }; struct CSPartyWorldZoneList { bool bFlag; }; struct SCPartyWorldZoneList { int iRet; }; struct CSVillageSelectChannel //CS_PARTY / CS_SELECTCHANNEL { int nChannelID; }; struct CSPartyInfoModify //CS_PARTY / CS_PARTYMODIFY { BYTE cPartyMemberMax; TPARTYITEMLOOTRULE LootRule; TITEMRANK LootRank; BYTE cUserLvLimitMin; int nTargetMapIdx; TDUNGEONDIFFICULTY Difficulty; WCHAR wszName[PARTYNAMELENMAX]; #if defined( PRE_PARTY_DB ) int iBitFlag; int iPassword; #else BYTE cUserLvLimitMax; BYTE cIsJobDice; WCHAR wszPass[PARTYPASSWORDMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct CSSelectDunGeon //CS_PARTY / CS_SELECTDUNGEON { BYTE cDiffyculty; UINT nMapIndex; //short nCanEnterCode; //ERROR_NONE이면 들어갈 수 있음 아닌 값이면 상황에 따른값 eError 값참조 }; struct CSJoinParty // CS_PARTY / CS_JOINPARTY { TPARTYID PartyID; #if defined( PRE_PARTY_DB ) int iPassword; #else BYTE cPartyPasswordSize; WCHAR wszBuf[PARTYPASSWORDMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct CSPartyListInfo // CS_PARTY / CS_PARTYLISTINFO { #if defined( PRE_PARTY_DB ) USHORT unReqPage; WCHAR wszSearchWord[Party::Max::SearchWordLen]; Party::OrderType::eCode OrderType; Party::StageOrderType::eCode StageOrderType; bool bOnlySameVillage; #if defined( PRE_FIX_61545 ) WCHAR cSeperator; #endif // #if defined( PRE_FIX_61545 ) bool operator==(const CSPartyListInfo& rhs) const { if( this->unReqPage == rhs.unReqPage && this->OrderType == rhs.OrderType && this->StageOrderType == rhs.StageOrderType && this->bOnlySameVillage == rhs.bOnlySameVillage && wcscmp(this->wszSearchWord,rhs.wszSearchWord) == 0 ) return true; return false; } void Clear() { this->OrderType = Party::OrderType::Max; } #else BYTE cOffSetCnt; //한번에 받고 싶은 카운트 BYTE cGetPage; //위에 있는 카운트를 오프셋으로 몇번째 페이지를 받고 싶은지 TDUNGEONDIFFICULTY Difficulty; BYTE cIsRefresh; int nSortMapIdx[PARTYSORTCONDITIONMAX]; #endif // #if defined( PRE_PARTY_DB ) }; #if defined(PRE_MOD_REQ_JOIN_PARTY_ANSWER_MSG_APP) struct CSPartyInfo // CS_PARTY / CS_PARTYINFO { TPARTYID PartyID; WCHAR wszCharName[NAMELENMAX]; }; #endif struct SCJoinParty // SC_PARTY / SC_JOINPARTY { int nRetCode; TPARTYID PartyID; WCHAR wszPartyName[PARTYNAMELENMAX]; }; struct SCRefreshParty // SC_PARTY / SC_REFRESHPARTY { UINT nLeaderSessionID; BYTE cCurrentUserCount; BYTE cPartyMemberMax; BYTE cUserLvLimitMin; TPARTYITEMLOOTRULE ItemLootRule; TITEMRANK ItemLootRank; BYTE cVoiceChatAvailable; int nTargetMapIdx; TDUNGEONDIFFICULTY Difficulty; #if defined( PRE_PARTY_DB ) int iBitFlag; ePartyType PartyType; int iPassword; #else BYTE cUserLvLimitMax; BYTE cIsJobDice; BYTE cPartyType; //ePartyType WCHAR wszPass[PARTYPASSWORDMAX]; #endif // #if defined( PRE_PARTY_DB ) BYTE cPartyRefreshSubJect; //ePartyRefreshSubject 참조 #if defined( PRE_WORLDCOMBINE_PARTY ) int nWorldCombinePartyTableIndex; #endif WCHAR wszName[PARTYNAMELENMAX]; SPartyMemberInfo Member[PARTYMAX]; }; struct SCPartyOut // SC_PARTY / SC_PARTYOUT { UINT nSessionID; //누가 나간건지 int nRetCode; // success, fail 구별 char cKickKind; //-1킥아니고 나간거 0일반킥 1영구킥 }; //struct SCDelPartyMember // SC_PARTY / SC_DELPARTYMEMBER //{ // UINT nMemberUID; // BYTE cIsUnintenedDelMember; //}; struct SPartyListInfo { TPARTYID PartyID; BYTE cUserLvLimitMin; #if defined( PRE_PARTY_DB ) int iCurMapIndex; bool bIsBonus; #if defined( _FINAL_BUILD ) #else INT64 biSortPoint; #endif // #if defined( _FINAL_BUILD ) #else BYTE cUserLvLimitMax; USHORT nChannelMaxUser; USHORT nChannelCurUser; #endif // #if defined( PRE_PARTY_DB ) BYTE cCurrentCount; BYTE cMaxCount; BYTE cIsPrivateRoom; int nTargetMapIdx; TDUNGEONDIFFICULTY TargetDifficulty; #if defined( PRE_PARTY_DB ) #else USHORT wMasterFatigue; #endif // #if defined( PRE_PARTY_DB ) BYTE cUseVoice; ePartyType PartyType; //ePartyType BYTE cPartyNameLen; WCHAR wszBuf[PARTYNAMELENMAX]; #if defined( PRE_WORLDCOMBINE_PARTY ) int nWorldCombinePartyTableIndex; // 월드파티 인덱스 #endif #if defined( PRE_ADD_NEWCOMEBACK ) bool bCheckComeBackParty; #endif }; struct SCPartyListInfo // SC_PARTY / SC_PARTYLISTINFO { int nRetCode; #if defined( PRE_PARTY_DB ) USHORT unReqPage; int iTotalCount; int iListCount; SPartyListInfo PartyListInfo[PARTYLISTOFFSET*2]; // 페이징 비용을 줄이기 위해 한번에 2페이지씩 보낸다. #else USHORT nWholeCount; BYTE cCount; SPartyListInfo PartyListInfo[PARTYLISTOFFSET*2]; #endif // #if defined( PRE_PARTY_DB ) }; #if defined(PRE_MOD_REQ_JOIN_PARTY_ANSWER_MSG_APP) struct SCPartyInfo // SC_PARTY / SC_PARTYINFO { int nRetCode; SPartyListInfo PartyInfo; }; #endif //#if defined(_GAMESERVER) || defined(_VILLAGESERVER) || defined(_WINDOWS) #if defined(_GAMESERVER) || defined(_VILLAGESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct CSRefreshGateInfo // CS_PARTY / CS_REFRESHGATEINFO { EtVector3 Position; bool boEnter; }; #endif struct SCRefreshGateInfo // SC_PARTY / SC_REFRESHGATEINFO { int nRet; BYTE cCount; char GateNo[PARTYMAX]; }; struct SCGateInfo // SC_PARTY / SC_GATEINFO { UINT nLeaderUID; char cGateNo; char cMapCount; char cPermitFlag[5]; char cCanEnter[5][5]; }; struct TPartyMemberDefaultParts { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET int iDefaultPartsIndex[4]; }; struct TPartyMemberWeaponOrder { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET char cViewCashEquipBitmap[VIEWCASHEQUIPMAX_BITSIZE]; }; struct TPartyMemberEquip { char cCount; #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET TItemInfo EquipArray[EQUIPMAX]; }; struct TPartyMemberCashEquip { char cCount; #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET TItemInfo EquipArray[CASHEQUIPMAX]; }; struct TPartyMemberSkill { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET char cCount; TSkill SkillArray[SKILLMAX]; }; struct TPartyMemberGlyphEquip { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET char cCount; TItemInfo EquipArray[GLYPHMAX]; }; #if defined(PRE_ADD_TALISMAN_SYSTEM) struct TPartyMemberTalismanEquip { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET char cCount; TItemInfo TalismanArray[TALISMAN_MAX]; }; #endif struct CSStartStage { bool bReturnVillage; TDUNGEONDIFFICULTY Difficulty; char cSelectDungeonIndex; UINT nFarmDBID; char cSelectMapIndex; }; struct CSGameToGameStageEnter { bool bReturnVillage; TDUNGEONDIFFICULTY Difficulty; char cSelectDungeonIndex; UINT nFarmDBID; char cSelectMapIndex; }; #define SCSelectDunGeon CSSelectDunGeon // SC_PARTY //SC_SELECTDUNGEON struct SCPartyInfoModify // SC_PARTY / SC_PARTYMODIFY { int nRet; }; struct SCPartyQuickJoinFail // SC_PARTY / SC_PARTYQUICKJOINFAIL { int nRet; }; struct SCVerifyJoinParty // SC_PARTY / SC_VERIFYJOINPARTY { int nPartyIdx; int nChannelID; int nRet; }; struct SCDefaultPartsData // SC_PARTY //SC_DEFAULTPARTSDATA { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberDefaultParts DefaultParts[MAX_SEND_SYNCPLAYER]; }; struct SCWeaponOrderData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberWeaponOrder WeaponOrder[MAX_SEND_SYNCPLAYER]; }; struct SCEquipData // SC_PARTY //SC_EQUIPDATA { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberEquip MemberEquip[MAX_SEND_SYNCPLAYER]; }; struct SCCashEquipData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberCashEquip MemberEquip[MAX_SEND_SYNCPLAYER]; }; struct SCGlyphEquipData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberGlyphEquip MemberEquip[MAX_SEND_SYNCPLAYER]; }; #if defined(PRE_ADD_TALISMAN_SYSTEM) struct SCTalismanEquipData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberTalismanEquip MemberEquip[MAX_SEND_SYNCPLAYER]; }; #endif struct SCVehicleEquipData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TVehicleCompact MemberVehicle[MAX_SEND_SYNCPLAYER]; }; struct SCSkillData // SC_PARTY //SC_SKILLDATA { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyMemberSkill MemberSkill[MAX_SEND_SYNCPLAYER]; }; struct SCMoveChannelFail // SC_PARTY / SC_MOVECHANNELFAIL { int nRetCode; }; struct SCPartyInfoErr // SC_PARTY / SC_PARTYINFO_ERROR { int nRetCode; }; struct SCStartStage // SC_PARTY / SC_STARTSTAGE { #if defined(PRE_FIX_RANDOM_MAPINDEX) int nMapIndex; #endif // #if defined(PRE_FIX_RANDOM_MAPINDEX) int nRandomSeed; TDUNGEONDIFFICULTY Difficulty; short nExtendDropRate; //이벤트용 추가 드랍확율 }; struct SCStartStageDirect { int nMapIndex; char cGateNo; int nRandomSeed; TDUNGEONDIFFICULTY Difficulty; short nExtendDropRate; //이벤트용 추가 드랍확율 }; struct SCCancelStage { int nRetCode; }; struct CSSelectStage { char cSelectMapIndex; }; struct SCSelectStage { char cSelectMapIndex; }; struct SCPartyChangeLeader // SC_PARTY / SC_CHANGEPARTYLEADER { UINT nNewLeaderSessionID; }; struct SCPartyInvite // SC_PARTY / SC_PARTYINVITE { TPARTYID PartyID; USHORT nPartyNameLen; BYTE cPartyInviterNameLen; BYTE cMaxUserCount; BYTE cCurUserCount; USHORT nAvrLevel; int nGameServerID; // int nGameMapIdx; //이게 0 보다 크다면 게임서버에서 초대받는거다 #if defined( PRE_PARTY_DB ) int iPassword; WCHAR wszBuf[PARTYNAMELENMAX+NAMELENMAX]; #else BYTE cPartyPassLen; WCHAR wszBuf[PARTYNAMELENMAX + PARTYPASSWORDMAX + NAMELENMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct SCPartyInviteNotice //SC_PARTY / SC_PARTYINVITENOTICE { int nRetCode; WCHAR wszInvitedCharacterName[NAMELENMAX]; //초대하는 사람의 캐릭터이름 }; struct SCPartyInviteFail //SC_PARTY / SC_PARTYINVITEFAIL { int nRetCode; }; struct SCPartyAskJoinToLeader //SC_PARTY / SC_ASKJOINPARTYTOLEADER { char cJob; BYTE cLevel; WCHAR wszAskChracterName[NAMELENMAX]; }; struct SCPartyAskJoinResult //SC_PARTY / SC_ASKJOINPARTYRESULT { int nRet; }; struct SCPartyAskJoinDecisionInfo //SC_PARTY / SC_ASKJOINPARTYDECISIONINFO { TPARTYID PartyID; #if defined( PRE_PARTY_DB ) int iPassword; #else WCHAR wszPartyPassword[PARTYPASSWORDMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct SCPartyUpdateFieldUI //SC_PARTY / SC_PARTYUPDATEFIELDUI { UINT nSessionID; BYTE cLeader; //0 none, 1 leader }; //struct SCPartySwapMemberIndex //SC_PARTY / SC_SWAPMEMBERINDEX //{ // BYTE cOriginIndex; // BYTE cSwapIndex; // int nRetCode; //}; struct TPartyMemberInfo { BYTE cUserLevel; USHORT wJob; BYTE cClassID; WCHAR wszName[NAMELENMAX]; }; struct SCPartyMemberInfo //SC_PARTY / SC_PARTYMEMBER_INFO { #if defined( PRE_PARTY_DB ) TPARTYID PartyID; ePartyType PartyType; short nCount; Party::MemberData MemberData[PARTYCOUNTMAX]; #else TPARTYID PartyID; BYTE cLeaderIdx; BYTE cIsRaidParty; BYTE cCount; TPartyMemberInfo Info[PARTYMAX]; #endif // #if defined( PRE_PARTY_DB ) }; struct SCPartyInviteDenied //SC_PARTY / SC_PARTYINVITEDENIED { int nRetCode; WCHAR wszCharName[NAMELENMAX]; }; struct SCPartyKickedMember //SC_PARTY / SC_PARTYMEMBERKICKED { UINT nSessionID; int nRetCode; }; struct SCSwapPartyLeader //SC_PARTY / SC_PARTYLEADERSWAP { UINT nSessionID; int nRetCode; }; #if defined(_GAMESERVER) || defined(_VILLAGESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct SCPartyMemberMove // SC_PARTY / SC_PARTYMEMBER_MOVE { UINT nSessionID; EtVector3 Position; }; #endif struct SCPartyMemberPart // SC_PARTY / SC_PARTYMEMBER_PART { UINT nSessionID; int nExp; BYTE cLevel; BYTE cJobArray[JOBMAX]; int nHairID; int nFaceID; DWORD dwHairColor; DWORD dwEyeColor; DWORD dwSkinColor; USHORT wFatigue; int nHelmetID; int nEarringID; }; struct TPartyEtcData { #ifdef PRE_MOD_SYNCPACKET UINT nSessionID; #endif //#ifdef PRE_MOD_SYNCPACKET int nSelectAppellation; short nCoverAppellation; BYTE cGMTrace; #if defined(PRE_ADD_VIP) bool bVIP; #endif // #if defined(PRE_ADD_VIP) char cAccountLevel; // 계정권한(eAccountLevel) }; struct SCEtcData { BYTE cCount; #ifdef PRE_MOD_SYNCPACKET #else //#ifdef PRE_MOD_SYNCPACKET USHORT unStartIndex; #endif //#ifdef PRE_MOD_SYNCPACKET TPartyEtcData EtcData[MAX_SEND_SYNCPLAYER]; }; // SC_PARTY / SC_GUILDDATA struct TPartyMemberGuild { public: struct TPartyMemberGuildView : public TGuildSelfView { public: TPartyMemberGuildView() { Reset(); } void Set(UINT nMemberSessionID, const TGuildSelfView& pGuildSelfView) { nSessionID = nMemberSessionID; TGuildSelfView::Set(pGuildSelfView); } void Reset() { nSessionID = 0; TGuildSelfView::Reset(); } bool IsSet() { return((0 != nSessionID) && TGuildSelfView::IsSet()); } public: UINT nSessionID; }; public: TPartyMemberGuild() { Reset(); } void Set() { nCount = 0; } void Reset() { nCount = 0; unStartIndex = 0; } bool Add(UINT nSessionID, const TGuildSelfView& pGuildSelfView) { if (PARTYMAX <= nCount) { return false; } List[nCount].Set(nSessionID, pGuildSelfView); ++nCount; return true; } const TPartyMemberGuildView* At(int iIndex) const { if (0 > iIndex || _countof(List) <= iIndex) return NULL; return(&List[iIndex]); } public: int nCount; // 파티원 길드 시각화 정보 목록 개수 USHORT unStartIndex; TPartyMemberGuildView List[MAX_SEND_SYNCPLAYER]; // 파티원 길드 시각화 정보 목록 }; struct SCRollDiceForGetReverseItem { UINT nSessionID; bool bRoll; int nDiceValue; }; struct SCResultGetReverseItem { UINT nSessionID; TItem itemInfo; DWORD dropItemUniqueId; }; struct SCPartyJoinGetReversionItemInfo { TItem itemInfo; DWORD dropItemUniqueId; }; struct SCMemberAbsent //SC_PARTY / SC_ABSENT { UINT nSessionID; BYTE cAbsentFlag; //0 absent, 1 present }; struct SCVerifyDungeon //SC_PARTY / SC_VERIFYTARGETDUNGEON { BYTE cVerifyFlag[5]; //0부터 순차적으로 어려워짐//0 not allowed, 1 allowed }; struct SCPartyBonusValue //SC_PARTY / SC_PARTYBONUSVALUE { BYTE cUpkeepBonus; //%단위 BYTE cFriendBonus; //%단위 BYTE cUpKeepBonusLimit; //유지보너스 맥스 지호씨 이게 0이상이면 가득찼다고 띄워주시면 데용~ //일단은 가득차있어도 평상시에는 0이 가고 클리어시점에만 판단되어서 0이상이 나갑니다. 이거 받았을때 0이 아니면 파팡 찍어주시면뎀 #ifdef PRE_ADD_BEGINNERGUILD BYTE cBeginnerGuildBonus; //초보길드원끼리 파티일경우 #endif //#ifdef PRE_ADD_BEGINNERGUILD }; struct SCPartyCheckLastDungeonInfo { WCHAR wszPartyName[PARTYNAMELENMAX]; }; struct CSPartyConfirmLastDungeonInfo { bool bIsOK; }; struct SCPartyConfirmLastDungeonInfo { int iRet; }; #if defined (PRE_ADD_BESTFRIEND) struct TPartyBestFriend { int nSessionID; INT64 biBFItemSerial; WCHAR wszBFName[NAMELENMAX]; }; struct SCPartyBestFriend { int nCount; TPartyBestFriend List[PARTYMAX]; }; #endif //------------------------------------------------- // ITEM (CS_ITEM, SC_ITEM) //------------------------------------------------- struct SCEquipList { char cCount; char cCashCount; char cGlyphCount; #if defined(PRE_ADD_TALISMAN_SYSTEM) char cTalismanCount; int nTalismanSlotOpenFlag; #endif #if defined(PRE_ADD_TALISMAN_SYSTEM) TItemInfo EquipArray[EQUIPMAX+CASHEQUIPMAX+GLYPHMAX+TALISMAN_MAX]; #else TItemInfo EquipArray[EQUIPMAX+CASHEQUIPMAX+GLYPHMAX]; #endif }; struct SCInvenList // SC_ITEM / SC_INVENLIST { BYTE cInvenMaxCount; // 몇개까지 열려있느냐 (일반인벤만. 기간제 포함 안되어있음) BYTE cInvenCount; #if defined(PRE_PERIOD_INVENTORY) TItemInfo Inven[INVENTORYTOTALMAX]; #else // #if defined(PRE_PERIOD_INVENTORY) TItemInfo Inven[INVENTORYMAX]; #endif // #if defined(PRE_PERIOD_INVENTORY) }; struct SCCashInvenList { int nTotalCashInventoryCount; BYTE cInvenCount; TItem Inven[CASHINVENTORYMAX]; }; struct SCBuyedItemCount { short count; ItemCount items[INVENTORYMAX + WAREHOUSEMAX]; }; // api_trigger_InvenToEquip 트리거에서 사용하므로 해당구조체 변경시 같이 변경되어야 합니다!!! struct CSMoveItem // CS_ITEM / CS_MOVEITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_EquipToInven, MoveType_InvenToEquip) BYTE cSrcIndex; INT64 biSrcItemSerial; BYTE cDestIndex; short wCount; }; struct SCMoveItem // SC_ITEM / SC_MOVEITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_EquipToInven, MoveType_InvenToEquip...) int nRetCode; TItemInfo SrcItem; TItemInfo DestItem; }; // api_trigger_UnRideVehicle 트리거에서 사용하므로 해당구조체 변경시 같이 변경되어야 합니다!!! struct CSMoveCashItem // CS_ITEM / CS_MOVECASHITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_CashEquipToCashInven, MoveType_CashInvenToCashEquip) BYTE cCashEquipIndex; INT64 biEquipItemSerial; INT64 biCashInvenSerial; short wCount; }; struct SCMoveCashItem // SC_ITEM / SC_MOVECASHITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_CashEquipToCashInven, MoveType_CashInvenToCashEquip) int nRetCode; TItemInfo CashEquipItem; TItem CashInvenItem; }; #if defined(PRE_ADD_SERVER_WAREHOUSE) struct SCServerWareList // SC_ITEM / SC_SERVERWARE_LIST { BYTE cWareCount; TItem WareItems[WAREHOUSEMAX]; }; struct SCCashServerWareList // SC_ITEM / SC_CASHSERVERWARE_LIST { BYTE cWareCount; TItem WareCashItems[WAREHOUSEMAX]; }; struct CSMoveServerWare // CS_ITEM / CS_MOVE_SERVERWARE { char cMoveType; // eItemMoveType 참조 (MoveType_InvenToServerWare, MoveType_ServerWareToInven) BYTE cInvenIndex; INT64 biInvenItemSerial; INT64 biWareItemSerial; short wCount; }; struct SCMoveServerWare // SC_ITEM / SC_MOVE_SERVERWARE { char cMoveType; // eItemMoveType 참조 (MoveType_CashEquipToCashInven, MoveType_CashInvenToCashEquip) int nRetCode; TItemInfo InvenItem; TItem ServerWareItem; }; struct CSMoveCashServerWare // CS_ITEM / CS_MOVE_CASHSERVERWARE { char cMoveType; // eItemMoveType 참조 (MoveType_CashToServerWare, MoveType_ServerWareToCash) INT64 biItemSerial; }; struct SCMoveCashServerWare // SC_ITEM / SC_MOVE_CASHSERVERWARE { char cMoveType; // eItemMoveType 참조 (MoveType_CashToServerWare, MoveType_ServerWareToCash) int nRetCode; INT64 biSrcItemSerial; TItem SrcItem; TItem DestItem; }; #endif //#if defined(PRE_ADD_SERVER_WAREHOUSE) struct CSMoveGuildItem // CS_ITEM / CS_MOVEGUILDITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_InvenToGuildWare, MoveType_GuildWareToInven) BYTE cDestIndex; // 도착 인덱스 (길드창고 <--> 인벤) INT64 biDestItemSerial; // 이벤트를 받을 아이템 시리얼 BYTE cSrcIndex; // 출발 인덱스 (길드창고 <--> 인벤) INT64 biSrcItemSerial; // 이벤트 발생한 아이템 short wCount; // 해당 갯수 }; struct SCMoveGuildItem // SC_ITEM / SC_MOVEGUILDITEM, { char cMoveType; // eItemMoveType 참조 (MoveType_InvenToGuildWare, MoveType_GuildWareToInven) int nRetCode; int nTakeItemCount; INT64 biSrcSerial; INT64 biDestSerial; TItemInfo DestItem; TItemInfo SrcItem; }; struct SCRefreshGuildItem // SC_ITEM / SC_REFRESH_GUILDITEM { char cMoveType; // eItemMoveType 참조 (MoveType_InvenToGuildWare, MoveType_GuildWareToInven) INT64 biSrcSerial; INT64 biDestSerial; TItemInfo SrcItem; TItemInfo DestItem; }; struct SCRefreshGuildCoin // SC_ITEM / SC_REFRESH_GUILDCOIN { INT64 biTotalCoin; // 전체금액 }; struct CSMoveGuildCoin // CS_ITEM / CS_MOVEGUILDCOIN { char cMoveType; // eItemMoveType 참조 (MoveType_InvenToGuildWare, MoveType_GuildWareToInven) INT64 nMoveCoin; }; struct SCMoveGuildCoin // SC_ITEM / SC_MOVEGUILDCOIN { int nRet; char cMoveType; // eItemMoveType 참조 (MoveType_InvenToGuildWare, MoveType_GuildWareToInven) INT64 nMoveCoin; INT64 nInventoryCoin; INT64 nWarehouseCoin; INT64 nWithdrawCoin; }; struct CSPickUp // CS_ITEM / CS_PICKUP, { int nItemID; short wCount; }; struct SCPickUp // SC_ITEM / SC_PICKUP, { int nRetCode; short wCount; TItemInfo PickUpItem; }; struct CSRemoveItem // CS_ITEM / CS_REMOVEITEM, { char cType; // eItemPositionType 1: Equip 2: Inven 3: Ware BYTE cSlotIndex; short wCount; INT64 biItemSerial; }; struct SCRemoveItem // SC_ITEM / SC_REMOVEITEM, { int nRetCode; char cType; // eItemPositionType 1: Equip 2: Inven 3: Ware TItemInfo ItemInfo; }; struct SCChangeEquip // SC_ITEM / SC_CHANGEEQUIP { UINT nSessionID; TItemInfo ItemInfo; }; struct SCChangeCashEquip // SC_ITEM / SC_CHANGECASHEQUIP { UINT nSessionID; TItemInfo ItemInfo; }; struct SCRefreshInven // SC_ITEM / SC_REFRESHINVEN { bool bNewSign; // new표시 할껀가 안할껀가 TItemInfo ItemInfo; }; struct SCRefreshCashInven // SC_ITEM / SC_REFRESHINVEN { bool bNewSign; // new표시 할껀가 안할껀가 int nCount; TItem ItemList[CASHINVENTORYMAX]; }; struct SCRefreshEquip // SC_ITEM / SC_REFRESHEQUIP { TItemInfo ItemInfo; #if defined(PRE_ADD_EQUIPED_ITEM_ENCHANT) bool bRefreshState; #endif }; struct SCRefreshWarehouse // SC_ITEM / SC_REFRESHWAREHOUSE { TItemInfo ItemInfo; }; struct SCCreateDropItem // SC_ITEM / SC_CREATE_DROPITEM { UINT nSessionID; float fpos[3]; UINT nItemID; UINT nRandomSeed; char cOption; USHORT nCount; USHORT nRotate; UINT nOwnerSessionID; }; struct SCCreateDropItemList { int nCount; SCCreateDropItem sDropItem[20]; // 한번에 최대 보낼 수 있는 DropItem 최대 개수 }; struct SCDropItem // SC_ITEM / SC_DROPITEM_MSG { UINT nSessionID; USHORT nItemProtocol; char cBuf[16]; }; struct SCWarehouseList // SC_ITEM / SC_WAREHOUSELIST { INT64 nWarehouseCoin; BYTE cWareMaxCount; // 창고 max값이 몇까지 열수 있는지 (일반창고만. 기간제 포함 안되어있음) BYTE cWareCount; #if defined(PRE_PERIOD_INVENTORY) TItemInfo Warehouse[WAREHOUSETOTALMAX]; #else // #if defined(PRE_PERIOD_INVENTORY) TItemInfo Warehouse[WAREHOUSEMAX]; #endif // #if defined(PRE_PERIOD_INVENTORY) }; struct CSUseItem // CS_ITEM / CS_USEITEM { char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; }; struct SCUseItem // SC_ITEM / SC_USEITEM { char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; }; struct CSCompleteRandomItem { char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; }; // 추후에 NPC 별로 리스트 보여달라고 넣어야 할 듯.. // 지금은 임시로 CompoundTableID 넣음 struct CSEmblemCompoundOpenReq // CS_ITEM / CS_EMBLEM_COMPOUND_OPEN_REQ { BYTE cPlateItemSlotIndex; INT64 biPlateItemSerialID; int nCompoundTableID; }; struct SCEmblemCompundOpenRes // CS_ITEM / SC_EMBLEM_COMPOUND_OPEN_RES { int nResult; }; struct CSItemCompoundOpenReq // CS_ITEM / CS_ITEM_COMPOUND_OPEN_REQ { int nCompoundTableID; INT64 biNeedItemSerialID; }; struct SCItemCompoundOpenRes // CS_ITEM / CS_ITEM_COMPOUND_OPEN_RES { int nResult; }; struct CSCompoundEmblemReq { BYTE cPlateItemSlotIndex; INT64 biPlateItemSerialID; int nCompoundTableID; }; struct CSCompoundItemReq // CS_ITEM / CS_COMPOUND_EMBLEM_REQ { int nCompoundTableID; INT64 biNeedItemSerialID; }; struct SCCompoundEmblemRes // CS_ITEM / CS_COMPOUND_EMBLEM_RES { short sResult; int nResultItemID; }; struct SCCompoundItemRes // SC_ITEM / SC_ITEM_COMPOUND_RES { short sResult; int nResultItemID; char cLevel; char cOption; }; struct CSEmblemCompoundCancelReq // CS_ITEM / CS_EMBLEM_COMPOUND_CANCEL_REQ { int nCompoundTableID; }; struct SCEmblemCompoundCancelRes // CS_ITEM / CS_EMBLEM_COMPOUND_CANCEL_RES { int nResult; }; struct CSItemCompoundCancelReq // CS_ITEM / CS_ITEM_COMPOUND_CANCEL_REQ { int nCompoundTableID; }; struct SCItemCompoundCancelRes // CS_ITEM / CS_ITEM_COMPOUND_CANCEL_RES { int nResult; }; struct CSItemDisjointReq // CS_ITEM / CS_DISJOINT_REQ { UINT nNpcUniqueID; // 게임서버에서 처리해야하고, Npc위치까지 알아야해서 UniqueID 추가로 보낸다. BYTE cSlotIndex; INT64 biItemSerial; short nCount; }; struct CSItemDisjointReqNew // CS_ITEM / CS_DISJOINT_REQ { UINT nNpcUniqueID; // 게임서버에서 처리해야하고, Npc위치까지 알아야해서 UniqueID 추가로 보낸다. BYTE cSlotIndex[4]; INT64 biItemSerial[4]; short nCount[4]; }; struct SCItemDisjointRes // SC_ITEM / SC_DISJOINT_RES { int nItemID; bool bSuccess; }; struct SCItemDisjointResNew // SC_ITEM / SC_DISJOINT_RES //rlkt_disjoint { int nItemID[20]; int nCount[20]; bool bSuccess; }; struct SCInventoryMaxCount // SC_ITEM / SC_INVENTORYMAXCOUNT { BYTE cInvenMaxCount; // 몇개까지 열려있느냐 }; struct SCGlyphExtendCount { BYTE cCount; }; struct SCGlyphExpireData { BYTE cCount; TCashGlyphData TGlyphData[CASHGLYPHSLOTMAX]; }; struct SCWarehouseMaxCount // SC_ITEM / SC_WAREHOUSEMAXCOUNT { BYTE cWareMaxCount; // 창고 max값이 몇까지 열수 있는지 }; struct SCQuestInvenList // SC_ITEM / SC_QUESTINVENLIST { char cQuestInvenCount; TItemInfo QuestInventory[QUESTINVENTORYMAX]; }; struct SCRefreshQuestInven // SC_ITEM / SC_REFRESHQUESTINVEN { TItemInfo ItemInfo; }; struct SCRebirthCoin // SC_ITEM / SC_REBIRTH_COIN { int nUsableRebirthCoin; // 던젼 가능 남은 코인개수 BYTE cRebirthCoin; // 부활코인 남은개수 USHORT wRebirthCashCoin; // 캐쉬템 부활코인 남은개수 int nRet; // 코인 사용 성공 여부 int nRebirthType; UINT nSessionID; BYTE cPCBangRebirthCoin; // 부활코인 남은개수 #if defined(PRE_ADD_VIP) BYTE cVIPRebirthCoin; #endif // #if defined(PRE_ADD_VIP) }; struct SCRefreshRebirthCoin // SC_PARTY / SC_REFRESHREBIRTHCOIN { UINT nSessionID; BYTE cRebirthCoin; BYTE cPCBangRebirthCoin; short nCashRebirthCoin; #if defined(PRE_ADD_VIP) BYTE cVIPRebirthCoin; #endif // #if defined(PRE_ADD_VIP) }; #if defined(PRE_ADD_REBIRTH_EVENT) struct SCRebirthMaxCoin // SC_CHAR / SC_REBIRTH_MAXCOIN { int nRebirthMaxCoin; }; #endif struct SCRepairResult // SC_ITEM / SC_REPAIR_EQUIP, SC_REPAIR_ALL { int nRet; }; struct CSMoveCoin // CS_ITEM / CS_MOVEITEM { char cMoveType; // eItemMoveType 참조 (MoveType_EquipToInven, MoveType_InvenToEquip) INT64 nMoveCoin; }; struct SCMoveCoin // SC_ITEM / SC_MOVECOIN { char cMoveType; // eItemMoveType 참조 (MoveType_EquipToInven, MoveType_InvenToEquip) INT64 nMoveCoin; INT64 nInventoryCoin; INT64 nWarehouseCoin; int nRet; }; struct SCRequestRandomItem { char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; int nRet; }; struct SCCompleteRandomItem { char cInvenType; // eItemPositionType char cLevel; int nResultItemID; int nItemCount; int nRet; }; struct SCChangeEternityItem // SC_ITEM / SC_ETERNITYITEM { UINT nSessionID; char cType; USHORT wEternityItem; }; struct SCGlyphTimeInfo // SC_ITEM / SC_GLYPHTIMEINFO { int nDelayTime; // glyph 관련된 cooltime int nRemainTime; }; struct TSortSlot { BYTE cCurrent; BYTE cNew; }; struct CSSortInventory // CS_ITEM / CS_SORTINVENTORY, CS_SORTPERIODINVENTORY { BYTE cTotalCount; TSortSlot SlotInfo[INVENTORYMAX]; }; struct SCSortInventory // SC_ITEM / SC_SORTINVENTORY, SC_SORTPERIODINVENTORY { int nRet; }; struct SCDecreaseDurabilityInventory //SC_ITEM / SC_DECREASE_DURABILITY_INVENTORY { char cType; union { int nAbsolute; float fRatio; }; }; struct CSSortWarehouse // CS_ITEM / CS_SORTWAREHOUSE, CS_SORTPERIODWAREHOUSE { BYTE cTotalCount; TSortSlot SlotInfo[WAREHOUSEMAX]; }; struct SCSortWarehouse // SC_ITEM / SC_SORTWAREHOUSE, SC_SORTPERIODWAREHOUSE { int nRet; }; #if defined( PRE_ADD_STAGE_USECOUNT_ITEM ) struct SCStageUseLimitItem // SC_ITEM / SC_STAGE_USELIMITITEM { int nItemID; int nUseCount; }; #endif // 강화 /* CS_ENCHANT 강화할 아이템 올려놓고 강화버튼 누르고 SC_ENCHANT 가능한지 응답받고 동영상나오고 CS_ENCHANTCOMPLETE 동영상 끝나면 강화완료라고 보내고 SC_ENCHANTCOMPLETE 강화결과 알려주고 (끝) CS_ENCHANTCANCEL 중간에 취소할꺼면 날려주고 SC_ENCHANTCANCEL */ struct CSEnchantItem { #if defined(PRE_ADD_EQUIPED_ITEM_ENCHANT) int cItemIndex; bool bEnchantEquipedItem; #else BYTE cInvenIndex; #endif INT64 biItemSerial; #if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM) // 추후에 강화 보조 아이템이 더 추가될수 있어서 변경합니다. char cEnchantGuardType; // 강화 보호 타입 0-NONE, 1-강화보호젤리(파괴x), 2-상위강화보호젤리(파괴x,다운x) eEnchantGuardType #else bool bUseEnchantGuard; #endif // #if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM) bool bCashItem; }; struct SCEnchantItem { #if defined(PRE_ADD_EQUIPED_ITEM_ENCHANT) int cItemIndex; bool bEnchantEquipedItem; #else BYTE cInvenIndex; #endif bool bCashItem; int nRet; }; struct SCEnchantComplete { int nItemID; char cLevel; char cOption; bool bIsCashItem; int nRet; }; struct SCEnchantCancel { int nRet; }; struct SCBroadcastingEffect // SC_ITEM / SC_BROADCASTINGEFFECT { UINT nSessionID; char cType; // eBroadcastingEffect char cState; // eBroadcastingEffect }; // SC_CHANGEGLYPH, // 주변애들한테 glyph정보 날려주기 struct SCChangeGlyph { UINT nSessionID; TItemInfo ItemInfo; }; struct SCVehicleEquipList // SC_ITEM, SC_VEHICLEEQUIPLIST { TVehicleCompact VehicleEquip; }; struct SCVehicleInvenList // SC_ITEM, SC_VEHICLEINVENLIST { int nTotalInventoryCount; BYTE cInvenCount; TVehicleCompact VehicleInven[VEHICLEINVENTORYPAGEMAX]; }; struct SCChangeVehicleParts // SC_ITEM, SC_CHANGEVEHICLEPARTS, SC_CHANGEPETPARTS { UINT nSessionID; char cSlotIndex; TVehicleItem Equip; }; struct SCChangeVehicleColor // SC_ITEM, SC_CHANGEVEHICLECOLOR { UINT nSessionID; DWORD dwColor; char cSlotIndex; INT64 biSerial; }; struct SCRefreshVehicleInven // SC_ITEM / SC_REFRESHVEHICLEINVEN { bool bNewSign; // new표시 할껀가 안할껀가 int nCount; TVehicleCompact ItemList[VEHICLEINVENTORYPAGEMAX]; }; struct SCAddPetExp // SC_ITEM / SC_ADDPETEXP { UINT nSessionID; INT64 biPetSerial; int nExp; }; struct SCChangePetBody // SC_ITEM, SC_CHANGEPETBODY { UINT nSessionID; TVehicleCompact PetInfo; }; struct SCPetCurrentSatiety { INT64 biPetSerial; int nCurrentSatiety; }; struct SCPetFoodEat { int nResult; int nIncSatiety; }; #if defined(PRE_ADD_EXPUP_ITEM) struct SCDailyLimitItemError { int nWeightTableIndex; }; #endif struct CSRemoveCash // CS_ITEM, CS_REMOVECASH { INT64 biItemSerial; bool bRecovery; }; struct SCRemoveCash // SC_ITEM, SC_REMOVECASH { INT64 biItemSerial; bool bEternity; // 영구아이템 __time64_t tExpireDate; bool bExpireComplete; int nRet; }; struct SCModItemExpireDate { int nRet; }; #if defined( PRE_ADD_LIMITED_SHOP ) struct SCLimitedShopItemData // SC_ITEM, SC_LIMITEDSHOPITEMDATA { short count; bool bAllClear; LimitedShop::LimitedItemData items[INVENTORYMAX + WAREHOUSEMAX]; }; #endif #if defined(PRE_ADD_TALISMAN_SYSTEM) struct CSOpenTalismanSlot // CS_ITEM / CS_OPEN_TALISMANSLOT { int nSlotIndex; }; struct SCOpenTalismanSlot // SC_ITEM / SC_OPEN_TALISMANSLOT { int nRet; int nTalismanOpenFlag; }; struct SCChangeTalisman // SC_ITEM / SC_CHANGETALISMAN { UINT nSessionID; TItemInfo ItemInfo; }; struct SCTalismanExpireData // SC_ITEM / SC_TALISMANEXPIREDATA { bool bActivate; // 탈리스만 캐쉬 확장 슬롯 활성화 여부 __time64_t tTalismanExpireDate; // 탈리스만 슬롯 기간 }; #endif #if defined(PRE_ADD_EQUIPLOCK) struct CSItemLockReq // CS_ITEM / CS_ITEM_LOCK_REQ, CS_ITEM_UNLOCK_REQ { bool IsCashEquip; BYTE nItemSlotIndex; // Lock(UnLock)시킬 Item의 인덱스 번호 INT64 biItemSerial; // 해당 아이템 Serial }; struct SCItemLockRes // SC_ITEM / SC_ITEM_LOCK_RES, SC_ITEM_UNLOCK_RES { int nRet; //결과값 bool IsCashEquip; EquipItemLock::TLockItemInfo LockItems; }; struct SCEquipItemLockList // SC_ITEM / SC_EQUIPITEM_LOCKLIST { int nEquipCount; //일반 장비 갯수 int nCashEquipCount; //캐쉬 장비 갯수 EquipItemLock::TLockItemInfo LockItems[EQUIPMAX+CASHEQUIPMAX]; }; #endif // #if defined(PRE_ADD_EQUIPLOCK) #if defined(PRE_PERIOD_INVENTORY) struct SCPeriodInventory // SC_ITEM / SC_PERIODINVENTORY { bool bEnable; __time64_t tExpireDate; }; struct SCPeriodWarehouse // SC_ITEM / SC_PERIODWAREHOUSE { bool bEnable; __time64_t tExpireDate; }; #endif // #if defined(PRE_PERIOD_INVENTORY) //-------------------------------------------------------------------------------------------------- // Item Goods (CS_ITEMGOODS, SC_ITEMGOODS) //-------------------------------------------------------------------------------------------------- struct CSUnSealItem { BYTE cInvenIndex; INT64 biInvenSerial; }; struct SCUnSealItem { int nRet; BYTE cInvenIndex; }; struct CSSealItem { BYTE cInvenIndex; INT64 biInvenSerial; INT64 biItemSerial; }; struct SCSealItem { int nRet; BYTE cInvenIndex; }; struct SCRequestCashWorldMsg { INT64 biItemSerial; char cType; }; // 클라이언트에서 요청온 스킬 리셋 아이템 사용에 관해 사용 가능한지 아닌지 응답. struct SCCanUseSkillResetCashItem { INT64 biItemSerial; int nRet; int nRewardSP; }; // 클라이언트에서 최종적으로 스킬 리셋 아이템 사용 패킷을 보냄 struct CSUseSkillResetCashItemReq { #if defined(PRE_MOD_SKILLRESETITEM) char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) #endif INT64 biItemSerial; char cSkillPage; }; // 스킬 리셋 캐쉬템 사용한 결과를 클라로 통보 struct SCUseSkillResetCashItemRes { int nRet; int nResultSP; // 최종 결과로 나온 스킬 포인트. char cSkillPage; }; #ifdef PRE_ADD_CHANGEJOB_CASHITEM struct CSUseChangeJobCashItemReq { INT64 biItemSerial; int iJobToChange; }; struct SCUseChangeJobCashItemRes { int nRet; int nFirstJobID; int nSecondJobID; int nResultSkillPoint; }; #endif // #ifdef PRE_ADD_CHANGEJOB_CASHITEM // SC_CHANGECOLOR struct SCChangeColor { UINT nSessionID; char cItemType; DWORD dwColor; }; #ifdef PRE_ADD_GACHA_JAPAN struct SCGachaShopOpen_JP // SC_ITEMGOODS / SC_JP_GACHAPON_OPEN_SHOP_RES { int nGachaShopIndex; }; struct CSGachaRequest_JP // SC_ITEMGOODS / CS_JP_GACHAPON_REQ { int nJobClassID; int nSelectedPart; }; struct SCGachaRes_JP // SC_ITEMGOODS / SC_JP_GACHAPON_RES { int nRet; int nResultItemID; }; #endif // 코스튬 합성 struct SCCosMixOpen { int nRet; }; struct SCCosMixClose { int nRet; bool bComplete; }; struct CSCosMix { INT64 nStuffSerialID[MAXCOSMIXSTUFF]; UINT nResultItemID; char cOption; }; struct SCCosMix { int nRet; UINT nResultItemID; char cOption; }; struct SCCosDesignMixOpen { int nRet; }; struct SCCosDesignMixClose { int nRet; bool bComplete; }; struct CSCosDesignMix { INT64 nStuffSerialID[eCDMST_MAX]; }; struct SCCosDesignMix { int nRet; INT64 biItemSertial; int nLookItemID; }; #ifdef PRE_ADD_COSRANDMIX struct SCCosRandomMixOpen { int nRet; #ifdef PRE_ADD_COSRANDMIX_ACCESSORY int nOpenType; #endif }; struct SCCosRandomMixClose { int nRet; bool bComplete; }; struct CSCosRandomMix { INT64 nStuffSerialID[MAX_COSTUME_RANDOMMIX_STUFF]; UINT nResultItemID; }; struct SCCosRandomMix { int nRet; UINT nResultItemID; }; #endif // PRE_ADD_COSRANDMIX struct CSPotentialItem { BYTE cInvenIndex; INT64 biInvenSerial; INT64 biItemSerial; }; struct SCPotentialItem { int nRet; BYTE cInvenIndex; }; #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL) struct SCPotentialItemRollback { int nRet; }; #endif // #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL) struct CSCharmItemRequest // CS_ITEMGOODS / CS_CHARMITEMREQUEST { char cInvenType; // eItemPositionType short sInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; BYTE cKeyInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) int nKeyItemID; INT64 biKeyItemSerial; }; #ifdef PRE_ADD_GETITEM_WITH_RANDOMVALUE struct TRangomGiveItemData { int nItemID; // 아이템 int nCount; // 유저가 획득할 개수 int nPeriod; // 기간 int nGold; }; #endif //#ifdef PRE_ADD_GETITEM_WITH_RANDOMVALUE struct SCCharmItemRequest // CS_ITEMGOODS / SC_CHARMITEMREQUEST { char cInvenType; // eItemPositionType short sInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; int nRet; #ifdef PRE_ADD_GETITEM_WITH_RANDOMVALUE BYTE cRandomGiveCount; TRangomGiveItemData RandomGiveItems[RANDOMGIVE_CHARMITEM_MAX]; #endif //#ifdef PRE_ADD_GETITEM_WITH_RANDOMVALUE }; struct CSCharmItemComplete // CS_ITEMGOODS / CS_CHARMITEMCOMPLETE { char cInvenType; // eItemPositionType short sInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; BYTE cKeyInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) int nKeyItemID; INT64 biKeyItemSerial; }; struct SCCharmItemComplete // SC_ITEMGOODS / SC_CHARMITEMCOMPLETE { char cInvenType; // eItemPositionType int nResultItemID; int nItemCount; int nPeriod; int nRet; }; #if defined (PRE_ADD_CHAOSCUBE) struct TChaosItem { short wCount; short sInvenIndex; INT64 biInvenSerial; }; struct CSChaosCubeRequest // CS_ITEMGOODS / CS_CHAOSCUBEREQUEST { char cCubeInvenType; short sCubeInvenIndex; INT64 biCubeInvenSerial; #if defined( PRE_ADD_CHOICECUBE ) int nChoiceItemID; // 선택한 결과아이템(초이스박스에서만 사용) #endif char cInvenType; int nCount; TChaosItem ChaosItem[MAX_CHAOSCUBE_STUFF]; #if defined( PRE_ADD_CHOICECUBE ) CSChaosCubeRequest() : nChoiceItemID(0) {} #endif }; struct SCChaosCubeRequest // CS_ITEMGOODS / SC_CHAOSCUBEREQUEST { int nRet; char cInvenType; int nCount; TChaosItem ChaosItem[MAX_CHAOSCUBE_STUFF]; }; struct CSChaosCubeComplete // CS_ITEMGOODS / CS_CHAOSCUBECOMPLETE { char cCubeInvenType; short sCubeInvenIndex; INT64 biCubeInvenSerial; #if defined( PRE_ADD_CHOICECUBE ) int nChoiceItemID; // 선택한 결과아이템(초이스박스에서만 사용) #endif char cInvenType; int nCount; TChaosItem ChaosItem[MAX_CHAOSCUBE_STUFF]; #if defined( PRE_ADD_CHOICECUBE ) CSChaosCubeComplete() : nChoiceItemID(0) {} #endif }; struct SCChaosCubeComplete // SC_ITEMGOODS / SC_CHAOSCUBECOMPLETE { char cInvenType; int nResultItemID; int nItemCount; int nPeriod; int nRet; }; #endif // #if defined (PRE_ADD_CHAOSCUBE) struct SCPetalTokenResult // SC_ITEMGOODS / SC_PETALTOKENRESULT, // 페탈 상품권 산거 채팅창에.. { int nUseItemID; int nTotalPetal; }; struct SCAppellationGainResult { int nArrayIndex; int nRet; }; struct CSGuildRename // CS_ITEMGOODS / CS_GUILDRENAME { char cInvenType; BYTE cInvenIndex; INT64 biItemSerial; WCHAR wszGuildName[GUILDNAME_MAX]; }; struct SCGuildRename // SC_ITEMGOODS / SC_GUILDRENAME { int nRet; }; struct CSCharacterRename // CS_ITEMGOODS / CS_CHARACTERRENAME { char cInvenType; BYTE cInvenIndex; INT64 biItemSerial; WCHAR wszCharacterName[NAMELENMAX]; }; struct SCCharacterRename // SC_ITEMGOODS / SC_CHARACTERRENAME { int nRet; //ERROR_DB_CHANGENAME_NEXTDAY일 경우tNextChangeDate로 날짜제한 표시 UINT nUserSessionID; __time64_t tNextChangeDate; WCHAR wszCharacterName[NAMELENMAX]; }; #if defined (PRE_ADD_BESTFRIEND) struct CSBestFriendItemRequest { INT64 biGiftSerial; int nMemuItemID; }; struct SCBestFriendItemRequest { INT64 biGiftSerial; int nRet; }; struct CSBestFriendItemComplete { INT64 biGiftSerial; int nMemuItemID; }; struct SCBestFriendItemComplete { int nResultItemID; int nItemCount; int nPeriod; int nRet; }; #endif struct CSChangePetName { INT64 itemSerial; INT64 petSerial; WCHAR name[NAMELENMAX]; }; struct SCChangePetName { int nRet; INT64 biItemSerial; UINT nUserSessionID; WCHAR wszPetName[NAMELENMAX]; }; struct CSModItemExpireDate { INT64 biExpireDateItemSerial; // 기간연장에 사용한 아이템 시리얼 INT64 biItemSerial; // 기간 연장할 아이템 시리얼 }; struct CSPetSkillItem { INT64 biItemSerial; // 펫아이템 Serial 번호 }; struct SCPetSkillItem { int nRet; char cSlotNum; // 슬롯 Num int nSkillID; // 스킬 ID }; struct CSPetSkillDelete { char cSlotNum; // 삭제할 슬롯 Num }; struct SCPetSkillDelete { int nRet; char cSlotNum; }; struct CSPetSkillExpand { INT64 biItemSerial; // 스킬 확장 아이템 Serial }; struct SCPetSkillExpand { int nRet; }; struct CSEnchantJewelItem { BYTE cInvenIndex; INT64 biInvenSerial; INT64 biItemSerial; }; struct SCEnchantJewelItem { int nRet; BYTE cInvenIndex; }; struct SCExpandSkillPageItem { int nRet; }; struct CSGuildMark // CS_ITEMGOODS / CS_GUILDMARK // 길드마크 변경 { int nItemID; INT64 biItemSerial; int nInvenIndex; // 일반아이템일 경우 인벤토리인덱스 short wGuildMark; short wGuildMarkBG; short wGuildMarkBorder; }; struct SCGuildMark // SC_ITEMGOODS / SC_GUILDMARK { int nRet; short wGuildMark; short wGuildMarkBG; short wGuildMarkBorder; }; struct SCSourceItem { int nSessionID; int nItemID; int nRemainTime; bool bUsedInGameServer; }; #if defined( PRE_ADD_NAMEDITEM_SYSTEM ) struct SCEffectSkillItem { int nSessionID; int nCount; bool bUsedInGameServer; TEffectSkillData EffectSkill[EFFECTSKILLMAX]; }; struct SCDelEffectSkillItem { int nSessionID; int nItemID; }; struct SCShowEffect { int nItemID; int nSessionID; bool bUseSession; }; struct SCNamedItemID { int nSessionID; int nItemID; }; #endif #if defined(PRE_ADD_TRANSFORM_POTION) struct SCChangeTransform { int nSessionID; int nTransformID; int nExpireTime; // minute; }; #endif //---------------------------------------------------------------1----------------------------------- // NPC (CS_NPC, SC_NPC) //-------------------------------------------------------------------------------------------------- struct CSNpcTalk // CS_NPC / CS_NPCTALK { UINT nNpcUniqueID; DWORD dwIndexHashCode; DWORD dwTargetHashCode; }; struct CSNpcTalkEnd { UINT nNpcUniqueID; }; struct TalkParam { enum { STRING = 1, INT, }; char cType; WCHAR wszKey[NAMELENMAX]; int nValue; }; const int TALK_PARAM_MAX = 10; struct SCNpcTalk // SC_NPC / SC_NPCTALK { UINT nNpcUniqueID; DWORD dwIndexHashCode; DWORD dwTargetHashCode; bool bIsEnd; short nCount; TalkParam TalkParamArray[TALK_PARAM_MAX]; }; struct SCShowWareHouse { int iItemID; }; struct SCOpenUpgradeItem { int iItemID; }; struct SCOpenCompoundItem // SC_NPC / eNpc::SC_OPENCOMPOUND_ITEM { UINT nCompoundShopID; }; struct SCOpenCompound2Item // SC_NPC / eNpc::SC_OPENCOMPOUND2_ITEM { UINT nCompoundGroupID; int iItemID; }; struct SCOpenGuildMgrBox // SC_NPC / eNpc::SC_OPENGUILDMGRBOX { int nGuildMgrNo; // ? }; struct SCOpenBrowser { char url[MAX_BROWSER_URL]; int nX; int nY; int nWidth; int nHeight; }; #if defined(PRE_ADD_OPEN_QUEST_TEXTURE_DIALOG) struct SCOpenTextureDialog { int nFileIndex; float fX; float fY; int nPosition; int nTime; int nDialogIndex; bool bAutoCloseDialog; }; struct SCCloseTextureDialog { int nDialogID; }; #endif //-------------------------------------------------------------------------------------------------- // QUEST (CS_QUEST, SC_QUEST) //-------------------------------------------------------------------------------------------------- struct CSCancelQuest // CS_QUEST / CS_CANCEL_QUEST { int nQuestIndex; }; struct SCQuestInfo // SC_QUEST / SC_QUESTINFO { DNNotifier::Data NotifierData[DNNotifier::RegisterCount::Total]; char cCount; TQuest Quest[MAX_PLAY_QUEST]; }; struct SCQuestCompleteInfo // SC_QUEST / SC_QUESTCOMPLETEINFO { char CompleteQuest[COMPLETEQUEST_BITSIZE]; }; struct RefreshType { enum { ADD_QUEST = 1, CANCEL_QUEST, REFRESH_STEP, REFRESH_JOURNAL, REFRESH_COUNTING, REFRESH_COMPLETECOUNTING, REFRESH_ALLCOMPLETECOUNTING, REFRESH_STEPANDJOURNAL, }; }; struct SCRefreshQuest // SC_QUEST / SC_REFRESH_QUEST { short nRefreshType; char cQuestSlot; UINT nQuestID; TQuest Quest; }; struct SCCompleteQuest // SC_QUEST / SC_COMPLETE_QUEST { bool bDeletePlayList; char cQuestSlot; UINT nQuestID; bool bNeedMarking; }; struct SCMarkingCompleteQuest // SC_QUEST / SC_MARKING_COMPLETE_QUEST { UINT nQuestID; }; struct SCRemoveQuest // SC_QUEST / SC_REMOVE_QUEST { char cQuestSlot; UINT nQuestID; int nRetCode; }; struct SCPlayCutScene // SC_ETC / SC_PLAYCUTSCENE { UINT nCutSceneTableID; int nQuestIndex; int nQuestStep; UINT nNpcObjectID; bool bQuestAutoFadeIn; DWORD dwQuestPlayerUniqueID; }; struct SCQuestReward // SC_QUEST / SC_QUEST_REWARD { int nRewardTableIndex; bool bActivate; }; struct SCQuestResult // SC_QUEST / SC_QUESTRESULT { int nRetCode; }; struct SCCompleteCutScene { bool bFadeIn; }; struct SCSkipCutScene { UINT nSessionID; }; struct CSSelectQuestReward { UINT nIndex; // 보상테이블 인덱스 bool SelectArray[QUESTREWARD_INVENTORYITEMMAX]; bool SelectCashArray[MAILATTACHITEMMAX]; }; struct CSCompleteCutScene { UINT nSessionID; }; struct SCAssignPeriodQuest // SC_QUEST / SC_ASSIGN_PERIODQUEST { UINT nQuestID; bool bFlag; }; struct SCPeriodQuestNotice // SC_QUEST / SC_NOTICE_PERIODQUEST { int nItemID; int nNoticeCount; }; struct SCScorePeriodQuest // SC_QUEST / SC_SCORE_PERIODQUEST { int nCurrentCount; int nMaxCount; }; struct CSShortCutQuest { UINT nQuestID; }; #if defined(PRE_ADD_REMOTE_QUEST) struct SCGainRemoteQuest // CS_QUEST / CS_ACCEPT_REMOTE_QEUST { UINT nQuestID; }; struct CSAcceptRemoteQuest // CS_QUEST / CS_ACCEPT_REMOTE_QEUST { UINT nQuestID; }; struct SCAcceptRemoteQuest // SC_QUEST / SC_ACCEPT_REMOTE_QEUST { int nRet; UINT nQuestID; }; struct CSCompleteRemoteQuest : public CSSelectQuestReward // CS_QUEST / CS_COMPLETE_REMOTE_QUEST { UINT nQuestID; }; struct CSCancelRemoteQuest // CS_QUEST / CS_CANCEL_REMOTE_QUEST { UINT nQuestID; }; struct SCRemoveRemoteQuest // SC_QUEST / SC_REMOVE_REMOTE_QEUST { UINT nQuestID; }; struct SCCompleteRemoteQuest // SC_QUEST / SC_COMPLETE_REMOTE_QEUST { UINT nQuestID; }; #endif //-------------------------------------------------------------------------------------------------- // CHAT (CS_CHAT, SC_CHAT) //-------------------------------------------------------------------------------------------------- struct CSChat // CS_ETC / CS_CHAT { eChatType eType; INT64 biItemSerial; short nLen; WCHAR wszChatMsg[CHATLENMAX]; }; struct CSChatPrivate // CS_ETC / CS_CHAT_PRIVATE { WCHAR wszToCharacterName[NAMELENMAX]; short nLen; WCHAR wszChatMsg[CHATLENMAX]; }; struct SCChat // SC_ETC / SC_CHATMSG { eChatType eType; WCHAR wszFromCharacterName[NAMELENMAX]; int nRet; // 1: success -1: 상대없다 -2: 본인한테 보낸것 short nLen; WCHAR wszChatMsg[CHATLENMAX]; }; struct SCWorldSystemMsg // SC_WORLDSYSTEMMSG { WCHAR wszFromCharacterName[NAMELENMAX]; char cType; // eChatType (WORLDCHATTYPE_...) int nID; int nValue; WCHAR wszToCharacterName[NAMELENMAX]; }; struct SCNotice //SC_NOTICE { int nShowSec; short nLen; WCHAR wszNoticeMsg[CHATLENMAX]; }; struct SCGuildChat { TGuildUID GuildUID; UINT nAccountDBID; // 계정 DBID INT64 nCharacterDBID; // 캐릭터 DBID short nLen; // 채팅 길이 WCHAR wszChatMsg[CHATLENMAX]; // 채팅 메시지 }; #ifdef PRE_ADD_DOORS_GUILDCHAT_DISCONNECT struct SCDoorsGuildChat { TGuildUID GuildUID; INT64 biCharacterDBID; // 캐릭터 DBID short nLen; // 채팅 길이 WCHAR wszChatMsg[CHATLENMAX]; // 채팅 메시지 }; #endif //#ifdef PRE_ADD_DOORS_GUILDCHAT_DISCONNECT struct CSDice { eChatType eType; short range; }; struct CSChatChatRoom // CS_CHAT_CHATROOM { short nLen; WCHAR wszChatMsg[CHATLENMAX]; }; struct SCChatServerMsg // SC_SERVERMSG { char cType; char cStringType; int nMsgIndex; char cCaption; // 클라의 CDnInterface::emCAPTION_TYPE 요거임. BYTE cFadeTime; // 페이드 시간(second) }; //-------------------------------------------------------------------------------------------------- // ROOM (CS_ROOM, SC_ROOM) //-------------------------------------------------------------------------------------------------- struct CSSyncWait // CS_ROOM / CS_SYNC_WAIT { UINT nSessionID; }; struct CSOKDungeonClear { UINT nSessionID; }; //struct CSWarpDungeonClear //{ // bool bWarpVillage; //}; struct CSWarpDungeon { bool bWarpVillage; }; struct CSSelectRewardItem { char cItemIndex; }; struct CSIdentifyRewardItem { char cItemIndex; }; struct CSDLChallengeResponse { bool bAccept; }; struct SCDLChallengeResponse { bool bAccept; }; struct SCSyncWait // SC_ROOM / SC_SYNC_WAIT { UINT nSessionID; }; struct SCSyncStart // SC_ROOM / SC_SYNC_START { UINT nSessionID; }; struct SCRefreshMember // SC_ROOM / SC_REFRESH_MEMBER { BYTE cCount; UINT nMemberSessionID[PARTYMAX]; }; struct SCSelectRewardItem { UINT nSessionID; char cItemIndex; }; struct SCIdentifyRewardItem { char cItemIndex; char cBoxType; }; struct SCRoomSyncSeqLevel //SC_ROOM / SC_ROOMSYNC_SEQLEVEL { BYTE cSeqLevel; }; //#if defined(_GAMESERVER) || defined(_WINDOWS) #if defined(_GAMESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct SCGenerationMonster //SC_GENERATION_MONSTER_MSG { UINT nSessionID; int nSeed; UINT nMonsterID; int nEventAreaUniqueID; EtVector3 vPos; EtVector3 vVel; EtVector3 vResistance; int nTeam; bool bRandomFrameSummon; bool bUseRotationQuat; // SummonMonster 시그널을 사용한 경우 소환된 몬스터의 각도값을 패킷으로 보내줌. EtQuat qRotation; }; // 가변 패킷으로 대체됨. ///////////////////////////////////////////////// struct SCGenerationProp //SC_GENERATION_PROP_MSG { int nSummonPropTableID; int nPropUniqueID; int nSeed; EtVector3 vPos; EtVector3 vRotate; EtVector3 vScale; }; ////////////////////////////////////////////////////////////////////////// #endif struct SCGateInfoMessage // SC_ROOM / SC_GATEINFO_MSG { BYTE cCount; BYTE cGateIndex[WORLDMAP_GATECOUNT]; BYTE cPermitFlag[WORLDMAP_GATECOUNT]; }; struct SCGateEjectInfo // SC_ROOM / SC_GATEEJECTINFO_MSG { BYTE cGateIndex; BYTE cLessLevelCount; BYTE cNotEnoughItemCount; BYTE cExceedCount; BYTE cNotRideVehicleCount; BYTE cActorIndex[PARTYMAX*2]; }; struct sEventStageClearBonus { BYTE nType; //eEventType3 참조 UINT nClearEventBonusExperience; }; struct TDungeonClearInfo { UINT nSessionID; BYTE cRank; UINT nDefaultCP; UINT nBonusCP; USHORT nMaxComboCount; USHORT nKillBossCount; UINT nRewardGold; char cClearRewardType; UINT nCompleteExperience; UINT nRewardExperience; UINT nMeritBonusExperience; char cMaxLevelCharCount; UINT nPromotionExperience; char cShowBoxCount; char cSelectBoxCount; BYTE cBonusCount; sEventStageClearBonus EventClearBonus[EVENTCLEARBONUSMAX]; }; struct SCDungeonClear // SC_ROOM / SC_DUNGEONCLEAR_MSG { BYTE cCount; UINT nDungeonClearTableID; UINT nClearTime; char cCurLevel; int nCurExp; bool bIgnoreRewardItem; TDungeonClearInfo Info[PARTYMAX]; }; #if defined(PRE_ADD_CP_RANK) struct TStageClearBest { INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; char cRank; int nClearPoint; }; struct SCAbyssStageClearBest // SC_ROOM / SC_ABYSS_STAGE_CLEAR_BEST { TStageClearBest sLegendClearBest; TStageClearBest sMonthlyClearBest; char cMyBestRank; int nMyBestCP; }; #endif struct TRewardItemResultStruct { UINT nSessionID; BYTE cIndex; }; struct SCDungeonClearRewardItemResult { BYTE cCount; TRewardItemResultStruct Info[PARTYMAX]; }; struct TRewardItemStruct { UINT nSessionID; UINT nRewardItemID[4]; #if !defined( PRE_ADD_NAMEDITEM_SYSTEM ) BYTE cRewardItemType[4]; #endif int nRewardItemRandomSeed[4]; char cRewardItemOption[4]; short wRewardItemCount[4]; char cRewardItemSoulBound[4]; #if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD) char cRewardItemLevel[4]; //강화정보 char cRewardItemPotential[4]; //잠재력 정보 #endif // #if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD) }; #if defined( PRE_ADD_NAMEDITEM_SYSTEM ) struct TRewardBoxTypeStruct { UINT nSessionID; BYTE cRewardItemType[4]; }; struct SCDungeonClearBoxType { BYTE cCount; TRewardBoxTypeStruct Info[PARTYMAX]; }; #endif struct SCDungeonClearRewardItem { BYTE cCount; TRewardItemStruct Info[PARTYMAX]; }; struct SCWarpDungeonClear { #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME) int nLastVillageMapIndex; #endif // #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME) }; struct SCDungeonClearLeaderWarp { bool bEnable; }; struct SCDungeonFailed { bool bCanWarpWorldMap; bool bTimeOut; #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME) int nLastVillageMapIndex; #endif // #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME) }; struct SCDungeonClearWarpOutFail { int nRet; }; struct SCOpenDungeonOpenLevel { UINT nMapIndex; char cDifficulty; }; struct SCSyncDungeonTimeAttack { int iRemainSec; int iOrgSec; }; #if defined(PRE_MOD_DARKLAIR_RECONNECT) struct SCDLRoundInfo // SC_ROOM / SC_DLROUND_INFO { int nCurrentRound; int nTotalRound; bool bBossRound; }; #endif struct TDLDungeonClearInfo { UINT nSessionID; UINT nExperience; UINT nMeritBonusExperience; char cShowBoxCount; char cSelectBoxCount; UINT nRewardGold; char cClearRewardType; char cMaxLevelCharCount; UINT nPromotionExperience; BYTE cBonusCount; sEventStageClearBonus EventClearBonus[EVENTCLEARBONUSMAX]; }; struct SCDLDungeonClear // SC_ROOM / SC_DUNGEONCLEAR_MSG { BYTE cCount; UINT nClearTime; int nClearRound; bool bClear; TDLDungeonClearInfo Info[PARTYMAX]; }; struct TDLRankHistoryMemberInfo { USHORT nLevel; int nJobIndex; WCHAR wszCharacterName[NAMELENMAX]; }; struct TDLRankHistoryPartyInfo { int nRank; USHORT nPlayRound; UINT nPlaySec; WCHAR wszPartyName[PARTYNAMELENMAX]; BYTE cPartyUserCount; TDLRankHistoryMemberInfo Info[DarkLair::Common::MaxPlayer]; }; struct SCDLRankInfo { TDLRankHistoryPartyInfo CurScore; TDLRankHistoryPartyInfo TopScore; TDLRankHistoryPartyInfo HistoryScore[DarkLair::Rank::SelectTop]; }; struct SCChangeGateState // SC_ROOM / SC_CHANGE_GATESTATE_MSG { BYTE cGateInde; UINT nPermitFlag; }; struct SCChangeGameSpeed // SC_ROOM /SC_CHANGE_GAMESPEED { float fSpeed; UINT dwDelay; }; struct SCDungeonHistory { BYTE cBuf[1024]; }; struct SCROOM_SYNC_MEMBERINFO { bool bIsBreakInto; bool bIsStart; short nCount; SPartyMemberInfo Member[MAX_SEND_SYNCPLAYER]; }; #ifdef PRE_MOD_SYNCPACKET struct TSyncTeam { UINT nSessionID; USHORT usTeam; }; struct SCROOM_SYNC_MEMBERTEAM { BYTE cCount; TSyncTeam tTeam[MAX_SEND_SYNCPLAYER]; }; #else //#ifdef PRE_MOD_SYNCPACKET struct SCROOM_SYNC_MEMBERTEAM { BYTE cCount; USHORT unStartIndex; USHORT usTeam[MAX_SEND_SYNCPLAYER]; }; #endif //#ifdef PRE_MOD_SYNCPACKET struct SCROOM_SYNC_MEMBERDEFAULTPARTS { short nCount; int iDefaultPartsIndex[PvPCommon::Common::MaxPlayer*4]; }; struct SCROOM_SYNC_MEMBEREQUIP { short nCount; TPartyMemberEquip MemberEquip[PvPCommon::Common::MaxPlayer]; }; struct SCROOM_SYNC_MEMBERSKILL { short nCount; TPartyMemberSkill MemberSkill[PvPCommon::Common::MaxPlayer]; }; struct SCROOM_SYNC_MEMBER_BREAKINTO { SPartyMemberInfo Member; USHORT usTeam; BYTE cGMTrace; int iDefaultPartsIndex[4]; char cViewCashEquipBitmap[VIEWCASHEQUIPMAX_BITSIZE]; TGuildSelfView GuildSelfView; // 길드 시각정보 (개인) short nEquipCount; short nCashEquipCount; short nSkillCount; short nGlyphCount; #if defined(PRE_ADD_TALISMAN_SYSTEM) short nTalismanCount; #endif int iSelectAppellation; int nCoverAppellation; #if defined(PRE_ADD_VIP) bool bVIP; #endif // #if defined(PRE_ADD_VIP) char cAccountLevel; // 계정권한 (eAccountLevel) char cEternityItemCount; TVehicleCompact VehicleInfo; TVehicleCompact PetInfo; TItemInfo EquipArray[EQUIPMAX]; TItemInfo CashEquipArray[CASHEQUIPMAX]; TItemInfo GlyphArray[GLYPHMAX]; #if defined(PRE_ADD_TALISMAN_SYSTEM) TItemInfo TalismanArray[TALISMAN_MAX]; #endif TSkill SkillArray[SKILLMAX]; }; #ifdef PRE_MOD_SYNCPACKET struct TSyncHPSP { UINT nSessionID; INT64 iHP; int iSP; }; struct SCROOM_SYNC_MEMBERHPSP { BYTE cCount; TSyncHPSP tHPSP[MAX_SEND_SYNCPLAYER]; }; #else //#ifdef PRE_MOD_SYNCPACKET struct SCROOM_SYNC_MEMBERHPSP { BYTE cCount; USHORT unStartIndex; int iHPSPArr[MAX_SEND_SYNCPLAYER*2]; }; #endif //#ifdef PRE_MOD_SYNCPACKET #ifdef PRE_MOD_SYNCPACKET struct TBattleMode { UINT nSessionID; BYTE cBattleMode; }; struct SCROOM_SYNC_MEMBERBATTLEMODE { BYTE cCount; TBattleMode tBattleMode[MAX_SEND_SYNCPLAYER]; }; #else //#ifdef PRE_MOD_SYNCPACKET struct SCROOM_SYNC_MEMBERBATTLEMODE { BYTE cCount; USHORT unStartIndex; BYTE cBattleModeArr[MAX_SEND_SYNCPLAYER]; }; #endif //#ifdef PRE_MOD_SYNCPACKET struct TDropItemSync:public SCCreateDropItem { UINT uiLifeTime; // m_fLifeTime*1000 float fDistance; }; struct SCROOM_SYNC_DROPITEMLIST { BYTE cCount; TDropItemSync sDropItemList[SENDDROPITEMLISTMAX]; }; //-------------------------------------------------------------------------------------------------- // SKILL (CS_SKILL, SC_SKILL) //-------------------------------------------------------------------------------------------------- struct SCSkillList // SC_SKILL / SC_SKILLLIST { BYTE cSkillCount; char cSkillPage; TSkill Skill[SKILLMAX]; }; struct CSAddSkill // CS_SKILL / CS_ADDSKILL { int nSkillID; }; struct SCAddSkill // SC_SKILL / SC_ADDSKILL { int nSkillID; int nRet; }; struct CSDelSkill // CS_SKILL / CS_ADDSKILL { int nSkillID; }; struct SCDelSkill // SC_SKILL / SC_DELSKILL { int nSkillID; int nRet; }; struct SCSkillLevelUp // SC_SKILL / SC_SKILLLEVELUP { int nSkillID; BYTE cLevel; int nRetCode; }; struct CSSkillLevelUpReq // CS_SKILL / CS_SKILLLEVELUP_REQ { int nSkillID; BYTE cUseSkillPoint; }; struct SCOtherPlayerSkillLevelUp // CS_SKILL / CS_OTHERPLAYERSKILLLEVELUP { int nPartyIndex; int nSkillID; BYTE cLevel; }; struct SCPushSkillPoint { unsigned short usSkillPoint; }; struct SCUnlockSkill // CS_SKILL / SC_UNLOCKSKILL { int nSkillID; int nRetCode; }; struct CSAcquireSkillReq // CS_SKILL / CS_ACQUIRESKILL_REQ { int nSkillID; }; struct SCAcquireSkill // CS_SKILL / SC_ACQUIRESKILL { int nSkillID; int nRetCode; }; struct CSUnlockSkillByMoneyReq // CS_SKILL / SC_UNLOCKSKILL_BY_MONEY { int nSkillID; }; #if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION) struct TReservationSkillReq { char cType; // eSkillReservation int nSkillID; BYTE nLevel; // LevelUp일 경우만 최종 레벨. }; struct TReservationSkillAck { TReservationSkillReq tReservationSkill; int nResult; }; struct CSReservationSkillListReq // CS_SKILL / CS_RESERVATION_SKILL_LIST_REQ { int nCount; TReservationSkillReq tReservationSkill[ReservationSKillList::ReservationMax]; }; struct SCReservationSkillListAck // SC_SKILL / SC_RESERVATION_SKILL_LIST_ACK { int nCount; TReservationSkillAck tReservationSkillAck[ReservationSKillList::ReservationMax]; }; #endif // #if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION) #ifdef PRE_ADD_PRESET_SKILLTREE struct TSkillSetPartialData { int nSkillID; BYTE cLevel; }; struct CSSaveSkillSet // CS_SKILL / CS_SAVE_SKILLSET { BYTE cIndex; WCHAR wszSetName[SKILLPRESETNAMEMAX]; BYTE cCount; TSkillSetPartialData SKills[SKILLMAX]; }; struct CSDeleteSkillSet // CS_SKILL / CS_DELETE_SKILLSET { BYTE cIndex; }; struct TSkillSetIndexData { BYTE cIndex; BYTE cCount; //해당 프리셋이 가지구 있는 스킬의 수 WCHAR wszSetName[SKILLPRESETNAMEMAX]; }; struct SCSKillSetList // CS_SKILL / SC_LIST_SKILLSET { int nRetCode; TSkillSetIndexData SKillIndex[SKILLPRESETMAX]; TSkillSetPartialData SKills[SKILLMAX * SKILLPRESETMAX]; }; struct SCSKillSaveResult // CS_SKILL / SC_SAVE_SKILLSET { int nRetCode; }; struct SCSKillDeleteResult // CS_SKILL / SC_DELETE_SKILLSET { int nRetCode; }; #endif //#ifdef PRE_ADD_PRESET_SKILLTREE struct SCSkillReset // CS_SKILL / SC_RESET_SKILL { char cSkillPage; int nResultSkillPoint; }; struct SCChangeSkillPage //SC_SKILL / SC_CHANGE_SKILLPAGE_RES { char cSkillPage; }; struct SCSkillPageCount //SC_SKILLPAGE_COUNT { char cSkillPageCount; }; struct CSChangeSkillPage // CS_SKILL / CS_CHANGE_SKILLPAGE { char cSkillPageIndex; }; //-------------------------------------------------------------------------------------------------- // TRADE (CS_TRADE, SC_TRADE) //-------------------------------------------------------------------------------------------------- // Shop // npc상점 struct CSShopRemoteOpen // CS_TRADE / CS_SHOP_REMOTEOPEN { Shop::Type::eCode Type; }; struct SCShopOpen // SC_TRADE / SC_SHOP_OPEN { int nShopID; Shop::Type::eCode Type; }; struct CSShopBuy // CS_TRADE / CS_SHOP_BUY { char cTapIndex; BYTE cShopIndex; // shoplist에서 받은 해당 index값 short wCount; }; struct SCShopBuyResult // SC_TRADE / SC_SHOP_BUY { int nRet; }; struct CSShopSell // CS_TRADE / CS_SHOP_SELL { BYTE cInvenIndex; // inven index short wCount; INT64 biItemSerial; }; struct SCShopSellResult // SC_TRADE / SC_SHOP_SELL { int nRet; }; struct SCShopRepurchaseList { int nRet; BYTE cCount; TRepurchaseItemInfo List[Shop::Repurchase::MaxList]; }; struct CSShopRepurchase { int iRepurchaseID; }; struct SCShopRepurchase { int iRet; int iRepurchaseID; }; // SkillShop struct TSkillShopInfo { BYTE cSlotIndex; int nSkillID; int nPrice; }; struct SCSkillShopOpen // SC_TRADE / SC_SKILLSHOP_OPEN { int nRet; // 현재 의미 없음. }; struct SCSkillShopBuyResult // SC_TRADE / SC_SKILLSHOP_BUY { int nSkillID; short wSkillPoint; int nRet; }; // 우편 struct CSMailBox // CS_TRADE / CS_MAILBOX { char cPageNum; // 페이지 번호: 1부터 시작 }; struct TMailBoxInfo { int nMailDBID; // mail db table id short wIndex; WCHAR wszFromCharacterName[MAILNAMELENMAX]; // 보낸이 WCHAR wszTitle[MAILTITLELENMAX]; // 우편 제목 BYTE cRemainDay; // 남은날짜 char cReadType; // 개봉 상태 char cAttachType; // 아이템 첨부상태 char cDeliveryType; char cMailType; // 메일종류 (0:일반메일, 1:미션메일, 2:마켓메일) bool bNewFlag; // 제목/본문 코드화 여부 }; struct SCMailBox // SC_TRADE / SC_MAILBOX { int nRetCode; char cDailyMailCount; // 일일발송개수 short wTotalCount; short wUnreadCount; char cMailBoxCount; // 몇개보내는건지 TMailBoxInfo MailBox[MAILBOXMAX]; // 메일 내용 }; struct TAttachMailItem { int nInvenIndex; // 첨부되는 아이템의 인벤 인덱스 int nItemID; int nCount; // 첨부되는 아이템 개수 INT64 biSerial; }; struct CSSendMail // CS_TRADE / CS_SENDMAIL { WCHAR wszToCharacterName[NAMELENMAX]; // 받는이 WCHAR wszTitle[MAILTITLELENMAX]; // 제목 WCHAR wszText[MAILTEXTLENMAX]; // 내용 char cDeliveryType; // eMailType (MAILTYPE_NORMAL, MAILTYPE_PREMIUM) int nAttachCoin; // 코인첨부 (21억을 넘진않을듯) char cAttachItemTotalCount; TAttachMailItem AttachMailItem[MAILATTACHITEMMAX]; }; struct CSMailDBIDArray // CS_TRADE / CS_MAIL_DELETE, CS_MAIL_ATTACHALL { int nMailDBID[MAILPAGEMAX]; }; struct SCSendMail // SC_TRADE / SC_MAIL_SEND { char cDailyMailCount; // 일일발송개수 int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 }; struct CSAttachMail { int nMailDBID; char cAttachSlotIndex; // -1: 5칸 모두 받기, 0 - 4: 개별받기 }; struct SCMailResult // SC_TRADE / SC_MAIL_ATTACH { int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 }; struct SCMailDeleteResult // SC_TRADE / SC_MAIL_DELETE { int nTotalMailCount; int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 }; struct SCAttachAllMailResult // SC_TRADE / SC_MAIL_ATTACHALL { int nMailDBID[MAILPAGEMAX]; int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 }; struct CSReadMail // CS_TRADE / CS_MAIL_READ, CS_MAIL_READCADGE { int nMailDBID; }; struct SCReadMail // SC_TRADE / SC_MAIL_READ { int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 bool bNewFlag; // 제목, 내용 코드화 여부 short wNotReadMailCount; // 읽지 않은 메일 int nMailDBID; WCHAR wszText[MAILTEXTLENMAX]; // 내용 __time64_t tSendDate; int nAttachCoin; char cDeliveryType; char cAttachCount; TItemInfo AttachItem[MAILATTACHITEMMAX]; // 첨부된 아이템 }; struct TWishItemInfo { int nItemSN; int nItemID; char nOptionIndex; }; struct SCReadCadgeMail // SC_TRADE / SC_MAIL_READCADGE { int nRet; // ERROR_MAIL_ 로 시작되는 것들로 보내질것임 bool bNewFlag; // 제목, 내용 코드화 여부 short wNotReadMailCount; // 읽지 않은 메일 int nMailDBID; WCHAR wszText[MAILTEXTLENMAX]; // 내용 __time64_t tSendDate; bool bCadgeComplete; // 조르기 완료 여부 int nPackageSN; char cWishListCount; TWishItemInfo WishList[PACKAGEITEMMAX]; }; struct SCNotifyMail { bool bNewMail; // 새 편지인지 그냥 읽지않은 메일만인지 short wTotalMailCount; // 총 우편수 short wNotReadMailCount; // 읽지 않은 메일 bool bExpiration; // 만료경고 }; // 무인상점 #ifdef PRE_ADD_ITEMNAME_AUTOCOMPLETE struct TSearchTrade { int nSearchItemID; int nSearchNameID; }; #endif //#ifdef PRE_ADD_ITEMNAME_AUTOCOMPLETE struct CSMarketList // CS_TRADE / CS_MARKETLIST { short wPageNum; // 페이지 번호: 1부터 시작 char cMinLevel; char cMaxLevel; char cItemGrade[ITEMRANK_MAX]; // 등급분류 char cJob; // 직업구분 (모두: -1) short cMainType; // 기본분류 (모두: -1) char cDetailType; // 상세분류 (모두: -1) WCHAR wszSearchWord1[SEARCHLENMAX]; // 검색단어 WCHAR wszSearchWord2[SEARCHLENMAX]; // 검색단어 WCHAR wszSearchWord3[SEARCHLENMAX]; // 검색단어 char cSortType; // eSortType WCHAR wszSearchItemName[SEARCHLENMAX]; // 아이템 검색단어 int nExchangeItemID; // ExchangeTable의 ItemID bool bLowJobGroup; // 하위 직업군 포함 char cPayMethodCode; // 0-혼합, 1-코인, 3-페탈 #ifdef PRE_ADD_ITEMNAME_AUTOCOMPLETE BYTE cCount; TSearchTrade SearchList[MultiLanguage::Common::SerachCountMax]; #endif //#ifdef PRE_ADD_ITEMNAME_AUTOCOMPLETE }; struct TMarketInfo { int nMarketDBID; // market table db ID WCHAR wszSellerName[NAMELENMAX]; // 판매자 이름 int nItemID; short wCount; // 개수 USHORT wDur; // 내구도 int nRandomSeed; char cLevel; // 레벨 char cPotential; // 잠재력 char cOption; char cSealCount; // 밀봉카운트 int nPrice; // 가격 int nUnitPrice; // 단가 bool bDisplayFlag1; // 0을 입력해 주세요. 현재 사용하지 않는 필드 bool bDisplayFlag2; // 0을 입력해 주세요. 현재 사용하지 않는 필드 bool bPremiumTrade; // 유료아이템을 통한 프리미엄 거래아이템 char cMethodCode; // 1=게임머니, 3=페탈 char cPotentialMoveCount; //잠재이전횟수 }; struct SCMarketList // SC_TRADE / SC_MARKETLIST { int nRetCode; int nMarketTotalCount; char cMarketCount; TMarketInfo MarketInfo[MARKETMAX]; }; struct TMyMarketInfo { int nMarketDBID; // market table db ID int nItemID; short wCount; // 개수 USHORT wDur; // 내구도 int nRandomSeed; DWORD dwColor; // 색깔 char cLevel; // 레벨 char cPotential; // 잠재력 char cOption; char cSealCount; // 밀봉카운트 int nItemPrice; // 가격 char cSellType; // 판매상태 0:안팔렸음, 1:팔렸음 int nRemainTime; bool bPremiumTrade; // 유료아이템을 통한 프리미엄 거래아이템 char cPayMethodCode; // PayMethodCode (DB데이터) 1-골드, 3-페탈 char cItemPotentialMoveCount; //잠재이전카운트 }; struct SCMyMarketList // SC_TRADE / SC_MYMARKETLIST { int nRetCode; short wSellingCount; // 판매중 short wClosingCount; // 기간마감 short wWeeklyRegisterCount; // 토요일 AM 04:00 를 기준으로 일주일간 등록한 거래 횟수 short wRegisterItemCount; // 등록한 아이템 개수 bool bPremiumTrade; char cMarketCount; TMyMarketInfo MarketInfo[MYMARKETMAX]; }; struct CSMarketRegister // CS_TRADE / CS_MARKET_REGISTER { char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; short wCount; #if defined(PRE_ADD_PETALTRADE) char cPayMethodCode; // PayMethodCode (DB데이터) 1-골드, 3-페탈 #endif int nPrice; char cPeriodIndex; bool bPremiumTrade; }; struct CSMarketBuy // CS_TRADE / CS_MARKET_BUY { int nMarketDBID; #if defined(PRE_ADD_DIRECT_BUY_UPGRADEITEM) bool bMini; #endif // #if defined(PRE_ADD_DIRECT_BUY_UPGRADEITEM) }; struct SCMarketBuyResult // SC_TRADE / SC_MARKET_BUY { int nMarketDBID; #if defined(PRE_ADD_DIRECT_BUY_UPGRADEITEM) bool bMini; #endif // #if defined(PRE_ADD_DIRECT_BUY_UPGRADEITEM) int nRet; }; struct CSMarketDBID // CS_TRADE / CS_MARKET_INTERRUPT, CS_MARKET_CALCULATION { int nMarketDBID; }; struct SCMarketResult // SC_TRADE / SC_MARKET_REGISTER, SC_MARKET_CALCULATION { int nMarketDBID; int nRet; }; struct SCMarketInterrupt // SC_TRADE / SC_MARKET_INTERRUPT { int nMarketDBID; short wRegisterItemCount; // 등록한 아이템 개수 int nRet; }; struct TMarketCalculationInfo { int nMarketDBID; // market table db ID int nItemID; short wCount; // 개수 USHORT wDur; // 내구도 int nRandomSeed; char cLevel; // 레벨 char cPotential; // 잠재력 char cOption; char cSealCount; // 밀봉카운트 int nPrice; // 가격 int nUnitPrice; // 단가 __time64_t tBuyDate; // 판매일자 char cPayMethodCode; // PayMethodCode (DB데이터) 1-골드, 3-페탈 char cPotentialMoveCount; }; struct SCMarketCalculationList // SC_TRADE / SC_MARKET_CALCULATIONLIST { int nRetCode; char cMarketCount; TMarketCalculationInfo MarketInfo[MYMARKETMAX]; }; struct SCMarketCalculationAll // SC_TRADE / SC_MARKET_CALCULATIONALL { int nRet; }; struct SCNotifyMarket // SC_TRADE / SC_MARKET_NOTIFY { int nItemID; // 판매됐을경우 ItemID를 넣어준다 short wCalculationCount; // 정산개수 }; struct SCMarketPetalBalance // SC_TRADE / SC_MARKET_PETALBALANCE { int nRetCode; int nPetalBalance; // 페탈 }; struct TMarketPrice { bool bFlag; // 등록여부 int nAvgPrice; int nMinPrice; int nMaxPrice; BYTE cPayMethodCode; // 1 = 게임머니, 3 = 페탈 }; struct CSMarketPrice // CS_MARKET_PRICE { int nMarketDBID; int nItemID; BYTE cLevel; BYTE cOption; }; struct SCMarketPrice // SC_MARKET_PRICE { int nRetCode; int nMarketDBID; TMarketPrice ItemPrices[2]; // Index 0 : 게임머니 1: 페탈 }; struct CSMarketMiniList // CS_TRADE / CS_MARKETMINILIST { int nItemID; char cPayMethodCode; // 0-혼합, 1-코인, 3-페탈 }; typedef SCMarketList SCMarketMiniList; // SC_TRADE / SC_MARKETMINILIST // 개인거래 struct CSExchangeRequest // CS_TRADE / CS_EXCHANGE_REQUEST // 거래 요청 { UINT nReceiverSessionID; // 거래 할 유저 bool bCancel; // 다시 취소할껀지 }; struct SCExchangeRequest // SC_TRADE / SC_EXCHANGE_REQUEST // 거래 요청 { UINT nSenderSessionID; // 거래 요청한 유저 int nRet; }; struct SCExchangeReject // SC_TRADE / SC_EXCHANGE_REJECT // 거래취소 { UINT nSessionID; int nRetCode; }; struct CSExchangeAccept // CS_TRADE / CS_EXCHANGE_ACCEPT // 거래 수락 { UINT nSenderSessionID; // 거래 요청한 유저 bool bAccept; // 수락 유무 }; struct SCExchangeStart // SC_TRADE / SC_EXCHANGE_START // 거래 시작 { UINT nTargetSessionID; // 상대방 int nRet; }; struct CSExchangeAddItem // CS_TRADE / CS_EXCHANGE_ADDITEM, // 아이템 등록 { BYTE cExchangeIndex; // 거래창 인덱스 BYTE cInvenIndex; short wCount; INT64 biItemSerial; }; struct SCExchangeAddItem // SC_TRADE / SC_EXCHANGE_ADDITEM // 아이템 등록 { UINT nSessionID; BYTE cExchangeIndex; // 거래창 인덱스 TItemInfo ItemInfo; int nRet; }; struct CSExchangeDeleteItem // CS_TRADE / CS_EXCHANGE_DELETEITEM, // 아이템 등록해제 { BYTE cExchangeIndex; // 거래창 index }; struct SCExchangeDeleteItem // SC_TRADE / SC_EXCHANGE_DELETEITEM { UINT nSessionID; // 거래창에 해당하는 유저 BYTE cExchangeIndex; // 거래창 index int nRet; }; struct CSExchangeAddCoin // CS_TRADE / CS_EXCHANGE_ADDCOIN, // 코인 등록 { INT64 nCoin; // 21억을 넘지 않을듯 }; struct SCExchangeAddCoin // SC_TRADE / SC_EXCHANGE_ADDCOIN { UINT nSessionID; // 거래창에 해당하는 유저 INT64 nCoin; // 21억을 넘지 않을듯 int nRet; }; struct CSExchangeConfirm // CS_TRADE / CS_EXCHANGE_CONFIRM { char cType; // eExchangeButton }; struct SCExchangeConfirm // SC_TRADE / SC_EXCHANGE_CONFIRM { char cType; // eExchangeButton UINT nSessionID; }; struct SCExchangeComplete // SC_TRADE / SC_EXCHANGE_COMPLETE { int nRet; }; #if defined(PRE_SPECIALBOX) // specialbox struct TSpecialBoxInfo // CS_TRADE / CS_SPECIALBOX_LIST { int nEventRewardID; BYTE cReceiveTypeCode; // SpecialBox::ReceiveTypeCode BYTE cTargetTypeCode; // SpecialBox::TargetTypeCode BYTE cWorldID; BYTE cTargetClassCode; BYTE cTargetMinLevel; BYTE cTargetMaxLevel; __time64_t tReserveSendDate; __time64_t tExpirationDate; //WCHAR wszEventName[MAILTITLELENMAX]; WCHAR wszSenderName[NAMELENMAX]; WCHAR wszContent[MAILTEXTLENMAX]; INT64 biRewardCoin; bool bSystemSendFlag; char cEventRewardTypeCode; }; struct SCSpecialBoxList // SC_TRADE / SC_SPECIALBOX_LIST { int nRet; char cCount; TSpecialBoxInfo BoxInfo[SpecialBox::Common::ListMax]; }; struct CSSpecialBoxItemList // CS_TRADE / CS_SPECIALBOX_ITEMLIST { int nEventRewardID; }; struct TSpecialBoxItemInfo { bool bCashItem; TItem RewardItem; }; struct SCSpecialBoxItemList // SC_TRADE / SC_SPECIALBOX_ITEMLIST { int nRet; INT64 biRewardCoin; BYTE cCount; TSpecialBoxItemInfo BoxItem[SpecialBox::Common::RewardSelectMax]; }; struct CSReceiveSpecialBoxItem // CS_TRADE / CS_SPECIALBOX_RECEIVEITEM { int nEventRewardID; int nItemID; // 선택보상일때만 세팅 }; struct SCReceiveSpecialBoxItem // SC_TRADE / SC_SPECIALBOX_RECEIVEITEM { int nRet; }; struct SCNotifySpecialBox // SC_TRADE / SC_SPECIALBOX_NOTIFY { int nNotifyCount; bool bNew; }; #endif // #if defined(PRE_SPECIALBOX) //Community //-------------------------------------------------------------------------------------------------- // FRIEND (CS_FRIEND, SC_FRIEND) //-------------------------------------------------------------------------------------------------- //Client -> Server struct CSFriendAddGroup //CS_FRIEND / CS_FRIEND_GROUP_CREATE { BYTE cNameLen; WCHAR wszBuf[FRIEND_GROUP_NAMELENMAX]; }; struct CSFriendDelGourp //CS_FRIEND / CS_FRIEND_GROUP_DELETE { UINT nGroupDBID; }; struct CSFriendGroupUpdate //CS_FRIEND / CS_FRIEND_GROUP_STATEUPDATE { UINT nGroupDBID; BYTE cNameLen; WCHAR wszBuf[FRIEND_GROUP_NAMELENMAX]; }; struct CSFriendAdd //CS_FRIEND / CS_FRIEND_ADD { UINT nGroupDBID; BYTE cNameLen; WCHAR wszBuf[NAMELENMAX]; }; struct CSFriendDelete //CS_FRIEND / CS_FRIEND_DELETE { INT64 biFriendCharacterDBID; }; struct CSFriendUpdate //CS_FRIEND / CS_FRIEND_STATEUPDATE { INT64 biFriendCharacterDBID; UINT nGroupDBID; BYTE cMemoLen; WCHAR wszBuf[FRIEND_MEMO_LEN_MAX]; }; struct CSFriendDetailInfo //CS_FRIEND / CS_FRIEND_INFO { INT64 biFriendCharacterDBID; }; //Server -> Client struct SCFriendGroupList //SC_FRIEND / SC_FRIEND_GROUP_LIST { BYTE cGroupCount; UINT nGroupDBID[FRIEND_GROUP_MAX]; BYTE cGroupNameLen[FRIEND_GROUP_MAX]; WCHAR wszBuf[FRIEND_GROUP_NAMELENMAX * FRIEND_GROUP_MAX]; }; struct TFriendInfo { UINT nGroupDBID; INT64 biFriendCharacterDBID; TCommunityLocation Location; WCHAR wszFriendName[NAMELENMAX]; }; struct SCFriendList //SC_FRIEND / SC_FRIEND_LIST { int nRetCode; BYTE cCount; TFriendInfo Info[FRIEND_MAXCOUNT]; }; struct TFriendLocation { UINT nGroupDBID; INT64 biFriendCharacterDBID; TCommunityLocation Location; }; struct SCFriendLocationList //SC_FRIEND / SC_FRIEND_LOCATIONLIST { BYTE cCount; TFriendLocation FriendLocation[FRIEND_MAXCOUNT]; }; struct SCFriendGroupAdded //SC_FRIEND / SC_FRIEND_GROUP_ADDED { int nRetCode; UINT nGroupDBID; BYTE cNameLen; WCHAR wszBuf[FRIEND_GROUP_NAMELENMAX]; }; struct SCFriendAdded //SC_FRIEND / SC_FRIEND_ADDED { int nRetCode; TFriendInfo Info; }; struct SCFriendGroupDeleted //SC_FRIEND / SC_FRIEND_GROUP_DELETED { UINT nGroupDBID; int nRetCode; }; struct SCFriendGroupUpdated //SC_FRIEND / SC_FRIEND_GROUP_UPDATED { int nRetCode; UINT nGroupDBID; BYTE cNameLen; WCHAR wszBuf[FRIEND_GROUP_NAMELENMAX]; }; struct SCFriendDeleted //SC_FRIEND / SC_FRIEND_ADDED_DELETED { int nRetCode; BYTE cCount; INT64 biFriendCharacterDBID[FRIEND_MAXCOUNT]; }; struct SCFriendUpdated //SC_FRIEND / SC_FRIEND_UPDATED { int nRetCode; UINT nGroupDBID; //이동된 그룹의 디비아이디 BYTE cCount; INT64 biFriendCharacterDBID[FRIEND_MAXCOUNT]; }; struct SCFriendDetailInfo //SC_FRIEND / SC_FRIEND_INFO { INT64 biFriendCharacterDBID; UINT nGroupDBID; USHORT nClass; USHORT nJob; BYTE cCharacterLevel; TCommunityLocation Location; }; struct SCFriendResult //SC_FRIEND / SC_FRIEND_RESULT { int nRet; }; struct SCFriendAddNotice //SC_FRIEND / SC_FRIEND_ADDNOTICE { WCHAR wszName[NAMELENMAX]; }; //-------------------------------------------------------------------------------------------------- // SC_ISOLATE (CS_BLACKLIST_GET, SC_GETGUILD) //-------------------------------------------------------------------------------------------------- // Isolation struct CSIsolateAdd //CS_ISOLATE / CS_ISOLATE_ADD { WCHAR wszIsolateName[NAMELENMAX]; }; struct CSIsoLateDelete //CS_ISOLATE / CS_ISOLATE_DELETE { WCHAR wszIsolateName[NAMELENMAX]; }; struct SCIsolateList //SC_ISOLATE / SC_ISOLATE_LIST { BYTE cCount; BYTE cNameLen[ISOLATELISTMAX]; WCHAR wszIsolateName[NAMELENMAX * ISOLATELISTMAX]; }; struct SCIsolateAdd //SC_ISOLATE / SC_ISOLATE_ADD { WCHAR wszIsolateName[NAMELENMAX]; }; struct SCIsolateDelete //SC_ISOLATE / SC_ISOLATE_DELETE { BYTE cCount; BYTE cNameLen[ISOLATELISTMAX]; WCHAR wszIsolateName[NAMELENMAX * ISOLATELISTMAX]; }; struct SCIsolateResult //SC_ISOLATE / SC_ISOLATE_RESULT { int nRetCode; }; //-------------------------------------------------------------------------------------------------- // GUILD (CS_GUILD, SC_GUILD) //-------------------------------------------------------------------------------------------------- // [CL -> GA/VI] // CS_GUILD / CS_CREATEGUILD // 길드 창설 요청 struct CSCreateGuild { WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 }; // CS_GUILD / CS_INVITEGUILDMEMBREQ // 길드원 초대 요청 struct CSInviteGuildMemberReq { WCHAR wszToCharacterName[NAMELENMAX]; // 초대할 캐릭터 이름 }; // CS_GUILD / CS_INVITEGUILDMEMBACK // 길드원 초대 응답 struct CSInviteGuildMemberAck { TGuildUID GuildUID; // 길드 UID UINT nFromSessionID; // 초대한 세션 ID bool bAccept; // 수락 여부 UINT nFromAccountID; // 초대한 UINT }; // CS_GUILD / CS_EXILEGUILDMEMB // 길드원 추방 요청 struct CSExileGuildMember { UINT nAccountDBID; // 계정 DBID INT64 nCharacterDBID; // 캐릭터 DBID }; // CS_GUILD / CS_CHANGEGUILDINFO // 길드 정보 변경 요청 struct CSChangeGuildInfo { BYTE btGuildUpdate; // 길드 정보 변경 타입 (eGuildUpdateType) int Int1; int Int2; int Int3; int Int4; INT64 Int64; WCHAR Text[GUILDPARAMTEXT_MAX+1]; }; // CS_GUILD / CS_CHANGEGUILDMEMBINFO // 길드원 정보 변경 요청 struct CSChangeGuildMemberInfo { BYTE btGuildMemberUpdate; // 길드원 정보 변경 타입 (eGuildMemberUpdateType) UINT nChgAccountDBID; // 변경할 계정 DBID (내 정보를 수정하는 것이면 0 입력) INT64 nChgCharacterDBID; // 변경할 캐릭터 DBID (내 정보를 수정하는 것이면 0 입력) int Int1; int Int2; INT64 Int64; WCHAR Text[GUILDPARAMTEXT_MAX+1]; }; // CS_GUILD / CS_GETGUILDHISTORYLIST // 길드 히스토리 목록 요청 struct CSGetGuildHistoryList { INT64 biIndex; // 길드 히스토리 목록 인덱스 (0 이면 가장 최근 기록부터 확인 ?) bool bDirection; // 목록 얻을 방향 (0:인덱스 이전 / 1:인덱스 이후) }; // CS_GUILD / CS_GETGUILDINFO // 길드 정보 요청 struct CSGetGuildInfo { bool bNeedMembList; // 길드원 목록도 필요한지 여부 }; // SC_GUILD / SC_CREATEGUILD // 길드 창설 결과 struct SCCreateGuild { UINT nSessionID; // 세션 ID TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) TGuild Info; // 길드 정보 UINT nAccountDBID; // 창설한 사용자 계정 DBID INT64 nCharacterDBID; // 창설한 캐릭터 DBID TP_JOB nJob; // 초대한 캐릭터 전직직업 CHAR cLevel; // 초대한 캐릭터 레벨 TCommunityLocation Location; // 현재 위치 (로그인 여부도 본 멤버의 상태로 체크) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 }; // SC_GUILD / SC_DISMISSGUILD // 길드 해체 결과 struct SCDismissGuild { UINT nSessionID; // 세션 ID int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) }; // SC_GUILD / SC_INVITEGUILDMEMBREQ // 길드원 초대 요청 struct SCInviteGuildMemberReq { TGuildUID GuildUID; // 길드 UID UINT nFromAccountDBID; // 요청한 사용자 계정 DBID UINT nFromSessionID; // 요청한 세션 ID UINT nToAccountDBID; // 초대한 사용자 계정 DBID UINT nToSessionID; // 초대한 세션 ID int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) WCHAR wszFromCharacterName[NAMELENMAX]; // 요청한 캐릭터 이름 (P.S.> 요청한 사용자에게 오류로 송신될 경우 초대한 상대방의 이름이 됨) WCHAR wszGuildName[GUILDNAME_MAX]; // 길드명 }; // SC_GUILD / SC_INVITEGUILDMEMBACK // 길드원 초대 결과 struct SCInviteGuildMemberAck { UINT nToAccountDBID; // 초대한 계정 DBID INT64 nToCharacterDBID; // 초대한 캐릭터 DBID UINT nFromAccountDBID; // 요청한 계정 DBID INT64 nFromCharacterDBID; // 요청한 캐릭터 DBID TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) TP_JOB nJob; // 초대한 캐릭터 전직직업 CHAR cLevel; // 초대한 캐릭터 레벨 TCommunityLocation Location; // 현재 위치 (로그인 여부도 본 멤버의 상태로 체크) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) WCHAR wszToCharacterName[NAMELENMAX]; // 초대한 캐릭터 이름 }; // SC_GUILD / SC_LEAVEGUILDMEMB // 길드원 탈퇴 결과 struct SCLeaveGuildMember { UINT nAccountDBID; // 탈퇴한 계정 DBID INT64 nCharacterDBID; // 탈퇴한 캐릭터 DBID TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) #ifdef PRE_ADD_BEGINNERGUILD bool bGraduateBeginnerGuild; //초보자길드졸업 #endif //#ifdef PRE_ADD_BEGINNERGUILD }; // SC_GUILD / SC_EXILEGUILDMEMB // 길드원 추방 결과 struct SCExileGuildMember { UINT nAccountDBID; // 추방한 계정 DBID INT64 nCharacterDBID; // 추방한 캐릭터 DBID TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) }; // SC_GUILD / SC_CHANGEGUILDINFO // 길드 정보 변경 결과 struct SCChangeGuildInfo { UINT nAccountDBID; // 요청한 계정 DBID (일반적인 경우 중요하지 않고 참조 용도로만 사용) INT64 nCharacterDBID; // 요청한 캐릭터 DBID (일반적인 경우 중요하지 않고 참조 용도로만 사용) BYTE btGuildUpdate; // 길드 정보 변경 타입 (eGuildUpdateType) int Int1; int Int2; int Int3; int Int4; INT64 Int64; WCHAR Text[GUILDHISTORYTEXT_MAX+1]; TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) }; // SC_GUILD / SC_CHANGEGUILDMEMBINFO // 길드원 정보 변경 결과 struct SCChangeGuildMemberInfo { UINT nReqAccountDBID; // 요청한 계정 DBID INT64 nReqCharacterDBID; // 요청한 캐릭터 DBID UINT nChgAccountDBID; // 변경될 계정 DBID (길드장이 길드원 정보를 변경하는 경우에는 요청자와 달라짐) INT64 nChgCharacterDBID; // 변경될 캐릭터 DBID (길드장이 길드원 정보를 변경하는 경우에는 요청자와 달라짐) BYTE btGuildMemberUpdate; // 길드원 정보 변경 타입 (eGuildMemberUpdateType) int Int1; int Int2; INT64 Int64; WCHAR Text[GUILDPARAMTEXT_MAX+1]; TGuildUID GuildUID; // 길드 UID (실패일 경우 무시됨) int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) }; // SC_GUILD / SC_GETGUILDHISTORYLIST // 길드 히스토리 목록 응답 struct SCGetGuildHistoryList { TGuildUID GuildUID; // 길드 UID INT64 biIndex; // 길드 히스토리 목록 인덱스 (0 이면 가장 최근 기록부터 확인 ?) bool bDirection; // 목록 얻을 방향 (0:인덱스 이전 / 1:인덱스 이후) int nCurCount; // 길드 히스토리 최초 인덱스 → 입력 인덱스 까지의 개수 int nTotCount; // 길드 히스토리 전체 개수 int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) int nCount; // 길드 히스토리 목록 개수 (실패일 경우 무시됨) TGuildHistory HistoryList[GUILDHISTORYLIST_MAX]; // 길드 히스토리 목록 (실패일 경우 무시됨) }; // SC_GUILD / SC_GETGUILDINFO // 길드 정보 응답 struct SCGetGuildInfo { int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) TGuild Info; // 길드 정보 (실패일 경우 무시됨) bool bNotRecruitMember; // 길드모집 게시판 가입승인 가능상태 체크( false:가입가능 true:가입불가) }; struct SCGetGuildMember { int iErrNo; // 결과 (NOERROR : 성공 / 그외 : 실패) int nPage; // 길드원 페이지 정보 bool bEndMember; // 마지막인지 체크 int nCount; // 길드원 정보 개수 (실패일 경우 무시됨) TGuildMember MemberList[SENDGUILDMEMBER_MAX]; // 길드원 정보 }; // SC_GUILD / SC_CHANGEGUILDSELFVIEW struct SCChangeGuildSelfView { UINT nSessionID; // 세션 ID TGuildSelfView GuildSelfView; // 길드 시각정보 (개인) }; // SC_GUILD / SC_GUILDMEMBLOGINLIST struct SCGuildMemberLoginList { TGuildUID GuildUID; // 길드 UID int nCount; // 로그인한 길드원 수 INT64 List[GUILDSIZE_MAX]; // 로그인한 길드원 목록 }; struct SCOpenGuildWare // SC_GUILD / SC_OPEN_GUILDWARE { int nError; // 에러값처리 int nResult; // 0:리스트 포함 1:리스트미포함 short wWareSize; // 창고사이즈 USHORT nTakeWareItemCount; // 창고아이템을 꺼낸 횟수 (하루기준) INT64 nWithdrawCoin; // 금일 골드를 꺼낸 금액 INT64 nGuildCoin; // 길드코인 __time64_t VersionDate; // 창고 버젼 BYTE cWareCount; // 웨어아이템카운트 TItemInfo WareList[GUILD_WAREHOUSE_MAX]; // 웨어리스트 }; struct CSGetGuildWareHistory // CS_GUILD / CS_GET_GUILDWARE_HISTORY // 길드창고 사용 히스토리 { int nIndex; // 히스토리 요청 인덱스 }; struct SCGetGuildWareHistory // SC_GUILD / SC_GET_GUILDWARE_HISTORY { int nCurrCount; int nTotalCount; int nErrNo; int nCount; TGuildWareHistory HistoryList[GUILD_WAREHOUSE_HISTORYLIST_MAX];// 히스토리 리스트 }; // SC_GUILD / SC_GUILDMEMBLOGINLIST struct SCChangeGuildName { WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 (일단 길드 창설 이후에는 이름은 변경되지 않는것을 전제로 함) }; struct SCChangeGuildMark // SC_GUILD / SC_CHANGEGUILDMARK { short wMark; short wMarkBG; short wMarkBorder; }; struct SCGuildLevelUp // SC_GUILD / SC_GUILDLEVELUP { int nLevel; }; struct SCUpdateGuildExp // SC_GUILD / SC_UPDATEGUILDEXP { int nError; // 결과 (ERROR_NONE : 성공 / ERROR_GUILD_DAILYLIMIT : 실패) BYTE cPointType; int nPointValue; int nGuildExp; INT64 biCharacterDBID; int nMissionID; }; // SC_GUILD_GET_REWARDITEM struct SCGetGuildRewardItem { TGuildRewardItem GuildRewardItem[GUILDREWARDEFFECT_TYPE_CNT]; }; struct CSBuyGuildRewardItem { int nItemID; }; struct SCBuyGuildRewardItem { int iRet; int nItemID; }; struct SCAddGUildRewardItem { TGuildRewardItem GuildRewardItem; }; struct SCExtendGuildSize { short nGuildSize; }; struct CSPlayerGuildInfo { int nSessionID; }; struct SCPlayerGuildInfo { UINT nSessionID; // 상대방 세션아이디 WCHAR wszMasterName[NAMELENMAX]; // 길드마스터 캐릭터 이름 WCHAR wszGuildName[GUILDNAME_MAX]; // 길드명 int nGuildLevel; // 길드 레벨 int nMemberSize; int nGuildSize; TGuildRewardItem GuildRewardItem[GUILDREWARDEFFECT_TYPE_CNT]; }; //SC_GUILD / SC_EXTEND_GUILDWARESIZE struct SCExtendGuildWare { short wTotalSize; }; // SC_GUILD / SC_ENROLL_GUILDWAR struct SCEnrollGuildWar { int iErrorNo; short wScheduleID; BYTE cTeamColorCode; }; // SC_GUILD / SC_CHANGE_WAREVENT struct SCGuildWarEvent { short wScheduleID; // 차수 char cEventStep; // 이벤트 스텝: GUILDWAR_STEP_NONE ~ GUILDWAR_STEP_END char cEventType; // GUILDWAR_EVENT_START(시작) / GUILDWAR_EVENT_END(끝) }; // SC_GUILD / SC_GUILDWAR_FESTIVAL_POINT struct SCGuildWarFestivalPoint { INT64 biGuildWarFestivalPoint; }; // SC_GUILD / SC_GUILDWAR_TRIAL_RESULT_OPEN struct SGuildWarRankingInfo { short wRanking; // 길드 순위 WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 WCHAR wszGuildMasterName[NAMELENMAX]; // 길드장 이름 short wCurGuildUserCount; // 현재 길드 인원 short wMaxGuildUserCount; // 최대 길드 인원 int nTotalPoint; // 획득한 총점 UINT nGuildDBID; // 길드 DBID }; struct SGuildWarMissionGuildRankingInfo //각 부문별 길드 순위 { WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 WCHAR wszGuildMasterName[NAMELENMAX]; // 길드장 이름 int nTotalPoint; // 획득한 총점 }; struct SMyGuildWarMissionGuildRankingInfo // 우리 길드의 부문별 순위 { short wRanking; // 부문별 순위 int nTotalPoint; // 획득한 총점 }; struct SGuildWarMissionRankingInfo { WCHAR wszCharName[NAMELENMAX]; // 1위 이름 WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 int nTotalPoint; // 획득한 총점 }; struct SMyGuildWarMissionRankingInfo { short wRanking; // 순위 int nTotalPoint; // 획득한 총점 }; struct SGuildWarDailyAward { WCHAR wszCharName[NAMELENMAX]; // 수상자 캐릭명 TGuildUID nGuildUID; // 수상한 길드의 UID; }; struct SCGuildWarTrialResult { // 길드 축제 결과 int nBluePoint; // 최종 청팀 점수 int nRedPoint; // 최종 홍팀 점수 bool bGuildWar; // 길드전 참여 여부(요게 false면 밑에 개인,우리길드 정보는 패킷에 포함되지 않습니다.) bool bReward; // 보상받기 여부 // 본선 진출 길드 SGuildWarRankingInfo sGuildWarRankingInfo[GUILDWAR_FINALS_TEAM_MAX]; // 부문별 길드 순위(전체) SGuildWarMissionGuildRankingInfo sGuildWarMissionGuildRankingInfo[GUILDWAR_RANKINGTYPE_MAX]; // 전체 길드 순위 // 부문별 개인 순위(전체) SGuildWarMissionRankingInfo sGuildWarMissionRankingInfo[GUILDWAR_RANKINGTYPE_MAX]; // 개인별 순위 // 특별상 // 토벌상과 같은건 개인순위의 넘을 그대로 보여주시면 됩니다. SGuildWarDailyAward sGuildWarDailyAward[GUILDWAR_DAILY_AWARD_MAX]; // 일자별 시상 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 내정보, 우리길드 정보들(만약 길드가 없거나 길드전에 참가하지 않는넘이면 이 정보는 보내지 않습니다.) int nFestivalPoint; // 기본 점수 int nFestivalPointAdd; // 수상을 통한 +된 점수 // 우리 길드 순위 정보 (전체순위) SMyGuildWarMissionGuildRankingInfo sMyGuildWarRankingInfo; // 부문별 길드 순위(우리길드) SMyGuildWarMissionGuildRankingInfo sMyGuildWarMissionGuildRankingInfo[GUILDWAR_RANKINGTYPE_MAX]; // 우리 길드 순위 // 부문별 내 순위 SMyGuildWarMissionRankingInfo sMyGuildWarMissionRaningInfo[GUILDWAR_RANKINGTYPE_MAX]; // 내 순위 }; // SC_GUILD / SC_GUILDWAR_STATUS_OPEN struct SCGuildWarStatus { int nBluePoint; // 청팀 점수 int nRedPoint; // 홍팀 점수 int nMyPoint; // 내 점수 int nMyGuildPoint; // 길드 현재 점수 int nRankingCount; // 랭킹 카운트..요넘 숫자만큼 날라 갑니다. SGuildWarRankingInfo sGuildWarPointTrialRanking[GUILDWAR_TRIAL_POINT_TEAM_MAX]; }; // CS_GUILD / CS_GUILDWAR_VOTE struct CSGuildWarVote { TGuildUID GuildUID; // 투표할 길드 UID (월드 ID + 길드 DBID) }; // SC_GUILD / SC_GUILDWAR_VOTE struct SCGuildWarVote { int nRetCode; // 투표 결과 int nAddFestivalPoint; // 얻은 축제 포인트 }; // SC_GUILD / SC_GUILDWAR_TOURNAMENT_INFO_OPEN struct SGuildTournamentInfo { TGuildUID GuildUID; // 길드 UID (월드 ID + 길드 DBID) WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 char cMatchTypeCode; // 마지막 차수 1=결승, 2=4강, 3=8강, 4=16강 bool bWin; // 이겼는지 졌는지 여부 short wGuildMark; // 길드마크 문양 short wGuildMarkBG; // 길드마크 배경 short wGuildMarkBorder; // 길드마크 테두리 }; struct SCGuildTournamentInfo { SGuildTournamentInfo TournamentInfo[GUILDWAR_FINALS_TEAM_MAX]; char cMatchTypeCode; // 현재 진행중인 차수 1=결승, 2=4강, 3=8강, 4=16강 __time64_t tStartTime; // 이게 0이면 현재 진행중이고 값이 있으면 이때 시작하는 것입니다. bool bPopularityVote; // 인기투표 활성화, 비활성화 }; // SC_GUILD / SC_GUILDWAR_VOTE_TOP struct SCGuildWarVoteTop { WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 int nVoteCount; // 총 득표한 수 }; // SC_GUILD / SC_GUILDWAR_COMPENSATION struct SCGuildWarCompensation { int nRetCode; // 보상 받기 결과 }; // SC_GUILD / SC_GUILDWAR_PRE_WIN struct SCGuildWarPreWin { bool bPreWin; // true면 우리길드가 우승길드임, false면 우승길드 해제.. }; // CS_GUILD / CS_GUILDWAR_WIN_SKILL struct CSGuildWarWinSkill { int nSkillID; // 시전 스킬ID }; // SC_GUILD / SC_GUILDWAR_WIN_SKILL struct SCGuildWarWinSkill { int nRetCode; DWORD dwCoolTime; // 남은 쿨타임 }; // SC_GUILD / SC_GUILDWAR_USER_WINSKILL #if defined(_GAMESERVER) || defined(_VILLAGESERVER) || defined(_CLIENT) struct SCGuildWarUserWinSkill { TGuildUID GuildUID; // 스킬을 쓴넘의 GuildUID EtVector3 vPos; // 스킬을 쓴넘의 좌표. int nSkillID; // 스킬ID }; #endif //#if defined(_GAMESERVER) || defined(_VILLAGESERVER) || defined(_CLIENT) // SC_GUILD / SC_GUILDWAR_EVENT_TIME struct SGuildWarTime { __time64_t tBeginTime; __time64_t tEndTime; }; struct SCGuildWarEventTime { bool bFinalProgress; // 전체 길드전 스케쥴 SGuildWarTime tGuildWarTime[GUILDWAR_STEP_END-1]; // eGuildWarStepType에서 -1씩 해주세요.. // 본선 진행 차수 SGuildWarTime tFinalPartTime[GUILDWAR_FINALPART_MAX-1]; //eGuildFinalPart에서 -1씩 해주세요.. }; // SC_GUILD / SC_GUILDWAR_TOURNAMENT_WIN struct SCGuildWarTournamentWin { // 승리 차수 char cMatchTypeCode; // 현재 진행중인 차수 1=결승, 2=4강, 3=8강, 4=16강 // 승리한 길드명 WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 }; //-------------------------------------------------------------------------------------------------- // PVP (CS_PVP, SC_PVP) //-------------------------------------------------------------------------------------------------- //blondy //클라이언트에서 쓸 컨테이너 struct sRoomInfo { BYTE cGameMode; // PvPCommon::GameMode BYTE cVSMode; // PvPCommon::VSMode WCHAR RoomName[PvPCommon::TxtMax::RoomName]; BYTE cRoomState; // 방상태 BYTE cPlayerNum; //현재인원 BYTE cMaxPlayerNum; //최대인원 UINT nMapIndex; //맵인덱스 UINT nPVPIndex; //방인덱스 bool bInGameJoin; //난입가능 BYTE cMinLevel; BYTE cMaxLevel; UINT uiObjective; //오브젝티브 bool bDropItem; //드랍아이템 허용 int nEventID; BYTE cShowHP; #ifdef PRE_ADD_COLOSSEUM_BEGINNER BYTE cRoomType; //PvPCommon::RoomType #endif // #ifdef PRE_ADD_COLOSSEUM_BEGINNER UINT nGuildDBID[PvPCommon::TeamIndex::Max]; #ifdef PRE_MOD_PVPOBSERVER bool bExtendObserver; #endif // PRE_MOD_PVPOBSERVER #ifdef PRE_WORLDCOMBINE_PVP int nWorldPvPRoomType; #endif // PRE_WORLDCOMBINE_PVP #ifdef PRE_PVP_GAMBLEROOM BYTE cGambleType; int nGamblePrice; #endif // PRE_PVP_GAMBLEROOM }; //blondyend struct CSPVP_CREATEROOM { UINT uiMapIndex; UINT uiGameModeTableID; UINT uiSelectWinCondition; UINT uiSelectPlayTimeSec; BYTE cMaxUser; BYTE cMinUser; BYTE cRoomNameLen; BYTE cRoomPWLen; BYTE cMinLevel; BYTE cMaxLevel; USHORT unRoomOptionBit; // PvPCommon::RoomOption Bit UINT uiEventItemID; #ifdef PRE_ADD_COLOSSEUM_BEGINNER BYTE cRoomType; //PvPCommon::RoomType #endif //#ifdef PRE_ADD_COLOSSEUM_BEGINNER #ifdef PRE_MOD_PVPOBSERVER bool bExtendObserver; #endif //#ifdef PRE_MOD_PVPOBSERVER #if defined( PRE_WORLDCOMBINE_PVP ) int nWorldPvPRoomType; #endif WCHAR wszBuf[PvPCommon::TxtMax::RoomName + PvPCommon::TxtMax::RoomPW]; }; struct SCPVP_CREATEROOM { int nRetCode; UINT uiPvPIndex; CSPVP_CREATEROOM sCSPVP_CREATEROOM; }; struct CSPVP_MODIFYROOM { CSPVP_CREATEROOM sCSPVP_CREATEROOM; }; struct SCPVP_MODIFYROOM { int nRetCode; CSPVP_MODIFYROOM sCSPVP_MODIFYROOM; }; struct SCPVP_LEAVEROOM { short nRetCode; UINT uiLeaveUserSessionID; PvPCommon::LeaveType::eLeaveType eType; }; struct CSPVP_CHANGECAPTAIN { PvPCommon::CaptainType::eCode Type; UINT uiNewCaptainSessionID; }; struct CSPVP_ROOMLIST { UINT uiPage; BYTE cRoomSortType; // PvPCopmmon::RoomSortType 참고 BYTE cIsAscend; // 오름차순:1 내림차순:0 UINT uiSortData; // cRoomSortType 에 따라 필요한 부가 정보 #ifdef PRE_ADD_COLOSSEUM_BEGINNER BYTE cChannelType; #endif //#ifdef PRE_ADD_COLOSSEUM_BEGINNER }; struct SCPVP_ROOMLIST { short nRetCode; BYTE cRoomCount; UINT uiMaxPage; PvPCommon::RoomInfoList RoomInfoList; }; struct CSPVP_WAITUSERLIST { PvPCommon::WaitUserList::SortType::eSortType SortType; bool bIsAscend; // 오름차순:true 내림차순:false USHORT unPage; // ZeroBase }; struct SCPVP_WAITUSERLIST { short nRetCode; BYTE cUserCount; USHORT unMaxPage; PvPCommon::WaitUserList::Repository Repository; }; struct CSPVP_JOINROOM { UINT uiPvPIndex; bool bIsObserver; // 관전하기 UINT nGuildDBID; //길드전 참전일 경우 BYTE cRoomPWLen; WCHAR wszRoomPW[PvPCommon::TxtMax::RoomPW]; }; struct SCPVP_JOINROOM { short nRetCode; PvPCommon::RoomInfo RoomInfo; // 룸정보 BYTE cUserCount; // 유저수 PvPCommon::UserInfoList UserInfoList; }; struct SCPVP_JOINUSER { PvPCommon::UserInfo UserInfo; }; struct CSPVP_READY { BYTE cReady; }; struct CSPVP_START { USHORT unCheck; // PvPCommon::StartCheat 참고 }; struct CSPVP_CHANGETEAM { USHORT usTeam; // PvPCommon::Team }; struct SCPVP_CHANGETEAM { short nRetCode; UINT uiSessionID; USHORT usTeam; // PvPCommon::Team char cTeamSlotIndex; }; struct SCPVP_USERSTATE { UINT uiSessionID; UINT uiUserState; // PvPCommon::UserState }; struct SCPVP_START { short nRetCode; }; struct SCPVP_STARTMSG { BYTE cSec; }; struct SCPVP_ROOMSTATE { UINT uiRoomState; }; struct SCPVP_MODE_STARTTICK { UINT uiStartTick; UINT uiCurTick; }; struct SCPVP_FINISH_PVPMODE { UINT uiWinTeam; // PvPCommon::Team 참고 PvPCommon::FinishReason::eCode Reason; // PvPCommon::FinishReason 참고 UINT uiATeamScore; UINT uiBTeamScore; #if defined(PRE_ADD_PVP_TOURNAMENT) UINT uiWinSessionID; #endif }; struct SCPVP_FINISH_PVPROUND { UINT uiWinTeam; // PvPCommon::Team 참고 PvPCommon::FinishReason::eCode Reason; // PvPCommon::FinishReason 참고 UINT uiATeamScore; // RoundMode는 GameModeScore를 서버에서 알려준다. UINT uiBTeamScore; #if defined(PRE_ADD_PVP_TOURNAMENT) UINT uiWinSessionID; char cTournamentStep; // PvPCommon::Tournament::eStep #endif }; struct SCPVP_SUCCESSBREAKINTO { UINT uiSessionID; }; struct SCPVP_ADDPOINT { UINT uiSessionID; UINT uiScoreType; UINT uiAddPoint; }; struct SCPVP_SELECTCAPTAIN { UINT uiSessionID; }; struct TZombieInfo { UINT uiSessionID; int nMonsterMutationTableID; bool bZombie; bool bRemoveStateBlow; int iScale; }; struct SCPVP_SELECTZOMBIE { BYTE cCount; TZombieInfo Zombies[PARTYMAX]; }; struct SCPVP_LEVEL { UINT uiSessionID; BYTE cLevel; }; struct SCPVP_ROOMINFO { UINT uiIndex; UINT uiWinCondition; UINT uiGameModeTableID; UINT uiPlayTimeSec; BYTE cMaxUser; bool bIsGuildWar; //이게 트루면 나가기만 활성화 나머지는 전부 막힘 #if defined( PRE_PVP_GAMBLEROOM ) BYTE cGambleType; int nGamblePrice; #endif }; struct TPvPUserScore { UINT uiSessionID; UINT uiKillScore; UINT uiAssistScore; UINT uiSupportScore; UINT uiInstantSupportScore; UINT uiKillClassScore[PvPCommon::Common::MaxClass]; UINT uiKilledClassScore[PvPCommon::Common::MaxClass]; }; struct TPvPUserDieCount { UINT uiSessionID; UINT uiDieCount; }; struct TPvPUserCount { UINT uiSessionID; UINT uiKillCount; UINT uiDieCount; UINT uiContinuousKillCount; }; struct SCPVP_MODE_SCORE { USHORT unATeamScore; USHORT unBTeamScore; BYTE cScoreCount; BYTE cCount; TPvPUserScore sPvPUserScore[PvPCommon::Common::MaxPlayer]; TPvPUserCount sPvPUserCount[PvPCommon::Common::MaxPlayer]; }; struct TPvPCaptainKillCount { UINT uiSessionID; UINT uiCaptainKillCount; }; struct SCPVP_CAPTAINKILL_COUNT { BYTE cCount; TPvPCaptainKillCount sCaptainKillCount[PvPCommon::Common::MaxPlayer]; }; struct TPvPZombieKillCount { UINT uiSessionID; UINT uiZombieKillCount; }; struct SCPVP_ZOMBIEKILL_COUNT { BYTE cCount; TPvPZombieKillCount sZombieKillCount[PvPCommon::Common::MaxPlayer]; }; struct TPvPOccupationScoreInfo { UINT nSessionID; USHORT nTryAcquireCount; USHORT nAcquireCount; BYTE cBossKillCount; USHORT nStealAquireCount; }; struct TPvPOccupationTeamScoreInfo { USHORT nTeamID; int nTeamKillScore; int nTeamAcquireScore; int nTeamStealAcquireScore; TPvPOccupationTeamScoreInfo() : nTeamID( ) , nTeamKillScore( 0 ) , nTeamAcquireScore( 0 ) , nTeamStealAcquireScore( 0 ) {} }; struct TPvPOccupationScore { TPvPOccupationTeamScoreInfo TeamScoreInfo[PvPCommon::TeamIndex::Max]; BYTE cCount; TPvPOccupationScoreInfo Info[PvPCommon::Common::MaxPlayer]; }; #if defined(_GAMESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct SCPVP_RESPAWN_POINT { char szName[32]; int iBasePreferPoint; int iPoint; USHORT unTeam; EtVector3 Position; }; #endif struct TPvPUserXPScore { UINT uiSessionID; union { UINT uiAddXPScore; int iAddLadderGradePoint; }; union { UINT uiResultXPScore; UINT uiResultLadderGradePoint; }; UINT uiGainMedalCount; #if defined(PRE_MOD_PVP_LADDER_XP) UINT uiAddLadderXPScore; //래더게임에서 제공되는 경험치 #endif }; struct SCPVP_XPSCORE { char cCount; TPvPUserXPScore sXPScoreArr[PvPCommon::Common::MaxPlayer]; }; #if defined(PRE_ADD_RACING_MODE) struct TPvPUserRapTime { UINT uiSessionID; DWORD dwLapTime; //Tick }; //SC_PVP_RACING_RAPTIME struct SCPVP_RACING_RAPTIME { char cCount; TPvPUserRapTime sRapTimeArr[PvPCommon::Common::MaxPlayer]; }; //SC_PVP_RACING_FIRST_END struct SCPVP_RACING_FIRST_END { UINT uiSessionID; // 1위한 넘의 SessionID }; #endif // #if defined(PRE_ADD_RACING_MODE) struct CSPVP_BAN { UINT uiSessionID; PvPCommon::BanType::eBanType eType; }; struct CSPVP_CHANGECHANNEL { BYTE cType; //PvPCommon::RoomType; }; namespace LadderSystem { struct CS_ENTER_CHANNEL { MatchType::eCode MatchType; }; struct SC_ENTER_CHANNEL { int iRet; MatchType::eCode MatchType; }; struct SC_LEAVE_CHANNEL { int iRet; }; struct SC_NOTIFY_LEAVEUSER { INT64 biCharDBID; Reason::eCode Reason; }; struct LadderUserInfo { INT64 biCharDBID; WCHAR wszCharName[NAMELENMAX]; int iGradePoint; BYTE cJob; }; struct SC_NOTIFY_JOINUSER { LadderUserInfo sUserInfo; }; struct SC_NOTIFY_LEADER { WCHAR wszLeaderName[NAMELENMAX]; }; struct SC_NOTIFY_ROOMSTATE { RoomState::eCode State; RoomStateReason::eCode Reason; }; struct CS_LADDER_MATCHING { bool bIsCancel; }; struct SC_LADDER_MATCHING { int iRet; bool bIsCancel; }; struct SC_NOTIFY_GAMEMODE_TABLEID { int iTableID; }; struct CS_PLAYING_ROOMLIST { UINT uiReqPage; }; struct SC_PLAYING_ROOMLIST { int iRet; USHORT unMaxPage; USHORT unNameCount; BYTE cJob[Common::RoomListPerPage*MatchType::MaxMatchType*2]; WCHAR wszCharName[Common::RoomListPerPage*MatchType::MaxMatchType*2][NAMELENMAX]; }; struct CS_OBSERVER { WCHAR wszCharName[NAMELENMAX]; }; struct SC_OBSERVER { int iRet; }; struct SC_SCOREINFO { TPvPLadderScoreInfo Data; }; struct SC_SCOREINFO_BYJOB { int iRet; TPvPLadderScoreInfoByJob Data; }; struct SC_MATCHING_AVGSEC { int iSec; // -1 인경우 알수없음 }; struct SC_LADDERPOINT_REFRESH { int iPoint; }; struct CS_INVITE { WCHAR wszCharName[NAMELENMAX]; }; struct SC_INVITE { int iRet; WCHAR wszCharName[NAMELENMAX]; }; struct CS_INVITE_CONFIRM { bool bAccept; WCHAR wszCharName[NAMELENMAX]; }; struct SC_INVITE_CONFIRM_REQ { WCHAR wszCharName[NAMELENMAX]; LadderSystem::MatchType::eCode MatchType; int iCurUserCount; int iAvgGradePoint; }; struct SC_INVITE_CONFIRM { int iRet; WCHAR wszCharName[NAMELENMAX]; }; struct SC_REFRESH_USERINFO { BYTE cCount; LadderUserInfo sUserInfoArr[MatchType::MaxMatchType]; }; struct CS_KICKOUT { INT64 biCharacterDBID; }; struct SC_KICKOUT { int iRet; }; }; struct SCPVP_FATIGUE_REWARD // SC_FATIGUE_REWARD { int nGainExp; int nGainMedal; }; struct CSPVP_FATIGUE_OPTION // CS_FATIGUE_OPTION { bool bOption; // On,Off }; struct SCPVP_GHOUL_SCORES // SC_PVP_GHOULSCORES { TPvPGhoulScores GhoulScores; }; struct SCPVP_HOLYWATER_KILLCOUNT //SC_PVP_HOLYWATER_KILLCOUNT { UINT nSessionID; // 죽은 대상 UINT nKillerSessionID;// 죽인 대상 }; struct SCPVP_CHANGE_CHANNEL { BYTE cType; int nRetCode; }; #if defined(PRE_ADD_QUICK_PVP) // CS_PVP / CS_QUICKPVP_INVITE // 결투신청 요청 struct CSQuickPvPInvite { UINT nReceiverSessionID; // 초대할 유저 }; // CS_PVP / CS_QUICKPVP_RESULT // 결투신청 응답 struct CSQuickPvPResult { bool bAccept; // 수락 여부 UINT nSenderSessionID; // 초대한 유저 }; // SC_PVP / SC_QUICKPVP_INVITE // 결투신청 요청 struct SCQuickPvPInvite { UINT nSenderSessionID; // 초대한 유저 }; // SC_PVP / SC_QUICKPVP_RESULT // 결투신청 응답 struct SCQuickPvPResult { int nResult; // 신청 결과 }; #endif //#if defined(PRE_ADD_QUICK_PVP) #if defined(PRE_ADD_PVP_VILLAGE_ACCESS) // SC_PVP / SC_PVP_LIST_OPEN_UI struct SCPvPListOpenUI { int nResult; // UI오픈 결과 int nLimitLevel; // 제한 레벨 }; #endif struct SCPVP_ALLKILL_SHOW_SELECTPLAYER { bool bSelectPlayer; }; struct CSPVP_ALLKILL_SELECTPLAYER { UINT uiSelectPlayerSessionID; }; struct SCPVP_ALLKILL_SELECTPLAYER { UINT uiSelectPlayerSessionID; }; struct SCPVP_ALLKILL_GROUPCAPTAIN { UINT uiGroupCaptainSessionID; }; struct SCPVP_ALLKILL_ACTIVEPLAYER { UINT uiActivePlayerSessionID; }; struct SCPVP_ALLKILL_BATTLEPLAYER { UINT uiSessionIDArr[2]; }; struct SCPVP_ALLKILL_CONTINUOUSWIN { UINT uiSessionID; UINT uiCount; }; struct SCPVP_ALLKILL_FINISHDETAILREASON { PvPCommon::FinishDetailReason::eCode Reason; }; struct CSPvPTeamSwapMemberIndex //CS_SWAPMEMBERINDEX { BYTE cCount; TSwapMemberIndex Index[PARTYMAX]; }; struct CSPvPGuildWarChangeMemberGrade //CS_GUILDWAR_CHANGEMEMBER_GRADE { bool bAsign; //true면 임명 false면 해임 USHORT nType; //PvPCommon::UserState UINT nSessionID; //Target SessionID }; #if defined(_GAMESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct CSOrderConcentrate //CS_CONCENTRATE_ORDER { EtVector3 vPosition; }; struct SCConcentrateOrder //SC_CONCENTRATE_ORDER { UINT nSessionID; EtVector3 vPosition; }; #endif //#if defined(_GAMESERVER) || (defined(_WINDOWS) && !defined(_LAUNCHER)) struct CSPvPTryAcquirePoint //CS_PVP / CS_TRYCAPTURE { int nAreaID; }; struct CSPvPTryAcquireSKill //CS_PVP / CS_TRYACQUIRE_SKILL { int nSkillID; int nLevel; char cSlotIndex; }; struct CSPvPUseSkill //CS_PVP / CS_USESKILL { int nSkillID; }; struct CSPvPSwapSkillIndex //CS_PVP / CS_SWAPSKILLINDEX { char cFromIndex; char cToIndex; }; struct SCPvPOccupationModeState //SC_PVP / SC_PVP_OCCUPATION_MODESTATE { int nState; //PvPCommon::OccupationSystemState 참조 }; struct SCPvPOccupationState //SC_PVP / SC_PVP_OCCUPATIONSTATE { BYTE cCount; PvPCommon::OccupationStateInfo Info[PARTYMAX]; }; struct SCPvPOccupationTeamState //SC_PVP / SC_PVP_OCCUPATION_TEAMSTATE { int nTeam; int nResource; //현재자원 int nResourceSum; //획득총량 }; struct SCPvPOccupationSkillState { PvPCommon::OccupationSkillSlotInfo Info; }; #if defined(PRE_ADD_REVENGE) // CS_PVP / SC_PVP_SET_REVENGE_TARGET struct SCPvPSetRevengeTarget { UINT uiSessionID; UINT uiRevengeTargetSessionID; Revenge::TargetReason::eCode eReason; }; // CS_PVP / CS_PVP_SUCCESS_REVENGE struct SCPvPSuccessRevenge { UINT uiSessionID; UINT uiRevengeTargetSessionID; }; #endif #if defined(PRE_ADD_PVP_TOURNAMENT) // CS_PVP / CS_PVP_SWAP_TOURNAMENT_INDEX struct CSPvPSwapTournamentIndex { char cSourceIndex; char cDestIndex; }; // SC_PVP / SC_PVP_SWAP_TOURNAMENT_INDEX struct SCPvPSwapTournamentIndex { int nRetCode; char cSourceIndex; char cDestIndex; }; // SC_PVP / SC_PVP_TOURNAMENT_MATCHLIST struct TPvPTournamentUserInfo { char cTournamentStep; // 토너먼트 스텝(몇강?) // PvPCommon::Tournament::eStep bool bWin; // 이겼는지 졌는지. BYTE cJob; // 직업 UINT uiSessionID; WCHAR wszCharName[NAMELENMAX]; }; struct SCPvPTournamentMatchList { int nCount; #if defined( PRE_PVP_GAMBLEROOM ) BYTE cGambleType; int nGamblePrice; #endif TPvPTournamentUserInfo sTournamentUserInfo[PvPCommon::Common::PvPTournamentUserMax]; }; // SC_PVP / SC_PVP_TOURNAMENT_DEFAULTWIN struct SCPvPTournamentDefaultWin { char cTournamentStep; // 토너먼트 스텝(몇강?) // PvPCommon::Tournament::eStep UINT uiWinSessionID; // 부전승으로 이긴넘의 SessionID }; // SC_PVP / SC_PVP_TOURNAMENT_IDLE_TICK struct SCPvPTournamentIdleTick { UINT uiIdleTick; UINT uiCurTick; }; // SC_PVP / SC_PVP_TOURNAMENT_TOP4 struct SCPvPTournamentTop4 { UINT uiSessionID[4]; // 1~3(3위 2명)위까지 토너먼트 순위 uiSeesionID가 없는 순위는 나간 아이임.. #if defined( PRE_PVP_GAMBLEROOM ) BYTE cGambleType; int nGamblePrice[4]; #endif }; #endif // SC //-------------------------------------------------------------------------------------------------- // Trigger (CS_TRIGGER, SC_TRIGGER) //-------------------------------------------------------------------------------------------------- struct SCTriggerCallAction { short wSectorIndex; short wObjectIndex; UINT nRandomSeed; }; struct SCChangeMyBGM { int nBGM; int nFadeDelta; UINT nSessionID; }; struct SCRadioImage { int nFileID; UINT nSessionID; DWORD nTime; }; struct SCFileTableBGMOff { UINT nSessionID; }; struct SCForceEnableRide { UINT nSessionID; bool bForceEnableRide; }; //MISSION //-------------------------------------------------------------------------------------------------- // MISSION (CS_MISSION, SC_MISSION) //-------------------------------------------------------------------------------------------------- struct SCMissionList { int nMissionScore; char cGain[MISSIONMAX_BITSIZE]; char cAchieve[MISSIONMAX_BITSIZE]; short wLastUpdate[LASTMISSIONACHIEVEMAX]; }; struct SCMissionGain { int nArrayIndex; }; struct SCMissionAchieve { int nArrayIndex; }; struct SCMissionEventPopUp { int nItemID; }; struct SCMissionHelpAlarm { int nItemID; }; struct SCDailyMissionList { char cType; int nCount; TDailyMission Mission[DAILYMISSIONMAX > WEEKLYMISSIONMAX ? DAILYMISSIONMAX : WEEKLYMISSIONMAX]; }; struct SCWeeklyMissionList { int nCount; TDailyMission Mission[WEEKLYMISSIONMAX]; }; struct SCDailyMissionCount { char cType; int nArrayIndex; int nCount; }; struct SCDailyMissionAchieve { char cType; int nArrayIndex; bool bSecret; }; struct SCDailyMissionAlarm { char cType; }; struct SCConnectingTime { int nItemID; // TimeEventTable의 ItemID int nDuration; // 이벤트 시작시간으로부터 진행된 시간(초) }; #if defined(PRE_ADD_ACTIVEMISSION) struct SCActiveMissionGain //SC_MISSION / SC_GAIN_ACTIVE_MISSION { int nIndex; }; struct SCActiveMissionAchieve //SC_MISSION / SC_ACHIEVE_ACTIVE_MISSION { int nIndex; }; #endif #if defined(PRE_ADD_CHAT_MISSION) struct CSChatMission //CS_MISSION / CS_CHAT_MISSION { int nUIStringMid; }; #endif //APPELLATION //-------------------------------------------------------------------------------------------------- // Appellation (CS_APPELLATION, SC_APPELLATION) //-------------------------------------------------------------------------------------------------- struct SCAppellationList { char cGain[APPELLATIONMAX_BITSIZE]; }; struct SCAppellationGain { int nArrayIndex; }; struct SCSelectAppellation { int nArrayIndex; int nCoverArrayIndex; }; struct SCChangeAppellation { UINT nSessionID; int nArrayIndex; int nCoverArrayIndex; }; struct CSSelectAppellation { int nArrayIndex; int nCoverArrayIndex; }; struct SCPeriodAppellationTIme { BYTE cPeriodCount; TAppellationTime AppellationTime[PERIODAPPELLATIONMAX]; }; struct CSCollectionBook // CS_COLLECTIONBOOK { int nCollectionID; }; //-------------------------------------------------------------------------------------------------- // GameOption (CS_GAMEOPTION, SC_GAMEOPTION) //-------------------------------------------------------------------------------------------------- struct CSGameOptionUpdate //CS_GAMEOPTION_UPDATEOPTION { TGameOptions Option; }; struct CSGameOptionReqComm // CS_GAMEOPTION / CS_GAMEOPTION_REQCOMMOPTION { UINT nSessionID; }; struct SCGameOptionCommOption // SC_GAMEOPTION / SC_GAMEOPTION_USERCOMMOPTION { UINT nSessionID; char cCommunityOption[13]; TPARTYID PartyID; }; struct SCGameOptionRefreshNotifier { DNNotifier::Data data[DNNotifier::RegisterCount::Total]; }; struct CSGameOptionQuestNotifier // CS_GAMEOPTION / CS_GAMEOPTION_QUEST_NOTIFIER { DNNotifier::Data data[DNNotifier::RegisterCount::TotalQuest]; }; struct CSGameOptionMissionNotifier // CS_GAMEOPTION / CS_GAMEOPTION_MISSION_NOTIFIER { DNNotifier::Data data[DNNotifier::RegisterCount::TotalMission]; }; struct SCGameOptionGetProfile { TProfile sProfile; }; struct CSGameOptionSetProfile { TProfile sProfile; }; struct SCGameOptionDisplayProfile // 다른 유저에게 프로필 내용을 보여줄때 사용한다. (채팅방입장, 파티입장 등...) { int nSessionID; // 프로필 주인 TProfile sProfile; // 프로필 내용 }; struct SCGameOptionSelectKeySetting { bool bIsDefault; TKeySetting sKeySetting; }; struct CSGameOptionUpdateKeySetting { bool bIsDefault; TKeySetting sKeySetting; }; struct SCGameOptionSelectPadSetting { bool bIsDefault; TPadSetting sPadSetting; }; struct CSGameOptionUpdatePadSetting { bool bIsDefault; TPadSetting sPadSetting; }; struct SCGameOptionNotifySecondAuthInfo { bool bIsSetSecondAuthPW; // 2차 인증 비밀번호 설정 여부 bool bIsSetSecondAuthLock; // 2차 인증 계정 Lock 여부 __time64_t tSecondAuthResetDate; #ifdef PRE_ADD_23829 bool bSecondAuthPassFlag; #endif #ifdef PRE_ADD_IGNORESECONDAUTH_EKEYECARD bool bCompletlySecondAuthPassFlag; #endif }; struct CSGameOptionUpdateSecondAuthPassword { int nOldSeed; int nOldValue[SecondAuth::Common::PWMaxLength]; int nNewSeed; int nNewValue[SecondAuth::Common::PWMaxLength]; }; struct SCGameOptionUpdateSecondAuthPassword { int iRet; BYTE cFailCount; }; struct CSGameOptionUpdateSecondAuthLock { bool bIsLock; int nSeed; int nValue[SecondAuth::Common::PWMaxLength]; }; struct SCGameOptionUpdateSecondAuthLock { int iRet; BYTE cFailCount; }; struct CSGameOptionValidateSecondAuth { int nSeed; int nValue[SecondAuth::Common::PWMaxLength]; int nAuthCheckType; }; struct SCGameOptionValidateSecondAuth { int nRet; int nAuthCheckType; BYTE cFailCount; }; struct CSGameOptionInitSecondAuth { int nSeed; int nValue[SecondAuth::Common::PWMaxLength]; }; struct SCGameOptionInitSecondAuth { int iRet; BYTE cFailCount; }; //-------------------------------------------------------------------------------------------------- // Radio (CS_RADIO, SC_RADIO) //-------------------------------------------------------------------------------------------------- struct CSUseRadio //CS_RADIO / CS_USERADIO { USHORT nID; }; struct SCUseRadio //SC_RADIO / SC_USERADIO { UINT nSessionID; USHORT nID; }; //-------------------------------------------------------------------------------------------------- // Gesture (CS_GESTURE, SC_GESTURE) //-------------------------------------------------------------------------------------------------- struct SCGestureList { BYTE cGestureCount; USHORT nGestureID[GESTUREMAX]; }; struct SCGestureAdd { USHORT nGestureID; }; struct CSUseGesture { USHORT nGestureID; }; struct SCUseGesture { USHORT nGestureID; }; //-------------------------------------------------------------------------------------------------- // VoiceChat (CS_VOICECHAT, SC_VOICECHAT) //-------------------------------------------------------------------------------------------------- struct TTalkingInfo { UINT nSessionID; BYTE cTalking; //none zero is talking. 0-255 volume }; struct SCTalkingInfo //CS_VOICECHAT / SC_TALKINGINFO { BYTE cCount; TTalkingInfo Talking[PARTYMAX]; }; struct CSVoiceChatAvailable //CS_VOICECHAT / CS_VOICEAVAILABLE { BYTE cAvailable; }; struct CSVoiceMute //CS_VOICECHAT / CS_VOICEMUTE { UINT nSessionID; BYTE cMute; //0 mute, 1 unmute }; struct CSVoiceComplaintReq //CS_VOICECHAT / CS_VOICECOMPLAINTREQ { UINT nSessionID; char szCategory[32]; char szSubject[32]; char szMsg[32]; }; struct SCVoiceChatInfo // SC_VOICECHAT / SC_VOICECHATINFO { char szVoiceChatIp[IPLENMAX]; USHORT wControlPort; USHORT wAudioPort; UINT nAccountDBID; BOOL bInit; USHORT wManagedID; }; struct TVoiceMemberInfo { UINT nSessionID; BYTE cVoiceAvailable; }; struct SCVoiceMemberInfo // SC_VOICECHAT / SC_VOICEMEMBERINFO { UINT nVoiceMutedList[PARTYCOUNTMAX]; BYTE cCount; TVoiceMemberInfo Info[PARTYMAX]; }; //-------------------------------------------------------------------------------------------------- // Restraint (SC_RESTRAINT) //-------------------------------------------------------------------------------------------------- struct SCRestraintAdd // SC_RESTRAINT / SC_RESTRAINTADD { TRestraint Restraint; }; struct SCRestraintDel // SC_RESTRAINT / SC_RESTRAINTDEL { UINT nRestraintKey; }; struct SCRestraintRet // SC_RESTRAINT / SC_RESTRAINTRETCODE { short nRestraintRet; }; struct SCRestraintList // SC_RESTRAINT / SC_RESTRAINTLIST { BYTE cCount; TRestraint restraint[RESTRAINTMAX]; }; //-------------------------------------------------------------------------------------------------- // CashShop (CS_CASHSHOP, SC_CASHSHOP) //-------------------------------------------------------------------------------------------------- struct SCCashShopOpen // SC_CASHSHOP / SC_SHOPOPEN, // 샵 열기 { #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) UINT nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; WCHAR wszAccountName[IDLENMAX]; }; struct SCCashShopClose // SC_CASHSHOP / SC_SHOPCLOSE, // 샵 닫기 { int nRet; }; struct SCCashShopBalanceInquiry // SC_CASHSHOP / SC_BALANCEINQUIRY { int nRet; int nPetal; int nCash; #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeed; #endif // PRE_ADD_NEW_MONEY_SEED #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) }; struct TCashShopInfo { char cSlotIndex; // 카트인덱스 int nItemSN; int nItemID; // Commodity에 ItemID01-05사이 아이템아이디값 char nOptionIndex; }; typedef TWishItemInfo TCashShopPackageInfo; struct TPaymentItem { int nItemSN; int nItemID; char cItemOption; }; struct TPaymentItemInfo { INT64 biDBID; // (biPurchaseOrderDetailID) __time64_t tPaymentDate; // 결제(구매)일 TPaymentItem ItemInfo; // 아이템 정보 }; struct TPaymentPackageItemInfo { INT64 biDBID; // (biPurchaseOrderDetailID) int nPackageSN; // 패키지 씨리얼 __time64_t tPaymentDate; // 결제(구매)일 TPaymentItem ItemInfoList[PACKAGEITEMMAX]; // 가변적으로 처리해야 하는데..가변에 가변은.. }; struct TPaymentItemInfoEx // 서버만 쓰는 구조체 { UINT uiOrderNo; // Nexon int nPrice; // 상품 가격(환불용) TPaymentItemInfo PaymentItemInfo; }; struct TPaymentPackageItemInfoEx // 서버만 쓰는 구조체 { UINT uiOrderNo; int nPrice; // 상품 가격(환불용) TPaymentPackageItemInfo PaymentPackageItemInfo; }; struct CSCashShopBuy // CS_CASHSHOP / CS_BUY, // 구매하기 { char cType; // 구매 카트 타입 (3,7: PREVIEWCARTLISTMAX, 나머지: CARTLISTMAX, 50 + eInstantCashShopBuyType: 간편결재) #if defined(PRE_ADD_CASH_REFUND) bool bMoveCashInven; // 캐쉬인벤으로 바로 옮기기 플래그 #endif char cPaymentRules; // Cash::PaymentRules #if defined(PRE_ADD_SALE_COUPON) int nSaleCouponSN; // Sale 쿠폰 CashCommodity SN; INT64 biSaleCouponSerial; // Sale 쿠폰을 사용한 구매일경우(무조건 한개만 구매가 되야함) #endif // #if defined(PRE_ADD_SALE_COUPON) char cCount; TCashShopInfo BuyList[PREVIEWCARTLISTMAX]; }; struct SCCashShopBuy // SC_CASHSHOP / SC_BUY, // 구매하기 { #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) UINT nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; char cType; // (3,7: PREVIEWCARTLISTMAX, 나머지: CARTLISTMAX) #if defined(PRE_ADD_CASH_REFUND) TPaymentItemInfo ItemList[PREVIEWCARTLISTMAX]; //그냥 채워서 갑니다.biDBID가 0이면 무시하시면 될듯. #endif char cCount; TCashShopInfo BuyList[PREVIEWCARTLISTMAX]; }; struct CSCashShopPackageBuy // CS_CASHSHOP / CS_PACKAGEBUY { int nPackageSN; #if defined(PRE_ADD_CASH_REFUND) bool bMoveCashInven; // 캐쉬인벤으로 바로 옮기기 플래그 #endif char cPaymentRules; // Cash::PaymentRules #if defined(PRE_ADD_SALE_COUPON) int nSaleCouponSN; INT64 biSaleCouponSerial; #endif char cCount; TCashShopPackageInfo BuyList[PACKAGEITEMMAX]; }; struct SCCashShopPackageBuy // SC_CASHSHOP / SC_PACKAGEBUY { #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) int nPackageSN; int nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; #if defined(PRE_ADD_CASH_REFUND) TPaymentPackageItemInfo PackageItem; // 패키지는 무조건 하나. #endif }; struct CSCashShopCheckReceiver // CS_CASHSHOP / CS_CHECKRECEIVER, // 받는이 체크 (선물할때 필요) { WCHAR wszToCharacterName[NAMELENMAX]; // 받는이 }; struct SCCashShopCheckReceiver // SC_CASHSHOP / SC_CHECKRECEIVER, // 받는이 체크 (선물할때 필요) { BYTE cLevel; BYTE cJob; int nRet; }; struct CSCashShopGift // CS_CASHSHOP / CS_GIFT, // 선물하기, 조르기 { WCHAR wszToCharacterName[NAMELENMAX]; // 받는이 WCHAR wszMessage[GIFTMESSAGEMAX]; // 메모 #if defined( _US ) || defined( PRE_ADD_NEW_MONEY_SEED ) char cPaymentRules; // Cash::PaymentRules #endif // _US or PRE_ADD_NEW_MONEY_SEED #if defined(PRE_ADD_CADGE_CASH) int nMailDBID; #endif // #if defined(PRE_ADD_CADGE_CASH) char cType; // (3,7: PREVIEWCARTLISTMAX, 나머지: CARTLISTMAX) char cCount; TCashShopInfo GiftList[PREVIEWCARTLISTMAX]; }; struct SCCashShopGift // SC_CASHSHOP / SC_GIFT, // 선물하기 { #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) int nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; char cType; // (3,7: PREVIEWCARTLISTMAX, 나머지: CARTLISTMAX) char cCount; TCashShopInfo GiftList[PREVIEWCARTLISTMAX]; }; struct CSCashShopPackageGift // CS_CASHSHOP / CS_PACKAGEGIFT { WCHAR wszToCharacterName[NAMELENMAX]; // 받는이 WCHAR wszMessage[GIFTMESSAGEMAX]; // 메모 #if defined( _US ) || defined( PRE_ADD_NEW_MONEY_SEED ) char cPaymentRules; // Cash::PaymentRules #endif // _US or PRE_ADD_NEW_MONEY_SEED #if defined(PRE_ADD_CADGE_CASH) int nMailDBID; // 우편에서 조르기 누를때만 값 세팅 (캐쉬샵에서 누를땐 0) #endif // #if defined(PRE_ADD_CADGE_CASH) int nPackageSN; char cCount; TCashShopPackageInfo PackageGiftList[PACKAGEITEMMAX]; }; struct SCCashShopPackageGift // SC_CASHSHOP / SC_PACKAGEGIFT { #if defined(_US) int nNxAPrepaid; int nNxACredit; #endif // #if defined(_US) int nPackageSN; int nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; }; typedef CSCashShopPackageGift CSCashShopCadge; // CS_CASHSHOP / CS_CADGE struct SCCashShopCadge // SC_CASHSHOP / SC_CADGE, // 조르기 { int nRet; }; // CS_CASHSHOP / CS_GIFTLIST, // 선물함 (받은선물) 요청 struct TGiftInfo { char cPayMethodCode; // 선물 종류 (db:PayMethodCode) INT64 nGiftDBID; // (db:PurchaseOrderID) WCHAR wszSenderName[MAILNAMELENMAX]; // 보낸사람 int nItemSN; int nItemID; // 패키지일 경우엔 이값 무시(?) char cItemOption; __time64_t tOrderDate; WCHAR wszMessage[GIFTMESSAGEMAX]; // 메모 __time64_t tGiftExpireDate; // 선물함 저장기간 #if defined(PRE_ADD_GIFT_RETURN) bool bGiftReturn; // 선물 반송여부 #endif bool bNewFlag; int nPaidCashAmount; }; struct SCCashShopGiftList // SC_CASHSHOP / SC_GIFTLIST, // 선물함 (받은선물) { int nRet; char cCount; TGiftInfo GiftInfo[GIFTBOXLISTMAX]; }; struct TReceiveGiftData { INT64 nGiftDBID; char cPayMethodCode; // 선물 종류 (db:PayMethodCode) WCHAR wszEmoticonTitle[MAILTITLELENMAX]; WCHAR wszReplyMessage[GIFTMESSAGEMAX]; // 메모 }; struct CSCashShopReceiveGift // CS_CASHSHOP / CS_RECEIVEGIFT { TReceiveGiftData GiftData; }; struct CSCashShopReceiveGiftAll // CS_CASHSHOP / CS_RECEIVEGIFTALL { char cCount; TReceiveGiftData GiftData[GIFTPAGEMAX]; }; struct SCCashShopReceiveGift // SC_CASHSHOP / SC_RECEIVEGIFT { int nRet; INT64 nGiftDBID; }; struct SCCashShopReceiveGiftAll // SC_CASHSHOP / SC_RECEIVEGIFTALL { int nRet; char cCount; INT64 nGiftDBID[GIFTPAGEMAX]; }; #if defined(PRE_ADD_GIFT_RETURN) struct CSCashShopGiftReturn // CS_CASHSHOP / CS_GIFTRETURN { INT64 nGiftDBID; }; struct SCCashShopGiftReturn // SC_CASHSHOP / SC_GIFTRETURN { INT64 nGiftDBID; int nRet; }; #endif // SC_CASHSHOP / SC_COUPON struct CSCashShopCoupon // CS_CASHSHOP / CS_COUPON { WCHAR wszCoupon[COUPONMAX]; }; struct SCCashShopCoupon // CS_CASHSHOP / SC_COUPON { int nRet; }; struct SCNotifyGift // SC_CASHSHOP / SC_NOTIFYGIFT { bool bNew; // 새 선물인지 아닌지 (깜박깜박) int nGiftCount; }; struct CSVIPBuy // CS_CASHSHOP / CS_VIPBUY { int nItemSN; }; struct SCVIPBuy // CS_CASHSHOP / SC_VIPBUY, // vip 정보날려주기 { UINT nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; int nVIPPoint; // 포인트 __time64_t tVIPExpirationDate; // 만료일 bool bAutoPay; // 자동결제 유무 }; struct CSVIPGift // CS_CASHSHOP / CS_VIPGIFT { WCHAR wszToCharacterName[NAMELENMAX]; // 받는이 WCHAR wszMessage[GIFTMESSAGEMAX]; // 메모 int nItemSN; }; struct SCVIPGift // CS_CASHSHOP / SC_VIPGIFT, // vip 정보날려주기 { UINT nCashAmount; // 캐시금액 int nReserveAmount; // 적립금 #ifdef PRE_ADD_NEW_MONEY_SEED INT64 nSeedAmount; // 귀속화폐 시드 #endif // PRE_ADD_NEW_MONEY_SEED int nRet; }; struct SCVIPInfo // SC_CASHSHOP / SC_VIPINFO { bool bVIP; int nVIPPoint; // 포인트 __time64_t tVIPExpirationDate; // 만료일 bool bAutoPay; // 자동결제 유무 }; struct SCSaleAbortList // SC_CASHSHOP / SC_SALEABORTLIST { BYTE cCount; int nAbortList[SALEABORTLISTMAX]; }; #if defined(PRE_ADD_CASH_REFUND) struct SCPaymentList // SC_CASHSHOP / SC_PAYMENT_LIST { int nTotalPaymentCount; // 전체 결재인벤 갯수(일반) BYTE cInvenCount; // 지금 날라가는 인벤 갯수 TPaymentItemInfo ItemList[CASHINVENTORYMAX]; }; struct SCPaymentPackageList // SC_CASHSHOP / SC_PAYMENT_PACKAGELIST { int nTotalPaymentCount; // 전체 결재인벤 갯수(패키지) BYTE cInvenCount; // 지금 날라가는 인벤 갯수 TPaymentPackageItemInfo ItemList[CASHINVENTORYMAX]; // 여기서 버리는 바이트 좀 생길듯.. }; struct CSMoveCashInven // CS_CASHSHOP / CS_MOVE_CASHINVEN { BYTE cItemType; // 1..일반, 2..패키지 INT64 biDBID; // (biPurchaseOrderDetailID) }; struct SCMoveCashInven // SC_CASHSHOP / SC_MOVE_CASHINVEN { INT64 biDBID; // (biPurchaseOrderDetailID) int nRet; // 결과 int nReserveAmount; // 페탈 적립금 #if defined( PRE_ADD_NEW_MONEY_SEED ) INT64 nSeedAmount; // 시드 #endif }; struct CSCashRefund // CS_CASHSHOP / CS_CASH_REFUND { BYTE cItemType; // 1..일반, 2..패키지 INT64 biDBID; // (biPurchaseOrderDetailID) }; struct SCCashRefund // SC_CASHSHOP / SC_CASH_REFUND { INT64 biDBID; // (biPurchaseOrderDetailID) int nRet; // 결과 int nCashAmount; // 성공일시에 현재 캐쉬 }; #endif //#if defined(PRE_ADD_CASH_REFUND) struct SCCashShopChargeTime { __time64_t tTime; }; #ifdef PRE_ADD_LIMITED_CASHITEM struct CSQuantityLimitedItem { }; struct SCQuantityLimitedItem { BYTE cIsLast; BYTE cCount; LimitedCashItem::TLimitedQuantityCashItem Limited[LimitedCashItem::Common::DefaultPacketCount]; }; struct SCChangedQuantityLimitedItem { BYTE cCount; LimitedCashItem::TChangedLimitedQuantity Changed[LimitedCashItem::Common::DefaultPacketCount]; }; #endif //#ifdef PRE_ADD_LIMITED_CASHITEM struct CSDarkLairRankBoard { int iMapIndex; BYTE cPartyUserCount; }; struct SCDarkLairRankBoard { int iRet; #if defined(PRE_ADD_CHALLENGE_DARKLAIR) int iMapIndex; #endif TDLRankHistoryPartyInfo sBestHistory; TDLRankHistoryPartyInfo sHistoryTop[DarkLair::Rank::SelectRankBoardTop]; }; struct CSPvPLadderRankBoard { LadderSystem::MatchType::eCode MatchType; }; struct SCPvPLadderRankBoard { int iRet; TPvPLadderRanking MyRanking; TPvPLadderRanking Top[LadderSystem::Common::RankingTop]; }; struct CSWindowState { short sWinState; }; #if defined(PRE_ADD_PVP_RANKING) struct TPvPRanking { int iLevel; BYTE cJobCode; BYTE cPvPLevel; UINT uiExp; int iPvPRank; float fPvPRaito; INT64 biRank; int iChangedRank; int iKill; int iDeath; WCHAR wszGuildName[GUILDNAME_MAX]; WCHAR wszCharName[NAMELENMAX]; }; struct TPvPRankingDetail : public TPvPRanking { INT64 biClassRank; int iChangedClassRank; INT64 biSubClassRank; int iChangedSubClassRank; }; struct TPvPLadderRanking2 { int iLevel; BYTE cJobCode; BYTE cPvPLevel; UINT uiExp; int iPvPRank; float fPvPRaito; INT64 biRank; int iChangedRank; int iWin; int iLose; int iDraw; int iPvPLadderGradePoint; WCHAR wszGuildName[GUILDNAME_MAX]; WCHAR wszCharName[NAMELENMAX]; }; struct TPvPLadderRankingDetail : public TPvPLadderRanking2 { INT64 biClassRank; int iChangedClassRank; INT64 biSubClassRank; int iChangedSubClassRank; }; // struct CSPvPRankBoard //CS_PVP_RANK_BOARD // { // }; struct SCPvPRankBoard //SC_PVP_RANK_BOARD { int iRet; TPvPRankingDetail MyRanking; }; struct CSPvPRankInfo //CS_PVP_RANK_INFO { WCHAR wszCharName[NAMELENMAX]; }; struct SCPvPRankInfo //SC_PVP_RANK_INFO { int iRet; TPvPRankingDetail RankingInfo; }; struct CSPvPRankList //CS_PVP_RANK_LIST { int iPage; BYTE cClassCode; BYTE cSubClassCode; WCHAR wszGuildName[GUILDNAME_MAX]; }; struct SCPvPRankList //SC_PVP_RANK_LIST { int iRet; BYTE cRankingCount; INT64 nRankingTotalCount; TPvPRanking RankingInfo[RankingSystem::RANKINGMAX]; }; //Ladder Ranking struct CSPvPLadderRankBoard2 //CS_PVP_LADDER_RANK_BOARD { LadderSystem::MatchType::eCode MatchType; }; struct SCPvPLadderRankBoard2 //SC_PVP_LADDER_RANK_BOARD { int iRet; LadderSystem::MatchType::eCode MatchType; TPvPLadderRankingDetail MyRanking; }; struct CSPvPLadderRankInfo //CS_PVP_LADDER_RANK_INFO { LadderSystem::MatchType::eCode MatchType; WCHAR wszCharName[NAMELENMAX]; }; struct SCPvPLadderRankInfo //SC_PVP_LADDER_RANK_INFO { int iRet; LadderSystem::MatchType::eCode MatchType; TPvPLadderRankingDetail RankingInfo; }; struct CSPvPLadderRankList //CS_PVP_LADDER_RANK_LIST { int iPage; BYTE cClassCode; BYTE cSubClassCode; LadderSystem::MatchType::eCode MatchType; WCHAR wszGuildName[GUILDNAME_MAX]; }; struct SCPvPLadderRankList //SC_PVP_LADDER_RANK_LIST { int iRet; BYTE cRankingCount; INT64 nRankingTotalCount; LadderSystem::MatchType::eCode MatchType; TPvPLadderRanking2 RankingInfo[RankingSystem::RANKINGMAX]; }; #endif #if defined( PRE_ADD_GAMEQUIT_REWARD ) struct SCGameQuitRewardCheckRes //SC_ETC / SC_GAMEQUIT_REWARDCHECK_RES / 유저(클라이언트)가 받을 보상 종류 전송 { GameQuitReward::RewardType::eType eRewardType; // 접속 종료시 보상 종류 }; struct CSGameQuitRewardReq //CS_ETC / CS_GAMEQUIT_REWARD_REQ / 보상 요청 패킷 { GameQuitReward::RewardType::eType eRewardType; // SCGameQuitRewardCheckRes에서 보내준 보상 종류(타입) }; struct SCGameQuitRewardRes //SC_ETC / SC_GAMEQUIT_REWARD_REQ / 보상 받기 결과 { int nRet; // ERROR_NONE = 보상 받기 성공 / 에러인 경우 ERROR_ITEM_NOTFOUD(dnt 테이블에서 아이템 찾는데 실패한경우, 보상 받을 수 없는 유저인 경우) }; #endif // #if defined( PRE_ADD_GAMEQUIT_REWARD ) //-------------------------------------------------------------------------------------------------- // Farm //-------------------------------------------------------------------------------------------------- struct TFarmItemPartial { int iFarmDBID; int iFarmMapID; #if defined( PRE_ADD_FARM_DOWNSCALE ) int iAttr; #elif defined( PRE_ADD_VIP_FARM ) Farm::Attr::eType Attr; #endif // #if defined( PRE_ADD_FARM_DOWNSCALE ) WCHAR wszFarmName[Farm::Max::FARMNAMELEN]; //혹시나해서 일단 넣어놓음 }; struct TFarmItemFromDB:public TFarmItemPartial // DB에서 얻어온 농장자체정보 { int iFarmMaxUser; bool bEnableFlag; bool bStartActivate; //오픈시시작여부 }; struct TFarmItem:public TFarmItemFromDB // 농장자체정보 { int iFarmCurUser; bool bActivate; //사용여부 }; struct TFarmAttachItem { int iItemID; short iCount; }; struct TFarmField { short nFieldIndex; INT64 biCharacterDBID; WCHAR wszCharName[NAMELENMAX]; BYTE cLevel; BYTE cJob; int iItemID; int iElapsedTimeSec; TFarmAttachItem AttachItems[Farm::Max::ATTACHITEM_KIND]; }; struct TFarmFieldForCharacter { short nFieldIndex; int iItemID; int iElapsedTimeSec; __time64_t tUpdateDate; TFarmAttachItem AttachItems[Farm::Max::ATTACHITEM_KIND]; }; struct TFarmFieldPartial { int iFarmDBID; short nFieldIndex; int iItemID; int iElapsedTimeSec; TFarmAttachItem AttachItems[Farm::Max::ATTACHITEM_KIND]; }; //S-C #if defined( PRE_ADD_VIP_FARM ) struct SCFarmStart { int iRet; }; struct SCEffectItemInfo { int iItemID; __time64_t tExpireDate; }; #endif // #if defined( PRE_ADD_VIP_FARM ) struct SCChangeOwnerName { WCHAR wszOriginName[NAMELENMAX]; WCHAR wszCharacterName[NAMELENMAX]; }; struct SCFarmInfo //SC_FARMINFO { bool bRefreshGate; BYTE cCount; TFarmItem Farms[Farm::Max::FARMCOUNT]; }; struct SCFarmPlantedInfo //SC_FARMPLANTEDINFO { BYTE cCount; TFarmFieldPartial FarmFields[Farm::Max::FIELDCOUNT_PERCHARACTER]; }; struct CSFarmEnter { int iFarmDBID; int iMapID; }; struct SCFarmBeginAreaState { int iAreaIndex; Farm::AreaState::eState State; }; struct TFarmAttachItemSerial { INT64 biSerial; BYTE cCount; #if defined( PRE_ADD_TOTAL_LEVEL_SKILL ) bool bRemoveItem; // 삭제해야할 아이템인지 체크(스킬로 인한 아이템인 경우는 지울 아이템이 없기 떄문에 체크 #endif }; struct CSFarmPlant { int iAreaIndex; Farm::ActionType::eType ActionType; BYTE cSeedInvenIndex; BYTE cCount; TFarmAttachItemSerial AttachItems[Farm::Max::PLANTING_ATTACHITEM]; }; struct SCFarmPlant { int iRet; Farm::ActionType::eType ActionType; int iAreaIndex; int iItemID; int iAttachItemID; }; struct CSFarmHarvest { int iAreaIndex; Farm::ActionType::eType ActionType; BYTE cNeedItemInvenIndex; // 수확시 필요한 아이템 있는 인벤토리 인덱스 }; struct SCFarmHarvest { int iRet; int iAreaIndex; Farm::ActionType::eType ActionType; int iResultItemIDs[Farm::Max::HARVESTDEPOT_COUNT]; }; struct CSFarmAddWater { int iAreaIndex; Farm::ActionType::eType ActionType; BYTE cInvenType; BYTE cWaterItemInvenIndex; // 물이 있는 인벤토리 인덱스 INT64 biWaterItemItemSerial; }; struct SCFarmAddWater { int iRet; int iAreaIndex; Farm::ActionType::eType ActionType; }; struct TFarmAreaInfo { BYTE iAreaIndex; int iRandSeed; Farm::AreaState::eState State; int iElapsedTick; int iItemID; WCHAR wszCharName[NAMELENMAX]; BYTE cAttachCount; TFarmAttachItem AttachItems[Farm::Max::ATTACHITEM_KIND]; }; struct SCAreaInfo { TFarmAreaInfo AreaInfo; }; struct SCAreaInfoList { USHORT unCount; TFarmAreaInfo AreaInfos[Farm::Max::FIELDCOUNT]; }; struct SCFarmWareHouseList { int iRet; BYTE cCount; TFarmWareHouseItem Items[Farm::Max::HARVESTDEPOT_COUNT]; }; struct CSFarmTakeWareHouseItem { INT64 biUniqueID; }; struct SCFarmTakeWareHouseItem { int iRet; INT64 biUniqueID; }; struct SCFarmFieldCountInfo { int iCount; }; struct SCFarmWareHouseItemCount { int iCount; }; struct SCFarmAddWaterAnotherUser { WCHAR wszCharName[NAMELENMAX]; }; #ifdef PRE_ADD_CASHFISHINGITEM struct TFishingToolInfo { int nFishingRodInvenIdx; //사용할 낚시대의 인벤인덱스 (낚시대가 복수개가 생기고 포인트에 낚시대 제약등이 생길경우 커버하기위함) int nFishingBaitInvenIdx; //사용할 미끼의 인벤인덱스 INT64 biCashRodSerial; INT64 biCashBaitSerial; }; #endif //#ifdef PRE_ADD_CASHFISHINGITEM struct CSFishingReady //CS_READYFISHING { int nFishingAreaIdx; #ifdef PRE_ADD_CASHFISHINGITEM TFishingToolInfo ToolInfo; #else //#ifdef PRE_ADD_CASHFISHINGITEM int nFishingRodInvenIdx; //사용할 낚시대의 인벤인덱스 (낚시대가 복수개가 생기고 포인트에 낚시대 제약등이 생길경우 커버하기위함) int nFishingBaitInvenIdx; //사용할 미끼의 인벤인덱스 #endif //#ifdef PRE_ADD_CASHFISHINGITEM }; struct SCFishingReady //SC_READYFISHING { int nRetCode; }; struct CSCastBait //CS_CASTBAIT { Fishing::Cast::eCast eCastType; //Fishing::Cast참조 #ifdef PRE_ADD_CASHFISHINGITEM TFishingToolInfo ToolInfo; #else //#ifdef PRE_ADD_CASHFISHINGITEM int nFishingRodInvenIdx; //사용할 낚시대의 인벤인덱스 (낚시대가 복수개가 생기고 포인트에 낚시대 제약등이 생길경우 커버하기위함) int nFishingBaitInvenIdx; //사용할 미끼의 인벤인덱스 #endif //#ifdef PRE_ADD_CASHFISHINGITEM }; struct CSPullingRod //CS_PULLINGROD { Fishing::Control::eControl ePullingControl; }; struct SCCastBait //SC_CASTBAITRESULT { int nRetCode; }; struct SCStopFishing //SC_STOPFISHINGRESULT { int nRetCode; }; struct SCFishingPattern //SC_FISHINGPATTERN { int nPatternID; #ifdef PRE_ADD_CASHFISHINGITEM int nFishingAutoMaxTime; #endif //#ifdef PRE_ADD_CASHFISHINGITEM }; struct SCFishingReward //SC_FISHINGREWARD { UINT nSessionID; int nRewardItemID; int nRetCode; //-1이면 획득실패, 0이면 성공 nRewardItemID가 획득한 아이디 0보다 큰값이면 에러 }; struct SCFishingSync //SC_FISHINGSYNC { int nReduceTick; int nFishingGauge; }; struct SCFishingPlayer //SC_FISHINGPLAYER { UINT nSessionID; #ifdef PRE_ADD_CASHFISHINGITEM int nRodItemID; #endif //#ifdef PRE_ADD_CASHFISHINGITEM }; struct SCStartDragonNest { eDragonNestType Type; int nRebirthCount; }; //-------------------------------------------------------------------------------------------------- // ChatRoom //-------------------------------------------------------------------------------------------------- struct TChatRoomView // 채팅방 시각정보 { public: TChatRoomView() { Reset(); } void Set(const TChatRoomView& pChatRoomView) { Set(pChatRoomView.m_nChatRoomID, pChatRoomView.m_wszChatRoomName, pChatRoomView.m_nChatRoomType, pChatRoomView.m_bHasPassword, pChatRoomView.m_wszChatRoomPRLine1, pChatRoomView.m_wszChatRoomPRLine2, pChatRoomView.m_wszChatRoomPRLine3 ); } void Set( UINT nChatRoomID, const LPCWSTR lpwszChatRoomName, BYTE nChatRoomType, bool bHasPassword, const LPCWSTR lpwszChatRoomPRLine1, LPCWSTR lpwszChatRoomPRLine2, LPCWSTR lpwszChatRoomPRLine3 ) { m_nChatRoomID = nChatRoomID; ::wcsncpy_s(m_wszChatRoomName, _countof(m_wszChatRoomName), lpwszChatRoomName, _countof(m_wszChatRoomName)); m_nChatRoomType = nChatRoomType; m_bHasPassword = bHasPassword; ::wcsncpy_s(m_wszChatRoomPRLine1, _countof(m_wszChatRoomPRLine1), lpwszChatRoomPRLine1, _countof(m_wszChatRoomPRLine1)); ::wcsncpy_s(m_wszChatRoomPRLine2, _countof(m_wszChatRoomPRLine2), lpwszChatRoomPRLine2, _countof(m_wszChatRoomPRLine2)); ::wcsncpy_s(m_wszChatRoomPRLine3, _countof(m_wszChatRoomPRLine3), lpwszChatRoomPRLine3, _countof(m_wszChatRoomPRLine3)); } void Reset() { m_nChatRoomID = 0; m_wszChatRoomName[0] = L'\0'; m_nChatRoomType = 0; m_bHasPassword = false; m_wszChatRoomPRLine1[0] = L'\0'; m_wszChatRoomPRLine2[0] = L'\0'; m_wszChatRoomPRLine3[0] = L'\0'; } public: UINT m_nChatRoomID; WCHAR m_wszChatRoomName[CHATROOMNAME_MAX + 1]; WCHAR m_wszChatRoomPRLine1[CHATROOMNAME_MAX + 1]; WCHAR m_wszChatRoomPRLine2[CHATROOMNAME_MAX + 1]; WCHAR m_wszChatRoomPRLine3[CHATROOMNAME_MAX + 1]; BYTE m_nChatRoomType; bool m_bHasPassword; }; struct CSCreateChatRoom { WCHAR wszName[CHATROOMNAME_MAX + 1]; WCHAR wszPassword[CHATROOMPASSWORDMAX + 1]; BYTE nRoomType; USHORT nRoomAllow; WCHAR PRLine1[CHATROOMNAME_MAX + 1]; WCHAR PRLine2[CHATROOMNAME_MAX + 1]; WCHAR PRLine3[CHATROOMNAME_MAX + 1]; }; struct CSChatRoomEnterRoom { UINT nChatRoomID; WCHAR wszPassword[CHATROOMPASSWORDMAX + 1]; // 패스워드 }; struct CSChatRoomChangeRoomOption { TChatRoomView ChatRoomView; WCHAR wszPassword[CHATROOMPASSWORDMAX + 1]; USHORT nRoomAllow; }; struct CSChatRoomKickUser { int nKickUserSessionID; // 쫒아낼 캐릭터의 SessionID int nKickReason; // CHATROOMLEAVE_KICKED or CHATROOMLEAVE_FOREVERKICKED }; //---------------------------------------------------------------------------------- struct SCCreateChatRoom { int nRet; TChatRoomView ChatRoomView; }; struct SCChatRoomEnterRoom { int nRet; int LeaderSID; int UserSessionIDs[CHATROOMMAX]; // 참여자 리스트 }; struct SCChatRoomChangeRoomOption { int nRet; TChatRoomView ChatRoomView; }; struct SCChatRoomEnterUser { UINT nChatRoomID; BYTE cChatRoomType; int nUserSessionID; }; struct SCChatRoomKickUser { int nRet; int nKickedSessionID; }; struct SCChatRoomLeaveUser { int nUserSessionID; BYTE nLeaveReason; }; struct SCChatRoomView { int nSessionID; // 채팅방을 가지고 있는 캐릭터 TChatRoomView ChatRoomView; // 채팅방 간략 정보 - ChatRoomID가 0이면 방이 삭제되는 경우이다. }; struct SCROOM_SYNC_CHATROOMINFO { UINT nLeaderID; // 채팅방을 가지고 있는 캐릭터 TChatRoomView ChatRoomView; // 채팅방 간략 정보 - ChatRoomID가 0이면 방이 삭제되는 경우이다. int nCount; UINT nMembers[CHATROOMMAX]; }; #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM ) struct SCReputationList { BYTE cCount; TNpcReputation ReputationArr[30]; }; struct SCModReputation { BYTE cCount; TNpcReputation UpdateArr[NpcReputation::Common::MaxEffectNpcCount]; }; struct SCOpenGiveNpcPresent { UINT nNpcID; }; struct SCRequestSendSelectedPresent { UINT nNpcID; }; struct SCShowNpcEffect { UINT nNpcID; int nEffectIndex; }; struct CSGiveNpcPresent { UINT nNpcID; int nPresentID; // npc 선물 테이블에 있는 itemid int nPresentCount; // 선물 갯수 }; #endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM ) struct SCOpenDarkLairRankBoard { UINT uiNpcID; int iMapIndex; BYTE cPlayerCount; }; struct SCOpenPvPLadderRankBoard { UINT uiNpcID; LadderSystem::MatchType::eCode MatchType; }; namespace MasterSystem { struct SCSimpleInfo { TMasterSystemSimpleInfo SimpleInfo; bool bRefresh; // 리스트 갱신여부 }; struct SCCountInfo { int iMasterCount; int iPupilCount; int iClassmateCount; }; struct CSMasterList { UINT uiPage; // Zerobase BYTE cJob; // 0:모두 BYTE cGender; // 0:모두 }; struct SCMasterList { int iRet; BYTE cCount; TMasterInfo MasterInfoList[MasterSystem::Max::MasterPageRowCount]; }; struct SCMasterCharacterInfo { int iRet; TMasterCharacterInfo MasterCharacterInfo; }; struct SCPupilList { int iRet; INT64 biMasterCharacterDBID; BYTE cCount; TPupilInfoWithLocation PupilInfoList[MasterSystem::Max::PupilCount]; }; struct CSIntroduction { bool bRegister; // 등록 여부 WCHAR wszSelfIntroduction[MasterSystem::Max::SelfIntrotuctionLen]; }; struct SCIntroduction { int iRet; bool bRegister; WCHAR wszSelfIntroduction[MasterSystem::Max::SelfIntrotuctionLen]; }; struct CSMasterApplication { INT64 biCharacterDBID; }; struct SCMasterApplication { int iRet; }; struct CSJoin { INT64 biMasterCharacterDBID; WCHAR wszMasterCharName[NAMELENMAX]; }; struct SCJoin { int iRet; bool bIsDirectMenu; bool bIsAddPupil; bool bIsTransactor; // 행위 당사자인지 구분 Flag }; struct SCMasterClassmate { int iRet; BYTE cCount; TMasterAndClassmateInfoWithLocation DataList[MasterSystem::Max::MasterAndClassmateCount]; }; struct CSClassmateInfo { INT64 biClassmateCharacterDBID; }; struct SCClassmateInfo { int iRet; TClassmateInfoWithLocation ClassmateInfo; }; struct CSMyMasterInfo { INT64 biMasterCharacterDBID; }; struct SCMyMasterInfo { int iRet; TMyMasterInfoWithLocation MasterInfo; }; struct CSLeave { INT64 biDestCharacterDBID; bool bIsMaster; // 제자추방:true 스승삭제:false }; struct SCLeave { int iRet; bool bIsDelPupil; // true:제자삭제 false:스승삭제 int iPenaltyRespectPoint; // bIsDelPupil==true 인경우 감소할 존경수치값(양수) }; struct SCGraduate { WCHAR wszCharName[NAMELENMAX]; }; struct SCConnect { bool bIsConnect; WCHAR wszCharName[NAMELENMAX]; }; struct SCRespectPoint { int iRespectPoint; }; struct SCFavorPoint { INT64 biMasterCharacterDBID; INT64 biPupilCharacterDBID; int iFavorPoint; }; struct CSInvitePupil { WCHAR wszCharName[NAMELENMAX]; }; struct SCInvitePupil { int iRet; WCHAR wszCharName[NAMELENMAX]; }; struct SCInvitePupilConfirm { int iRet; WCHAR wszMasterCharName[NAMELENMAX]; }; struct CSInvitePupilConfirm { bool bIsAccept; WCHAR wszMasterCharName[NAMELENMAX]; }; struct CSJoinDirect { WCHAR wszMasterCharName[NAMELENMAX]; }; struct SCJoinDirect { int iRet; WCHAR wszMasterCharName[NAMELENMAX]; }; struct SCJoinDirectConfirm { int iRet; WCHAR wszPupilCharName[NAMELENMAX]; }; struct CSJoinDirectConfirm { bool bIsAccept; WCHAR wszPupilCharName[NAMELENMAX]; }; struct CSRecallMaster { WCHAR wszMasterCharName[NAMELENMAX]; }; struct SCRecallMaster { int iRet; bool bIsConfirm; // true:소환확인패킷 WCHAR wszCharName[NAMELENMAX]; // bIsConfirm==true : 제자이름 bIsConfirm==false : 스승이름 }; struct CSBreakInto { int iRet; WCHAR wszPupilCharName[NAMELENMAX]; }; struct SCJoinComfirm { BYTE cLevel; // 제자 레벨 BYTE cJob; // 제자 직업 WCHAR wszPupilCharName[NAMELENMAX]; // 제자 이름 }; struct CSJoinComfirm { bool bIsAccept; WCHAR wszPupilCharName[NAMELENMAX]; // 제자 이름 }; } #if defined( PRE_ADD_SECONDARY_SKILL ) namespace SecondarySkill { struct SCList { BYTE cCount; TSecondarySkillInfo SkillList[SecondarySkill::Max::LearnSecondarySkill]; }; struct CSDelete { int iSkillID; }; struct SCCreate { int iRet; int iSkillID; }; struct SCDelete { int iRet; int iSkillID; }; struct SCUpdateExp { int iRet; int iSkillID; SecondarySkill::Grade::eType Grade; int iExp; int iLevel; }; struct SCRecipeList { BYTE cCount; TSecondarySkillRecipe RecipeList[SecondarySkill::Max::LearnManufactureRecipe]; }; struct CSAddRecipe { int iSkillID; char cInvenType; // eItemPositionType BYTE cInvenIndex; // 일반인벤일때만 index넣어주면 됨 (캐쉬는 참조하지않음) INT64 biInvenSerial; }; struct SCAddRecipe { int iRet; int iSkillID; int iItemID; INT64 biItemSerial; short nExp; }; struct CSDeleteRecipe { int iSkillID; int iItemID; }; struct SCDeleteRecipe { int iRet; int iSkillID; int iItemID; }; struct CSExtractRecipe { int iSkillID; int iItemID; }; struct SCExtractRecipe { int iRet; int iSkillID; int iItemID; }; struct SCUpdateRecipeExp { int iRet; int iSkillID; int iItemID; int iExp; // 최종값(assign해야함) }; struct CSManufacture { bool bIsStart; int iSkillID; int iItemID; }; struct SCManufacture { int iRet; bool bIsStart; int iSkillID; int iItemID; }; struct SCCancelManufacture { int iRet; int iSkillID; }; } #endif // #if defined( PRE_ADD_SECONDARY_SKILL ) #if defined (PRE_ADD_BESTFRIEND) /* 절친 상태 확인 bStatus : 0 / bCancel 0 -> 누구나 절친 파기가능 함 bStatus : 1 / bCancel 1 -> 절친 파기를 한 상태이기 때문에 취소할 수 있음 bStatus : 1 / tEndDate가 현재시간에서 4일을 초과한 경우 -> 절친 삭제 */ struct TBestFriendInfo { // Common __time64_t tStartDate; __time64_t tEndDate; int nDay; // 일 bool bStatus; // 0:절친 1:파기 INT64 biWaitingTimeForDelete; // 삭제 대기시간 // Me INT64 biItemSerial; WCHAR wszMyMemo[BESTFRIENDMEMOMAX]; bool bCancel; // 0:절친파기당한 캐릭터 1:절친파기한 캐릭터 // Friend UINT nSessionID; INT64 biCharacterDBID; WCHAR wszName[NAMELENMAX]; WCHAR wszFriendMemo[BESTFRIENDMEMOMAX]; char cLevel; char cJob; TCommunityLocation Location; }; namespace BestFriend { struct CSSearch { WCHAR wszName[NAMELENMAX]; }; struct CSRegist { INT64 biInvenSerial; WCHAR wszBestFriendName[NAMELENMAX]; }; struct CSAccept { bool bAccept; UINT nFromAccountDBID; INT64 biFromCharacterDBID; WCHAR wszFromName[NAMELENMAX]; }; struct CSCancel { bool bCancel; }; struct CSEditMemo { WCHAR wszMemo[BESTFRIENDMEMOMAX]; }; struct SCGetInfo { int iRet; TBestFriendInfo Info; }; struct SCSearch { int iRet; char cLevel; char cJob; WCHAR wszName[NAMELENMAX]; }; struct SCRegistReq { int iRet; // 요청자 UINT nFromAccountDBID; INT64 biFromCharacterDBID; WCHAR wszFromName[NAMELENMAX]; // 응답자 UINT nToAccountDBID; INT64 biToCharacterDBID; WCHAR wszToName[NAMELENMAX]; }; struct SCRegistAck { int iRet; UINT nFromAccountDBID; // 응답자 UINT nToAccountDBID; // 요청자 WCHAR wszFromName[NAMELENMAX]; WCHAR wszToName[NAMELENMAX]; }; struct SCComplete { int iRet; WCHAR wszName[NAMELENMAX]; }; struct SCEditMemo { int iRet; bool bFromMe; WCHAR wszMemo[BESTFRIENDMEMOMAX]; }; struct SCCancel { int iRet; bool bCancel; WCHAR wszName[NAMELENMAX]; }; struct SCClose { int iRet; WCHAR wszName[NAMELENMAX]; }; } #endif //-------------------------------------------------------------------------------------------------- // Etc //-------------------------------------------------------------------------------------------------- #if defined( PRE_USA_FATIGUE ) struct SCChannelInfoFatigueInfo { int iNoFatigueExpValue; int iFatigueExpValue; }; #endif // #if defined( PRE_USA_FATIGUE ) struct TEvent { int nEventID; time_t _tBeginTime; time_t _tEndTime; union { struct { int nEventType1; int nEventType2; int nEventType3; }; int nEventType[3]; }; union { struct { int nAtt1; int nAtt2; int nAtt3; int nAtt4; int nAtt5; }; int nAtt[5]; }; }; struct SCIncreaseLife { char cType; int nIncreaseLife; }; struct SCSpecialRebirthItem { int nItemID; int nRebirthItemCount; }; // TIMEEVENT //-------------------------------------------------------------------------------------------------- // TIMEEVENT (CS_TIMEEVENT, SC_TIMEEVENT) //-------------------------------------------------------------------------------------------------- struct SCTimeEventList { int nCount; TTimeEvent Event[TIMEEVENTMAX]; }; struct SCTimeEventAchieve { int nItemID; INT64 nRemainTime; }; struct SCTimeEventExpire { int nItemID; }; struct CSAttendanceEvent { bool bIsOK; }; struct SCAttendanceEvent { bool bCheckAttendanceFirst; }; //PlayerCustomEventUI //-------------------------------------------------------------------------------------------------- // PlayerCustomEventUI (CS_CUSTOMEVENTUI, SC_CUSTOMEVENTUI) //-------------------------------------------------------------------------------------------------- struct CSGetPlayerCustomEventUI { UINT nSessionID; }; struct TCustomEventInfo { int nMissionID; BYTE cFlag; }; struct SCGetPlayerCustomEventUI { UINT nSessionID; BYTE cCount; TCustomEventInfo UIs[PlayerCustomEventUI::PlayerCustomEventUIMax]; }; //-------------------------------------------------------------------------------------------------- // 길드모집게시판 (CS_GUILDRECRUIT, SC_GUILDRECRUIT) //-------------------------------------------------------------------------------------------------- namespace GuildRecruitSystem { struct CSGuildRecruitList { UINT uiPage; #if defined( PRE_ADD_GUILD_EASYSYSTEM ) BYTE cPurposeCode; // 길드 목적(1:친목 2:전투 3:네스트 4:콜로세움 WCHAR wszGuildName[GUILDNAME_MAX]; //길드 홈페이지 BYTE cSortType; #endif }; struct SCGuildRecruitList { int iRet; UINT uiPage; BYTE cCount; TGuildRecruitInfo GuildRecruitList[GuildRecruitSystem::Max::GuildRecruitRowCount]; }; struct SCGuildRecruitCharacterList { int iRet; BYTE cCount; TGuildRecruitCharacter GuildRecruitCharacterList[GuildRecruitSystem::Max::GuildRecruitCharacterRowCount]; }; struct SCMyGuildRecruitList { int iRet; BYTE cCount; TGuildRecruitInfo MyGuildRecruitList[GuildRecruitSystem::Max::MaxRequestCount]; }; struct SCGuildRecruitRequestCount { int iRet; BYTE cRequestCount; BYTE cMaxRequestCount; }; struct SCGuildRecruitRegisterInfo { BYTE cClassGrade[CLASSKINDMAX]; // 모집클래스 int nMinLevel; // 최소 레벨 int nMaxLevel; // 최대 레벨 WCHAR wszGuildIntroduction[GUILDRECRUITINTRODUCE+1]; //길드 소개글 #if defined( PRE_ADD_GUILD_EASYSYSTEM ) BYTE cPurposeCode; // 길드 목적(1:친목 2:전투 3:네스트 4:콜로세움 bool bCheckHomePage; //길드 홈페이지 #endif }; struct CSGuildRecruitRegister { BYTE cRegisterType; // 등록 수정 삭제 BYTE cClassGrade[CLASSKINDMAX]; // 모집클래스 int nMinLevel; // 최소 레벨 int nMaxLevel; // 최대 레벨 WCHAR wszGuildIntroduction[GUILDRECRUITINTRODUCE+1]; //길드 소개글 #if defined( PRE_ADD_GUILD_EASYSYSTEM ) BYTE cPurposeCode; // 길드 목적(1:친목 2:전투 3:네스트 4:콜로세움 bool bCheckHomePage; //길드 홈페이지 #endif }; struct SCGuildRecruitRegister { int iRet; BYTE cRegisterType; // 등록 수정 삭제 }; struct CSGuildRecruitRequest { BYTE cRequestType; // 가입 신청/해지 TGuildUID GuildUID; // 길드 UID (월드 ID + 길드 DBID) }; struct SCGuildRecruitRequest { int iRet; BYTE cRequestType; // 가입 신청/해지 }; struct CSGuildRecruitAccept { BYTE cAcceptType; // 가입 승인/거절 TGuildUID GuildUID; // 길드 UID (월드 ID + 길드 DBID) INT64 biAcceptCharacterDBID; // 가입승인한 캐릭터 DBID WCHAR wszToCharacterName[NAMELENMAX]; // 가입승인한 캐릭터 이름 }; struct SCGuildRecruitAccept { int iRet; BYTE cAcceptType; INT64 biAcceptCharacterDBID; // 가입승인한 캐릭터 DBID bool bDelGuildRecruit; // 길드 모집 목록 삭제 여부 }; struct SCGuildRecruitMemberResult { int iRet; BYTE cAcceptType; WCHAR wszGuildName[GUILDNAME_MAX]; // 길드 이름 }; }; struct CSWarpVillageList { INT64 nItemSerial; }; struct SCWarpVillageList { BYTE btCount; WarpVillage::WarpVillageInfo VillageList[128]; }; struct CSWarpVillage { int nMapIndex; INT64 nItemSerial; }; struct SCWarpVillage { int nResult; }; #if defined (PRE_ADD_DONATION) struct CSDonate { INT64 nCoin; }; struct SCDonate { int nResult; }; struct CSDonationRanking { }; struct SCDonationRanking { Donation::Ranking Ranking[Donation::MAX_RANKING]; INT64 nMyCoin; int nMyRanking; }; #endif // #if defined (PRE_ADD_DONATION) #ifdef PRE_ADD_AUTOUNPACK struct CSAutoUnpack { bool bShow; INT64 serial; }; struct SCAutoUnpack { int nRetCode; INT64 serial; }; #endif #ifdef PRE_ADD_EXCHANGE_POTENTIAL struct CSExchangePotential //CS_ITEMGOODS : CS_EXCHANGE_POTENTIAL { int nExtractItemIndex; INT64 biExtractItemSerial; int nInjectItemIndex; INT64 biInjectItemSerial; }; struct SCExchangePotential //SC_ITEMGOODS : SC_EXCHANGE_POTENTIAL { int nRetCode; }; #endif //#ifdef PRE_ADD_EXCHANGE_POTENTIAL #if defined(PRE_ADD_EXCHANGE_ENCHANT) struct CSExchangeEnchant //CS_ITEMGOODS : CS_EXCHANGE_ENCHANT { int nExtractItemIndex; INT64 biExtractItemSerial; int nInjectItemIndex; INT64 biInjectItemSerial; }; struct SCExchangeEnchant //SC_ITEMGOODS : SC_EXCHANGE_ENCHANT { int nRetCode; }; #endif #if defined(PRE_ADD_PCBANG_RENTAL_ITEM) struct SCPcCafeRentItem // SC_PCCAFE_RENT_ITEM { int nRetCode; // 결과 int nNeedCount; // 필요한 인벤수 }; #endif // #if defined(PRE_ADD_PCBANG_RENTAL_ITEM) #ifdef PRE_ADD_DOORS struct SCDoorsGetAuthKey { int nRetCode; bool bMobileAuthentication; WCHAR wszAuthKey[Doors::Common::AuthenticationKey_LenMax]; }; struct SCDoorsCancelAuth { int nRetCode; }; struct SCDoorsGetAuthFlag { bool bFlag; }; #endif //#ifdef PRE_ADD_DOORS #if defined( PRE_PRIVATECHAT_CHANNEL ) namespace PrivateChatChannel { struct SCPrivateChannleInfo { int nCount; WCHAR wszChannelName[PrivateChatChannel::Common::MaxNameLen]; PrivateChatChannel::TMemberInfo Members[PrivateChatChannel::Common::MaxMemberCount]; }; struct SCPrivateChatChannleResult // CS 패킷에 대한 모든 결과값은 여기서 처리 { int nRet; }; struct CSPrivateChatChannleAdd // CS_PRIVATECHAT_CHANNEL_ADD { WCHAR wszChannelName[PrivateChatChannel::Common::MaxNameLen]; #if defined( PRE_ADD_PRIVATECHAT_CHANNEL ) int nPassWord; #endif }; struct CSPrivateChatChannleJoin // CS_PRIVATECHAT_CHANNEL_JOIN { WCHAR wszChannelName[PrivateChatChannel::Common::MaxNameLen]; int nPassWord; }; struct CSPrivateChatChannleInvite // CS_PRIVATECHAT_CHANNEL_INVITE { WCHAR wszCharacterName[NAMELENMAX]; }; struct SCPrivateChatChannleInviteResult // SC_PRIVATECHAT_CHANNEL_INVITERESULT { int nRet; }; struct SCPrivateChatChannleJoinResult // SC_PRIVATECHAT_CHANNEL_JOINRESULT { int nRet; WCHAR wszChannelName[PrivateChatChannel::Common::MaxNameLen]; }; struct CSPrivateChatChannleOut // CS_PRIVATECHAT_CHANNEL_OUT { }; struct SCPrivateChatChannleOutResult // SC_PRIVATECHAT_CHANNEL_OUTRESULT { int nRet; }; struct CSPrivateChatChannleKick // CS_PRIVATECHAT_CHANNEL_KICK { WCHAR wszCharacterName[NAMELENMAX]; }; struct CSPrivateChatChannleKickResult // SC_PRIVATECHAT_CHANNEL_KICKRESULT { int nRet; bool bMe; }; struct SCPrivateChatChannleAdd // SC_PRIVATECHAT_CHANNEL_ADD { int nRet; WCHAR wszChannelName[PrivateChatChannel::Common::MaxNameLen]; PrivateChatChannel::TMemberInfo Member; }; struct SCPrivateChatChannleDel // SC_PRIVATECHAT_CHANNEL_DEL { int nRet; INT64 biCharacterDBID; WCHAR wszCharacterName[NAMELENMAX]; }; struct SCPrivateChatChannleKick // SC_PRIVATECHAT_CHANNEL_KICK { int nRet; INT64 biCharacterDBID; }; struct CSPrivateChatChannleMod // CS_PRIVATECHAT_CHANNEL_MOD { int nModType; int nPassWord; INT64 biCharacterDBID; }; struct SCPrivateChatChannleMod // SC_PRIVATECHAT_CHANNEL_MOD { int nRet; int nModType; INT64 biCharacterDBID; WCHAR wszCharacterName[NAMELENMAX]; }; } #endif #if defined( PRE_WORLDCOMBINE_PVP ) namespace WorldPvPMissionRoom { struct SCWorldPvPRoomStartMsg // SC_PVP_WORLDPVPROOM_STARTMSG { bool bShow; UINT uiPvPIndex; }; struct CSWorldPvPRoomStartMsg // CS_PVP_WORLDPVPROOM_STARTMSG { UINT uiPvPIndex; }; struct SCWorldPvPRoomStartReturn // SC_PVP_WORLDPVPROOM_STARTMSG { int nRet; }; struct SCWorldPvPRoomJoinResult // SC_PVP_WORLDPVPROOM_STARTMSG { int nRet; }; struct SCWorldPvPRoomAllKillTeamInfo // SC_PVP_WORLDPVPROOM_STARTMSG { UINT nSessionID[PARTYMAX]; int nTeam[PARTYMAX]; }; struct SCWorldPvPRoomTournamentUserInfo { BYTE cUserCount; // 유저수 PvPCommon::UserInfoList UserInfoList; }; } #endif #if defined( PRE_ADD_PVP_COMBOEXERCISE ) struct SCPvPComboExerciseRoomMasterInfo // SC_PVP_COMBOEXERCISE_ROOMMASTERINFO { UINT uiRoomMasterSessionID; }; struct SCPvPComboExerciseChangeRoomMaster // SC_PVP_COMBOEXERCISE_CHANGEROOMMASTER { UINT uiRoomMasterSessionID; }; struct SCPvPComboExerciseRecallMonsterResult // SC_PVP_COMBOEXERCISE_RECALLMONSTER { int nRet; }; #endif // #if defined( PRE_ADD_PVP_COMBOEXERCISE ) #if defined( PRE_ALTEIAWORLD_EXPLORE ) namespace AlteiaWorld { struct CSAlteiaWorldInfo // CS_ALTEIAWORLD_INFO { AlteiaWorld::Info::eInfoType eType; }; struct SCAlteiaWorldJoinInfo // SC_ALTEIAWORLD_JOIN_INFO { BYTE cWeeklyClearCount; BYTE cDailyClearCount; BYTE cTicketCount; }; struct SCAlteiaWorldPrivateGoldKeyRankingInfo // SC_ALTEIAWORLD_PRIVATEGOLDKEYRANKING_INFO { int nMyBestGoldKeyCount; int nCount; AlteiaWorld::GoldKeyRankMemberInfo MemberInfo[AlteiaWorld::Common::MaxRankCount]; }; struct SCAlteiaWorldPrivatePlayTimeRankingInfo // SC_ALTEIAWORLD_PRIVATEPLAYTIMERANKING_INFO { UINT nPlaySec; int nCount; AlteiaWorld::PlayTimeRankMemberInfo MemberInfo[AlteiaWorld::Common::MaxRankCount]; }; struct SCAlteiaWorldGuildGoldKeyRankingInfo // SC_ALTEIAWORLD_GUILDGOLDKEYRANKING_INFO { int nMyBestGoldKeyCount; int nCount; AlteiaWorld::GuildGoldKeyRankInfo GuildRankInfo[AlteiaWorld::Common::MaxRankCount]; }; struct SCAlteiaWorldSendTicketInfo // SC_ALTEIAWORLD_GUILDGOLDKEYRANKING_INFO { BYTE cSendTicketCount; INT64 biCharacterDBID[AlteiaWorld::Common::MaxSendCount]; }; struct CSAlteiaWorldJoin // CS_ALTEIAWORLD_JOIN { }; struct SCAlteiaWorldJoinResult { int nRet; }; struct CSAlteiaWorldSendTicket // CS_ALTEIAWORLD_SENDTICKET { WCHAR wszCharacterName[NAMELENMAX]; }; struct SCAlteiaWorldSendTicket // SC_ALTEIAWORLD_SENDTICKET { WCHAR wszCharacterName[NAMELENMAX]; int nTicketCount; }; struct SCAlteiaWorldSendTicketResult // SC_ALTEIAWORLD_SENDTICKET_RESULT { int nRet; int nSendTicketCount; }; struct CSAlteiaWorldDice // CS_ALTEIAWORLD_DICE { }; struct SCAlteiaWorldDiceResult // SC_ALTEIAWORLD_DICE_RESULT { int nRet; int nNumber; }; } #endif // #if defined( PRE_ALTEIAWORLD_EXPLORE ) #if defined( PRE_ADD_STAMPSYSTEM ) namespace StampSystem { struct SCStampSystemInit { int nWeekDay; INT64 biTableStartTime; bool bCompleteFlagData[Common::MaxStampSlotCount]; }; struct SCStampSystemAddComplete { int nChallengeIndex; int nWeekDay; }; struct SCStampSystemChangeWeekDay { int nWeekDay; }; struct SCStampSystemChangeTable { INT64 biTableStartTime; }; } #endif // #if defined( PRE_ADD_STAMPSYSTEM ) #if defined( PRE_ADD_PVP_EXPUP_ITEM ) struct SCUsePvPExpup { int nRet; BYTE cLevel; UINT uiXP; int nIncrement; }; #endif // #if defined( PRE_ADD_PVP_EXPUP_ITEM ) #if defined( PRE_DRAGONBUFF ) struct SCWorldBuffMsg { WCHAR wszCharacterName[NAMELENMAX]; int nItemID; }; #endif #if defined(PRE_ADD_GUILD_CONTRIBUTION) namespace GuildContribution { // SC_GUILD / SC_GUILD_CONTRIBUTION_POINT struct SCGuildContributionPoint { int nWeeklyContributionPoint; //주간 길드 공헌도 int nTotalContributionPoint; //길드 공헌도 총합 }; // SC_GUILD / SC_GUILD_CONTRIBUTION_RANK struct SCGuildContributionRank { int nCount; // 공헌도 랭커 수 GuildContribution::TGuildContributionRankingData Data[GUILDSIZE_MAX]; // 공헌도 랭커 정보 }; } #endif // #if defined(PRE_ADD_GUILD_CONTRIBUTION) //-------------------------------------------------------------------------------------------------- // DWC (CS_DWC, SC_DWC) //-------------------------------------------------------------------------------------------------- #if defined(PRE_ADD_DWC) struct TDWCScore { int nTotalWin; int nTotalLose; int nTotalDraw; int nDWCPoint; int nHiddenDWCPoint; short wTodayWin; short wTodayLose; short wTodayDraw; short wConsecutiveWin; short wConsecutiveLose; int nWeeklyPlayCount; }; struct TDWCTeam { int nDWCRank; WCHAR wszTeamName[GUILDNAME_MAX]; int nTotalWin; int nTotalLose; int nTotalDraw; int nDWCPoint; int nHiddenDWCPoint; short wTodayWin; short wTodayLose; short wTodayDraw; short wConsecutiveWin; short wConsecutiveLose; int nWeeklyPlayCount; __time64_t tLastPlayDate; //필요없으면 삭제 }; struct TDWCTeamMember { TDWCTeamMember::TDWCTeamMember(){;} TDWCTeamMember::TDWCTeamMember( UINT nAccountDBID, INT64 biCharacterDBID, LPCWSTR lpwszMemberCharacterName, BYTE cJobCode, bool bTeamLeader ) : nAccountDBID(nAccountDBID), biCharacterDBID(biCharacterDBID), cJobCode(cJobCode), bTeamLeader(bTeamLeader) { Location.Reset(); memset(wszCharacterName, 0, sizeof(wszCharacterName)); ::wcsncpy_s(wszCharacterName, _countof(wszCharacterName), lpwszMemberCharacterName, _countof(wszCharacterName)); } UINT nAccountDBID; INT64 biCharacterDBID; WCHAR wszCharacterName[NAMELENMAX]; BYTE cJobCode; bool bTeamLeader; TCommunityLocation Location; }; struct CSCreateDWCTeam // CS_DWC / CS_CREATE_DWCTEAM { WCHAR wszTeamName[GUILDNAME_MAX]; }; struct SCCreateDWCTeam //SC_DWC / SC_CREATE_DWCTEAM { int nRet; UINT nSessionID; UINT nTeamID; WCHAR wszTeamName[GUILDNAME_MAX]; }; struct SCDismissDWCTeam // SC_DWC / SC_DISMISS_DWCTEAM { int nRet; UINT nTeamID; }; struct SCLeaveDWCTeamMember // SC_DWC / SC_LEAVE_DWCTEAM_MEMB { int nRet; UINT nTeamID; INT64 biLeaveUserCharacterDBID; WCHAR wszCharacterName[NAMELENMAX]; }; struct CSInviteDWCTeamMemberReq // CS_DWC / CS_INVITE_DWCTEAM_MEMBREQ // 팀원 초대 요청 { WCHAR wszToCharacterName[NAMELENMAX]; // 초대할 캐릭터 이름 }; struct SCInviteDWCTeamMemberReq // SC_DWC / SC_INVITE_DWCTEAM_MEMBREQ // 팀원 초대 요청 { UINT nTeamID; UINT nFromAccountDBID; // 발신자 계정 DBID UINT nToAccountDBID; // 수신자 계정 DBID WCHAR wszFromCharacterName[NAMELENMAX]; // 발신자 캐릭터 이름 WCHAR wszTeamName[GUILDNAME_MAX]; // 팀명 }; struct CSInviteDWCTeamMemberAck // CS_DWC / CS_INVITE_DWCTEAM_MEMBACK { UINT nTeamID; // 길드 UID UINT nFromAccountDBID; // 발신자 계정 DBID bool bAccept; // 수락 여부 }; struct SCInviteDWCTeamMemberAck // SC_DWC / SC_INVITE_DWCTEAM_MEMBACK { UINT nToAccountDBID; // 수신자 계정 DBID INT64 biToCharacterDBID; // 수신자 캐릭터 DBID UINT nFromAccountDBID; // 발신자 계정 DBID INT64 biFromCharacterDBID; // 발신자 캐릭터 DBID UINT nTeamID; // 팀ID TP_JOB nJob; // 수신자 직업 TCommunityLocation Location; // 현재 위치 (로그인 여부도 본 멤버의 상태로 체크) int nRet; // 결과 (NOERROR : 성공 / 그외 : 실패) WCHAR wszToCharacterName[NAMELENMAX]; // 수신자 캐릭터 이름 }; struct SCInviteDWCTeamMemberAckResult // SC_DWC / SC_INVITE_DWCTEAM_MEMBACK_RESULT { int nRet; // 결과 (NOERROR : 성공 / 그외 : 실패) }; struct CSGetDWCTeamInfo // CS_DWC / SC_GET_DWCTEAM_INFO { bool bNeedMembList; // 팀원 목록도 필요한지 여부 }; struct SCGetDWCTeamInfo // SC_DWC / SC_GET_DWCTEAM_INFO { int nRet; UINT nTeamID; TDWCTeam Info; }; struct SCGetDWCTeamMember // SC_DWC / SC_GET_DWCTEAM_MEMBER { int nRet; UINT nTeamID; int nCount; TDWCTeamMember MemberList[DWC::DWC_MAX_MEMBERISZE]; }; struct TRankMemberData { BYTE cJobCode; WCHAR wszMemberName[NAMELENMAX]; }; struct TDWCRankData { int nRank; int nTeamID; WCHAR wszTeamName[GUILDNAME_MAX]; int nWinCount; int nLoseCount; int nDrawCount; int nDWCPoint; int nChangedRanking; TRankMemberData LeaderData; TRankMemberData MemberData[DWC::DWC_MAX_MEMBERISZE]; }; struct CSGetDWCRankPage //CS_DWC / CS_GET_DWC_RANKPAGE { int nPageNum; int nPageSize; }; struct SCGetDWCRankPage { int nRetCode; UINT nTotalRankSize; int nPageNum; int nPageSize; TDWCRankData RankDataList[RankingSystem::RANKINGMAX]; }; struct CSGetDWCFindRank //CS_DWC / CS_GET_DWC_FINDRANK { BYTE cType; //0 캐릭터명 1 팀명 WCHAR wszFindKey[NAMELENMAX + GUILDNAME_MAX]; }; struct SCGetDWCFindRank //SC_DWC / SC_GET_DWC_FINDRANK { int nRetCode; TDWCRankData Rank; }; struct SCChangeDWCTeamMemberState //SC_DWC / SC_CHANGE_DWCTEAM_MEMBERSTATE { UINT nTeamID; INT64 biCharacterDBID; TCommunityLocation Location; }; struct SCDWCTeamNameInfo //SC_DWC / SC_DWC_TEAMNAME_INFO { WCHAR wszATeamName[GUILDNAME_MAX]; WCHAR wszBTeamName[GUILDNAME_MAX]; }; struct SCDWCChannelInfo // SC_DWC / SC_DWCCHANNELINFO { TDWCChannelInfo ChannelInfo; }; struct SCChangeDWCTeam // SC_DWC / SC_CHANGE_DWCTEAM { UINT nSessionID; WCHAR wszTeamName[GUILDNAME_MAX]; }; #endif //#if defined(PRE_ADD_DWC) #if defined( PRE_ADD_NEW_MONEY_SEED ) struct SCSendSeedPoint { INT64 nSeedPoint; bool bInc; }; #endif //rlkt_test struct SCOpenChangeJobDialog { int nNextClass; }; struct CSSpecialize { int nSelectedClass; }; //DragonJewel #ifdef PRE_ADD_DRAGON_GEM struct TGemData { INT64 nParentItemSerial; int nSequenceNumber; int nItemID; char nDragonJewelLocation; char nItemOption; char nSealCount; }; //SC_ITEM // SC_GEMLIST struct TGemClientData { INT64 nParentSerial; //Parent item serial int nItemID; //Gem ItemID char cDragonJewelSlot; //Slot 0,1,2,3 }; struct SCGemList { int nCount; TGemClientData GemData[MAX_GEM_LIST]; }; struct CSReqGemList { int nCount; INT64 nParentSerial[MAX_GEM_LIST]; }; #endif #pragma pack(pop)