#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 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 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 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 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 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().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 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 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 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 Answers; }; // key - 문단스트링인덱스, second - 문단 typedef std::map TALK_PARAGRAPH_MAP; typedef TALK_PARAGRAPH_MAP::iterator TALK_PARAGRAPH_MAP_IT; // key - 대사xml 파일 이름, second - 대사전체 typedef std::map TALK_MAP; typedef TALK_MAP::iterator TALK_MAP_IT; #include // key - 문단응답스트링인덱스 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도) typedef std::set TALK_ANSWER_SET; typedef TALK_ANSWER_SET::iterator TALK_ANSWER_SET_IT; // key - 대사xml 파일 이름, second - 문단응답스트링집합 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도) typedef std::map 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 vShopItem; // SHOPTABMAX TShopTabData() { Clear(); } void Clear() { nTabID = 0; vShopItem.clear(); } }; struct TShopData { int nShopID; // 샵 아이디 (npc가 가지고 있는 아이디와 비교해서 연결) std::vector 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 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 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 { UINT nGroupDBID; WCHAR wszGroupName[FRIEND_GROUP_NAMELENMAX]; }; struct TFriend:public TBoostMemoryPool { 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 vGameModeTableID; // PvPGameModeTableID std::vector 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 vWinCondition; std::vector 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 vVictoryExp; std::vector vVictoryBonusRate; std::vector vDefeatExp; std::vector 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 vRankRewardItem; std::vector 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= 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(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 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 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 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 VecPCBangParam; std::vector VecPremiumPCBangParam; std::vector VecGoldPCBangParam; std::vector VecSilverPCBangParam; std::vector 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 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 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 iQuestIDs; #endif // #if defined( PRE_ADD_REPUTATION_EXPOSURE ) int iMaxFavor; // 호의 최대치 int iTakeFavorPerDay; // 1일당 깎이는 호의 수치 int iMaxMalice; // 악의 최대치 int iAddMalicePerDay; // 1일당 올라가는 악의 수치 int iPresentIDArr[6]; // 받을 수 있는 선물 리스트 std::vector vFavorNpcID; // 호의 NPC 리스트 std::vector 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(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(iExp/static_cast(iMaxValue)*100); for( int i=0 ; i= 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 CharmItemList; }; const BYTE CharmItemKeyMax = 5; struct TCharmItemKeyData { int nCharmItemID; // 상자 아이템 아이디 std::vector 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 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 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 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 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 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 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 setAssignmentID; // 도전과제 목록 int nMailID4; // 3일 보상 int nMailID7; // 5일 보상 }; struct TStampTableData // 스탬프 테이블 { INT64 biStartTime; std::vector 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)