4104 lines
No EOL
101 KiB
C++
4104 lines
No EOL
101 KiB
C++
#pragma once
|
|
|
|
#include "DNPacket.h"
|
|
#include "MemPool.h"
|
|
|
|
/*--------------------------------------------------------------------------
|
|
Server쪽에서 쓰는 모든것들(?)
|
|
--------------------------------------------------------------------------*/
|
|
|
|
// const ----------------------------------------------------------------------------------------------
|
|
|
|
#if defined(_CH)
|
|
const WCHAR* const SQLPASSWORD = L"4795CEA6409d492";
|
|
const WCHAR* const SQLHOSTNAME = L"A2A375E23370f8a";
|
|
const WCHAR* const SQLAPPNAME = L"C98D23990E1119a";
|
|
#elif defined(_JP)
|
|
const WCHAR* const SQLPASSWORD = L"945C437D6632718";
|
|
//const WCHAR* const SQLPASSWORD = L"A443131C-2988-4C3E-9974-37033B2A0A33";
|
|
const WCHAR* const SQLHOSTNAME = L"E4C874F3D920ced";
|
|
const WCHAR* const SQLAPPNAME = L"2001C72210299d0";
|
|
#elif defined(_TW)
|
|
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
|
|
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
|
|
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
|
|
#elif defined(_US)
|
|
const WCHAR* const SQLPASSWORD = L"BACF8969BB00b2d";
|
|
const WCHAR* const SQLHOSTNAME = L"04B3944622a7c5b";
|
|
const WCHAR* const SQLAPPNAME = L"33518A83865e269";
|
|
#elif defined(_SG)
|
|
const WCHAR* const SQLPASSWORD = L"4708A804794d233";
|
|
const WCHAR* const SQLHOSTNAME = L"D3B8367356e19d7";
|
|
const WCHAR* const SQLAPPNAME = L"3A222498E96c63f";
|
|
#elif defined(_TH)
|
|
const WCHAR* const SQLPASSWORD = L"gozjtoRldi!*";
|
|
const WCHAR* const SQLHOSTNAME = L"rjfflausenlwlsek@#@";
|
|
const WCHAR* const SQLAPPNAME = L"roshatlRl!#";
|
|
#elif defined(_ID)
|
|
const WCHAR* const SQLPASSWORD = L"skQmsgozj!*sha";
|
|
const WCHAR* const SQLHOSTNAME = L"rhdqntlzlsi)*^";
|
|
const WCHAR* const SQLAPPNAME = L"rotoRjwuqjfu!#";
|
|
#elif defined(_RU)
|
|
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
|
|
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
|
|
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
|
|
#elif defined(_KAMO) //[OK_Cash]
|
|
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
|
|
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
|
|
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
|
|
#elif defined(_EU)
|
|
const WCHAR* const SQLPASSWORD = L"110C37F5B9fb934";
|
|
const WCHAR* const SQLHOSTNAME = L"D8FA71CD6Ee2479";
|
|
const WCHAR* const SQLAPPNAME = L"518BD8D722e2f6b";
|
|
#else
|
|
const WCHAR* const SQLPASSWORD = L"428A44DC4Eebd12";
|
|
const WCHAR* const SQLHOSTNAME = L"CF0EEDCEF386298";
|
|
const WCHAR* const SQLAPPNAME = L"D121240B6419392";
|
|
#endif // #if defined( _US )
|
|
|
|
const WCHAR* const SQLActozMembershipDBPassword = L"dnaccount$dnest7h.o.t.44_2";
|
|
const WCHAR* const SQLActozWorldDBPassword = L"dndb$dnest50h.o.t.44_2";
|
|
const WCHAR* const SQLActozCommonDBPassword_Test = L"devdb$game9mingi44_2";
|
|
const WCHAR* const SQLActozCommonDBPassword = L"dncomdb$game60mingi44_2";
|
|
|
|
#if defined( PRE_ADD_DWC )
|
|
const WCHAR* const DWCPREFIX = L"DWCGM_";
|
|
const int DWCPREFIXLEN = 6;
|
|
#endif // #if defined( PRE_ADD_DWC )
|
|
|
|
const char DBSERVERMAX = 16;
|
|
const char THREADMAX = 8; // DB THREAD
|
|
const char LOGINTIMELENMAX = 20; // last login time length max
|
|
const char TIMELENMAX = 20; // 데이트타임 타입
|
|
|
|
const int LOGINCOUNTMAX = 64; // 총 로그인 서버 개수
|
|
const int LOGINCONCOUNTINFOTERM = (1*30*1000); // 로그인 서버 현재 동시접속자 정보 마스터 서버에 보고 제한간격 (단위:ms)
|
|
const int LOGINSERVERLISTSORTTERM = (1*3*1000); // 로그인 서버 세션 정렬 제한간격 (단위:ms)
|
|
const int MASTERCOUNTMAX = 10; // 총 마스터 서버 개수
|
|
|
|
const int DELETECHAR_WAITTIME_MINUTE = 7*24*60; // 7일
|
|
const BYTE PROCESSCOUNT = 40; // 초당 오브젝트 처리개수
|
|
|
|
const int INTERNALBUFFERLENMAX = 51200;
|
|
|
|
const UINT PROCESSBUFFERLENMAX = 1024 * 64;
|
|
const UINT WORKERBUFFERLENMAX = 1024 * 64;
|
|
|
|
const int QUESTSIZEINFO = 2775;
|
|
|
|
const int QUERYOVERTIME = 1000;
|
|
|
|
const int QUERYNAMESIZE = 200; // 쿼리 최대 크기
|
|
const int GAMEDELAYSIZE = 200; // 게임딜레이 로그 최대 크기
|
|
|
|
const int SERVERDETACHPACKETSIZE = 1024*40; // 패킷전송시 버퍼사이즈크기
|
|
//const variable.
|
|
#ifdef _FINAL_BUILD
|
|
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_PARTY = 120 * 1000; //최초 게임서버 컨넥트 대기 시간
|
|
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_SINGLE = 120 * 1000;
|
|
const unsigned long WAIT_FOR_ANOTHER_USER_TIME_LIMIT = 15 * 1000; //최초인원이 컨넥을 하고 다른인원을 기다리는 시간
|
|
const unsigned long WAIT_FOR_LOAD_TIME_LIMIT = 60 * 1000; //데이타베이스의 로딩을 기다리는 시간
|
|
const unsigned long GOGO_SING_TO_PLAY_FOR_WAIT_TIME_LIMIT = 2 * 60 * 1000; //클라이언트 로딩과 싱크를 기다리는 시간
|
|
const unsigned long GOGO_SING_TO_FARMPLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000; //농장로딩 시간은 초큼 별개로
|
|
#else
|
|
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_PARTY = 60 * 1000; //최초 게임서버 컨넥트 대기 시간
|
|
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_SINGLE = 120 * 1000;
|
|
const unsigned long WAIT_FOR_ANOTHER_USER_TIME_LIMIT = 60 * 1000; //
|
|
const unsigned long WAIT_FOR_LOAD_TIME_LIMIT = 150 * 1000; //
|
|
const unsigned long GOGO_SING_TO_PLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000; //
|
|
const unsigned long GOGO_SING_TO_FARMPLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000; //농장로딩 시간은 초큼 별개로
|
|
#endif
|
|
|
|
const int EACH_GAMESERVER_MAX_ROOM_COUNT = 20;
|
|
const int EACH_GAMESERVER_MAX_USER_COUNT = 100;
|
|
|
|
const int INTERVALDELETE_TIMINGTICK = 1000 * 60; //1분쯤??...-_-;
|
|
const int CHECK_ZOMBIE_DISCONNECT_TICK = 1000 * 60 * 5;
|
|
const int DISTRIBUTE_IDLE_TICK = 1000 * 5;
|
|
|
|
const int DELAYED_PRCESS_CHECKTICK = 1000 * 10;
|
|
const int DELAYED_PRCESS_LOG_COUNT = 10;
|
|
const int FRAMEDEADLINE = 17;
|
|
|
|
const int EVENTMAPSTRMAX = 50;
|
|
|
|
const int CHECKLIVETICK = 60000 * 2;// * 5; // 핵쉴드 5분 마다 체크 -> 1분으로 바꾸라고 해서 바꿈 -> 2분으로 늘림
|
|
const int CHECKRESPONSETICK = 60000 * 3; // 핵쉴드 응답 시간 (3분정도?)
|
|
|
|
const int CHECKGPKFIRSTTICK = 1000 * 60 * 2; // 최초 검사타이밍
|
|
const int CHECKGPKTICK = 60000;
|
|
const int MANAGEDMAX = 20;
|
|
|
|
#if !defined(_FINAL_BUILD)
|
|
const DWORD CHECK_TCP_PING_TICK = 1000*30*1; // 1분
|
|
const DWORD CHECK_UDP_PING_TICK = 1000*30*1; // 1분
|
|
#else //#if !defined(_FINAL_BUILD)
|
|
const DWORD CHECK_TCP_PING_TICK = 1000*60*1; // 1분
|
|
const DWORD CHECK_UDP_PING_TICK = 1000*60*1; // 1분
|
|
#endif //#if !defined(_FINAL_BUILD)
|
|
|
|
#if defined(_CH)
|
|
const int CHECKLOGINUSERKICKTICK = 30 * 60 * 1000; // 로그인 서버에 30분 동안 머물면 강퇴!(중국만)
|
|
#else
|
|
const int CHECKLOGINUSERKICKTICK = 15 * 60 * 1000; // 로그인 서버에 15분 동안 머물면 강퇴!
|
|
#endif //#if defined(_CH)
|
|
const int CHECKNOTAUTHLOGINUSERKICKTICK = 5 * 60 * 1000; // 로그인 서버에 인증되지 않은체 5분 동안 머물면 강퇴!
|
|
|
|
const unsigned int DEFAULTUSERSESSIONID = 10000;
|
|
|
|
const unsigned int CASHDELUSERDELAY_LIMITTICK = (4*30*1000);
|
|
|
|
// DB 누적작업 관련 개수
|
|
const int DBQUERYSTREAMDATAMAX = (36*1024); // DB 누적작업 데이터 최대 크기 : DB 서버에 바로 송신되는 대신 큐에 누적 후 일괄처리가 필요한 데이터 구조체 중 가장 큰 것을 기준으로 설정 → 크기가 부족할 경우 지속적인 재조정 필요 예상
|
|
const unsigned int DBQUERYAUTOCHKSUM = 0xE41C723F; // DB 쿼리 직렬화 처리 시 체크값
|
|
|
|
const int QUESTINVENBLANKCHECKMIN = 2; // 퀘스트 인벤토리 체크 시 메시지 발송이 되는 최소 개수
|
|
const float MAX_ITEMPRICE_RATE = 0.5f;
|
|
|
|
#if defined(_FINAL_BUILD)
|
|
const int BEGINAUTHLIMITSEC = (9*10); // 최초 인증 제한시간 (단위:초, 0 이하는 무제한 대기 ?)
|
|
const int CHECKAUTHLIMITSEC = (6*10); // 일반 인증 제한시간 (단위:초)
|
|
const int BEGINAUTHLIMITTERM = (BEGINAUTHLIMITSEC*1000); // 최초 인증 제한간격 (단위:ms)
|
|
//const int CHECKAUTHLIMITTERM = (CHECKAUTHLIMITSEC*1000); // 일반 인증 제한간격 (단위:ms)
|
|
const int CHECKAUTHLIMITTERM = (1*30*1000); // 일반 인증 제한간격 (단위:ms) // P.S.> 던전, PVP 등 컨텐츠 참여자들의 불편사항을 고려하여 기존 시간보다 짧게 정함
|
|
#else // _FINAL_BUILD
|
|
const int BEGINAUTHLIMITSEC = (6*10); // 최초 인증 제한시간 (단위:초, 0 이하는 무제한 대기 ?)
|
|
const int CHECKAUTHLIMITSEC = (4*10); // 일반 인증 제한시간 (단위:초)
|
|
const int BEGINAUTHLIMITTERM = (BEGINAUTHLIMITSEC*1000); // 최초 인증 제한간격 (단위:ms)
|
|
//const int CHECKAUTHLIMITTERM = (CHECKAUTHLIMITSEC*1000); // 일반 인증 제한간격 (단위:ms)
|
|
const int CHECKAUTHLIMITTERM = (1*20*1000); // 일반 인증 제한간격 (단위:ms) // P.S.> 던전, PVP 등 컨텐츠 참여자들의 불편사항을 고려하여 기존 시간보다 짧게 정함
|
|
#endif // _FINAL_BUILD
|
|
|
|
const int RESETAUTHLISTMAX = (1000); // 인증정보 목록 초기화 크기 (주의!!! - 본 전역상수를 사용하는 패킷들이 송신/수신 패킷 크기를 넘지 않아야 함)
|
|
const int RESETAUTHLISTTERM = (1*1000); // 인증정보 목록 초기화 작업주기 (단위:ms)
|
|
const int RESETAUTHSERVERTERM = (5*1000); // 인증정보 서버 초기화 작업주기 (단위:ms)
|
|
const int RESETAUTHWORLDCHECKTERM = (5*1000); // 인증정보 월드 초기화 작업주기 (단위:ms)
|
|
const int RESETAUTHWORLDLIMITTERM = (2*30*1000); // 인증정보 월드 초기화 제한시간 (단위:ms)
|
|
|
|
const int GETAUTHUSERCOUNT = 1000 * 10; // 인증월드유저 카운트 획득주기
|
|
|
|
const int GUILDMGRCHKTERM = (5*1000); // 길드 관리자 체크 주기
|
|
const int GUILDMGRUPDTERM = (10*1000); // 길드 관리자 갱신 주기
|
|
const int GUILDCHKMEMBTERM = (30*1000); // 길드 멤버정보 체크 주기
|
|
const int GUILDCHKRESCTERM = (30*1000); // 길드 자원반납 체크 주기
|
|
const int GUILDREQINFOTERM = (60*1000); // 길드 정보요청 체크 주기
|
|
const int GUILDRFSVIEWTERM = (10*1000); // 길드 시각정보 갱신 주기
|
|
const int GUILDAPLPOINTTERM = (10*1000); // 길드 일반/래더 포인트 DB 적용 주기
|
|
const int GUILDCHKRESCLIMIT = (2*30*1000); // 길드 자원반납 체크 제한
|
|
|
|
const int PERIODQUESTTERM = (60*1000); // 기간제 퀘스트 갱신 주기
|
|
|
|
const int PERIODGUILDWARTERM = (60*1000); // 길드전 갱신 주기
|
|
const int GUILDWARMISSION_MAXGROUP = 4;
|
|
|
|
const int SERVICEMANAGER_SERVERDEALY_SIZE = 1000;
|
|
const int SERVICEMANAGER_REPORT_SIZE = 4096;
|
|
|
|
#define SWAP16(x) (((((x) & 0xff) << 8) | (((x) >> 8) & 0xff)))
|
|
#define SWAP32(x) (((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)))
|
|
#define SWAP64(x) (((((x) & 0xFF00000000000000ULL) >> 56) | (((x) & 0x00FF000000000000ULL) >> 40) | (((x) & 0x0000FF0000000000ULL) >> 24) | (((x) & 0x000000FF00000000ULL) >> 8) | \
|
|
(((x) & 0x00000000FF000000ULL) << 8) | (((x) & 0x0000000000FF0000ULL) << 24) | (((x) & 0x000000000000FF00ULL) << 40) | (((x) & 0x00000000000000FFULL) << 56)))
|
|
|
|
struct DNProcessCheck
|
|
{
|
|
enum eDNProcessCheck
|
|
{
|
|
Key = 0x00000001,
|
|
DisconnectInterval = 60*1000*2,
|
|
UpdateInterval = 10*1000,
|
|
HeartbeatKey = 0x00000002,
|
|
SQLHeartbeatInterval = 60*1000*10,
|
|
SelectIPMagicInterval = 60*1000*60,
|
|
};
|
|
};
|
|
|
|
// enum ----------------------------------------------------------------------------------------------
|
|
enum eServerType
|
|
{
|
|
SERVERTYPE_LOGIN, // 로그인 서버
|
|
SERVERTYPE_DB, // DB 서버
|
|
SERVERTYPE_VILLAGE, // 빌리지 서버
|
|
SERVERTYPE_GAME, // 게임 서버
|
|
SERVERTYPE_MASTER, // 마스터 서버
|
|
SERVERTYPE_LOG, // 로그 서버
|
|
SERVERTYPE_MAX,
|
|
};
|
|
|
|
enum ePatchType
|
|
{
|
|
PATCHTYPE_LOGIN, // 로그인 서버
|
|
PATCHTYPE_DB, // DB 서버
|
|
PATCHTYPE_VILLAGE, // 빌리지 서버
|
|
PATCHTYPE_GAME, // 게임 서버
|
|
PATCHTYPE_MASTER, // 마스터 서버
|
|
PATCHTYPE_LOG, // 로그 서버
|
|
PATCHTYPE_PATCHER, // ESM
|
|
PATCHTYPE_CASH, // 캐쉬 서버
|
|
};
|
|
|
|
enum eConnectionKey
|
|
{
|
|
CONNECTIONKEY_DEFAULT = 0,
|
|
CONNECTIONKEY_USER,
|
|
CONNECTIONKEY_LOGIN,
|
|
CONNECTIONKEY_DB,
|
|
CONNECTIONKEY_VILLAGE,
|
|
CONNECTIONKEY_GAME,
|
|
CONNECTIONKEY_MASTER,
|
|
CONNECTIONKEY_LOG,
|
|
CONNECTIONKEY_LAUNCHER,
|
|
CONNECTIONKEY_SERVICEMANAGER,
|
|
CONNECTIONKEY_AUTH, // 인증섭(넥슨)
|
|
CONNECTIONKEY_CASH,
|
|
CONNECTIONKEY_BILLING, // 빌링섭(퍼블리셔)
|
|
CONNECTIONKEY_SERVICEPATCHER,
|
|
CONNECTIONKEY_SERVERMONITOR,
|
|
CONNECTIONKEY_TW_AUTHLOGIN, // 인증섭(감마니아 1 - Authorization : 사용자 계정 인증 처리, 상태 (블록 여부, 캐쉬 잔여 포인트 ?) 체크)
|
|
CONNECTIONKEY_TW_AUTHLOGOUT, // 인증섭(감마니아 2 - Logout : 사용자 로그아웃 처리)
|
|
CONNECTIONKEY_TW_QUERY,
|
|
CONNECTIONKEY_TW_SHOPITEM,
|
|
CONNECTIONKEY_TW_COUPON, // 감마니아 쿠폰서버
|
|
CONNECTIONKEY_TW_COUPON_ROLLBACK, // 감마니아 쿠폰롤백..징그러운것들 서버를 포트별로 만들다니..ㅠ
|
|
CONNECTIONKEY_TH_AUTH,
|
|
CONNECTIONKEY_TH_OTP,
|
|
CONNECTIONKEY_TH_QUERY,
|
|
CONNECTIONKEY_TH_SHOPITEM,
|
|
CONNECTIONKEY_DOORS,
|
|
};
|
|
|
|
enum eAcceptOpenVerifyType
|
|
{
|
|
ACCEPTOPEN_VERIFY_TYPE_APPINITCOMPLETE = 0,
|
|
ACCEPTOPEN_VERIFY_TYPE_MASTERCONNECTION,
|
|
ACCEPTOPEN_VERIFY_TYPE_RESETAUTH,
|
|
ACCEPTOPEN_VERIFY_TYPE_MAX,
|
|
};
|
|
|
|
enum eServerLogLevel
|
|
{
|
|
ServerLogLevel_1 = 1,
|
|
ServerLogLevel_2 = 2,
|
|
ServerLogLevel_3 = 3,
|
|
};
|
|
|
|
enum eUserState // login에서 쓰는 상태값
|
|
{
|
|
STATE_NONE,
|
|
|
|
// login
|
|
STATE_CHECKVERSION,
|
|
STATE_CHECKLOGIN, // 아이디 패스워드 확인상태
|
|
STATE_SERVERLIST,
|
|
STATE_WAITUSER, // 대기유저
|
|
STATE_CHARLIST, // 캐릭터 리스트 상태
|
|
STATE_CHANNELLIST,
|
|
STATE_CONNECTVILLAGE, // 빌리지 서버에 접속가능상태
|
|
STATE_CONNECTGAME, // 겜 서버에 접속가능상태
|
|
STATE_RECONNECTLOGIN, // 리커넥트 상태
|
|
|
|
// master
|
|
STATE_CHECKVILLAGE, //빌리지로 넘어가기전의 상태입니다. 유저가 끊길경우 고아가 되므로 이 스테이트를 통해서 관리됩니다.
|
|
STATE_CHECKGAME, //게임으로 넘어가기 전의 상태입니다. 상동
|
|
STATE_CHECKRECONNECTLOGIN, //캐릭터선택창으로 넘어가기 전의 상태입니다. 상동
|
|
STATE_VILLAGE, // village상태인가
|
|
STATE_GAME, // game상태인가
|
|
STATE_LOGIN, // login상태인가
|
|
|
|
// village
|
|
STATE_LOADUSERDATA, // 유저데이터 DB에서 불러왔는지
|
|
STATE_READY, // 필드 나갈 준비 완료
|
|
STATE_READYTOVILLAGE, // village 딴 장비로 옮길때 (준비단계)
|
|
STATE_READYTOGAME, // game으로 넘어갈때 (준비단계)
|
|
STATE_READYTOLOGIN, // login으로 넘어갈때 (준비단계)
|
|
STATE_MOVETOVILLAGE, // village 딴 장비로 옮길때
|
|
STATE_MOVETOGAME, // game으로 넘어갈때
|
|
STATE_MOVETOLOGIN, // login으로 넘어갈때
|
|
STATE_MOVESAMECHANNEL, // 같은 채널 이동
|
|
|
|
#if defined(_HSHIELD)
|
|
HSHIELD_NONE = 0,
|
|
HSHIELD_RESPONSEVERSION = 1, // checkversion 패킷 받은 상태
|
|
HSHIELD_RECONNECTLOGIN, // 재접속 패킷 받은 상태
|
|
HSHIELD_LOADUSER, // 디비 로드 끝낸상태
|
|
HSHIELD_REQUEST, // _AhnHS_MakeRequest 요청상태
|
|
HSHIELD_RESPONSE, // 응답온 상태
|
|
#endif // _HSHIELD
|
|
|
|
};
|
|
|
|
//enumulation
|
|
//GameRoom
|
|
enum eGameRoomState
|
|
{
|
|
_GAME_STATE_NONE, //생성!
|
|
_GAME_STATE_READY2CONNECT, //초기화 완료 컨넥션 대기! 상태
|
|
_GAME_STATE_CONNECT2CHECKAUTH, //DB 를 이용한 인증정보 체크
|
|
_GAME_STATE_CONNECT2LOAD, //연결 및 검증 완료! 로드상태로 전이
|
|
_GAME_STATE_LOAD2SYNC, //클라이언트 연결완료 준비상태
|
|
_GAME_STATE_SYNC2SYNC,
|
|
_GAME_STATE_SYNC2PLAY, //플레이대기중
|
|
_GAME_STATE_PLAY, //게임중!
|
|
|
|
_GAME_STATE_CANCEL_LOADING, //백그라운드 로더와 싱크
|
|
_GAME_STATE_DESTROYED, //방깨졌삼!
|
|
_GAME_STATE_FARM_NONE, //농장용 스테이트입니다. 생성 루틴이 달라 일반과 다르게 흘러갑니다 _GAME_STATE_PLAY부터는 동일
|
|
_GAME_STATE_FARM_READY2LOAD, //디비에 농장관련 데이타를 요청한 상태
|
|
_GAME_STATE_FARM_LOAD2PLAY, //디비에서 농장관련 데이타를 받았다. 세팅하고 마스터에 알리자
|
|
_GAME_STATE_FARM_PAUSE, //농장 포우즈~
|
|
_GAME_STATE_PVP_SYNC2GAMEMODE, //피빕피일경우 유저가 없는 상태에서 시작시점이 생김(길드전) 접속스테이트를 건너뛰고 모드받고 로드로 넘어가는 중간스테이트
|
|
};
|
|
|
|
//GameSession
|
|
enum eGameSessionState
|
|
{
|
|
SESSION_STATE_NONE,
|
|
SESSION_STATE_READY, //객체생성만 되어 있음! 연결은 안되어 있음
|
|
SESSION_STATE_RUDP_CONNECTED,
|
|
SESSION_STATE_CONNECTED, //연결 되었음!
|
|
SESSION_STATE_LOAD, //연결 되면 디비에 요청합니다.
|
|
SESSION_STATE_LOADED, //게임로딩완료!
|
|
SESSION_STATE_WAIT_TO_READY, //Ready 상태 기다림
|
|
SESSION_STATE_READY_TO_SYNC, //Sync 준비 완료!
|
|
SESSION_STATE_SYNC_READY_2_DELAY, //서버가 메세지처리준비가 안되상태에서 메세지를 받았습니다.
|
|
SESSION_STATE_READY_TO_PLAY, //Sync 2 Play
|
|
SESSION_STATE_GAME_PLAY, //게임플레이중!
|
|
SESSION_STATE_READY_TO_VILLAGE, //game -> village (준비단계)
|
|
SESSION_STATE_READY_TO_LOGIN, //game -> login char select (준비단계)
|
|
SESSION_STATE_RECONNECTLOGIN, //game -> login char select
|
|
SESSION_STATE_SERVER_CHANGE, //서버이동중! 이동완료되면 끊김
|
|
SESSION_STATE_DISCONNECTED, //짤린상태! (tcp까지 전부 끊긴 상태)
|
|
//SESSION_STATE_CRASH, //크래쉬!
|
|
};
|
|
|
|
// GameServer Parse Type
|
|
enum eGameMsgType
|
|
{
|
|
MSG_TYPE_MASTER,
|
|
MSG_TYPE_DATABASE,
|
|
};
|
|
|
|
enum eFieldMessage
|
|
{
|
|
FM_CREATE,
|
|
FM_DESTROY,
|
|
FM_SHOW,
|
|
FM_HIDE,
|
|
FM_MOVE,
|
|
FM_ACTORMSG,
|
|
FM_CHAT,
|
|
FM_CHANGEEQUIP,
|
|
FM_ADDEXP,
|
|
FM_LEVELUP,
|
|
FM_CHANGEAPPELLATION,
|
|
FM_CHANGEHIDE,
|
|
FM_CHANGECASHEQUIP,
|
|
FM_CHANGEGUILDSELFVIEW,
|
|
FM_CHANGEJOB,
|
|
FM_EFFECT,
|
|
FM_CHANGECOLOR,
|
|
FM_CHANGEGLYPH,
|
|
FM_CHATROOMVIEW,
|
|
FM_CHATROOMUSER,
|
|
FM_CHANGEVEHICLE,
|
|
FM_CHANGEVEHICLECOLOR,
|
|
FM_CHANGEPET,
|
|
FM_CHANGEPETBODY,
|
|
FM_RENAME_PET,
|
|
FM_ENTERPARTY,
|
|
FM_LEAVEPARTY,
|
|
FM_CHARACTER_RENAME,
|
|
FM_GUILDWARWINSKILL,
|
|
FM_USE_SOURCE,
|
|
FM_USE_EFFECTSKILL,
|
|
FM_HAVE_NAMEDITEM,
|
|
FM_CHANGE_TRANSFORM,
|
|
FM_CHANGETALISMAN,
|
|
FM_CHANGEDWCTEAM,
|
|
};
|
|
|
|
enum eClass
|
|
{
|
|
CLASS_NONE = 0,
|
|
CLASS_WARRIER = 1,
|
|
CLASS_ARCHER,
|
|
CLASS_SOCERESS,
|
|
CLASS_CLERIC,
|
|
#if defined( PRE_ADD_ACADEMIC )
|
|
CLASS_ACADEMIC,
|
|
#endif // #if defined( PRE_ADD_ACADEMIC )
|
|
#if defined( PRE_ADD_KALI )
|
|
CLASS_KALI,
|
|
#endif // #if defined( PRE_ADD_KALI )
|
|
// CLASS_ASSASSIN,
|
|
// CLASS_LENCEA,
|
|
// CLASS_MACHINA,
|
|
CLASS_MAX,
|
|
};
|
|
|
|
enum eJob
|
|
{
|
|
JOB_NONE,
|
|
|
|
JOB_WARRIER = 1,
|
|
JOB_ARCHER,
|
|
JOB_SOCERESS,
|
|
JOB_CLERIC,
|
|
|
|
JOB_BLAZEWARRIER = 11,
|
|
JOB_SWORDMAN,
|
|
JOB_CHAINSOLDIER,
|
|
|
|
JOB_RANGER = 21,
|
|
JOB_HUNTER,
|
|
JOB_KEEPER,
|
|
|
|
JOB_WIZARD = 31,
|
|
JOB_MAGICIAN,
|
|
JOB_WITCH,
|
|
|
|
JOB_PRIEST = 41,
|
|
JOB_PALADIN,
|
|
JOB_MONK,
|
|
|
|
JOB_MAX = 47,
|
|
};
|
|
|
|
enum eAppendItemString
|
|
{
|
|
Append_ItemSN,
|
|
Append_Price,
|
|
Append_Limit,
|
|
Append_ItemID,
|
|
Append_Option,
|
|
Append_Refundable,
|
|
#ifdef PRE_ADD_LIMITED_CASHITEM
|
|
Append_QuantityLimited,
|
|
#endif //#ifdef PRE_ADD_LIMITED_CASHITEM
|
|
|
|
Append_Max,
|
|
};
|
|
|
|
enum eModItemBitmap
|
|
{
|
|
ModItem_Durability = 1,
|
|
ModItem_Level = (1<<1),
|
|
ModItem_Potential = (1<<2),
|
|
ModItem_SoulBound = (1<<3),
|
|
ModItem_SealCount = (1<<4),
|
|
ModItem_Option = (1<<5),
|
|
ModItemAll = ModItem_Durability|ModItem_Level|ModItem_Potential|ModItem_SoulBound|ModItem_SealCount|ModItem_Option,
|
|
};
|
|
|
|
enum eWeaponType
|
|
{
|
|
WEAPON_SWORD, // 대검
|
|
WEAPON_GAUNTLET, // 건틀렛
|
|
WEAPON_AXE, // 도끼
|
|
WEAPON_HAMMER, // 해머
|
|
WEAPON_SMALLBOW, // 소궁
|
|
WEAPON_BIGBOW, // 대궁
|
|
WEAPON_CROSSBOW, // 석궁
|
|
WEAPON_STAFF, // 스테프
|
|
WEAPON_BOOK, // 마법서
|
|
WEAPON_ORB, // 수정구
|
|
WEAPON_PUPPET, // 주술인형
|
|
WEAPON_MACE, // 메이스
|
|
WEAPON_FLAIL, // 프레일
|
|
WEAPON_WAND, // 완드
|
|
WEAPON_SHIELD, // 방패
|
|
WEAPON_ARROW, // 화살
|
|
WEAPON_CANNON, // 캐논
|
|
WEAPON_BUBBLEGUN, // 버블건
|
|
WEAPON_GLOVE, // 글러브
|
|
WEAPON_FAN, // 부채
|
|
WEAPON_CHAKRAM, // 차크람
|
|
WEAPON_CHARM, // 참
|
|
WEAPON_SCIMITER, // 시미터
|
|
WEAPON_DAGGER, // 대거
|
|
WEAPON_CROOK, // 크룩
|
|
WEAPON_SPEAR,
|
|
WEAPON_RESERVED1,
|
|
WEAPON_BRACELET,
|
|
WEAPON_KNUCKLE,
|
|
WEAPON_RESERVED2,
|
|
WEAPON_CLAW,
|
|
};
|
|
|
|
enum eParts
|
|
{
|
|
PARTS_FACE, //
|
|
PARTS_HAIR,
|
|
PARTS_HELMET, // 투구
|
|
PARTS_BODY, // 상체
|
|
PARTS_LEG, // 하체
|
|
PARTS_HAND, // 손
|
|
PARTS_FOOT, // 발
|
|
PARTS_NECKLACE,
|
|
PARTS_EARRING,
|
|
PARTS_RING,
|
|
PARTS_RING2,
|
|
PARTS_CREST,
|
|
PARTS_FULLSET, // 풀세트
|
|
};
|
|
|
|
enum eQuestDataType
|
|
{
|
|
QUESTDATA_STATE = 1, // 퀘스트 상태
|
|
QUESTDATA_STEP, // 현재 퀘스트 스텝
|
|
QUESTDATA_JOURNAL, // 현재 퀘스트 저널
|
|
};
|
|
|
|
enum eEtcType // DNEtc table Type
|
|
{
|
|
ETC_NONE,
|
|
ETC_QUICKSLOT, // TQuickSlot QuickSlot[QUICKSLOTMAX]; // 단축 슬롯창 (10개씩 2줄)
|
|
ETC_JOB, // USHORT wJobArray[JOBMAX]; // 직업 (0: 맨처음 직업, 나머지 쭉쭉~ 전직 포함)
|
|
ETC_NOTIFIER, // int Notifier[Notifier_MaxCount]; // 알리미 (quest, mission)
|
|
ETC_DUNGEONCLEAR, // TDungeonClearData DungeonClear[DUNGEONCLEARMAX]; // 던전 클리어 (120개)
|
|
ETC_ETERNITYITEM, // USHORT wEternityItem[ETERNITYITEMMAX]; // 영구아이템
|
|
ETC_EQUIPDELAYTIME, // int nEquipDelayTime[EQUIPMAX]; // equip index에 관련된 cooltime
|
|
ETC_EQUIPREMAINTIME, // int nEquipRemainTime[EQUIPMAX];
|
|
};
|
|
|
|
enum eAuthType
|
|
{
|
|
AUTHTYPE_BEGINAUTH, // 인증 시작
|
|
AUTHTYPE_STOREAUTH, // 인증 저장
|
|
AUTHTYPE_CHECKAUTH, // 인증 체크
|
|
AUTHTYPE_RESETAUTH, // 인증 리셋
|
|
AUTHTYPE_CNT,
|
|
};
|
|
|
|
enum eAbuseCode
|
|
{
|
|
ABUSE_NONE = 0,
|
|
ABUSE_MOVE_SERVERS, // 마을 <-> 던젼 워프
|
|
ABUSE_MOVE_INSKY, // 공중이동
|
|
ABUSE_HACKSHIELD, // 핵쉴드에서 부정이용자
|
|
ABUSE_TWN_EXTENDLOG, // 대만용 추가 로그값 #48714 관계 있음
|
|
#if defined( PRE_ADD_CHARACTERCHECKSUM )
|
|
ABUSE_CHARACTER_CHECKSUM, // #80315 캐릭터 체크섬 이상 발견
|
|
#endif // #if defined( PRE_ADD_CHARACTERCHECKSUM )
|
|
};
|
|
|
|
struct WorldUserState
|
|
{
|
|
enum eCode
|
|
{
|
|
Add = 0,
|
|
Delete,
|
|
Modify,
|
|
};
|
|
};
|
|
|
|
namespace DBDNMembership
|
|
{
|
|
struct OrderStatusCode
|
|
{
|
|
enum eOrderStatusCode
|
|
{
|
|
SuccessPayment = 1, // 결제성공 & pickup 대기
|
|
Success = 2, // 구매완료
|
|
FailPayment = 3, // 결제실패
|
|
};
|
|
};
|
|
};
|
|
|
|
namespace DBDNWorldDef
|
|
{
|
|
struct CharacterExpChangeCode
|
|
{
|
|
enum eCharacterExpChangeCode
|
|
{
|
|
Quest = 1, // : 퀘스트 보상 -> FKey = QuestID
|
|
Dungeon = 2, // : 던전 보상 -> FKey = PartyID or NULL
|
|
Cheat = 3, // : 치트 -> FKey = NULL
|
|
Admin = 4, // : 보정 변경
|
|
Eternity = 5, // 영구아이템 -> FKey = ItemSerial
|
|
PvP = 6, // : PvP 피로도 보상 -> FKey = NULL
|
|
DungeonMonster = 7, // :던젼 몬스터 사냥 경험치 -> FKey = PartyID or NULL( 서버에서 구분자로 쓰임..DB에 넘어갈때는 Dungeon 으로 Convert 된다. )
|
|
Item = 8, // : 경험치증가 아이템 -> FKey = ItemID
|
|
};
|
|
};
|
|
|
|
struct CharacterLevelChangeCode
|
|
{
|
|
enum eCharacterLevelChangeCode
|
|
{
|
|
Normal = 1, // : 일반
|
|
Cheat = 2, // : 치트
|
|
Admin = 3, // : 관리자 변경
|
|
};
|
|
};
|
|
|
|
struct CoinChangeCode
|
|
{
|
|
enum eCoinChangeCode // 주의 : 던전 보상, 우편첨부, 창고 입출금, 아이템 되팔기, 교환 입출금, 교환 수수료, 강화 수수료, 스킬 언락, 상점 구입, 우편 수수료 인 경우 각각의 SP에 포함되어 있습니다.
|
|
{
|
|
DoNotDBSave = 0,
|
|
QuestReward = 1, // : 퀘스트 보상 (FKey: QuestID)
|
|
PickUp = 2, // : 픽업 (FKey: PartyID or NULL)
|
|
Cheat = 3, // : 치트 (FKey: NULL)
|
|
Admin = 4, // : 관리자 변경 (FKey: AuditLogID)
|
|
Use = 5, // : 사용 (FKey: NULL)
|
|
// 6: 우편송신첨부 (FKey: MailID)
|
|
// 7: 우편수신첨부 (FKey: MailID)
|
|
InvenToWare = 8, // : 창고 입금 (FKey: NULL)
|
|
WareToInven = 9, // : 창고 출금 (FKey: NULL)
|
|
// 10: 아이템 되팔기 (FKey: NpcID)
|
|
// 11: 교환 입금 (FKey: CharacterID)
|
|
// 12: 교환 출금 (FKey: CharacterID)
|
|
QuestSub = 13, // 퀘스트 차감 (FKey: QuestID)
|
|
RepairItem = 14, // 아이템 수리 (FKey: ItemSerial)
|
|
// 15: 교환 수수료 (FKey: NULL)
|
|
// 16: 강화 수수료 (FKey: ItemEnchantLogID)
|
|
// 17: 스킬 언락 (FKey: SkillID)
|
|
// 18: 상점 구입 (FKey: ItemSerial)
|
|
DisjointTax = 19, // 분해수수료 (FKey: NULL)
|
|
// 20: 우편 수수료 (FKey: MailID)
|
|
// 21: 무인상점등록 수수료 (FKey: TradeID)
|
|
// 22: 무인상점 아이템 구 (FKey: TradeID)입
|
|
// 23: 무인상점 아이템 판매금 (FKey: TradeID)
|
|
// 24: 무인상점 거래 성립 수수료 (FKey: TradeID)
|
|
CompoundTax = 25, // 조합수수료 (FKey: NULL)
|
|
// 26: 캐릭터 삭제 (FKey: NULL)
|
|
MaxLevelExperienceTransGold = 27, // 만랩 경험치 골드 보상 (FKey: NULL)
|
|
Present = 28, // 선물 (FKey: NpcID)
|
|
// 29: 길드 창설 (FKey: GuildID)
|
|
GuildLevelup = 30, // 30: 길드 레벨 업 (FKey: GuildID)
|
|
InvenToGuildWare = 31, // 31: 길드 창고 입금 (FKey: GuildID)
|
|
GuildWareToInven = 32, // 32: 길드 창고 출금 (FKey: GuildID)
|
|
GuildRewardBuy = 33, // 33: 길드 보상 구매 (FKey: GuildItemID)
|
|
Donation = 34, // 기부
|
|
// 35: (DOORS) 등록수수료
|
|
// 36: (DOORS) 입찰수수료
|
|
// 37: (DOORS) 낙찰수수료
|
|
// 38: (DOORS) 낙찰결제
|
|
// 39: (DOORS) 낙찰정산
|
|
// 40: (DOORS) 등록수수료취소
|
|
// 41: (DOORS) 입찰수수료취소
|
|
// 42: (DOORS) 낙찰수수료취소
|
|
// 43: (DOORS) 낙찰결제취소
|
|
// 44: (DOORS) 낙찰정산취소
|
|
CharmItem = 45, // 보물상자 (FKey: ItemID)
|
|
ChaosItem = 46, // 카오스 큐브 (FKey: ItemID)
|
|
SpecialBox = 47, // 특수보관함 (FKey: EventRewardID)
|
|
// 48: 월드창고 사용 수수료
|
|
// 49: C2C 보관
|
|
// 50: C2C 회수
|
|
// 51: C2C 거래
|
|
TalismanSlotOpen = 52, // 52: 탈리스만 슬롯 오픈(FKey: 슬롯 인덱스)
|
|
TalismanSlotChange = 53, // 53: 탈리스만 슬롯 장착 위치 이동
|
|
|
|
GamblePrice=55, // 55: 도박모드 참가비
|
|
GambleFirstWinner=56, // 56: 도박모드 1등 골드
|
|
GambleSecondWinner=57, // 56: 도박모드 2등 골드
|
|
DWC = 58, // 58: DWC 캐릭터 기본 소유 골드
|
|
};
|
|
enum ePetalChangeCode
|
|
{
|
|
GambleEnterPetal= 9, // 9: 도박모드 페탈 입장료
|
|
GambleFirstWinPetal= 12, // 12: 도박모드 1등 페탈 상금
|
|
GambleSecondWinPetal= 13, // 13: 도박모드 2등 페탈 상금
|
|
};
|
|
};
|
|
|
|
struct CoinTypeCode
|
|
{
|
|
enum eCoinTypeCode
|
|
{
|
|
Coin = 1, // : 코인
|
|
WarehouseCoin = 2, // : 창고 코인
|
|
RebirthCoin = 3, // : 부활 코인
|
|
PCBangRebirthCoin = 4, // : PC방 부활 코인
|
|
};
|
|
};
|
|
|
|
struct EquipmentAttributeCode
|
|
{
|
|
enum eEquipmentAttributeCode
|
|
{
|
|
DelayTime = 1, // : 딜레이 시간
|
|
RemainTime = 2, // : Remain 시간
|
|
};
|
|
};
|
|
|
|
struct FatigueTypeCode
|
|
{
|
|
enum eFatigueTypeCode
|
|
{
|
|
PCBang = 1, // : PC방 피로도
|
|
Daily = 2, // : 일일 피로도
|
|
Weekly = 3, // : 주간 피로도
|
|
Event = 4, // 이벤트 피로도
|
|
VIP = 5, // VIP피로도
|
|
};
|
|
};
|
|
|
|
struct PublisherCode
|
|
{
|
|
enum ePublisherCode
|
|
{
|
|
Studio = 0,
|
|
KR = 1,
|
|
CH = 2,
|
|
JP = 3,
|
|
TW = 4,
|
|
US = 5,
|
|
SG = 6,
|
|
TH = 7,
|
|
ID = 8,
|
|
RU = 9,
|
|
EU = 10,
|
|
};
|
|
};
|
|
|
|
struct QuestStatusCode
|
|
{
|
|
enum eQuestStatusCode
|
|
{
|
|
Gain = 0, // : 퀘스트획득
|
|
Progress = 1, // : 퀘스트진행
|
|
};
|
|
};
|
|
|
|
struct SkillPointCode
|
|
{
|
|
enum eSkillPointCode
|
|
{
|
|
LevelUp = 1, // 스킬레벨업
|
|
EternityItem = 2, // 영구적용아이템
|
|
Repair = 10, // 걍 강제로 복구 세팅
|
|
};
|
|
};
|
|
|
|
struct SkillChangeCode
|
|
{
|
|
enum eSkillChangeCode
|
|
{
|
|
Gain = 1, // : 스킬포인트 획득
|
|
Use = 2, // : 스킬레벨업 & 스킬포인트 사용
|
|
Reset = 3, // : 스킬포인트 리셋
|
|
GainByQuest = 4, // : 스킬 획득 (퀘스트)
|
|
GainByDungeon = 5, // : 스킬 획득 (던전 보상)
|
|
GainByBook = 6, // : 스킬 획득 (스킬북)
|
|
GainByEvent = 7, // : 스킬 획득 (이벤트)
|
|
GainByAdmin = 8, // : 스킬 획득 (by 관리자)
|
|
DelByDrop = 9, // : 스킬 삭제 (드랍)
|
|
DelByQuest = 10, // : 스킬 삭제 (퀘스트)
|
|
DelByEvent = 11, // : 스킬 삭제 (이벤트 만료)
|
|
DelByAdmin = 12, // : 스킬 삭제 (by 관리자)
|
|
ModSkillLevelByAdmin = 13, // : 스킬레벨 조정 (by 관리자)
|
|
GainByBuy = 14, // 14스킬획득(구입)
|
|
};
|
|
};
|
|
|
|
struct TradeStatusCode
|
|
{
|
|
enum eTradeStatusCode
|
|
{
|
|
Sell = 0, // : 판매중
|
|
CompleteSellByItem = 1, // : 판매완료(아이템 수령)
|
|
CompleteSellByCoin = 2, // : 판매완료(판매금 수령)
|
|
CancelSell = 3, // : 판매취소
|
|
Expire = 4, // : 기간만료
|
|
};
|
|
};
|
|
|
|
struct AddMaterializedItem
|
|
{
|
|
enum eCode
|
|
{
|
|
Pick = 1, // 1=줍기 -> FKey: PartyID or NULL
|
|
Mission = 2, // 2=미션 -> FKey: MissionID
|
|
QuestReward = 3, // 3=퀘스트보상 -> FKey: QuestID
|
|
Present = 4, // 4=선물 -> FKey: PurchaseID
|
|
PointBuy = 5, // 5=인게임포인트 구입 -> FKey: NPCID
|
|
CashBuy = 6, // 6=캐쉬 구입 -> FKey: PurchaseID
|
|
ReserveMoneyBuy = 7, // 7=페탈 구입 -> FKey: PurchaseID
|
|
GetGachaResultCashItem_JP = 9, // 9=일본 가챠 돌려서 나온 캐쉬 아이템.
|
|
GMGive = 10, // 10=관리자 지급 -> FKey: AuditLogID
|
|
ItemDecompose = 11, // 11=아이템 분해 -> FKey: NPCID
|
|
// ItemEnchantFail = 12, // 12=아이템 강화 실패 -> FKey: ItemEnchantID
|
|
ItemCompound = 13, // 조합
|
|
RandomItem = 14, // 랜덤아이템
|
|
DungeonReward = 15, // 던젼보상
|
|
PvPReward = 16, // pvp보상
|
|
CharacterCreate = 17, // 기본지급
|
|
SystemMail = 18, // 시스템메일 (미션보상)
|
|
FixedItem = 19, // 캐쉬템 (얼굴, 머리) - 기존얼굴/머리 지우고 덮어쓰기 -> FKey: 캐쉬템 사용아이템시리얼 (인벤에 있는애)
|
|
CostumeMix = 21, // 코스튬 합성
|
|
FishingReward = 22, // 낚시보상
|
|
Harvest = 23, // 수확
|
|
Cheat = 24, // 치트
|
|
PvPLadderPoint = 25, // 래더포인트
|
|
UnionPoint = 26, // 연합포인트
|
|
Trigger = 27, // 트리거
|
|
GuildWarFestivalPoint = 28, // 길드 축제 포인트
|
|
Repurchase = 29,
|
|
GuildReversionItem = 30,
|
|
CostumeRandomMixItem = 31,
|
|
BestFriendItem = 34,
|
|
COMEBACKREWARD = 35, // 복귀유저보상
|
|
SpecialBoxReward = 36,
|
|
NewbieGameQuitReward = 37, //신규 유저 접속 종료할 때 보상
|
|
NewbiewReConnectReward = 38, //신규 유저 재접속시 보상
|
|
ComebackGameQuitReward = 39, //귀환자 접속 종료할 때 보상
|
|
SeedPointBuy = 40, //시드로 구입
|
|
};
|
|
};
|
|
|
|
struct MailTypeCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Normal = MailType::NormalMail, // 일반 메일
|
|
Mission = MailType::MissionMail, // 미션 보상
|
|
Admin = MailType::AdminMail, // 관리자 메일
|
|
EventMail = MailType::EventMail, // 이벤트 메일
|
|
VIP = MailType::VIPMail, // VIP
|
|
MasterSystem = MailType::MasterSystemMail, // 사제시스템
|
|
NpcReputaion = MailType::NpcReputationMail, // NPC호감도시스템
|
|
Quest = MailType::Quest, // 퀘스트
|
|
GuildWarReward = MailType::GuildWarReward, // 길드전 보상
|
|
SpecialBox_Account = MailType::SpecialBox_Account, // 특수보관함_계정타겟
|
|
SpecialBox_Character = MailType::SpecialBox_Character, // 특수보관함_현캐릭터타겟
|
|
Cadge = MailType::Cadge, // 조르기
|
|
GuildMaxLevelReward = MailType::GuildMaxLevelReward,// 최초길드가입 만랩 길드 보상
|
|
AppellationBookReward = MailType::AppellationBookReward, // 칭호 컬렉션북 완료 보상
|
|
};
|
|
};
|
|
|
|
struct UseItem
|
|
{
|
|
enum eUseItemCode
|
|
{
|
|
DoNotDBSave = 0,
|
|
Use = 1, // 1=소모성 아이템 사용
|
|
Destroy = 2, // 2=버리기
|
|
DeCompose = 4, // 4=분해
|
|
Present = 5, // 5=선물
|
|
GuildReversionItem = 6, // 6=길드탈퇴나 추방으로 길드귀속아이템 삭제
|
|
};
|
|
};
|
|
|
|
struct ItemLocation
|
|
{
|
|
enum eCode
|
|
{
|
|
Equip = 1,
|
|
Inventory = 2,
|
|
Warehouse = 3,
|
|
QuestInventory = 4,
|
|
CashInventory = 5,
|
|
GiftRepository = 6,
|
|
CashEquip = 7,
|
|
Glyph = 8,
|
|
VehicleInventory = 9,
|
|
PetInventory = 10,
|
|
HarvestDepot = 11, // 수확창고
|
|
ServerWare = 17, // 서버 일반 아이템 창고
|
|
ServerWareCash = 18, // 서버 캐쉬 아이템 창고
|
|
Talisman = 19, // 탈리스만
|
|
PeriodInventory = 20,
|
|
PeriodWarehouse = 21,
|
|
};
|
|
};
|
|
|
|
struct PetType
|
|
{
|
|
enum eCode
|
|
{
|
|
Vehicle = 1,
|
|
Pet = 2,
|
|
SATIETY_PET = 3,
|
|
};
|
|
};
|
|
|
|
struct PayMethodCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Coin = 1, // 1: 코인
|
|
Cash = 2, // 2: 캐쉬
|
|
Petal = 3, // 3: 적립금
|
|
Coupon = 4, // 4: 쿠폰
|
|
Admin = 5, // 5: 관리자 지급
|
|
Quest = 6, // 6: 퀘스트보상
|
|
Mission = 7, // 7: 미션보상
|
|
LevelupEvent = 8, // 8=캐릭터 레벨 업 보상
|
|
VIP = 9, // 9 : VIP 선물
|
|
PvP = 10, // 10 : PVP 래더 포인트
|
|
Union_Commerical = 11, // 11 : 상인 연합 포인트
|
|
Union_Royal = 12, // 12 : 왕성 연합 포인트
|
|
Union_Liberty = 13, // 13 : 자유 연합 포인트
|
|
Cash_NexonUSA = 14, // 14 : 넥슨아메리카 캐쉬
|
|
Event = 15, // 15 : 이벤트
|
|
GuildWar_Festival = 16, // 16 : 길드전 축제 포인트
|
|
GuildWar_Reward = 17, // 17 : 길드전 보상
|
|
Comeback = 19, // 18 : 복귀유저보상
|
|
BestFriend = 20, // 20 : 절친
|
|
BeginnerGuild = 21, // 21 : 초보자길드 선물
|
|
GuildSupport = 22, // 22 : 길드지원보상
|
|
ActiveMission = 23, // 23 : 액티브미션 보상
|
|
#if defined( PRE_ADD_STAMPSYSTEM )
|
|
Stamp = 24, // 24 : 스탬프 보상
|
|
#endif // #if defined( PRE_ADD_STAMPSYSTEM )
|
|
#if defined( PRE_ADD_NEW_MONEY_SEED )
|
|
SeedPoint = 25, // 25 : 시드로 구입
|
|
#endif
|
|
};
|
|
};
|
|
|
|
struct CashRebirthCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Cash = 1,
|
|
Petal = 2,
|
|
Admin = 3,
|
|
Item = 4,
|
|
Seed = 5,
|
|
};
|
|
};
|
|
|
|
struct EffectItemGetCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Cash = 1,
|
|
Petal = 2,
|
|
Cooper = 3,
|
|
Admin = 4,
|
|
Union = 5,
|
|
Item = 6,
|
|
Guild = 7,
|
|
BestFriend = 8,
|
|
Seed = 9,
|
|
};
|
|
};
|
|
|
|
struct EffectItemLifeSpanType
|
|
{
|
|
enum eCode
|
|
{
|
|
New = 0,
|
|
Extend = 1,
|
|
Update = 2,
|
|
};
|
|
};
|
|
|
|
struct DifficultyCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Easy = 1,
|
|
Normal,
|
|
Hard,
|
|
Master,
|
|
Abyss,
|
|
};
|
|
};
|
|
|
|
struct ClearGradeCode
|
|
{
|
|
enum eCode
|
|
{
|
|
SSS = 10,
|
|
SS,
|
|
S,
|
|
A,
|
|
B,
|
|
C,
|
|
D,
|
|
};
|
|
};
|
|
|
|
struct RewardBoxCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Wood = 1,
|
|
Bronze,
|
|
Silver,
|
|
Gold,
|
|
};
|
|
};
|
|
|
|
struct WhereToGoCode
|
|
{
|
|
enum eCode
|
|
{
|
|
StageEntrance = 1,
|
|
Village,
|
|
};
|
|
};
|
|
|
|
struct PvPModeCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Round = 1,
|
|
Respawn,
|
|
Captain,
|
|
IndividualRespawn,
|
|
Zombie,
|
|
Ladder1vs1,
|
|
Ladder2vs2,
|
|
Ladder3vs3,
|
|
Ladder4vs4,
|
|
GuildWar,
|
|
Occupation,
|
|
AllKill,
|
|
Racing,
|
|
Tournament,
|
|
#if defined( PRE_ADD_PVP_COMBOEXERCISE )
|
|
ComboExercise,
|
|
#endif // #if defined( PRE_ADD_PVP_COMBOEXERCISE )
|
|
#if defined(PRE_ADD_DWC)
|
|
DWCRegular,
|
|
DWCPractice,
|
|
#endif
|
|
};
|
|
};
|
|
|
|
struct PvPTeamCode
|
|
{
|
|
enum eCode
|
|
{
|
|
A = 1,
|
|
B,
|
|
};
|
|
};
|
|
|
|
struct PvPResultCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Win = 1,
|
|
Lose,
|
|
Draw,
|
|
GiveUp,
|
|
};
|
|
};
|
|
|
|
struct RestraintTargetCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Account = 1, // 계정
|
|
Character, // 캐릭터
|
|
};
|
|
};
|
|
|
|
struct RestraintTypeCode
|
|
{
|
|
enum eCode
|
|
{
|
|
ConnectRestraint = 1,
|
|
ChatRestraint,
|
|
TradeRestraint,
|
|
};
|
|
};
|
|
|
|
struct RestraintDolisReasonCode
|
|
{
|
|
enum eCode
|
|
{
|
|
DefaultCode = 110,
|
|
AbuseRestraintCode = 111,
|
|
AbuseTradeRestraintCode = 112,
|
|
};
|
|
};
|
|
|
|
struct TransactorCode
|
|
{
|
|
enum eCode
|
|
{
|
|
Master = 1,
|
|
Pupil,
|
|
};
|
|
};
|
|
|
|
struct GetMasterCharacterCode
|
|
{
|
|
enum eCode
|
|
{
|
|
MyInfo = 1, // 자신의 스승 정보
|
|
MyMasterInfo, // 내 스승 정보
|
|
OptionalMasterInfo, // 임의의 특정 스승 정보
|
|
};
|
|
};
|
|
#if defined( PRE_ADD_SECONDARY_SKILL )
|
|
|
|
struct SecondarySkillTypeCode
|
|
{
|
|
enum eCode
|
|
{
|
|
ProductionSkill = SecondarySkill::Type::ProductionSkill, // 생산스킬
|
|
ManufactureSkill = SecondarySkill::Type::ManufactureSkill, // 제작스킬
|
|
CommonSkill = SecondarySkill::Type::CommonSkill, // 공용스킬
|
|
};
|
|
};
|
|
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )
|
|
|
|
struct AppellationKind
|
|
{
|
|
enum eAppellationKind
|
|
{
|
|
Select = 1,
|
|
Cover = 2
|
|
};
|
|
};
|
|
|
|
struct EtcPointCode
|
|
{
|
|
enum eCode
|
|
{
|
|
None = 0,
|
|
PvP = 1,
|
|
Union_Commercial = 2,
|
|
Union_Royal = 3,
|
|
Union_Liberty = 4,
|
|
GuildWar_Festival = 5, // 길드전 축제 포인트
|
|
SeedPoint = 6, // 시드 머니
|
|
Max,
|
|
};
|
|
};
|
|
struct GuildWarRewardType
|
|
{
|
|
enum eGuildWarRewardType
|
|
{
|
|
GuildWarFestivalWin = 1, // 길드축제우승
|
|
GuildWarFestivalLose, // 길드축제패배
|
|
GuildWarFinalUnder4, // 본선 4강미만
|
|
GuildWarFinal4, // 본선 4강보상
|
|
GuildWarFinal2, // 본선 2위보상
|
|
GuildWarFinalWin, // 본선 우승보상
|
|
GuildWarFinalAbnormalLose, // 본선 비정상패배(동점때 예선점수?)
|
|
};
|
|
};
|
|
|
|
struct EventRewardType
|
|
{
|
|
enum eEventRewardType
|
|
{
|
|
Admin = 1,
|
|
System = 2,
|
|
};
|
|
};
|
|
};
|
|
|
|
//Exception Report
|
|
enum eExceptionRepert
|
|
{
|
|
_EXCEPTIONTYPE_NONE = 0,
|
|
|
|
//for game
|
|
_EXCEPTIONTYPE_ROOMCRASH,
|
|
_EXCEPTIONTYPE_SESSIONCRASH,
|
|
_EXCEPTIONTYPE_ROOMDESTRUCTOR,
|
|
_EXCEPTIONTYPE_GAME_DELAYED,
|
|
|
|
//for db
|
|
_EXCEPTIONTYPE_DBMW_DELAYED,
|
|
};
|
|
|
|
//GameServerAffinity Type
|
|
enum eGameServerAffinityType
|
|
{
|
|
_GAMESERVER_AFFINITYTYPE_NORMAL = 0, //그냥 일반 던전이미 머니 그런거
|
|
_GAMESERVER_AFFINITYTYPE_HYBRYD, //피비피도 받고 다 받아요
|
|
_GAMESERVER_AFFINITYTYPE_PVP, //피비피만 받아요
|
|
_GAMESERVER_AFFINITYTYPE_FARM, //게임서버 월드 통합처리용 농장 전용 겜섭!
|
|
};
|
|
|
|
// Cash
|
|
enum eCashEtc
|
|
{
|
|
Reason_GameClient = 1,
|
|
Reason_Web = 2,
|
|
Reason_PCBangGameClient = 3,
|
|
Reason_PCBangWeb = 4,
|
|
|
|
Category_Main = 1,
|
|
Category_Costume = 2,
|
|
Category_Item = 3,
|
|
Category_Package = 4,
|
|
|
|
CashItemState_None = 1,
|
|
CashItemState_Hot = 2,
|
|
CashItemState_New = 3,
|
|
CashItemState_Normal = 4,
|
|
CashItemState_Discount = 5,
|
|
};
|
|
|
|
#if defined(_CH)
|
|
enum eChSndaAuthFlag
|
|
{
|
|
eChSndaAuthFlag_UseEKey = (1 << 0), // EKey 기능 사용 여부
|
|
eChSndaAuthFlag_UseECard = (1 << 1), // ECard 기능 사용 여부
|
|
};
|
|
#endif // _CH
|
|
|
|
// structure -----------------------------------------------------------------------------------------------
|
|
|
|
struct TChannelInfo
|
|
{
|
|
USHORT nChannelID; //할당된 채널(필드)아이디
|
|
USHORT nChannelIdx;
|
|
USHORT nMapIdx; //담당하는 맵의 아이디
|
|
USHORT nChannelMaxUser;
|
|
USHORT nCurrentUser;
|
|
int nAttribute; //DirtyBit
|
|
int nMeritBonusID; //Merit bonus
|
|
bool bVisibility;
|
|
WCHAR wszMapName[MAPNAMELENMAX];
|
|
int nLimitLevel;
|
|
bool bShow;
|
|
USHORT nDependentMapID;
|
|
int nServerID;
|
|
BYTE cThreadID;
|
|
#if defined(PRE_ADD_CHANNELNAME)
|
|
WCHAR wszLanguageName[CHANNELLANGUAGEMAX];
|
|
#endif //#if defined(PRE_ADD_CHANNELNAME)
|
|
int GetUserPercentage() const
|
|
{
|
|
if( nChannelMaxUser > 0 )
|
|
return nCurrentUser*100/nChannelMaxUser;
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
struct TVillageInfo
|
|
{
|
|
BYTE cVillageID;
|
|
int nManagedID;
|
|
char szIP[IPLENMAX];
|
|
USHORT nPort;
|
|
|
|
std::vector <TChannelInfo> vOwnedChannelList;
|
|
TVillageInfo()
|
|
{
|
|
cVillageID = 0;
|
|
nManagedID = 0;
|
|
memset(szIP, 0, sizeof(szIP));
|
|
nPort = 0;
|
|
}
|
|
};
|
|
|
|
struct TGameInfo
|
|
{
|
|
int nServerID;
|
|
int nServerAttribute;
|
|
ULONG nIP;
|
|
USHORT nPort;
|
|
USHORT nTcpPort;
|
|
|
|
int nRoomCnt;
|
|
int nUserCnt;
|
|
bool bHasMargin;
|
|
UINT nFrame;
|
|
|
|
bool bComplete;
|
|
UINT uiLastDelayReportTick;
|
|
};
|
|
|
|
// Server Info
|
|
struct TServerInfo
|
|
{
|
|
bool bMergedWorld;
|
|
int nWorldSetID; // 통합 월드 아이디
|
|
char cWorldID;
|
|
WCHAR wszWorldName[WORLDNAMELENMAX];
|
|
UINT nWorldMaxUser; //대기자용
|
|
USHORT nDefaultMaxUser;
|
|
bool bOnline; // online, offline 상태표시용
|
|
bool bOnTop;
|
|
std::vector <TVillageInfo> vOwnedVillageList;
|
|
|
|
TServerInfo()
|
|
{
|
|
bMergedWorld = false;
|
|
nWorldSetID = 0;
|
|
cWorldID = 0;
|
|
memset(wszWorldName, 0, sizeof(wszWorldName));
|
|
nWorldMaxUser = 0;
|
|
nDefaultMaxUser = 0;
|
|
bOnline = false;
|
|
bOnTop = false;
|
|
}
|
|
};
|
|
|
|
//
|
|
struct TChannelInfoEx
|
|
{
|
|
TChannelInfo Channel;
|
|
BYTE cVillageID;
|
|
char szIP[IPLENMAX];
|
|
USHORT nPort;
|
|
};
|
|
typedef std::map<int, TChannelInfoEx> TMapChannel;
|
|
|
|
// 서버에서는 float로 바로 쓰지않는다. 클라에서 받은 좌표에 *1000을 해서 사용함
|
|
struct TPosition
|
|
{
|
|
int nX;
|
|
int nY;
|
|
int nZ;
|
|
};
|
|
|
|
struct TLocation
|
|
{
|
|
UINT nMapIndex;
|
|
TPosition Pos;
|
|
};
|
|
|
|
// npc, user object생성에 해당. 공통된 부분만
|
|
struct TBaseData
|
|
{
|
|
UINT nObjectID;
|
|
WCHAR wszName[NAMELENMAX];
|
|
int nChannelID;
|
|
TPosition CurPos, TargetPos;
|
|
TPosition MoveDir;
|
|
float fRotate;
|
|
bool bBattleMode;
|
|
};
|
|
|
|
struct TParamData
|
|
{
|
|
eChatType eChatType;
|
|
int nChatSize;
|
|
WCHAR wszChatMsg[CHATLENMAX];
|
|
char Buffer[128];
|
|
int nBufSize;
|
|
USHORT wActorProtocol;
|
|
TItemInfo ItemInfo;
|
|
TItemInfo CashItemInfo;
|
|
BYTE cLevel;
|
|
UINT nExp;
|
|
int nJob;
|
|
int nSelectAppellation;
|
|
int nCoverAppellation;
|
|
bool bHide;
|
|
bool bEncrypt;
|
|
DNEncryptPacketSeq sEncrypt;
|
|
char cType;
|
|
char cState;
|
|
DWORD dwColor;
|
|
int nChatRoomParam;
|
|
int nIndex;
|
|
DWORD dwSendSessionID; // SendSessionID
|
|
TItem Vehicle;
|
|
TVehicleCompact PetInfo;
|
|
char cPetPartsType;
|
|
};
|
|
|
|
struct TDefaultCreateData
|
|
{
|
|
BYTE cClassID; // 클래스
|
|
int cDarkClass; // rlkt_dark dark class :)
|
|
int cDarkClassJobID; // rlkt_dark dark class :)
|
|
int nCreateMapIndex; // 처음 생성시 시작 맵 인덱스
|
|
int nCreateMapStartPositionX[DEFAULTPOSITIONMAX]; // 처음 생성시 시작 위치 X
|
|
int nCreateMapStartPositionY[DEFAULTPOSITIONMAX]; // 처음 생성시 시작 위치 Y
|
|
int nCreateMapStartRadius[DEFAULTPOSITIONMAX]; // 반경
|
|
|
|
int nCreateTutorialMapIndex; // 처음 생성시 튜토리얼 맵 인덱스 (GameServer쪽)
|
|
int nCreateTutorialGateNo; // 처음 생성시 튜토리얼 게이트 (GameServer쪽)
|
|
|
|
int nDefaultBody; // 기본몸
|
|
int nDefaultLeg; // 기본다리
|
|
int nDefaultHand; // 기본손
|
|
int nDefaultFoot; // 기본발
|
|
int nFace[DEFAULTPARTSMAX]; // 얼굴
|
|
int nHair[DEFAULTPARTSMAX]; // 머리
|
|
int nHelmet[DEFAULTPARTSMAX]; // 헬멧
|
|
int nBody[DEFAULTPARTSMAX]; // 상의
|
|
int nLeg[DEFAULTPARTSMAX]; // 하의
|
|
int nHand[DEFAULTPARTSMAX]; // 손
|
|
int nFoot[DEFAULTPARTSMAX]; // 발
|
|
int nWeapon[WEAPONMAX]; // 무기
|
|
|
|
DWORD dwHairColor[DEFAULTHAIRCOLORMAX];
|
|
DWORD dwSkinColor[DEFAULTSKINCOLORMAX];
|
|
DWORD dwEyeColor[DEFAULTEYECOLORMAX];
|
|
|
|
int nDefaultItemID[DEFAULTITEMMAX]; // 소유아이템
|
|
int nDefaultItemCount[DEFAULTITEMMAX]; // 소유아이템 개수
|
|
|
|
int nDefaultSkillID[DEFAULTSKILLMAX]; // 소유스킬
|
|
|
|
TQuickSlot DefaultQuickSlot[DEFAULTQUICKSLOTMAX]; // 퀵슬롯개수
|
|
int nDefaultGestureID[DEFAULTGESTUREMAX]; // 소유 제스처
|
|
};
|
|
|
|
#if defined( PRE_ADD_DWC )
|
|
struct TDWCCreateData
|
|
{
|
|
BYTE cClassID; // 기본 클래스 ID
|
|
BYTE cJobCode1; // 1차 전직 클래스 ID
|
|
BYTE cJobCode2; // 2차 전직 클래스 ID
|
|
BYTE cLevel;
|
|
int nExp;
|
|
int nCreateMapIndex; // 처음 생성시 시작 맵 인덱스
|
|
int nCreateMapStartPositionX[DEFAULTPOSITIONMAX]; // 처음 생성시 시작 위치 X
|
|
int nCreateMapStartPositionY[DEFAULTPOSITIONMAX]; // 처음 생성시 시작 위치 Y
|
|
int nCreateMapStartRadius[DEFAULTPOSITIONMAX]; // 반경
|
|
|
|
int nDefaultBody; // 기본몸
|
|
int nDefaultLeg; // 기본다리
|
|
int nDefaultHand; // 기본손
|
|
int nDefaultFoot; // 기본발
|
|
int nEquipArray[EQUIPMAX]; // 장착 장비
|
|
|
|
DWORD dwHairColor;
|
|
DWORD dwSkinColor;
|
|
DWORD dwEyeColor;
|
|
|
|
int nDefaultItemID[DEFAULTITEMMAX]; // 소유아이템
|
|
int nDefaultItemCount[DEFAULTITEMMAX]; // 소유아이템 개수
|
|
|
|
int nDefaultSkillID[DEFAULTSKILLMAX]; // 소유스킬
|
|
|
|
TQuickSlot DefaultQuickSlot[DEFAULTQUICKSLOTMAX]; // 퀵슬롯개수
|
|
int nDefaultGestureID[DEFAULTGESTUREMAX]; // 소유 제스처
|
|
short nSkillPoint; // 스킬 포인트
|
|
int nGold; // 골드 - 필요 없다면 제거하자
|
|
|
|
};
|
|
#endif // #if defined( PRE_ADD_DWC )
|
|
|
|
struct TMapInfo
|
|
{
|
|
int nMapID;
|
|
char szMapName[10][256];
|
|
BYTE GateMapCount[WORLDMAP_GATECOUNT];
|
|
USHORT GateMapIndexs[WORLDMAP_GATECOUNT][WORLDMAP_GATECOUNT];
|
|
BYTE GateStartIndexs[WORLDMAP_GATECOUNT][WORLDMAP_GATECOUNT];
|
|
int nWorldLevel;
|
|
GlobalEnum::eMapTypeEnum MapType;
|
|
GlobalEnum::eMapSubTypeEnum MapSubType;
|
|
int nMaxClearCount;
|
|
int nAllowMapType;
|
|
std::vector<int> vMapAreaIndex;
|
|
bool bExpandable;
|
|
bool bUserReturnSystem; // 유저 복귀시스템
|
|
bool bVehicleMode;
|
|
bool bPetMode;
|
|
bool bAllowFreePass;
|
|
#if defined( PRE_PARTY_DB )
|
|
std::wstring wstrMapName;
|
|
int iEnterConditionTable;
|
|
#endif // #if defined( PRE_PARTY_DB )
|
|
#if defined( PRE_NORMALSTAGE_REGULATION )
|
|
char cRevisionNum; //보정넘버
|
|
#endif
|
|
#if defined(PRE_ADD_VEHICLE_SPECIAL_ACTION)
|
|
bool bVehicleSpecalActionMode;
|
|
#endif
|
|
};
|
|
|
|
struct TCoinCountData
|
|
{
|
|
BYTE cLevel;
|
|
int nRebirthCoin[WORLDCOUNTMAX]; // 부활코인
|
|
int nCashRebirthCoin[WORLDCOUNTMAX]; // 부활캐쉬코인
|
|
int nRebirthCoinLimit; // 무료코인소지제한개수
|
|
int nCashRebirthCoinLimit; // 유료코인소지제한개수
|
|
int nVIPRebirthCoin; // VIP부활코인
|
|
};
|
|
|
|
struct TActorData
|
|
{
|
|
int nActorID;
|
|
BYTE cClass; // 유닛 타입 종류
|
|
};
|
|
|
|
const int QUEST_MAX_CNT = 20;
|
|
struct TNpcData
|
|
{
|
|
int nNpcID;
|
|
int nParam[2];
|
|
WCHAR wszName[EXTDATANAMELENMAX];
|
|
char szTalkFile[256]; // 대사파일이름
|
|
char szScriptFile[256]; // script 파일이름
|
|
int QuestIndexArr[QUEST_MAX_CNT]; // 퀘스트인덱스
|
|
TActorData ActorData;
|
|
};
|
|
|
|
struct TItemData
|
|
{
|
|
int nItemID;
|
|
WCHAR wszItemName[EXTDATANAMELENMAX];
|
|
int nType; // 타입
|
|
int nTypeParam[3]; // 타입파라미터
|
|
BYTE cLevelLimit; // 레벨제한
|
|
BYTE cRank; // 등급
|
|
BYTE cReversion; // 귀속여부
|
|
bool IsCash; // 캐쉬템인가
|
|
bool IsDestruction; // 파괴여부
|
|
bool IsAuthentication; // 인증여부
|
|
int nAmount; // 금액
|
|
int nSellAmount; // 판매금액
|
|
int nOverlapCount; // 중첩개수
|
|
std::vector<int> nNeedJobClassList; // 직업제한
|
|
|
|
int nSkillID; // 스킬 인덱스
|
|
char cSkillLevel; // 스킬 레벨
|
|
char cSkillUsingType; // 스킬 사용 타입
|
|
int nMaxCoolTime; // 최대 쿨타임 (변하지 않는 값)
|
|
int nEnchantID; // 인챈트아이디
|
|
int nAllowMapType; // 사용가능한 맵 타입
|
|
char cSealCount; // 밀봉 횟수
|
|
int nSealID; // SealCountTableID
|
|
int nNeedBuyItemID; // 상점에서 구입할 때 필요한 아이템ID
|
|
int nNeedBuyItemCount; // 상점에서 구입할 때 필요한 아이템개수
|
|
int nNeedPvPRank; // 장착할 때 필요한 PvP 랭크
|
|
bool IsSealed; // 획득 시 밀봉여부
|
|
int nCashTradeCount; // 캐시아이템 교환개수
|
|
bool IsEnableCostumeMix;
|
|
int nApplicableValue;
|
|
bool IsCollectingEvent; // 아이템 수집 API를 호출여부
|
|
int nExchangeCode; // 아이템 카테고리 ID
|
|
int iNeedBuyLadderPoint;
|
|
int iUseLevelLimit;
|
|
int iNeedBuyUnionPoint;
|
|
int iNeedBuyGuildWarPoint;
|
|
bool bRebuyable;
|
|
int nPeriod;
|
|
#if defined(PRE_ADD_SERVER_WAREHOUSE)
|
|
bool IsWStorage; // 서버 창고에 넣을 수 있는 예외
|
|
#endif
|
|
int DragonJewelType;
|
|
|
|
void Reset()
|
|
{
|
|
memset( wszItemName, 0, sizeof(wszItemName) );
|
|
memset( nTypeParam, 0, sizeof(nTypeParam) );
|
|
nNeedJobClassList.clear();
|
|
std::vector<int>().swap(nNeedJobClassList);
|
|
|
|
nItemID = 0;
|
|
nType = 0;
|
|
cLevelLimit = 0;
|
|
cRank = 0;
|
|
cReversion = 0;
|
|
IsCash = 0;
|
|
IsDestruction = 0;
|
|
IsAuthentication= 0;
|
|
nAmount = 0;
|
|
nSellAmount = 0;
|
|
nOverlapCount = 0;
|
|
nSkillID = 0;
|
|
cSkillLevel = 0;
|
|
cSkillUsingType = 0;
|
|
nMaxCoolTime = 0;
|
|
nAllowMapType = 0;
|
|
cSealCount = 0;
|
|
nNeedBuyItemID = 0;
|
|
nNeedBuyItemCount = 0;
|
|
nNeedPvPRank = 0;
|
|
IsSealed = 0;
|
|
nCashTradeCount = 0;
|
|
IsEnableCostumeMix = 0;
|
|
nApplicableValue = 0;
|
|
IsCollectingEvent = 0;
|
|
nExchangeCode = 0;
|
|
iNeedBuyUnionPoint = 0;
|
|
iNeedBuyGuildWarPoint = 0;
|
|
bRebuyable = false;
|
|
nPeriod = 0;
|
|
DragonJewelType = 0;
|
|
}
|
|
};
|
|
|
|
struct TWeaponData
|
|
{
|
|
int nWeaponIndex;
|
|
char cEquipType; // 장착타입
|
|
int nLength; // 무기 길이
|
|
int nDurability; // 내구도
|
|
int nDurabilityRepairCoin; // 수리비
|
|
int nPermitJob[10];
|
|
bool bOneType;
|
|
};
|
|
|
|
struct TPartData
|
|
{
|
|
int nPartIndex;
|
|
int nParts; // 파츠
|
|
int nDurability; // 내구도
|
|
int nDurabilityRepairCoin; // 수리비
|
|
int nPermitJob[10];
|
|
std::vector<int> nSubPartsList; // 서브파츠 (한벌옷)
|
|
|
|
TPartData()
|
|
{
|
|
nPartIndex = 0;
|
|
nParts = 0;
|
|
nDurability = 0;
|
|
nDurabilityRepairCoin = 0;
|
|
memset(nPermitJob, 0, sizeof(nPermitJob));
|
|
}
|
|
};
|
|
|
|
struct TVehiclePartsData
|
|
{
|
|
int nItemID;
|
|
int nVehicleClassID;
|
|
int nVehiclePartsType;
|
|
std::string strSkinName;
|
|
std::string strAniName;
|
|
std::string strActName;
|
|
int nSkinColor;
|
|
TVehiclePartsData()
|
|
{
|
|
nItemID = 0;
|
|
nVehicleClassID = 0;
|
|
nVehiclePartsType = 0;
|
|
nSkinColor = 0;
|
|
}
|
|
};
|
|
|
|
struct TVehicleData
|
|
{
|
|
int nItemID;
|
|
int nVehicleClassID;
|
|
int nVehicleActorID;
|
|
int nDefaultBody;
|
|
int nDefaultParts1;
|
|
int nDefaultParts2;
|
|
int nVehicleSummonTime;
|
|
int nVehicleDefaultSpeed;
|
|
int nPetLevelTypeID; // pet 등급(?)값 등급이 다른 펫을 참조하기위한 키값
|
|
int nPetSkillID1; //
|
|
int nPetSkillID2;
|
|
int nRange; // 스캔 범위값. 이를테면 줍기 같은거
|
|
int nFoodID;
|
|
};
|
|
|
|
const BYTE PetStateMax = 10;
|
|
struct TPetLevelDetail
|
|
{
|
|
int nTableIndex;
|
|
int nPetLevel;
|
|
int nPetExp;
|
|
int nState[PetStateMax];
|
|
char *szStateMin[PetStateMax];
|
|
char *szStateMax[PetStateMax];
|
|
int nVipExp;
|
|
};
|
|
|
|
struct TPetLevelData
|
|
{
|
|
int nPetLevelType;
|
|
std::vector<TPetLevelDetail> VecPetLevel;
|
|
};
|
|
|
|
struct TPetFoodData
|
|
{
|
|
int nItemID;
|
|
int nTickTime; // 소모 시간(second)
|
|
int nFullTic; // 틱당 소모량
|
|
BYTE cFullTimeLogOut; // 로그아웃시 기존 만복도 나누기값
|
|
int nFullMaxCount; // 만복도 최대 max수치
|
|
int nUseExp[Pet::MAX_SATIETY_SELECTION];
|
|
int nUseState[Pet::MAX_SATIETY_SELECTION];
|
|
};
|
|
|
|
struct TPotentialJewelData
|
|
{
|
|
int nItemID;
|
|
int nApplyApplicableValue;
|
|
int nPotentialNo;
|
|
bool bErasable;
|
|
bool bCanApplySealedItem;
|
|
|
|
#if defined(PRE_ADD_REMOVE_PREFIX)
|
|
bool bSuffix;
|
|
#endif // PRE_ADD_REMOVE_PREFIX
|
|
#if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
|
|
int nRollbackAmount; // 잠재력 부여 롤백 수수료
|
|
#endif // #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
|
|
};
|
|
|
|
struct TEnchantJewelData
|
|
{
|
|
int nItemID;
|
|
int nApplyApplicableValue;
|
|
int nRequireMaxItemLevel;
|
|
int nRequireEnchantLevel;
|
|
int nEnchantLevel;
|
|
bool bCanApplySealedItem;
|
|
};
|
|
|
|
struct TItemDropData
|
|
{
|
|
int nItemDropID;
|
|
bool bIsGroup[20];
|
|
int nIndex[20];
|
|
int nProb[20];
|
|
int nInfo[20];
|
|
};
|
|
|
|
struct TGlobalWeightData
|
|
{
|
|
int nID;
|
|
float fValue;
|
|
};
|
|
|
|
struct TGlobalWeightIntData
|
|
{
|
|
int nID;
|
|
int nValue;
|
|
};
|
|
|
|
struct TLevelData
|
|
{
|
|
int nIndex;
|
|
short wStrength; // 힘
|
|
short wAgility; // 민첩
|
|
short wIntelligence; // 지능
|
|
short wStamina; // 건강
|
|
int nExperience; // 경험치
|
|
int nFatigue; // 피로도
|
|
};
|
|
|
|
struct TStat
|
|
{
|
|
USHORT wStr;
|
|
USHORT wDex;
|
|
USHORT wInt;
|
|
USHORT wHealth;
|
|
USHORT wLuck;
|
|
};
|
|
|
|
struct TSkillLevelData
|
|
{
|
|
char cSkillLevel; // 스킬 레벨
|
|
char cLevelLimit; // 제한 레벨
|
|
//int nNeedJobClass; // 직업제한 -> 스킬 테이블로 옮겨졌음.
|
|
int nDelayTime; // 스킬딜레이(ms)
|
|
int nAddRange; // 추가 사거리(cm)
|
|
int nNeedItemID; // 소모아이템
|
|
int nNeedItemDecreaseCount; // 소모 아이템 개수
|
|
int nDecreaseHP; // 소모HP
|
|
int nDecreaseSP; // 소모SP
|
|
int nNeedSkillPoint;
|
|
int nEffectClassValue1Duration;
|
|
float nMagicDamage; //rlkt_damage
|
|
float nPhyDamage; //rlkt_damage
|
|
};
|
|
|
|
struct TSkillData
|
|
{
|
|
int nSkillID; // 스킬id
|
|
char cNeedWeaponType[ 2 ]; // 필요무기
|
|
int nMaxLevel; // 최대레벨
|
|
char cSkillType; // 스킬타입
|
|
char cDurationType; // 지속타입
|
|
char cTargetType; // 타겟타입
|
|
char cDissolvable; // 해제 가능 여부
|
|
int nNeedJobID; // 직업 제한
|
|
bool bDefaultLocked; // 디폴트로 락이 된 건지 여부
|
|
int nUnlockSkillBookItemID; // 언락하는 스킬북의 아이템 ID
|
|
int nUnlockPrice; // 돈으로 언락할 때 비용.
|
|
int nExclusiveID; // 이 아이디가 같은 값인 스킬은 같이 배울 수 없다.
|
|
int nGlobalCoolTime; // 글로벌 스킬 쿨타임 (#36858)
|
|
int nGlobalSkillGroup; // 글로벌 스킬 그룹 (#36858)
|
|
std::vector<TSkillLevelData> vLevelDataList;
|
|
|
|
TSkillData()
|
|
{
|
|
nSkillID =0;
|
|
memset(cNeedWeaponType, 0, sizeof(cNeedWeaponType));
|
|
nMaxLevel = 0;
|
|
cSkillType = 0;
|
|
cDurationType = 0;
|
|
cTargetType = 0;
|
|
cDissolvable = 0;
|
|
nNeedJobID = 0;
|
|
bDefaultLocked = false;
|
|
nUnlockSkillBookItemID = 0;
|
|
nUnlockPrice = 0;
|
|
nExclusiveID = 0;
|
|
nGlobalCoolTime = 0;
|
|
nGlobalSkillGroup = 0;
|
|
}
|
|
};
|
|
|
|
struct TSkillTreeData
|
|
{
|
|
int nSkillID;
|
|
int nTreeSlotIndex;
|
|
int nParentSkillID[ 3 ];
|
|
int nNeedParentSkillLevel[ 3 ];
|
|
#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
|
|
int nNeedBasicSP;
|
|
int nNeedFirstSP;
|
|
int nNeedSecondSP;
|
|
#endif // #if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
|
|
#if defined( PRE_ADD_ONLY_SKILLBOOK )
|
|
bool bNeedSkillBook;
|
|
#endif // #if defined( PRE_ADD_ONLY_SKILLBOOK )
|
|
};
|
|
|
|
// npc 대화 관련 구조체
|
|
struct TALK_QUESTION
|
|
{
|
|
std::wstring szQuestion;
|
|
};
|
|
|
|
struct TALK_ANSWER
|
|
{
|
|
std::wstring szLinkTarget;
|
|
std::wstring szLinkIndex;
|
|
std::wstring szAnswer;
|
|
bool bOtherTargetLink; // 다른 토크파일로 링크 하는 경우 true
|
|
};
|
|
|
|
struct TALK_PARAGRAPH
|
|
{
|
|
std::wstring szIndex;
|
|
TALK_QUESTION Question;
|
|
std::vector<TALK_ANSWER> Answers;
|
|
};
|
|
|
|
// key - 문단스트링인덱스, second - 문단
|
|
typedef std::map<std::wstring, TALK_PARAGRAPH> TALK_PARAGRAPH_MAP;
|
|
typedef TALK_PARAGRAPH_MAP::iterator TALK_PARAGRAPH_MAP_IT;
|
|
|
|
// key - 대사xml 파일 이름, second - 대사전체
|
|
typedef std::map<std::wstring, TALK_PARAGRAPH_MAP> TALK_MAP;
|
|
typedef TALK_MAP::iterator TALK_MAP_IT;
|
|
|
|
#include <set>
|
|
|
|
// key - 문단응답스트링인덱스 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도)
|
|
typedef std::set<std::wstring> TALK_ANSWER_SET;
|
|
typedef TALK_ANSWER_SET::iterator TALK_ANSWER_SET_IT;
|
|
|
|
// key - 대사xml 파일 이름, second - 문단응답스트링집합 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도)
|
|
typedef std::map<std::wstring, TALK_ANSWER_SET> TALK_ANSWER_MAP;
|
|
typedef TALK_ANSWER_MAP::iterator TALK_ANSWER_MAP_IT;
|
|
|
|
// 퀘스트 보상 아이템 테이블 정보
|
|
// 돈과 아이템 6종류 까지 세팅할 수 있다. nItemID 과 nItemCount는 세트이다.
|
|
|
|
struct TQuestRewardBase
|
|
{
|
|
struct _ITEMSET
|
|
{
|
|
int nItemID;
|
|
int nItemCount;
|
|
int nItemOptionTableID;
|
|
};
|
|
};
|
|
|
|
struct TQuestReward : public TQuestRewardBase
|
|
{
|
|
UINT nIndex; // 보상테이블 인덱스
|
|
UINT nStringIndex; // 보상테이블 스트링
|
|
char cType; // 보상타입 1이면 전체보상 / 2면 선택보상
|
|
char cSelectMax; // 선택보상일경우 몇개까지 선택할것인지.
|
|
UINT nCoin; // 보상금액
|
|
int nExp; // 보상 경험치
|
|
int nQuestID; // 퀘스트 ID
|
|
int nQuestStep; // 퀘스트 완료 시 스텝
|
|
BYTE nClass; // 보상 클래스
|
|
_ITEMSET ItemArray[QUESTREWARD_INVENTORYITEMMAX];
|
|
_ITEMSET LevelCapItemArray[MAX_QUEST_LEVEL_CAP_REWARD];
|
|
int nMailID;
|
|
int nFatigue;
|
|
};
|
|
|
|
struct TQuestLevelCapReward : public TQuestRewardBase
|
|
{
|
|
UINT uIndex;
|
|
char cType;
|
|
char cClassID;
|
|
_ITEMSET Items[MAX_QUEST_LEVEL_CAP_REWARD];
|
|
};
|
|
|
|
struct TCompleteEventQuest
|
|
{
|
|
short wCompleteCount;
|
|
int nScheduleID;
|
|
};
|
|
|
|
// Shop
|
|
struct TShopItem
|
|
{
|
|
int nItemID; // 상점 아이템 아이디
|
|
int nCount; // 상점 아이템 수량
|
|
int nMaxCount; // 아이템 최대수량
|
|
int nPrice; // 아이템 가격
|
|
int buyLimitCount;
|
|
#if defined (PRE_ADD_COMBINEDSHOP_PERIOD)
|
|
int nPeriod;
|
|
#endif
|
|
#if defined( PRE_ADD_LIMITED_SHOP )
|
|
int nShopLimitReset;
|
|
#endif
|
|
};
|
|
|
|
struct TShopTabData
|
|
{
|
|
int nTabID;
|
|
std::vector<TShopItem> vShopItem; // SHOPTABMAX
|
|
TShopTabData()
|
|
{
|
|
Clear();
|
|
}
|
|
void Clear()
|
|
{
|
|
nTabID = 0;
|
|
vShopItem.clear();
|
|
}
|
|
};
|
|
|
|
struct TShopData
|
|
{
|
|
int nShopID; // 샵 아이디 (npc가 가지고 있는 아이디와 비교해서 연결)
|
|
std::vector<TShopTabData> vShopTabData; // SHOPITEMMAX
|
|
TShopData()
|
|
{
|
|
nShopID = 0;
|
|
}
|
|
};
|
|
|
|
// Skill Shop
|
|
struct TSkillShopItem
|
|
{
|
|
int nSkillID; // 스킬아이디
|
|
int nPrice; // 스킬 가격
|
|
};
|
|
|
|
struct TSkillShopData
|
|
{
|
|
int nShopID; // 샵 아이디 (npc가 가지고 있는 아이디와 비교해서 연결)
|
|
TSkillShopItem SkillShopItem[SKILLSHOPITEMMAX]; // 최대 10개밖에 안된다
|
|
};
|
|
|
|
// Enchant
|
|
const int ENCHANTITEMMAX = 5;
|
|
struct TEnchantLevelData
|
|
{
|
|
int nItemID;
|
|
char cLevel;
|
|
#ifdef PRE_FIX_MEMOPT_ENCHANT
|
|
int nNeedItemTableID;
|
|
int nStateTableID;
|
|
int nNeedCoin;
|
|
#else
|
|
char cEnchantProb;
|
|
char cBreakRatio;
|
|
char cMinDownLevel;
|
|
char cMaxDownLevel;
|
|
int nNeedItemID[ENCHANTITEMMAX];
|
|
int nNeedItemCount[ENCHANTITEMMAX];
|
|
int nNeedCoin;
|
|
int nFailResultItemID;
|
|
int nPotentialID;
|
|
char cPotentialProb;
|
|
int nProtectItemCount;
|
|
#if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM)
|
|
int nShieldItemCount; // 상위강화보호젤리용(다운그레이드x)
|
|
#endif
|
|
#endif // PRE_FIX_MEMOPT_ENCHANT
|
|
};
|
|
|
|
struct TEnchantData
|
|
{
|
|
int nEnchantID;
|
|
char cCount;
|
|
std::map<char, TEnchantLevelData*> pMapLevelData;
|
|
};
|
|
|
|
#ifdef PRE_FIX_MEMOPT_ENCHANT
|
|
struct TEnchantNeedItemData
|
|
{
|
|
char cEnchantProb;
|
|
char cBreakRatio;
|
|
char cMinDownLevel;
|
|
char cMaxDownLevel;
|
|
int nNeedItemID[ENCHANTITEMMAX];
|
|
int nNeedItemCount[ENCHANTITEMMAX];
|
|
float fUpStateRatio;
|
|
int nFailResultItemID;
|
|
int nProtectItemCount;
|
|
#if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM)
|
|
int nShieldItemCount; // 상위강화보호젤리용(다운그레이드x)
|
|
#endif
|
|
};
|
|
#endif // PRE_FIX_MEMOPT_ENCHANT
|
|
|
|
struct TPotentialDataItem
|
|
{
|
|
int nItemID;
|
|
int nPotentailOffset;
|
|
int nPotentialNo;
|
|
int nProb;
|
|
|
|
int nSkillID;
|
|
int nSkillLevel;
|
|
int nSkillUsingType;
|
|
};
|
|
|
|
struct TPotentialData
|
|
{
|
|
int nPotentialID;
|
|
int nTotalProb;
|
|
std::vector<TPotentialDataItem*> pVecItemData;
|
|
};
|
|
|
|
// Exchange
|
|
struct TExchangeData
|
|
{
|
|
int nInvenIndex; // 인벤 인덱스
|
|
short wCount; // 몇개 넣었는지
|
|
INT64 biSerial;
|
|
};
|
|
|
|
#ifdef PRE_ADD_GACHA_JAPAN
|
|
// gachapon japan
|
|
struct TGachaponShopInfoByJob_JP
|
|
{
|
|
int nGachaponTableID; // 가챠폰 테이블 ID
|
|
int nGachaponIndex; // 가챠폰 샵 인덱스.
|
|
int nJobClassID; // 이 가챠폰에서 드랍해주는 아이템들의 직업
|
|
int nPartsLinkDropTableID[ CASHEQUIPMAX ];
|
|
};
|
|
|
|
struct TGachaponData_JP
|
|
{
|
|
int nGachaponIndex; // 가챠폰 샵 인덱스. npc 테이블에 쓰인 인덱스를 이걸로 찾음. 테이블 인덱스 아님.
|
|
TGachaponShopInfoByJob_JP GachaponShopInfo[ CLASSKINDMAX ];
|
|
};
|
|
#endif // PRE_ADD_GACHA_JAPAN
|
|
|
|
struct TCostumeMix
|
|
{
|
|
int nMinScore;
|
|
int nDropID;
|
|
};
|
|
|
|
//community
|
|
//getsimple characterdata patialy enum type
|
|
enum eReqCharacterPartialy
|
|
{
|
|
_REQCHARACTERPARTIALY_FRIEND,
|
|
};
|
|
|
|
//Friend
|
|
struct TFriendGroup:public TBoostMemoryPool<TFriendGroup>
|
|
{
|
|
UINT nGroupDBID;
|
|
WCHAR wszGroupName[FRIEND_GROUP_NAMELENMAX];
|
|
};
|
|
|
|
struct TFriend:public TBoostMemoryPool<TFriend>
|
|
{
|
|
UINT nFriendAccountDBID;
|
|
INT64 biFriendCharacterDBID;
|
|
UINT nGroupDBID;
|
|
|
|
TCommunityLocation Location;
|
|
|
|
WCHAR wszCharacterName[NAMELENMAX];
|
|
WCHAR wszGroupName[FRIEND_GROUP_NAMELENMAX];
|
|
WCHAR wszFriendMemo[FRIEND_MEMO_LEN_MAX];
|
|
#ifdef PRE_ADD_DOORS
|
|
bool bMobileAuthentication;
|
|
#endif //#ifdef PRE_ADD_DOORS
|
|
};
|
|
|
|
//UserState
|
|
enum eCummunityState //초대 받는다 안받는다 쪽지 받겠다 안받겠다 등등
|
|
{
|
|
_COMMUNITY_NONE = 0,
|
|
_COMMUNITY_MSG_PERMIT, //모든 메세지 받아효~
|
|
_COMMUNITY_MSG_NOTPERMIT,//메세지 안받아효~ 나좀 내버려 두삼!
|
|
};
|
|
|
|
struct sWorldUserState
|
|
{
|
|
WCHAR wszCharacterName[NAMELENMAX];
|
|
INT64 biCharacterDBID; //일단은 혹쉬나 해서 훗훗
|
|
int nChannelID; //
|
|
int nMapIdx;
|
|
int nLocationState; //eLocationState
|
|
int nCummunityState; //eCummunityState
|
|
};
|
|
|
|
//ServiceManager NoticeType
|
|
enum eSMNoticeType
|
|
{
|
|
_NOTICETYPE_ALL = 0,
|
|
_NOTICETYPE_WORLD,
|
|
_NOTICETYPE_EACHSERVER,
|
|
_NOTICETYPE_CHANNEL,
|
|
_NOTICETYPE_ZONE,
|
|
};
|
|
|
|
//VoiceChannelReqType
|
|
enum eVoiceChannelReqType
|
|
{
|
|
_VOICECHANNEL_REQTYPE_PARTY,
|
|
_VOICECHANNEL_REQTYPE_PVP,
|
|
//머 이런식으로 생기지 않을까나..
|
|
//_VOICECHANNELTYPE_GUILD,
|
|
//_VOICECHANNELTYPE_PRIVATE,
|
|
};
|
|
|
|
//Invite PartyInfo
|
|
struct TInvitePartyInfo
|
|
{
|
|
TPARTYID PartyID;
|
|
int nMapIdx;
|
|
BYTE cLimitLevelMin;
|
|
#if defined( PRE_PARTY_DB )
|
|
#else
|
|
BYTE cLimitLevelMax;
|
|
#endif // #if defined( PRE_PARTY_DB )
|
|
BYTE cPartyMemberMax;
|
|
BYTE cPartyMemberCount;
|
|
BYTE cPartyAvrLevel;
|
|
WCHAR wszPartyName[PARTYNAMELENMAX];
|
|
};
|
|
|
|
// PvP
|
|
struct TPvPMapTable
|
|
{
|
|
UINT uiGameType; // PvPCommon::GameType
|
|
std::vector<UINT> vGameModeTableID; // PvPGameModeTableID
|
|
std::vector<UINT> vNumOfPlayerOption; // 인원수 옵션
|
|
bool bIsBreakInto; // 난입가능Flag
|
|
UINT uiItemUsageType; // PvPCommon::ItemUsageType
|
|
bool bIsAllowItemDrop; // 아이템드롭 Flag
|
|
bool bIsGuildBattleGround; // 길드전에서 사용할수 있는지 Flag
|
|
bool bIsReleaseShow; // 릴리즈버전에서노출
|
|
LadderSystem::MatchType::eCode MatchType;
|
|
|
|
// Function
|
|
bool CheckMaxUser( const BYTE cMaxUser ) const
|
|
{
|
|
for( UINT i=0 ; i<vNumOfPlayerOption.size() ; ++i )
|
|
{
|
|
if( vNumOfPlayerOption[i] == cMaxUser )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckGameModeTableID( const UINT uiTableID ) const
|
|
{
|
|
for( UINT i=0 ; i<vGameModeTableID.size() ; ++i )
|
|
{
|
|
if( vGameModeTableID[i] == uiTableID )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckBreakIntoOption( const BYTE cBreakIntoFlag ) const
|
|
{
|
|
if( cBreakIntoFlag )
|
|
{
|
|
if( !bIsBreakInto )
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct TPvPGameModeTable
|
|
{
|
|
int nItemID;
|
|
UINT uiGameMode; // PvPCommon::GameMode
|
|
std::vector<UINT> vWinCondition;
|
|
std::vector<UINT> vPlayTimeSec;
|
|
UINT uiRespawnTimeSec;
|
|
UINT uiRespawnNoDamageTimeSec;
|
|
UINT uiRespawnHPPercent;
|
|
UINT uiRespawnMPPercent;
|
|
UINT uiWinXPPerRound;
|
|
UINT uiLoseXPPerRound;
|
|
UINT uiItemDropTableID;
|
|
bool bIsLevelRegulation;
|
|
bool bIsReleaseShow; // 릴리즈버전에서노출
|
|
UINT uiMedalExp;
|
|
UINT uiNumOfPlayersMin;
|
|
UINT uiNumOfPlayersMax;
|
|
std::vector<UINT> vVictoryExp;
|
|
std::vector<UINT> vVictoryBonusRate;
|
|
std::vector<UINT> vDefeatExp;
|
|
std::vector<UINT> vDefeatBonusRate;
|
|
LadderSystem::MatchType::eCode LadderMatchType;
|
|
int iRewardItemID;
|
|
int nFatigueConTime;
|
|
int nFatigueConValue;
|
|
int nFatigueConExp;
|
|
int nFatigueConMedal;
|
|
int iNeedInven;
|
|
int iSkillSetting;
|
|
bool bIsSelectableRegulation;
|
|
bool bIsDefaultRegulation;
|
|
int nBattleGroundTableID;
|
|
bool bAllowedUserCreateMode;
|
|
#if defined( PRE_ADD_RACING_MODE ) || defined( PRE_ADD_PVP_TOURNAMENT )
|
|
int nDefaultRewardItem;
|
|
int nDefaultRewardValue;
|
|
std::vector<int> vRankRewardItem;
|
|
std::vector<int> vRankRewardValue;
|
|
#endif // #if defined( PRE_ADD_RACING_MODE ) || defined( PRE_ADD_PVP_TOURNAMENT )
|
|
|
|
// Function
|
|
bool CheckWinCondition( const UINT uiWinCondition ) const
|
|
{
|
|
if( vWinCondition.empty() )
|
|
return true;
|
|
|
|
for( UINT i=0 ; i<vWinCondition.size() ; ++i )
|
|
{
|
|
if( vWinCondition[i] == uiWinCondition )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckPlayTimeSec( const UINT uiPlayTime ) const
|
|
{
|
|
if( vPlayTimeSec.empty() )
|
|
return true;
|
|
|
|
for( UINT i=0 ; i<vPlayTimeSec.size() ; ++i )
|
|
{
|
|
if( vPlayTimeSec[i] == uiPlayTime )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 실패시 -1 리턴
|
|
int GetWinconditionIndex( const UINT uiWinCondition ) const
|
|
{
|
|
for( UINT i=0 ; i<vWinCondition.size() ; ++i )
|
|
{
|
|
if( vWinCondition[i] == uiWinCondition )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool CheckMaxUser( const UINT uiMaxUser ) const
|
|
{
|
|
return (uiMaxUser >= uiNumOfPlayersMin && uiMaxUser <= uiNumOfPlayersMax);
|
|
}
|
|
};
|
|
|
|
struct TPvPGameStartConditionTable
|
|
{
|
|
UINT uiMinTeamPlayerNum; // 최소 시작 팀 인원
|
|
UINT uiMaxTeamPlayerDiff; // 최대 양팀 인원 허용 수
|
|
|
|
short Check( const UINT uiATeam, const UINT uiBTeam, const bool bRandomTeam ) const
|
|
{
|
|
// 최소 시작 팀 인원 검사
|
|
if( uiATeam < uiMinTeamPlayerNum || uiBTeam < uiMinTeamPlayerNum )
|
|
return ERROR_PVP_CANTSTART_LESS_MINTEAMPLAYER;
|
|
|
|
if (!bRandomTeam) // 랜덤팀이 아닌 경우 처리한다.
|
|
{
|
|
// 최대 양팀 인원 허용 수 검사
|
|
UINT uiDiff = ::abs( static_cast<int>(uiATeam-uiBTeam) );
|
|
if( uiDiff > uiMaxTeamPlayerDiff )
|
|
return ERROR_PVP_CANTSTART_MORE_MAXDIFFTEAMPLAYER;
|
|
}
|
|
|
|
|
|
return ERROR_NONE;
|
|
}
|
|
};
|
|
|
|
struct TPvPRankTable
|
|
{
|
|
UINT uiXP;
|
|
#ifdef PRE_MOD_PVPRANK
|
|
BYTE cType; //PvPCommon::RankTable 참조
|
|
BYTE cMinRange; //rate or rank
|
|
BYTE cMaxRange; //rate or rank
|
|
|
|
TPvPRankTable()
|
|
{
|
|
uiXP = 0;
|
|
cType = PvPCommon::RankTable::InitValue;
|
|
cMinRange = 0;
|
|
cMaxRange = 0;
|
|
}
|
|
#endif //#ifdef PRE_MOD_PVPRANK
|
|
};
|
|
|
|
struct TAppellationData
|
|
{
|
|
int nAppellationID;
|
|
int nArrayIndex;
|
|
int nColor;
|
|
int nLevelLimit;
|
|
int nType;
|
|
#if defined( PRE_ADD_NEWCOMEBACK )
|
|
int nSkillItemID;
|
|
#endif
|
|
#if defined( PRE_MOD_APPELLATIONBOOK_RENEWAL)
|
|
std::vector<int> nUseCollectionBookIndex;
|
|
#endif // #if defined( PRE_MOD_APPELLATIONBOOK_RENEWAL)
|
|
};
|
|
|
|
// 미션 시스템 관련
|
|
struct TEventCondition
|
|
{
|
|
char cEvent;
|
|
char cType[5];
|
|
int nParam[5];
|
|
char cOperator[5];
|
|
bool bCheckType;
|
|
};
|
|
|
|
struct TMissionData
|
|
{
|
|
bool bActivate;
|
|
int nType; // 미션타입(eMissionType)
|
|
int nMailID;
|
|
int nRewardAppellation;
|
|
int nRewardPoint;
|
|
bool bIsAchieveNotice;
|
|
TEventCondition GainCondition;
|
|
TEventCondition AchieveCondition;
|
|
};
|
|
|
|
struct TDailyMissionData
|
|
{
|
|
int nMailID;
|
|
int nRewardAppellation;
|
|
int nRewardPoint;
|
|
TEventCondition AchieveCondition;
|
|
int nCounterParam;
|
|
char cCounterOperator;
|
|
int nItemID;
|
|
int nType;
|
|
int nTypeParam;
|
|
__time64_t tStartDate;
|
|
#if defined(PRE_ADD_WEEKLYEVENT_MISSION_ENDTIME)
|
|
__time64_t tEndDate;
|
|
#endif // #if defined(PRE_ADD_WEEKLYEVENT_MISSION_ENDTIME)
|
|
};
|
|
|
|
#if defined(PRE_ADD_REMOTE_QUEST)
|
|
struct TRemoteQuestData
|
|
{
|
|
bool bActivate;
|
|
int nIndex;
|
|
int nQuestID;
|
|
bool bPreQuestCheckType;
|
|
std::vector<int> nVecPreQuestCondition;
|
|
TEventCondition GainCondition;
|
|
};
|
|
#endif
|
|
|
|
#if defined(PRE_ADD_ACTIVEMISSION)
|
|
struct TActiveMissionData
|
|
{
|
|
int nIndex;
|
|
bool bActivate;
|
|
int nMailID;
|
|
TEventCondition AchieveCondition;
|
|
};
|
|
#endif
|
|
|
|
// Collection
|
|
const char CollectionAppellationMax = 10;
|
|
struct TCollectionBookData
|
|
{
|
|
int nID;
|
|
std::vector<int> nVecAppellationArrayIndex;
|
|
int nRewardAppellationArrayIndex;
|
|
#if defined(PRE_MOD_APPELLATIONBOOK_RENEWAL)
|
|
int nMailID[2]; // 0 - 50% 넘겼을 때 보내줄 메일 ID, 1- 칭호 컬렉션 완성시 보상 MailID
|
|
#endif //#if defined(PRE_MOD_APPELLATIONBOOK_RENEWAL)
|
|
};
|
|
|
|
// TaxTable
|
|
struct TTaxData
|
|
{
|
|
char cTaxType; // 세금종류 (TaxType_PostTax)
|
|
int nLevelStart; // 시작 레벨
|
|
int nLevelEnd; // 끝 레벨
|
|
int nAmountStart; // 시작금액 (골드단위)
|
|
int nAmountEnd; // 끝금액
|
|
float fRate; // 세율
|
|
int nTaxAmount; // 세액
|
|
};
|
|
|
|
// Seal
|
|
const BYTE SEALENCHANTMAX = 16; // 노강화부터 15강까지.
|
|
struct TSealCountData
|
|
{
|
|
int nType1;
|
|
int nType2;
|
|
int nLevel[SEALENCHANTMAX];
|
|
char cSuccessRate[SEALENCHANTMAX];
|
|
};
|
|
|
|
// PCBang
|
|
const BYTE PCParamMax = 2;
|
|
struct TPCBangParam
|
|
{
|
|
int nParam[PCParamMax];
|
|
};
|
|
|
|
struct TPCBangData
|
|
{
|
|
char cType; // PCBang 혜택 종류 (ePCBangType)
|
|
std::vector<TPCBangParam> VecPCBangParam;
|
|
std::vector<TPCBangParam> VecPremiumPCBangParam;
|
|
std::vector<TPCBangParam> VecGoldPCBangParam;
|
|
std::vector<TPCBangParam> VecSilverPCBangParam;
|
|
std::vector<TPCBangParam> VecRedPCBangParam;
|
|
};
|
|
|
|
// CashShop
|
|
const BYTE COMMODITYITEMMAX = 5;
|
|
const BYTE COMMODITYLINKMAX = 5;
|
|
struct TCashCommodityData
|
|
{
|
|
int nSN;
|
|
#if defined(_JP)
|
|
std::string strJPSN;
|
|
#endif // #if defined(_JP)
|
|
BYTE cCategory;
|
|
int nSubCategory;
|
|
int nItemID[COMMODITYITEMMAX]; // ItemTable 아이템 ID
|
|
int nLinkSN[COMMODITYLINKMAX]; // 연계상품
|
|
std::string strName;
|
|
short wPeriod; // 기간
|
|
int nPrice; // 가격
|
|
int nCount; // 구매시 주어지는 개수
|
|
int nPriority; // 캐시샵에 표시되는 우선순위
|
|
bool bOnSale; // 판매상태
|
|
bool bOnSaleReal; // 진짜(?)판매상태
|
|
char cState; // HOT, NEW등 상태 표시용
|
|
bool bLimit; // 한정 판매
|
|
bool bReserveGive; // 적립금 제공 여부
|
|
int nReserve; // 구매시 주어지는 적립금
|
|
int nValidity; // 유효기간
|
|
bool bReserveAble; // 적립금으로 살수 있는지 여부
|
|
bool bPresentAble; // 선물 가능 여부
|
|
char cItemSort; // 아이템종류
|
|
int nPriceFix; // 정가
|
|
bool bCartAble; // 장바구니에 담을 수 있는지
|
|
bool bVIPSell; // VIP 전용 판매 여부
|
|
int nVIPLevel; // VIP 등급
|
|
bool bAutomaticPay; // 자동결제 여부
|
|
int nAutomaticPaySale; // 자동결제 후 할인적용
|
|
int nVIPPoint; // 구매시 지급하는 VIPPoint
|
|
int nOverlapBuy; // 중복구매방지
|
|
#if defined(PRE_ADD_CASH_REFUND)
|
|
bool bNoRefund; // 청약 철회 불가능여부(true : 불가능)
|
|
#endif
|
|
#if defined(PRE_ADD_CASHSHOP_CREDIT)
|
|
bool bCreditAble; // 미쿡빌링
|
|
int nCreditAbleLevel; // 미쿡빌링 크레딧레벨
|
|
#endif // #if defined(PRE_ADD_CASHSHOP_CREDIT)
|
|
#if defined(PRE_ADD_SALE_COUPON)
|
|
bool bUseCoupon;
|
|
#endif //#if defined(PRE_ADD_SALE_COUPON)
|
|
#if defined( PRE_ADD_NEW_MONEY_SEED )
|
|
bool bSeedAble;
|
|
int nSeed;
|
|
bool bSeedGive;
|
|
#endif
|
|
|
|
TCashCommodityData()
|
|
{
|
|
nSN=0; cCategory=0; nSubCategory =0;
|
|
memset(nItemID, 0, sizeof(nItemID));
|
|
memset(nLinkSN, 0, sizeof(nLinkSN));
|
|
wPeriod=0; nPrice=0; nCount=0; nPriority=0;
|
|
bOnSale=false; bOnSaleReal=false; cState=0;
|
|
bLimit=false; bReserveGive=false; nReserve=0;
|
|
nValidity=0; bReserveAble=false; bPresentAble=false;
|
|
cItemSort=0; nPriceFix=0; bCartAble=false;
|
|
bVIPSell=false; nVIPLevel=0; bAutomaticPay=false;
|
|
nAutomaticPaySale=0; nVIPPoint=0;
|
|
nOverlapBuy =0;
|
|
|
|
#if defined(PRE_ADD_CASH_REFUND)
|
|
bNoRefund = true; // 기본 불가능
|
|
#endif
|
|
#if defined(PRE_ADD_CASHSHOP_CREDIT)
|
|
bCreditAble = false;
|
|
nCreditAbleLevel = 0;
|
|
#endif // #if defined(PRE_ADD_CASHSHOP_CREDIT)
|
|
#if defined(PRE_ADD_SALE_COUPON)
|
|
bUseCoupon = false;
|
|
#endif // #if defined(PRE_ADD_SALE_COUPON)
|
|
#if defined( PRE_ADD_NEW_MONEY_SEED )
|
|
bSeedAble = false;
|
|
nSeed = 0;
|
|
bSeedGive = false;
|
|
#endif
|
|
}
|
|
};
|
|
|
|
struct TCashPackageData
|
|
{
|
|
int nSN; // 패키지판매SN
|
|
std::vector<int> nVecCommoditySN;
|
|
|
|
TCashPackageData()
|
|
{
|
|
nSN = 0;
|
|
nVecCommoditySN.clear();
|
|
}
|
|
};
|
|
|
|
struct TCashLimitData
|
|
{
|
|
int nSN; // 한정판매할 상품 SN
|
|
time_t tStartDate; // _StartDate 시작일
|
|
time_t tEndDate; // _EndDate 종료일
|
|
int nBuyAbleCount; // 캐릭터당 구매가능횟수
|
|
#if defined(PRE_ADD_LIMITED_CASHITEM)
|
|
int nLimitedSellCount; //갯수한정아이템!
|
|
#endif //#if defined(PRE_ADD_LIMITED_CASHITEM)
|
|
};
|
|
|
|
struct TVIPData
|
|
{
|
|
int nVipID; // VIPTable에서의 ID
|
|
int nMonthItemSN; // 캐시 아이템 상품 넘버 (30일 결제시 한번 주기)
|
|
int nMailID[4]; // 0:서비스만료 7일전, 1:서비스만료 1일전, 2:서비스만료시, 3:자동결제시 캐시 부족할때
|
|
int nAutoPayItemSN; // 자동결제할때 결제할 아이템SN
|
|
};
|
|
|
|
// DL Table
|
|
struct TDLMapData
|
|
{
|
|
int nTotalRound;
|
|
int nFloor;
|
|
|
|
#if defined( PRE_ADD_CHALLENGE_DARKLAIR )
|
|
bool bChallengeDarkLair;
|
|
#endif // #if defined( PRE_ADD_CHALLENGE_DARKLAIR )
|
|
};
|
|
|
|
struct TDLClearDataItem
|
|
{
|
|
int nLevelMin;
|
|
int nLevelMax;
|
|
int nRoundMin;
|
|
int nRoundMax;
|
|
int nRewardExperience;
|
|
int nShowBoxCount;
|
|
int nSelectBoxCount;
|
|
char cTreasureBoxRatio[4];
|
|
int nRewardItemID[4];
|
|
int nReturnWorldSetID;
|
|
int nReturnWorldGateID;
|
|
int nRewardGP;
|
|
};
|
|
|
|
struct TDLClearData
|
|
{
|
|
std::vector<TDLClearDataItem*> pVecClearItem;
|
|
};
|
|
|
|
// Levelup Event
|
|
struct TLevelupEvent
|
|
{
|
|
enum eEventType
|
|
{
|
|
Levelup = 1, // 일반 레벨업이벤트
|
|
ShandaPromotion = 2, // 샨다 프로모션이벤트
|
|
CombackUser = 3, // 복귀유저이벤트
|
|
LevelupNew = 4, // 레벨업이벤트 새거 (한번 받으면 더이상 못받는 버젼)
|
|
ComeBackUserInven = 5, // 귀환자에게 바로 넣어주는 아이템 타입
|
|
NewbieQuitReward = 6, //신규 유저 접속 종료 보상
|
|
NewbieReconnectReward = 7, //신규 유저 재접속 보상
|
|
ComeBackUserQuitReward = 8, //귀환자 접속 종료 보상
|
|
};
|
|
|
|
int nLevel; // Player 캐릭터의 레벨
|
|
char cClassID; // 클래스
|
|
BYTE cJob;
|
|
int nMailID;
|
|
int nCashMailID;
|
|
int nEventType; // eEventType
|
|
|
|
TLevelupEvent()
|
|
{
|
|
nLevel = 0;
|
|
cClassID = 0;
|
|
nMailID = 0;
|
|
nCashMailID = 0;
|
|
cJob = 0;
|
|
}
|
|
};
|
|
|
|
struct TItemOptionTableData
|
|
{
|
|
int iEnchant;
|
|
int iOption;
|
|
int iPotential;
|
|
TItemOptionTableData()
|
|
{
|
|
iEnchant = 0;
|
|
iOption = 0;
|
|
iPotential = 0;
|
|
}
|
|
};
|
|
|
|
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
|
|
|
|
struct TReputeTableData
|
|
{
|
|
#if defined( PRE_ADD_REPUTATION_EXPOSURE )
|
|
int iMissionID;
|
|
int iNpcPresentRepute1; // 선물1 지급 호감도 달성 조건
|
|
int iNpcPresentRepute2; // 선물2 지급 호감도 달성 조건
|
|
int iNpcPresentID1; // NpcPresentRepute1 달성 시 NPC가 주는 선물 1 ItemID
|
|
int iNpcPresentID2; // NpcPresentRepute1 달성 시 NPC가 주는 선물 2 ItemID
|
|
#else
|
|
std::vector<int> iQuestIDs;
|
|
#endif // #if defined( PRE_ADD_REPUTATION_EXPOSURE )
|
|
|
|
int iMaxFavor; // 호의 최대치
|
|
int iTakeFavorPerDay; // 1일당 깎이는 호의 수치
|
|
int iMaxMalice; // 악의 최대치
|
|
int iAddMalicePerDay; // 1일당 올라가는 악의 수치
|
|
int iPresentIDArr[6]; // 받을 수 있는 선물 리스트
|
|
std::vector<int> vFavorNpcID; // 호의 NPC 리스트
|
|
std::vector<int> vMaliceNpcID; // 악의 NPC 리스트
|
|
int iFavorGroupBomb;
|
|
int iMaliceGroupBomb;
|
|
int iMailID[NpcReputation::Common::MaxMailCount];
|
|
int iMailRand[NpcReputation::Common::MaxMailCount];
|
|
int iPlusItemID;
|
|
int iPlusProb;
|
|
int iUnionID;
|
|
int iPresentPointArr[6]; // 선물마다 받을수 있는 연합포인트
|
|
|
|
TReputeTableData()
|
|
{
|
|
#if defined( PRE_ADD_REPUTATION_EXPOSURE )
|
|
iMissionID = 0;
|
|
iNpcPresentRepute1 = 0;
|
|
iNpcPresentRepute2 = 0;
|
|
iNpcPresentID1 = 0;
|
|
iNpcPresentID2 = 0;
|
|
#else
|
|
#endif // #if defined( PRE_ADD_REPUTATION_EXPOSURE )
|
|
iMaxFavor = 0;
|
|
iTakeFavorPerDay = 0;
|
|
iMaxMalice = 0;
|
|
iAddMalicePerDay = 0;
|
|
iFavorGroupBomb = 0;
|
|
iMaliceGroupBomb = 0;
|
|
for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
|
|
iPresentIDArr[i] = 0;
|
|
for( UINT i=0 ; i<NpcReputation::Common::MaxMailCount ; ++i )
|
|
{
|
|
iMailID[i] = 0;
|
|
iMailRand[i] = 0;
|
|
}
|
|
vFavorNpcID.clear();
|
|
vMaliceNpcID.clear();
|
|
|
|
iPlusItemID = 0;
|
|
iPlusProb = 0;
|
|
iUnionID = 0;
|
|
for( UINT i=0 ; i<_countof(iPresentPointArr) ; ++i )
|
|
iPresentPointArr[i] = 0;
|
|
}
|
|
|
|
int GetUnionPointByPresent (const int iPresentID)
|
|
{
|
|
for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
|
|
{
|
|
if( iPresentIDArr[i] == iPresentID )
|
|
{
|
|
// 혹시 몰라서 사이즈 검사 한번더!
|
|
if (0 <= i && i < _countof(iPresentPointArr))
|
|
return iPresentPointArr[i];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool CheckPresentID( const int iPresentID )
|
|
{
|
|
for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
|
|
{
|
|
if( iPresentIDArr[i] == iPresentID )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool bIsFavorNpc( const int iNpcID )
|
|
{
|
|
for( UINT i=0 ; i<vFavorNpcID.size() ; ++i )
|
|
{
|
|
if( vFavorNpcID[i] == iNpcID )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool bIsMaliceNpc( const int iNpcID )
|
|
{
|
|
for( UINT i=0 ; i<vMaliceNpcID.size() ; ++i )
|
|
{
|
|
if( vMaliceNpcID[i] == iNpcID )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
struct TPresentTableData
|
|
{
|
|
enum eType
|
|
{
|
|
Normal = 0,
|
|
Cash = 1,
|
|
Coin = 2,
|
|
Max,
|
|
};
|
|
|
|
eType Type;
|
|
int iTypeID;
|
|
int iCount;
|
|
int iAddFavorPoint;
|
|
int iTakeMalicePoint;
|
|
int iFavorGroupPoint;
|
|
int iMaliceGroupPoint;
|
|
|
|
TPresentTableData()
|
|
{
|
|
Type = Max;
|
|
iTypeID = 0;
|
|
iCount = 0;
|
|
iAddFavorPoint = 0;
|
|
iTakeMalicePoint = 0;
|
|
iFavorGroupPoint = 0;
|
|
iMaliceGroupPoint = 0;
|
|
}
|
|
};
|
|
|
|
struct TMailTableData
|
|
{
|
|
DBDNWorldDef::MailTypeCode::eCode Code;
|
|
bool IsCash;
|
|
int nSenderUIStringIndex;
|
|
int nTitleUIStringIndex;
|
|
int nTextUIStringIndex;
|
|
int ItemIDArr[MAILATTACHITEMMAX];
|
|
int ItemCountArr[MAILATTACHITEMMAX];
|
|
int ItemSNArr[MAILATTACHITEMMAX];
|
|
int nPresentMoney;
|
|
#if defined(PRE_SPECIALBOX)
|
|
int nKeepBoxReceive;
|
|
int nKeepBoxType;
|
|
int nKeepBoxLevelMin;
|
|
int nKeepBoxLevelMax;
|
|
int nKeepBoxClass;
|
|
#endif // #if defined(PRE_SPECIALBOX)
|
|
|
|
TMailTableData()
|
|
{
|
|
Code = static_cast<DBDNWorldDef::MailTypeCode::eCode>(0);
|
|
IsCash = false;
|
|
nSenderUIStringIndex = 0;
|
|
nTitleUIStringIndex = 0;
|
|
nTextUIStringIndex = 0;
|
|
nPresentMoney = 0;
|
|
memset( ItemIDArr, 0, sizeof(ItemIDArr) );
|
|
memset( ItemCountArr, 0, sizeof(ItemCountArr) );
|
|
memset( ItemSNArr, 0, sizeof(ItemSNArr) );
|
|
#if defined(PRE_SPECIALBOX)
|
|
nKeepBoxReceive = 0;
|
|
nKeepBoxType = 0;
|
|
nKeepBoxLevelMin = 0;
|
|
nKeepBoxLevelMax = 0;
|
|
nKeepBoxClass = 0;
|
|
#endif // #if defined(PRE_SPECIALBOX)
|
|
}
|
|
};
|
|
|
|
struct TStoreBenefitData
|
|
{
|
|
// 아래의 순서는 StoreBenefit 테이블의 정의와 맞춘 것이기 때문에 절대로 순서가 바뀌면 안됨.
|
|
enum eType
|
|
{
|
|
EnchantFeeDiscount = NpcReputation::StoreBenefit::EnchantFeeDiscount,
|
|
RepairFeeDiscount = NpcReputation::StoreBenefit::RepairFeeDiscount,
|
|
SellingPriceUp = NpcReputation::StoreBenefit::SellingPriceUp,
|
|
BuyingPriceDiscount = NpcReputation::StoreBenefit::BuyingPriceDiscount,
|
|
FishProficiencyUp = NpcReputation::StoreBenefit::FishProficiencyUp,
|
|
CookProficiencyUp = NpcReputation::StoreBenefit::CookProficiencyUp,
|
|
CultivateProficiencyUp = NpcReputation::StoreBenefit::CultivateProficiencyUp,
|
|
Max = NpcReputation::StoreBenefit::Max,
|
|
};
|
|
|
|
int iNpcID;
|
|
eType Type;
|
|
int aiFavorThreshold[ STORE_BENEFIT_MAX ];
|
|
int aiAdjustPercent[ STORE_BENEFIT_MAX ];
|
|
|
|
TStoreBenefitData( void ) : iNpcID( 0 ), Type( Max )
|
|
{
|
|
memset( aiFavorThreshold, 0, sizeof(aiFavorThreshold) );
|
|
memset( aiAdjustPercent, 0, sizeof(aiAdjustPercent) );
|
|
}
|
|
};
|
|
|
|
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
|
|
|
|
struct TShopPurchaseType
|
|
{
|
|
Shop::PurchaseType::eCode PurchaseType;
|
|
int iPurchaseItemID;
|
|
int iPurchaseItemValue;
|
|
};
|
|
|
|
struct TCombinedShopTableData
|
|
{
|
|
TShopItem ShopItem;
|
|
TShopPurchaseType PurchaseType[Shop::Max::PurchaseType];
|
|
Shop::PurchaseLimitType::eCode PurchaseLimitType;
|
|
int iPurchaseLimitValue;
|
|
#if defined(PRE_SAMPLEITEMNPC)
|
|
int nSampleVersion; // 샘플아이템 회차
|
|
#endif //#if defined(PRE_SAMPLEITEMNPC)
|
|
};
|
|
|
|
struct TMasterSystemDecreaseTableData
|
|
{
|
|
int iPupilLevel;
|
|
int iPupilFavor;
|
|
int iFavorUpDecreaseRespectPoint;
|
|
int iFavorDownDecreaseRespectPoint;
|
|
int iMasterSuccessMailID;
|
|
int iMasterFailureMailID;
|
|
int iPupilSuccessMailID;
|
|
int iPupilFailureMailID;
|
|
|
|
int GetDecreaseRespectPoint( int iFavorPoint )
|
|
{
|
|
if( iFavorPoint >= iPupilFavor)
|
|
return iFavorUpDecreaseRespectPoint;
|
|
return iFavorDownDecreaseRespectPoint;
|
|
}
|
|
};
|
|
|
|
struct TMasterSystemGainTableData
|
|
{
|
|
int iFavorPoint;
|
|
int iRepectPoint;
|
|
};
|
|
|
|
#if defined( PRE_ADD_SECONDARY_SKILL )
|
|
|
|
struct TSecondarySkillTableData
|
|
{
|
|
int iSkillID;
|
|
SecondarySkill::Type::eType Type;
|
|
SecondarySkill::SubType::eType SubType;
|
|
SecondarySkill::ExecuteType::eType ExecuteType;
|
|
};
|
|
|
|
struct TSecondarySkillLevelTableData
|
|
{
|
|
int iSkillID;
|
|
SecondarySkill::Grade::eType Grade;
|
|
int iLevel;
|
|
int iExp;
|
|
int iNextID;
|
|
int iParam;
|
|
};
|
|
|
|
struct TSecondarySkillRecipeTableData
|
|
{
|
|
public:
|
|
int iManufactureItemID[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
|
|
int iMinExp[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
|
|
int iMaxExp[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
|
|
SecondarySkill::Grade::eType RequireGrade;
|
|
int iRequireSkillLevel;
|
|
int iToolItemID[SecondarySkill::ManufactureSkill::MaxToolItemCount];
|
|
int iMasterExp;
|
|
int iStartExp;
|
|
int iMaxTime; // 단위(ms)
|
|
int iSuccessProbability;
|
|
int iSuccessUpExp;
|
|
int iRecipeUpExp;
|
|
int iMaterialItemID[SecondarySkill::ManufactureSkill::MaxMaterialItemCount];
|
|
int iMaterialItemCount[SecondarySkill::ManufactureSkill::MaxMaterialItemCount];
|
|
int iSuccessCount;
|
|
|
|
// 경험치로 생산될 ItemID 얻기
|
|
int GetManufactureItemID( int iExp, int iMaxValue )
|
|
{
|
|
int iExpRate = static_cast<int>(iExp/static_cast<float>(iMaxValue)*100);
|
|
|
|
for( int i=0 ; i<SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount ; ++i )
|
|
{
|
|
if( iExpRate >= iMinExp[i] && iExpRate <= iMaxExp[i] )
|
|
return iManufactureItemID[i];
|
|
}
|
|
|
|
_ASSERT_EXPR(0, L"[GetManufactureItemID] can not find ItemID");
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )
|
|
|
|
|
|
#ifdef PRE_ADD_CASHFISHINGITEM
|
|
struct TFishingMeritInfo
|
|
{
|
|
int nRodItemID;
|
|
|
|
bool bUseCashBait;
|
|
INT64 biBaitSerial;
|
|
int nBaitIndex;
|
|
|
|
int nMeritReduceFishingTime;
|
|
int nMeritSuccessRate;
|
|
};
|
|
#endif //#ifdef PRE_ADD_CASHFISHINGITEM
|
|
|
|
struct TFarmCultivateTableData
|
|
{
|
|
int iCultivateMaxTimeSec;
|
|
int iMaxWater;
|
|
int iConsumeWater;
|
|
int iHarvestNeedItemID;
|
|
int iHarvestDropRate[Farm::Max::HARVESTITEM_COUNT];
|
|
int iHarvestDropTableID;
|
|
int iSkillPointPlant; // 씨앗심기 시 경험치
|
|
int iSkillPointWater; // 물주기 시 경험치
|
|
int iCatalystCount; // 필요 성장촉진제 개수
|
|
SecondarySkill::Grade::eType RequiredSkillGrade;
|
|
int iRequiredSkillLevel;
|
|
int iOverlap;
|
|
};
|
|
|
|
struct TFishingTableData
|
|
{
|
|
int nMaxTime;
|
|
#ifdef PRE_ADD_CASHFISHINGITEM
|
|
int nAutoMaxTime;
|
|
#endif //#ifdef PRE_ADD_CASHFISHINGITEM
|
|
int nPullingTargetMin;
|
|
int nPullingTargetMax;
|
|
int nPullingTargetSpeed;
|
|
int nPullingTargetUpTime;
|
|
int nSkillPointSuccess;
|
|
int nSkillPointFailure;
|
|
int nSuccessProbability;
|
|
int nSuccessDropTableID;
|
|
};
|
|
|
|
struct TFishingPattern
|
|
{
|
|
int nPatternID;
|
|
int nProbabillity;
|
|
};
|
|
|
|
struct TFishingPointTableData
|
|
{
|
|
int nSecondarySkillClass; //낚시보조스킬등급
|
|
int nSecondarySkillLevel; //낚시보조스킬레벨
|
|
int nRequireItemType1;
|
|
int nRequireItemType2;
|
|
TFishingPattern Pattern[Fishing::Max::FISHINGPATTERNMAX];
|
|
};
|
|
|
|
struct TFishingAreaTableData
|
|
{
|
|
int nMatchedMapID;
|
|
int nMatchedFishingAreaID;
|
|
int nFishingPointID;
|
|
};
|
|
|
|
|
|
|
|
struct TJobTableData
|
|
{
|
|
char cJobNumber;
|
|
char cBaseClass;
|
|
char cParentJob;
|
|
float afMaxUsingSP[ 5 ];
|
|
char cClass;
|
|
};
|
|
|
|
struct TGlyphSkillData
|
|
{
|
|
int nGlyphID;
|
|
int nGlyphType;
|
|
int nSkillID;
|
|
int nSkillLevelID;
|
|
};
|
|
|
|
struct TGlyphSlotData
|
|
{
|
|
int nID;
|
|
char cSlotID;
|
|
char cLevelLimit;
|
|
char cSlotType;
|
|
bool IsCash;
|
|
};
|
|
|
|
struct TGlyphChargeData
|
|
{
|
|
char cGlyphType; // 1: 강화문장 2: 스킬문장 3: 특수스킬문장 (eGlyphType)
|
|
char cGlyphRank; // 1: 매직 2: 레어 3: 에픽 4: 유니크 (eItemRank)
|
|
int nCharge;
|
|
};
|
|
|
|
struct TCharmItem
|
|
{
|
|
#if defined(PRE_FIX_68828)
|
|
int nCharmID; // 참테이블 ID
|
|
#endif
|
|
int nItemID; // 아이템
|
|
int nCount; // 유저가 획득할 개수
|
|
int nProb; // 확률
|
|
int nPeriod; // 기간
|
|
int nAccumulationProb;
|
|
int nGold;
|
|
bool bMsg;
|
|
};
|
|
|
|
struct TCharmItemData
|
|
{
|
|
int nCharmNo; // 매력아이템 번호
|
|
std::vector<TCharmItem> CharmItemList;
|
|
};
|
|
|
|
const BYTE CharmItemKeyMax = 5;
|
|
struct TCharmItemKeyData
|
|
{
|
|
int nCharmItemID; // 상자 아이템 아이디
|
|
std::vector<int> nKeyList;
|
|
};
|
|
|
|
struct TCharmCountData
|
|
{
|
|
int nID;
|
|
int nMin;
|
|
int nMax;
|
|
};
|
|
|
|
#if defined (PRE_ADD_CHAOSCUBE)
|
|
struct TChaosStuffItem
|
|
{
|
|
int nItemID;
|
|
int nCount;
|
|
int nChaosNo;
|
|
};
|
|
|
|
struct TChaosResultItem
|
|
{
|
|
int nItemID; // 아이템
|
|
int nCount; // 유저가 획득할 개수
|
|
int nProb; // 확률
|
|
int nPeriod; // 기간
|
|
int nAccumulationProb;
|
|
int nGold;
|
|
bool bMsg;
|
|
};
|
|
|
|
struct TChaosItemData
|
|
{
|
|
int nChaosNo;
|
|
std::vector<TChaosResultItem> ChaosItemList;
|
|
|
|
};
|
|
#endif // #if defined (PRE_ADD_CHAOSCUBE)
|
|
|
|
//ServerMonitor
|
|
enum eServerMonitorLevel
|
|
{
|
|
SERVERMONITOR_LEVEL_NONE = 0,
|
|
SERVERMONITOR_LEVEL_MONITOR, //동접정보와 서버의상태
|
|
SERVERMONITOR_LEVEL_ADMIN, //동접정보와 서버상태 및 프로세스 시작만 가능
|
|
SERVERMONITOR_LEVEL_SUPERADMIN, //동접정보와 서버상태 및 모든컨트롤 가능
|
|
};
|
|
|
|
enum eServerMonitorNotice
|
|
{
|
|
SERVERMONITOR_UPDATENOTICE_CHANNELINFO,
|
|
SERVERMONITOR_UPDATENOTICE_SERVERINFO,
|
|
SERVERMONITOR_UPDATENOTICE_MERITINFO,
|
|
SERVERMONITOR_UPDATENOTICE_WOLRDINFO,
|
|
};
|
|
|
|
enum eSIDConnectionType
|
|
{
|
|
SID_CONNECTION_TYPE_LOG = 1,
|
|
SID_CONNECTION_TYPE_DB,
|
|
};
|
|
|
|
struct TPromotionData
|
|
{
|
|
int nID;
|
|
int nConditionType; //ePromotionConditionType
|
|
int nConditionValue;
|
|
int nPromotionType; //ePromotionType
|
|
int nRewardValue; //Percent
|
|
};
|
|
|
|
struct TUserPromotionData
|
|
{
|
|
int nType; //ePromotionType
|
|
int nValue; //Percent
|
|
};
|
|
|
|
struct TSchedule
|
|
{
|
|
char cHour;
|
|
char cMinute;
|
|
int nCycle;
|
|
};
|
|
|
|
|
|
struct TGuildLevel
|
|
{
|
|
int nLevel;
|
|
int nReqGold;
|
|
int nReqGuildPoint;
|
|
int nDailyGuildPointLimit;
|
|
int nDailyMissionPointLimit;
|
|
bool bApplicable;
|
|
};
|
|
|
|
struct TGuildWarPoint
|
|
{
|
|
int nRank;
|
|
int nRewardGuildPoint;
|
|
};
|
|
|
|
struct TGuildWarMapInfo
|
|
{
|
|
UINT uiMapTableID;
|
|
char cGuildWarUseMonth;
|
|
};
|
|
|
|
struct TGuildWarEventInfo
|
|
{
|
|
//char cEventStep;
|
|
__time64_t tBeginTime;
|
|
__time64_t tEndTime;
|
|
};
|
|
// 길드전 보상 메일관련
|
|
struct TGuildWarRewardData
|
|
{
|
|
char cType; // 보상 타입..eGuildWarRewardType
|
|
char cClass; // 클래스(워리어,아처, 소서리스, 클래릭)
|
|
int nMailID; // 우편 아이디
|
|
int nPresentID; // 선물함 아이디
|
|
int nGuildFestivalPoint; // 본선에서 지급할 길드축제포인트
|
|
int nGuildPoint; // 본선에서 지급할 길드포인트
|
|
};
|
|
|
|
|
|
struct TPeriodQuestDate
|
|
{
|
|
int nPeriodType;
|
|
__time64_t tAssignDate;
|
|
};
|
|
|
|
struct TExchangeTrade
|
|
{
|
|
int nItemID;
|
|
int nCategoryType;
|
|
int nGroupID;
|
|
int ExchangeType;
|
|
};
|
|
|
|
struct TPvPMissionRoom
|
|
{
|
|
int nItemID;
|
|
int nGroupID;
|
|
int nMapID;
|
|
int nModeID;
|
|
int nWinCondition;
|
|
int nPlayTime;
|
|
int nMaxPlayers;
|
|
int nStartPlayers;
|
|
int nRoomNameIndex;
|
|
bool bDropItem;
|
|
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
|
|
int nChannelType;
|
|
#endif //#ifdef PRE_ADD_COLOSSEUM_BEGINNER
|
|
};
|
|
|
|
typedef std::vector<TPvPMissionRoom> TVecPvPMissionRoom;
|
|
|
|
struct TGhoulConditionData
|
|
{
|
|
int nItemID;
|
|
int nItemIdx;
|
|
int nPlayerMaxNum[PvPCommon::Common::GhouConditionColCount];
|
|
int nGhoulCount[PvPCommon::Common::GhouConditionColCount];
|
|
int nMatchingMutationGroupID[PvPCommon::Common::GhouConditionColCount];
|
|
};
|
|
|
|
struct TMonsterMutationGroup
|
|
{
|
|
int nGroupID;
|
|
int nGourpIdx;
|
|
int nMonsterID[PvPCommon::Common::MonsterMutationColCount];
|
|
int nProbability[PvPCommon::Common::MonsterMutationColCount];
|
|
};
|
|
|
|
struct TMonsterMutationData
|
|
{
|
|
int nMutationID;
|
|
int nMutationIdx;
|
|
int nMutationActorID;
|
|
|
|
int nMutationHP;
|
|
int nMutationStrPMax;
|
|
int nMutationStrMMax;
|
|
int nMutationDefP;
|
|
int nMutationDefM;
|
|
int nMutationStiff;
|
|
|
|
int nMutationStiffResis;
|
|
int nMutationCriticalResis;
|
|
int nMutationStunResis;
|
|
|
|
int nMutationWeaponIdx1;
|
|
int nMutationWeaponIdx2;
|
|
int nMutationSkillTableID;
|
|
int nMutationSuperArmor;
|
|
|
|
int nSizeMin;
|
|
int nSizeMax;
|
|
int nMoveSpeed;
|
|
};
|
|
|
|
struct TMonsterMutationSkill
|
|
{
|
|
int nMonsterID;
|
|
int nMonsterIdx;
|
|
int nMonsterSkillIndex[PvPCommon::Common::MonsterMutationSkillColCount];
|
|
int nMonsterSkillLevel[PvPCommon::Common::MonsterMutationSkillColCount];
|
|
};
|
|
|
|
struct TOccupationModeInfo
|
|
{
|
|
int nVictoryCondition[PvPCommon::Common::MaximumVitoryCondition]; //PvPCommon::BattleGroundVictoryState
|
|
int nVictoryParam[PvPCommon::Common::MaximumVitoryCondition]; //PvPCommon::BattleGroundVictoryState
|
|
int nBossID[PvPCommon::TeamIndex::Max]; //생성보스아이디
|
|
int nBossSpawnAreaID[PvPCommon::TeamIndex::Max]; //보스생성시 스폰위치
|
|
};
|
|
|
|
struct TBattleGourndModeInfo
|
|
{
|
|
int nID;
|
|
int nWaitingMin;
|
|
int nFinishingMin;
|
|
int nPvPSkillPoint;
|
|
int nMaximumResourceLimit;
|
|
int nAllOcuupationBonusGain;
|
|
int nOccupationBonusGain[PvPCommon::Common::MaximumCapturePosition];
|
|
|
|
int nCaptureScore;
|
|
int nStealScore;
|
|
int nKillScore;
|
|
int nClimaxTime;
|
|
int nClimaxRespawnTime;
|
|
|
|
TOccupationModeInfo ModeInfo;
|
|
};
|
|
|
|
struct TPositionAreaInfo
|
|
{
|
|
int nID;
|
|
int nMapID;
|
|
int nPvPModeID;
|
|
int nAreaID;
|
|
int nGainResourceTermTick; //점령시 획득텀
|
|
int nGainResource; //획특텀시 획득량
|
|
int nRequireTryTick; //획득시도시 클릭상태지속 유지필요시간
|
|
int nCompleteOccupationTick; //클릭완료후 점령권 넘어가기 전의 대기시간
|
|
int nBonusBuffID;
|
|
//클라이막스~
|
|
int nClimaxGainTermTick;
|
|
int nClimaxGainVal;
|
|
int nClimaxTryTick;
|
|
int nClimaxCompleteOccupationTick;
|
|
};
|
|
|
|
struct TBattleGroundEffectValue
|
|
{
|
|
int nSkillID;
|
|
int nSkillLevel;
|
|
int nNeedSkillPoint; //획득시필요포인트
|
|
int nUseResPoint; //스킬사용시 소모 점령전 포인트
|
|
std::string strEffectValue[PvPCommon::Common::MaximumEffectCount];
|
|
int nEffectValueDuration[PvPCommon::Common::MaximumEffectCount];
|
|
//int nMonsterID;
|
|
//int nSummonDist;
|
|
std::string strActionName;
|
|
int nCoolTime;
|
|
|
|
void Reset()
|
|
{
|
|
nSkillID = 0;
|
|
nSkillLevel = 0;
|
|
nNeedSkillPoint = 0; //획득시필요포인트
|
|
nUseResPoint = 0; //스킬사용시 소모 점령전 포인트
|
|
for (int i = 0; i < PvPCommon::Common::MaximumEffectCount; i++)
|
|
{
|
|
strEffectValue[i].clear();;
|
|
nEffectValueDuration[i] = 0;
|
|
}
|
|
|
|
//nMonsterID = 0;
|
|
//nSummonDist = 0;
|
|
strActionName.clear();
|
|
nCoolTime = 0;
|
|
}
|
|
};
|
|
|
|
struct TBattleGroundSkillInfo
|
|
{
|
|
int nSkillID;
|
|
int nSkillMaxLevel;
|
|
int nSkillType; //CDnSkill::SkillTypeEnum //점령전 스킬은 스킬타입에 그닥 영향을 받지 않지만 추가확장시 필요할까 해서 읽어둠
|
|
int nSkillDurationType; //CDnSkill::DurationTypeEnum
|
|
int nSkillTargetType; //CDnSkill::TargetTypeEnum
|
|
int nEffectType[PvPCommon::Common::MaximumEffectCount];
|
|
int nEffectApplyType[PvPCommon::Common::MaximumEffectCount];
|
|
int nProcess; //프로세스타입은 하나만 사용
|
|
int nCanDuplicate; //중첩가능?
|
|
};
|
|
|
|
struct TBattleGroundSkill
|
|
{
|
|
};
|
|
|
|
struct TUnionReputeBenefitData
|
|
{
|
|
int nItemID;
|
|
int nPeriod;
|
|
int nBenefitType[NpcReputation::Common::MaxBenefitCount];
|
|
int nBenefitNum[NpcReputation::Common::MaxBenefitCount];
|
|
};
|
|
|
|
struct TGuildMarkData
|
|
{
|
|
int nItemID;
|
|
int nType;
|
|
bool bCash;
|
|
bool bMarkOnly;
|
|
bool bMarkView;
|
|
};
|
|
|
|
struct TPlayerCommonLevelTableInfo
|
|
{
|
|
int iFatigue10000Ratio; // 10000배율
|
|
float fMasterGainExp;
|
|
//int nMasterGainItemID;
|
|
//int nMasterGainItemCount;
|
|
float fAddGainExp;
|
|
float fDefense;
|
|
float fCritical;
|
|
float fFinalDamage;
|
|
#if defined(PRE_ADD_TALISMAN_SYSTEM)
|
|
int iTalismanCost; // 탈리스만 장착 해제, 위치교환 비용
|
|
#endif
|
|
};
|
|
|
|
struct TMasterSysFeelTableInfo
|
|
{
|
|
int nMinFeel;
|
|
int nMaxFeel;
|
|
int nAddExp; //(%값임)
|
|
};
|
|
|
|
struct TGlobalEventData
|
|
{
|
|
int nItemID;
|
|
int nCollectItemID;
|
|
int nScheduleID;
|
|
int nCollectTotalCount;
|
|
int nNoticeCount[MAX_NOTICE_WORLDEVENT];
|
|
bool bCheckNotice[MAX_NOTICE_WORLDEVENT];
|
|
|
|
time_t tCollectStartDate;
|
|
time_t tCollectEndDate;
|
|
time_t tRewardDate;
|
|
};
|
|
|
|
struct TEveryDayEventData
|
|
{
|
|
int nEventID;
|
|
int nEventOnOff;
|
|
int nSquenceDateCount;
|
|
int nMailID;
|
|
int nCashMailID;
|
|
int nNumber;
|
|
time_t tStartDate;
|
|
time_t tEndDate;
|
|
};
|
|
|
|
enum eDBJobSystem //g_szDBJobSystem
|
|
{
|
|
DBJOB_GUILDWAR_INIT = 0, // 길드전 초기화
|
|
DBJOB_GUILDWAR_STATS, // 길드전 통계
|
|
DBJOB_SYSTEM_MAX,
|
|
};
|
|
|
|
enum eDBJobSystemStatus
|
|
{
|
|
JOB_STATUS_RESERVE, // 예약
|
|
JOB_STATUS_COMPLETED, // 완료
|
|
JOB_STATUS_DOING, // 실행중
|
|
JOB_STATUS_FAIL, // 실패
|
|
};
|
|
|
|
struct TGuildRewardItemData
|
|
{
|
|
int nItemID; // 길드보상테이블에 있는 아이디
|
|
short nNeedGuildLevel; // 구입하기위한 길드레벨
|
|
int nNeedGold; // 구입하기위한 골드
|
|
int nItemType; // 길드보상아이템 타입
|
|
int nTypeParam1;
|
|
int nTypeParam2;
|
|
bool bCheckInven; // 이미 구입한건지 체크
|
|
bool bEternity; // 0:기간제 1:영구
|
|
int nPeriod; // 기간
|
|
bool bCheckMaster; // 마스터체크 여부
|
|
int nCheckType; // 필요 조건 체크(0:NONE 1:ITEMID 2:길드마크
|
|
int nCheckID; // 필요한 이전 아이템아이디
|
|
};
|
|
struct TExpData
|
|
{
|
|
int nExperience;
|
|
int nEventExperience;
|
|
int nPcBangExperience;
|
|
int nVIPExperience;
|
|
int nPromotionExperience;
|
|
int nItemExperience;
|
|
int nGuildExp;
|
|
TExpData()
|
|
{
|
|
nExperience = 0;
|
|
nEventExperience = 0;
|
|
nPcBangExperience = 0;
|
|
nVIPExperience = 0;
|
|
nPromotionExperience = 0;
|
|
nItemExperience = 0;
|
|
nGuildExp = 0;
|
|
}
|
|
void set(float Exp, float EventBonusExp = 0, float PcBangExp = 0, float VIPExp = 0, float PromotionBonusExp = 0, float ItemExp = 0, float GuildExp = 0)
|
|
{
|
|
nExperience = (int)Exp;
|
|
nEventExperience = (int)EventBonusExp;
|
|
nPcBangExperience = (int)PcBangExp;
|
|
nVIPExperience = (int)VIPExp;
|
|
nPromotionExperience = (int)PromotionBonusExp;
|
|
nItemExperience = (int)ItemExp;
|
|
nGuildExp = (int)GuildExp;
|
|
}
|
|
};
|
|
#if defined(PRE_ADD_SALE_COUPON)
|
|
struct TSaleCouponData
|
|
{
|
|
int nItemID; // 쿠폰 ID
|
|
int nUseItemSN[MAX_SALE_USEITEM]; // 쿠폰이 적용될 아이템 SN
|
|
};
|
|
#endif
|
|
|
|
#if defined( PRE_PARTY_DB )
|
|
|
|
namespace Party
|
|
{
|
|
struct QueryOutPartyType
|
|
{
|
|
enum eCode
|
|
{
|
|
Normal = 0,
|
|
Disconnect,
|
|
Kick,
|
|
EternityKick,
|
|
};
|
|
};
|
|
|
|
struct AddPartyAndMemberGame
|
|
{
|
|
Party::Data PartyData;
|
|
UINT nKickedMemberList[PARTYKICKMAX];
|
|
INT64 biCharacterDBID[PARTYMAX];
|
|
UINT nSessionID[PARTYMAX];
|
|
#if defined( PRE_ADD_NEWCOMEBACK )
|
|
bool bCheckComebackAppellation[PARTYMAX];
|
|
#endif
|
|
};
|
|
|
|
struct PartyMemberVillageData
|
|
{
|
|
UINT nAccountDBID;
|
|
INT64 biCharacterDBID;
|
|
BYTE cMemberIndex;
|
|
BYTE cVoiceAvailable;
|
|
#if defined( PRE_ADD_NEWCOMEBACK )
|
|
bool bCheckComebackAppellation;
|
|
#endif
|
|
UINT nMutedList[PARTYCOUNTMAX];
|
|
};
|
|
struct AddPartyAndMemberVillage
|
|
{
|
|
Party::Data PartyData;
|
|
UINT nVoiceChannelID;
|
|
WCHAR wszPartyName[PARTYNAMELENMAX];
|
|
UINT nKickedMemberList[PARTYKICKMAX];
|
|
PartyMemberVillageData MemberData[PARTYMAX];
|
|
};
|
|
};
|
|
|
|
#endif // #if defined( PRE_PARTY_DB )
|
|
|
|
#if defined( PRE_ADD_NAMEDITEM_SYSTEM )
|
|
struct TNamedItemData
|
|
{
|
|
int nItemID; // 네임드아이템아이디
|
|
int nMaxCount; // 최대 갯수
|
|
int nSwapItemID; // 대체할 아이템아이디
|
|
};
|
|
namespace EffectSkillNameSpace
|
|
{
|
|
struct SearchType
|
|
{
|
|
enum eType
|
|
{
|
|
ItemType = 0,
|
|
ItemID,
|
|
SkillID,
|
|
};
|
|
};
|
|
struct BuffType
|
|
{
|
|
enum eType
|
|
{
|
|
Partybuff = 0,
|
|
SelfBuff,
|
|
};
|
|
};
|
|
struct ShowEffectType
|
|
{
|
|
enum eType
|
|
{
|
|
NONEEFFECT = 0,
|
|
BUFFEFFECT,
|
|
SPELLEFFECT,
|
|
};
|
|
};
|
|
};
|
|
#endif
|
|
|
|
#ifdef PRE_ADD_EXCHANGE_POTENTIAL
|
|
struct TPotentialTransferData
|
|
{
|
|
int nItemID;
|
|
int nExtractItemLevel;
|
|
int nExtractItemRank;
|
|
int nInjectItemLevel;
|
|
int nInjectItemRank;
|
|
int nConsumptionCount;
|
|
int nMainType;
|
|
int nSubType;
|
|
};
|
|
#endif //#ifdef PRE_ADD_EXCHANGE_POTENTIAL
|
|
|
|
#if defined(PRE_ADD_INSTANT_CASH_BUY)
|
|
const int CashBuyShortcutMax = 10;
|
|
struct TCashBuyShortcutData
|
|
{
|
|
int nType;
|
|
int nAllowMapTypes;
|
|
int nShow;
|
|
std::vector<int> nSNList;
|
|
};
|
|
#endif // #if defined(PRE_ADD_INSTANT_CASH_BUY)
|
|
|
|
#if defined(PRE_ADD_EXCHANGE_ENCHANT)
|
|
struct TExchangeEnchantData
|
|
{
|
|
BYTE cRank; // 아이템 등급
|
|
BYTE cLevelLimit; // 제한 레벨
|
|
BYTE cEnchantLevel; // 강화 레벨
|
|
int nNeedCoin; // 수수료
|
|
int nNeedItemID1; // 필요아이템1
|
|
short wNeedItemCount1; // 필요아이템 카운트1
|
|
int nNeedItemID2; // 필요아이템2
|
|
short wNeedItemCount2; // 필요아이템 카운트2
|
|
};
|
|
#endif //#if defined(PRE_ADD_EXCHANGE_ENCHANT)
|
|
|
|
#if defined( PRE_WORLDCOMBINE_PARTY )
|
|
namespace WorldCombineParty
|
|
{
|
|
enum eType
|
|
{
|
|
MAXSKILLCOUNT = 2,
|
|
};
|
|
|
|
struct WrldCombinePartyData
|
|
{
|
|
BYTE cIndex; // 인덱스
|
|
BYTE cGroupIndex; // 그룹인덱스
|
|
WCHAR wszPartyName[PARTYNAMELENMAX];
|
|
int nWorldMap; // 월드존
|
|
int nTargetMap; // 타겟맵(기준값)
|
|
ePartyType PartyType; // 파티타입
|
|
BYTE cPartyMemberMax;
|
|
int nItemID; // 입장권아이템
|
|
TDUNGEONDIFFICULTY Difficulty;
|
|
TPARTYITEMLOOTRULE ItemLootRule; //ePartyItemLootRule 참조
|
|
TITEMRANK ItemRank; //아이템랭크(루트룰기획참조)
|
|
BYTE cUserLvLimitMin; //민맥스값이 있단다.
|
|
int iBitFlag;
|
|
int nSkillID[MAXSKILLCOUNT]; // 스킬아이디
|
|
};
|
|
}
|
|
#endif
|
|
|
|
#if defined(PRE_ADD_PCBANG_RENTAL_ITEM)
|
|
struct TPcBangRentItem
|
|
{
|
|
int nItemID;
|
|
BYTE cLevelStart;
|
|
BYTE cLevelEnd;
|
|
BYTE cClassID;
|
|
BYTE cJob;
|
|
BYTE cGrade;
|
|
int nItemOption;
|
|
};
|
|
#endif
|
|
|
|
#if defined( PRE_PRIVATECHAT_CHANNEL )
|
|
struct TPrivateChatChannelInfo
|
|
{
|
|
INT64 nPrivateChatChannelID;
|
|
WCHAR wszName[PrivateChatChannel::Common::MaxNameLen];
|
|
INT64 biMasterCharacterDBID;
|
|
int nMemberCount;
|
|
int nPassWord;
|
|
};
|
|
|
|
struct TPrivateChatChannelMember
|
|
{
|
|
time_t tJoinDate;
|
|
UINT nAccountDBID;
|
|
INT64 biCharacterDBID;
|
|
bool bMaster;
|
|
WCHAR wszCharacterName[NAMELENMAX];
|
|
};
|
|
|
|
struct TPrivateMemberDelServer
|
|
{
|
|
INT64 nPrivateChatChannelID;
|
|
INT64 biCharacterDBID;
|
|
WCHAR wszCharacterName[NAMELENMAX];
|
|
};
|
|
#endif
|
|
|
|
#if defined(PRE_ADD_WEEKLYEVENT)
|
|
namespace WeeklyEvent
|
|
{
|
|
struct TWeeklyEventData
|
|
{
|
|
int nStartTime;
|
|
int nEndTime;
|
|
BYTE cRaceType; // eRaceType
|
|
BYTE cClassType; // eClass
|
|
int nEventType;
|
|
int nValue; // %값
|
|
};
|
|
|
|
struct TWeeklyEvent
|
|
{
|
|
int nDayOfWeek; // eDayType
|
|
std::vector<TWeeklyEventData> VecEventData;
|
|
};
|
|
|
|
enum eDayType
|
|
{
|
|
Monday = 1,
|
|
Tuesday = 2,
|
|
Wednesday = 3,
|
|
Thursday = 4,
|
|
Friday = 5,
|
|
Saturday = 6,
|
|
Sunday = 7,
|
|
};
|
|
|
|
enum eRaceType
|
|
{
|
|
Player = 1,
|
|
Monster = 2,
|
|
};
|
|
|
|
enum eEventType
|
|
{
|
|
Event_1 = 1, // 1. hp상승 및 하락
|
|
Event_2 = 2, // 2. 공격력 강화 및 약화
|
|
Event_3 = 3, // 3. 방어력 강화 및 약화
|
|
Event_4 = 4, // 4. 강화 확률 증가
|
|
Event_5 = 5, // 5. 경험치 증가
|
|
Event_6 = 6, // 6. 파티유지 경험치 증가
|
|
Event_7 = 7, // 7. 친구 경험치 증가 (절친아님, 서로친구)
|
|
Event_8 = 8, // 8. 호감도 증가
|
|
Event_9 = 9, // 9. 연합 포인트획득량 증가
|
|
Event_10 = 10, // 10. 아이템 드랍률 증가
|
|
};
|
|
}
|
|
#endif // #if defined(PRE_ADD_WEEKLYEVENT)
|
|
|
|
#if defined( PRE_ADD_TOTAL_LEVEL_SKILL )
|
|
namespace TotalLevelSkill
|
|
{
|
|
struct TTotalSkillLevelTable
|
|
{
|
|
int nSkillID;
|
|
int nTotalLevelLimit;
|
|
int nUseLevelLimit;
|
|
int nSkillType;
|
|
};
|
|
struct TTotalSkillBlowTable
|
|
{
|
|
int nSkillID;
|
|
int nBlowID;
|
|
float fBlowValue;
|
|
int nBlowValue; // 농장 아이템 아이디문에 사용
|
|
};
|
|
struct TTotalSkillSlotTable
|
|
{
|
|
int nSlotIndex;
|
|
int nLevelLimit;
|
|
bool bCash;
|
|
};
|
|
}
|
|
#endif
|
|
|
|
#if defined(PRE_SPECIALBOX)
|
|
struct TProvideItemData
|
|
{
|
|
int nCashSN;
|
|
int nItemID;
|
|
int nCount;
|
|
int nSealCount;
|
|
int nOption;
|
|
};
|
|
|
|
struct TKeepBoxProvideItemData
|
|
{
|
|
int nType;
|
|
std::vector<TProvideItemData> VecProvideItem;
|
|
};
|
|
#endif // #if defined(PRE_SPECIALBOX)
|
|
|
|
#ifdef PRE_ADD_JOINGUILD_SUPPORT
|
|
struct TGuildSupportData
|
|
{
|
|
int nID;
|
|
int nJoinMinLevel; //최초길드가입시 최소레벨
|
|
int nJoinMaxLevel; //최초길드가입시 최대레벨
|
|
int nFirstJoinMailID; //최초가입시 보상메일아이디
|
|
int nMaxLevelGuildSupportMailID; //최초가입한 길드에서 만랩시 보상아이디
|
|
};
|
|
#endif //#ifdef PRE_ADD_JOINGUILD_SUPPORT
|
|
|
|
#if defined( PRE_FIX_67546 )
|
|
|
|
struct TChannelDBInfo
|
|
{
|
|
int nDBConnectionID;
|
|
BYTE cThreadID;
|
|
};
|
|
|
|
struct TDBConnectionInfo
|
|
{
|
|
int nThreadCount[THREADMAX];
|
|
};
|
|
|
|
#endif
|
|
#if defined( PRE_WORLDCOMBINE_PVP )
|
|
|
|
struct TWorldPvPMissionRoom
|
|
{
|
|
int nItemID;
|
|
int nMapID;
|
|
BYTE cModeID;
|
|
int nWinCondition;
|
|
int nPlayTime;
|
|
BYTE cMaxPlayers;
|
|
int nStartPlayers;
|
|
int nRoomNameIndex;
|
|
bool bDropItem;
|
|
USHORT unRoomOptionBit;
|
|
WorldPvPMissionRoom::Common::eReqType eWorldReqType;
|
|
int nMinLevel;
|
|
int nMaxLevel;
|
|
int nChannelType;
|
|
WCHAR wszRoomName[PARTYNAMELENMAX];
|
|
int nRoomPW;
|
|
};
|
|
|
|
struct TWorldPvPRoomDBData
|
|
{
|
|
int nDBRoomID;
|
|
int nWorldID;
|
|
int nServerID;
|
|
int nRoomID;
|
|
BYTE cModeID;
|
|
WCHAR wszRoomName[PARTYNAMELENMAX];
|
|
BYTE cMaxPlayers;
|
|
int nMapID;
|
|
int nWinCondition;
|
|
UINT nPlayTimeSec;
|
|
bool bBreakIntoFlag;
|
|
bool bDropItem;
|
|
bool bRegulationFlag;
|
|
bool bObserverFlag;
|
|
bool bRandomFlag;
|
|
BYTE cMinLevel;
|
|
BYTE cMaxLevel;
|
|
int nPassWord;
|
|
int nRoomMemberCount;
|
|
BYTE cChannelType;
|
|
};
|
|
|
|
typedef std::vector<TWorldPvPMissionRoom> TVecWorldPvPMissionRoom;
|
|
|
|
#endif
|
|
|
|
#if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD)
|
|
struct TBonusDropTable
|
|
{
|
|
int nIndex;
|
|
int nMapID; //맵ID
|
|
int nDropType;
|
|
int nNeedItemID[3]; //필요한 열쇠 아이템 ID
|
|
int nDropItemGroupID[3]; //드랍될 드랍아이템그룹ID
|
|
};
|
|
#endif // #if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD)
|
|
|
|
namespace ActozCommon
|
|
{
|
|
struct CharacterStatus
|
|
{
|
|
enum eCharacterStatus
|
|
{
|
|
Revive = 0,
|
|
Create = 0,
|
|
Delete = 1,
|
|
};
|
|
};
|
|
|
|
struct UpdateType
|
|
{
|
|
enum eUpdateType
|
|
{
|
|
Login = 1,
|
|
Logout = 2,
|
|
Levelup = 3,
|
|
Sync = 4,
|
|
};
|
|
};
|
|
};
|
|
|
|
#if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD)
|
|
struct TItemDropEnchantData
|
|
{
|
|
int nIndex; //IDX
|
|
int nDropID; // ItemDropTable의 ID와 매칭되는 값
|
|
int nEnchantCount; //인챈트가 몇개인지 카운트
|
|
int nEnchantOption[20]; //인챈트 정보
|
|
int nEnchantProb[20]; //인챈트가 선택될 확률
|
|
};
|
|
#endif // #if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD)
|
|
|
|
#if defined( PRE_ALTEIAWORLD_EXPLORE )
|
|
struct TAlteiaWorldMapInfo
|
|
{
|
|
int nIndex;
|
|
int nMapID;
|
|
TDUNGEONDIFFICULTY Difficulty;
|
|
};
|
|
#endif // #if defined( PRE_ALTEIAWORLD_EXPLORE )
|
|
|
|
#if defined( PRE_ADD_STAMPSYSTEM )
|
|
namespace StampSystem
|
|
{
|
|
struct ChallengeType
|
|
{
|
|
enum eType
|
|
{
|
|
DailyQuest = 1,
|
|
DailyMission = 2,
|
|
};
|
|
};
|
|
|
|
struct RewardCount
|
|
{
|
|
enum eCount
|
|
{
|
|
Day3 = 3,
|
|
Day5 = 5,
|
|
};
|
|
};
|
|
|
|
struct TStampChallenge // 스탬프 도전과제
|
|
{
|
|
BYTE cType;
|
|
std::set<int> setAssignmentID; // 도전과제 목록
|
|
int nMailID4; // 3일 보상
|
|
int nMailID7; // 5일 보상
|
|
};
|
|
|
|
struct TStampTableData // 스탬프 테이블
|
|
{
|
|
INT64 biStartTime;
|
|
std::vector<TStampChallenge> vChallengeList;
|
|
};
|
|
}
|
|
#endif // #if defined( PRE_ADD_STAMPSYSTEM )
|
|
|
|
#if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
|
|
struct TPrevPotentialData
|
|
{
|
|
int nItemID; //아이템 ID
|
|
INT64 nSerial; //시리얼
|
|
char cPotential; //이전 잠재력데이터
|
|
char cOption; //이전 잠재력데이터
|
|
char cNowPotential; //새로 부여된 잠재력
|
|
char cPotentialMoveCount; //(이전)잠재 이전 카운트
|
|
INT64 nPotentialItemSerial; //잠재력 부여에 사용한 코드 시리얼
|
|
int nPotentialItemID; //잠재력 부여에 사용한 아이템 ID
|
|
};
|
|
#endif // #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
|
|
|
|
struct TEffectItemData
|
|
{
|
|
int nItemSN;
|
|
int nItemID;
|
|
int nCount;
|
|
bool bFail;
|
|
INT64 nGiftDBID;
|
|
};
|
|
|
|
#if defined(PRE_ADD_TALISMAN_SYSTEM)
|
|
struct TTalismanData
|
|
{
|
|
int nTalismanID;
|
|
int nType;
|
|
int nPeriod;
|
|
};
|
|
|
|
struct TTalismanSlotData
|
|
{
|
|
bool bService;
|
|
int nLevel;
|
|
int nAmount;
|
|
int nItem;
|
|
int nNeedItemCount;
|
|
float fEfficiency;
|
|
int nType;
|
|
};
|
|
#endif
|
|
|
|
#if defined( PRE_PVP_GAMBLEROOM )
|
|
|
|
struct TPvPGambleRoomData
|
|
{
|
|
int nRoomIndex;
|
|
bool bRegulation;
|
|
BYTE cGambleType;
|
|
int nPrice;
|
|
};
|
|
|
|
struct TPvPGambleRoomWinData
|
|
{
|
|
INT64 biCharacterDBID;
|
|
int nPrice;
|
|
};
|
|
|
|
#endif // #if defined( PRE_PVP_GAMBLEROOM )
|
|
|
|
#if defined(PRE_ADD_EQUIPLOCK)
|
|
struct TDBLockItemInfo
|
|
{
|
|
BYTE cItemCode;
|
|
BYTE cItemSlotIndex;
|
|
INT64 biItemSerial;
|
|
EquipItemLock::TLockItem ItemData;
|
|
};
|
|
#endif // #if defined(PRE_ADD_EQUIPLOCK)
|
|
|
|
#if defined( PRE_ADD_STAGE_WEIGHT )
|
|
struct TStageWeightData
|
|
{
|
|
float fHPRate;
|
|
float fAttackRate;
|
|
float fSuperArmorRate;
|
|
float fItemDropRate;
|
|
};
|
|
#endif // #if defined( PRE_ADD_STAGE_WEIGHT )
|
|
|
|
#if defined( PRE_ADD_CHARACTERCHECKSUM )
|
|
struct CheckSumReason
|
|
{
|
|
enum eReason
|
|
{
|
|
LogoutCharacter = 1,
|
|
C2C_KeepGameMoney = 2,
|
|
C2C_TransferGameMoney = 3,
|
|
};
|
|
};
|
|
#endif // #if defined( PRE_ADD_CHARACTERCHECKSUM )
|
|
|
|
#if defined(PRE_ADD_STAGECLEAR_TIMECHECK)
|
|
namespace StageClearCheckTime
|
|
{
|
|
enum eCheckMinTime // 최소 클리어 타임
|
|
{
|
|
CheckMinTime = 60 * 1000, // 1분
|
|
};
|
|
enum eAbuseCount // 증가할 AbuseCount값
|
|
{
|
|
AbuseCount = 10,
|
|
};
|
|
// CheckTime을 사용하지 않을 맵(보스맵ID를 기준으로 판별한다
|
|
struct IgnoreMapIndex
|
|
{
|
|
enum eIgnoreMapIndex
|
|
{
|
|
MAP_CHAOSE_FIELD_BossA = 15157, //혼돈의 틈 파르마
|
|
MAP_CHAOSE_FIELD_32Lv_BossA = 15167, //혼돈의 틈 바이라
|
|
MAP_CHAOSE_FIELD_24Lv_BossA = 15174, // 혼돈의 틈 카말라
|
|
};
|
|
};
|
|
};
|
|
#endif // #if defined(PRE_ADD_STAGECLEAR_TIMECHECK)
|