3403 lines
78 KiB
C++
3403 lines
78 KiB
C++
|
|
#pragma once
|
|
|
|
//#include <vector>
|
|
#include <mmo/ArMove.h>
|
|
#include "SkillBase.h"
|
|
#include "SMessage.h"
|
|
#include "SNetMessage.h"
|
|
#include "SNetMessageBill.h"
|
|
|
|
#include "K3DTypes.h"
|
|
#include "Util.h"
|
|
#include "Enc.h"
|
|
|
|
#pragma pack( 1 )
|
|
|
|
|
|
struct SMSG_AC_RESULT : public SGameMessage
|
|
{
|
|
SMSG_AC_RESULT() : SGameMessage(MSG_AC_RESULT)
|
|
{
|
|
request_msg_id = 0;
|
|
result = 0;
|
|
value = 0;
|
|
}
|
|
|
|
unsigned short request_msg_id;
|
|
unsigned short result;
|
|
int value;
|
|
};
|
|
|
|
/// 2011.05.20 GNE 인증 방식 - prodongi
|
|
struct SMSG_AC_RESULT_WITH_STRING : public SGameMessage
|
|
{
|
|
SMSG_AC_RESULT_WITH_STRING() : SGameMessage(MSG_AC_RESULT_WITH_STRING)
|
|
{
|
|
request_msg_id = 0;
|
|
result = 0;
|
|
value = 0;
|
|
str = NULL;
|
|
}
|
|
virtual ~SMSG_AC_RESULT_WITH_STRING()
|
|
{
|
|
SAFE_DELETE_ARRAY(str);
|
|
}
|
|
|
|
unsigned short request_msg_id;
|
|
unsigned short result;
|
|
int value;
|
|
char* str;
|
|
};
|
|
|
|
struct SMSG_AC_SERVER_LIST : public SGameMessage
|
|
{
|
|
SMSG_AC_SERVER_LIST() : SGameMessage(MSG_AC_SERVER_LIST)
|
|
{
|
|
count = 0;
|
|
m_pServerInfo = NULL;
|
|
}
|
|
~SMSG_AC_SERVER_LIST()
|
|
{
|
|
SAFE_DELETE_ARRAY( m_pServerInfo );
|
|
}
|
|
unsigned short last_login_server_idx;
|
|
unsigned short count;
|
|
|
|
struct TS_SERVER_INFO * m_pServerInfo; ///< 이 아래로 TS_SERVER_INFO 들이 붙게 됨
|
|
};
|
|
|
|
struct SMSG_AC_SELECT_SERVER : public SGameMessage
|
|
{
|
|
SMSG_AC_SELECT_SERVER() : SGameMessage(MSG_AC_SELECT_SERVER)
|
|
{
|
|
result = 0;
|
|
one_time_key_en_len = 0;
|
|
memset( one_time_key, 0, sizeof( one_time_key ) );
|
|
pending_time = 0;
|
|
}
|
|
unsigned short result;
|
|
size_t one_time_key_en_len;
|
|
unsigned char one_time_key[sizeof( __int64 ) + GameRule::MAX_CRYPTO_BLOCK_LEN];
|
|
AR_TIME pending_time; ///< 대기 할 시간
|
|
};
|
|
|
|
struct SMSG_AC_UPDATE_PENDING_TIME : public SGameMessage
|
|
{
|
|
SMSG_AC_UPDATE_PENDING_TIME() : SGameMessage(MSG_AC_UPDATE_PENDING_TIME)
|
|
{
|
|
pending_time = 0;
|
|
}
|
|
AR_TIME pending_time; ///< 대기 할 시간
|
|
};
|
|
|
|
|
|
struct SMSG_RESULT : public SGameMessage
|
|
{
|
|
SMSG_RESULT() : SGameMessage(MSG_RESULT)
|
|
{
|
|
request_msg_id = 0;
|
|
result = 0;
|
|
value = 0;
|
|
}
|
|
|
|
unsigned short request_msg_id;
|
|
unsigned short result;
|
|
int value;
|
|
};
|
|
|
|
|
|
struct SMSG_SECRET_KEY : public SGameMessage
|
|
{
|
|
SMSG_SECRET_KEY() : SGameMessage(MSG_SECRET_KEY)
|
|
{
|
|
nEncryptSize = 0;
|
|
pEncryptData = NULL;
|
|
}
|
|
~SMSG_SECRET_KEY()
|
|
{
|
|
delete pEncryptData;
|
|
}
|
|
|
|
size_t nEncryptSize;
|
|
unsigned char* pEncryptData;
|
|
};
|
|
|
|
struct SMSG_ACCOUNT_INFO : public SGameMessage
|
|
{
|
|
SMSG_ACCOUNT_INFO() : SGameMessage(MSG_ACCOUNT_INFO)
|
|
{
|
|
}
|
|
~SMSG_ACCOUNT_INFO()
|
|
{
|
|
}
|
|
|
|
std::string strAccount;
|
|
int user_no; // 유럽 db 통합 account id 중복 버그 방지위해 크루샵에서 사용할 고유값
|
|
};
|
|
|
|
|
|
struct SMSG_MOVE : public SGameMessage
|
|
{
|
|
SMSG_MOVE() : SGameMessage(MSG_MOVE)
|
|
{
|
|
handle = 0;
|
|
start_time = 0;
|
|
bReqMove = false;
|
|
pos_target = K3DVector(0,0,0);
|
|
speed = 0;
|
|
}
|
|
~SMSG_MOVE()
|
|
{
|
|
m_vecMoveInfo.clear();
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
AR_TIME start_time;
|
|
|
|
bool bReqMove;
|
|
|
|
K3DVector pos_target; ///< 이동 할 위치
|
|
|
|
unsigned char speed;
|
|
|
|
std::vector< ArPosition > m_vecMoveInfo;
|
|
};
|
|
|
|
/// Local Player 이동 응답
|
|
struct SMSG_MOVE_ACK : public SGameMessage
|
|
{
|
|
SMSG_MOVE_ACK() : SGameMessage(MSG_MOVE_ACK)
|
|
{
|
|
time = 0;
|
|
speed = 0;
|
|
}
|
|
|
|
AR_TIME time;
|
|
unsigned char speed;
|
|
|
|
};
|
|
|
|
struct SMSG_REGION_ACK : public SGameMessage
|
|
{
|
|
SMSG_REGION_ACK() : SGameMessage(MSG_REGION_ACK)
|
|
{
|
|
rx = 0;
|
|
ry = 0;
|
|
}
|
|
unsigned rx;
|
|
unsigned ry;
|
|
};
|
|
|
|
struct SMSG_LOGIN : public SGameMessage
|
|
{
|
|
SMSG_LOGIN() : SGameMessage(MSG_LOGIN)
|
|
{
|
|
// 2010.05.20 - prodongi
|
|
result = 0;
|
|
//bIsAccepted = 0;
|
|
handle = 0;
|
|
x=y=z = 0;
|
|
layer = 0;
|
|
region_size = 0;
|
|
hp = 0;
|
|
mp = 0;
|
|
max_hp = 0;
|
|
max_mp = 0;
|
|
race = 0;
|
|
skin_color = 0;
|
|
ZeroMemory( szName, sizeof(szName) );
|
|
cell_size = 6;
|
|
// 2010.05.20 - prodongi
|
|
hideEquipInfo = 0;
|
|
}
|
|
|
|
//char bIsAccepted;
|
|
//unsigned short bIsAccepted;
|
|
unsigned short result;
|
|
|
|
AR_HANDLE handle;
|
|
AR_UNIT x,y,z;
|
|
unsigned char layer;
|
|
float face_direction; ///< 보고있는 방향
|
|
int region_size;
|
|
|
|
// blow is game conetents
|
|
int hp;
|
|
int mp;
|
|
int max_hp;
|
|
int max_mp;
|
|
|
|
int sex;
|
|
int race;
|
|
|
|
unsigned long skin_color;
|
|
ItemBase::ItemCode faceid;
|
|
ItemBase::ItemCode hairid;
|
|
|
|
int hairColorIndex;
|
|
unsigned long hairColorRGB;
|
|
// 2010.05.20 - prodongi
|
|
unsigned int hideEquipInfo;
|
|
|
|
char szName[19];
|
|
|
|
int cell_size;
|
|
int guild_id;
|
|
int back_board;
|
|
};
|
|
|
|
struct SMSG_CHARLIST : public SGameMessage
|
|
{
|
|
SMSG_CHARLIST() : SGameMessage( MSG_CHARLIST ), current_server_time(0), nCharCount( 0 ), pCharInfo( NULL ) { }
|
|
~SMSG_CHARLIST() { SAFE_DELETE_ARRAY( pCharInfo ); }
|
|
|
|
unsigned int current_server_time; ///< 1970년 1월 1일 0시 0분 0초로부터 몇초가 경과되었는지를 알려줌.
|
|
// ( CRT 의 time() 리턴값임)
|
|
|
|
unsigned short last_login_index;
|
|
|
|
int nCharCount;
|
|
LOBBY_CHARACTER_INFO* pCharInfo;
|
|
};
|
|
|
|
struct SMSG_LEAVE : public SGameMessage
|
|
{
|
|
SMSG_LEAVE() : SGameMessage(MSG_LEAVE)
|
|
{
|
|
handle = 0;
|
|
}
|
|
AR_HANDLE handle;
|
|
};
|
|
|
|
struct SMSG_ENTER : public SGameMessage
|
|
{
|
|
SMSG_ENTER() : SGameMessage(MSG_ENTER)
|
|
{
|
|
type = 0;
|
|
handle = 0;
|
|
x=y=z = 0;
|
|
layer = 0;
|
|
|
|
// blow is game conetents
|
|
ObjType = 0;
|
|
}
|
|
unsigned char type;
|
|
AR_HANDLE handle;
|
|
AR_UNIT x,y,z;
|
|
unsigned char layer;
|
|
|
|
// below is game conetents
|
|
|
|
unsigned char ObjType;
|
|
|
|
struct TS_ITEM_PICK_UP_ORDER
|
|
{
|
|
AR_TIME drop_time;
|
|
AR_HANDLE hPlayer[ 3 ];
|
|
int nPartyID[ 3 ];
|
|
};
|
|
|
|
struct ItemInfo
|
|
{
|
|
ENC_INT code; ///< code 가 0인것은 돈임. 액수는 cnt
|
|
__int64 cnt;
|
|
TS_ITEM_PICK_UP_ORDER pick_up_order;
|
|
};
|
|
|
|
struct SkillInfo
|
|
{
|
|
AR_HANDLE caster;
|
|
AR_TIME start_time;
|
|
int skill_num;
|
|
};
|
|
|
|
struct CreatureInfo
|
|
{
|
|
enum
|
|
{
|
|
FLAG_BATTLE_MODE = 1 << 0,
|
|
FLAG_INVISIBLE = 1 << 1,
|
|
};
|
|
|
|
unsigned status;
|
|
|
|
float face_direction; ///< 보고있는 방향
|
|
int hp;
|
|
int max_hp;
|
|
int mp;
|
|
int max_mp;
|
|
int level;
|
|
unsigned char race;
|
|
unsigned long skin_color;
|
|
bool is_first_enter;
|
|
|
|
int energy;
|
|
};
|
|
|
|
struct MonsterInfo : CreatureInfo
|
|
{
|
|
enum
|
|
{
|
|
FLAG_DEAD = 1 << 8, // 2010.07.15 - prodongi
|
|
FLAG_DUNGEON_ORIGINAL_OWNER = 1 << 15,
|
|
FLAG_DUNGEON_ORIGINAL_SIEGER = 1 << 17,
|
|
};
|
|
|
|
//int monster_id;
|
|
ENC_INT monster_id;
|
|
bool is_tamed; ///< 테이밍 되었는지 여부
|
|
};
|
|
|
|
struct SummonInfo: CreatureInfo
|
|
{
|
|
AR_HANDLE master_handle;
|
|
ENC_INT summon_code;
|
|
char szName[19];
|
|
unsigned char enhance;
|
|
};
|
|
|
|
struct PetInfo : CreatureInfo ///< sonador 10.2.1 팻 시스템 구현
|
|
{
|
|
enum
|
|
{
|
|
FLAG_SHOVELING_SEARCH = 1 << 18,
|
|
FLAG_SHOVELING_APPROACH = 1 << 19,
|
|
FLAG_SHOVELING_DIG = 1 << 20,
|
|
};
|
|
AR_HANDLE master_handle;
|
|
ENC_INT pet_code;
|
|
char szName[ 19 ];
|
|
};
|
|
|
|
struct NPCInfo: CreatureInfo
|
|
{
|
|
enum
|
|
{
|
|
FLAG_HAS_STARTABLE_QUEST = 1 << 8,
|
|
FLAG_HAS_IN_PROGRESS_QUEST = 1 << 9,
|
|
FLAG_HAS_FINISHABLE_QUEST = 1 << 10,
|
|
};
|
|
|
|
ENC_INT npc_id;
|
|
};
|
|
|
|
struct PlayerInfo: CreatureInfo
|
|
{
|
|
enum
|
|
{
|
|
FLAG_SITDOWN = 1 << 8,
|
|
FLAG_BUY_BOOTH = 1 << 9,
|
|
FLAG_SELL_BOOTH = 1 << 10,
|
|
FLAG_PK_ON = 1 << 11,
|
|
FLAG_BLOODY = 1 << 12,
|
|
FLAG_DEMONIAC = 1 << 13,
|
|
FLAG_GM = 1 << 14,
|
|
FLAG_DUNGEON_ORIGINAL_OWNER = 1 << 15,
|
|
FLAG_WALKING = 1 << 16,
|
|
FLAG_DUNGEON_ORIGINAL_SIEGER = 1 << 17,
|
|
};
|
|
|
|
unsigned char sex;
|
|
|
|
ItemBase::ItemCode faceId;
|
|
int faceTextureId; // 2010.06.18 deco index이다, 변수명이 너무 헷깔린다. - prodongi
|
|
ItemBase::ItemCode hairId;
|
|
|
|
int hairColorIndex;
|
|
unsigned long hairColorRGB;
|
|
// 2010.05.20 - prodongi
|
|
unsigned int hideEquipFlag;
|
|
|
|
char szName[19];
|
|
|
|
unsigned short job_id;
|
|
|
|
AR_HANDLE ride_handle;
|
|
int guild_id;
|
|
int title_code; // 2012. 5. 30 - marine
|
|
int back_board;
|
|
};
|
|
|
|
struct FieldPropInfo
|
|
{
|
|
int prop_id;
|
|
float fZOffset;
|
|
float fRotateX, fRotateY, fRotateZ;
|
|
float fScaleX, fScaleY, fScaleZ;
|
|
bool bLockHeight;
|
|
float fLockHeight;
|
|
};
|
|
};
|
|
|
|
struct SMSG_ATTACK_DOUBLE : public SGameMessage
|
|
{
|
|
SMSG_ATTACK_DOUBLE() : SGameMessage(MSG_ATTACK_DOUBLE)
|
|
{
|
|
attacker_handle = 0;
|
|
target_handle = 0;
|
|
right_hand_damage = 0;
|
|
left_hand_damage = 0;
|
|
attack_speed = 0;
|
|
hp_percentage = 0;
|
|
|
|
pos_target = K3DVector(0,0,0);
|
|
|
|
flag = 0;
|
|
memset( right_hand_elemental_damage, 0, sizeof( right_hand_elemental_damage ) );
|
|
memset( left_hand_elemental_damage, 0, sizeof( left_hand_elemental_damage ) );
|
|
}
|
|
|
|
AR_HANDLE attacker_handle;
|
|
AR_HANDLE target_handle;
|
|
short right_hand_damage;
|
|
short left_hand_damage;
|
|
unsigned short attack_speed; ///< ms
|
|
unsigned char hp_percentage; ///< HP %
|
|
|
|
unsigned short flag;
|
|
unsigned char right_hand_elemental_damage[ CreatureElemental::COUNT ]; ///< 추가데미지
|
|
unsigned char left_hand_elemental_damage[ CreatureElemental::COUNT ]; ///< 추가데미지
|
|
|
|
K3DVector pos_target; ///< 이동 할 위치
|
|
};
|
|
|
|
struct SMSG_ATTACK : public SGameMessage
|
|
{
|
|
SMSG_ATTACK() : SGameMessage(MSG_ATTACK)
|
|
{
|
|
attacker_handle = 0;
|
|
target_handle = 0;
|
|
|
|
// pTarget = NULL;
|
|
pos_target = K3DVector(0,0,0);
|
|
|
|
attack_speed = 0;
|
|
|
|
count = 0;
|
|
|
|
nTypeBow = 0;
|
|
}
|
|
~SMSG_ATTACK()
|
|
{
|
|
m_vAttackInfoList.clear();
|
|
}
|
|
|
|
AR_HANDLE attacker_handle;
|
|
AR_HANDLE target_handle;
|
|
|
|
unsigned short attack_speed; ///< ms
|
|
unsigned short attack_delay; ///< ms
|
|
|
|
char attack_action;
|
|
|
|
char attack_flag;
|
|
|
|
unsigned char count;
|
|
|
|
int nTypeBow; ///< 활 공격 종류 ItemClass 참조~
|
|
|
|
// class SGameObject * pTarget; //공격 대상
|
|
K3DVector pos_target; ///< 이동 할 위치
|
|
|
|
std::vector< ATTACK_INFO > m_vAttackInfoList;
|
|
};
|
|
|
|
struct SMSG_CANT_ATTACK : public SGameMessage
|
|
{
|
|
SMSG_CANT_ATTACK() : SGameMessage(MSG_CANT_ATTACK)
|
|
{
|
|
attacker_handle = 0;
|
|
target_handle = 0;
|
|
// tx = 0;
|
|
// ty = 0;
|
|
// attack_range = 0;
|
|
}
|
|
AR_HANDLE attacker_handle;
|
|
AR_HANDLE target_handle;
|
|
// AR_UNIT tx,ty;
|
|
// AR_UNIT attack_range;
|
|
int reason;
|
|
};
|
|
|
|
struct SMSG_DAMAGE : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
NORMAL_DAMAGE = 0,
|
|
SKILL_DAMAGE,
|
|
DOT_DAMAGE,
|
|
};
|
|
|
|
enum
|
|
{
|
|
FIRE_SKILL = 0,
|
|
REGION_FIRE_SKILL,
|
|
};
|
|
|
|
SMSG_DAMAGE() : SGameMessage(MSG_DAMAGE)
|
|
{
|
|
nDamage = 0;
|
|
flag = 0;
|
|
nHittingAdd_FxID = 0;
|
|
attacker_handle = 0;
|
|
target_handle = 0;
|
|
memset( elemental_damage, 0 ,sizeof(elemental_damage) );
|
|
skillresult.damage.type = SkillResult::NOT_USE;
|
|
bSphereDamage = false;
|
|
bBowAttack = false;
|
|
nSkillID = 0;
|
|
nSkillLevel = 0; // TODO: Change later skill levels everywhere to short or char because it actually can't be higher than 255
|
|
strTargetName.clear();
|
|
|
|
attack_action = 0;
|
|
attack_flag = 0;
|
|
|
|
nDamage_Type = NORMAL_DAMAGE;
|
|
|
|
strCasterName = "Somebody";
|
|
strTargetName = "Somebody";
|
|
|
|
skill_type = FIRE_SKILL;
|
|
chainCaster = 0; /// 2011.03.25 - prodongi
|
|
}
|
|
|
|
AR_HANDLE attacker_handle;
|
|
AR_HANDLE target_handle;
|
|
|
|
bool bSphereDamage; ///< 범위데미지
|
|
bool bBowAttack; ///< 활 공격이냐
|
|
|
|
int nHittingAdd_FxID; ///<부가 FX ID
|
|
|
|
int nDamage; ///<데미지
|
|
unsigned char flag;
|
|
int elemental_damage[ CreatureElemental::COUNT ]; ///< 추가데미지
|
|
|
|
int nSkillID;
|
|
int nSkillLevel;
|
|
|
|
std::string strCasterName;
|
|
std::string strTargetName;
|
|
|
|
SkillResult skillresult;
|
|
|
|
char attack_action;
|
|
char attack_flag;
|
|
|
|
short nDamage_Type;
|
|
int skill_type;
|
|
AR_HANDLE chainCaster; /// 2011.03.25 - prodongi
|
|
};
|
|
|
|
struct SMSG_STAT_INFO : public SGameMessage
|
|
{
|
|
SMSG_STAT_INFO() : SGameMessage(MSG_STAT_INFO)
|
|
{
|
|
handle = 0;
|
|
memset( &stat , 0, sizeof(stat) );
|
|
memset( &attribute, 0, sizeof(attribute) );
|
|
type = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
|
|
CreatureStat stat;
|
|
CreatureAttribute attribute;
|
|
|
|
unsigned char type;
|
|
};
|
|
|
|
struct SMSG_GOLD_UPDATE : public SGameMessage
|
|
{
|
|
SMSG_GOLD_UPDATE() : SGameMessage(MSG_GOLD_UPDATE), gold(0) { }
|
|
money_t gold; ///< [sonador][3.4.1]소지금 한도 증가 관련 서버 메시지 변경
|
|
int chaos;
|
|
};
|
|
|
|
struct SMSG_LEVEL_UPDATE : public SGameMessage
|
|
{
|
|
SMSG_LEVEL_UPDATE() : SGameMessage(MSG_LEVEL_UPDATE), handle(0), level(0), job_level(0) { }
|
|
AR_HANDLE handle;
|
|
int level;
|
|
int job_level;
|
|
};
|
|
|
|
struct SMSG_EXP_UPDATE : public SGameMessage
|
|
{
|
|
SMSG_EXP_UPDATE() : SGameMessage(MSG_EXP_UPDATE), handle(0), exp(0), jp(0) { }
|
|
AR_HANDLE handle;
|
|
__int64 exp;
|
|
__int64 jp; /// 2011.04.29 int -> __int64 - prodongi
|
|
};
|
|
|
|
struct SMSG_BONUS_EXP_JP : public SGameMessage
|
|
{
|
|
SMSG_BONUS_EXP_JP() : SGameMessage(MSG_BONUS_EXP_JP)
|
|
{
|
|
}
|
|
|
|
std::vector< TS_SC_BONUS_EXP_JP::BONUS_INFO > m_vBonusInfo;
|
|
};
|
|
|
|
struct SMSG_STATUS_CHANGE : public SGameMessage
|
|
{
|
|
SMSG_STATUS_CHANGE() : SGameMessage(MSG_STATUS_CHANGE)
|
|
{
|
|
handle = 0;
|
|
status = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
unsigned status;
|
|
};
|
|
|
|
struct SMSG_WATCH_BOOTH : public SGameMessage
|
|
{
|
|
SMSG_WATCH_BOOTH( AR_HANDLE h = NULL, bool bIsStart = false ) : SGameMessage( MSG_WATCH_BOOTH ), hTarget( h ), bIsStartWatch( bIsStart ) {}
|
|
|
|
AR_HANDLE hTarget;
|
|
bool bIsStartWatch;
|
|
};
|
|
|
|
struct SMSG_BOOTH_NAME_CHANGED : public SGameMessage
|
|
{
|
|
SMSG_BOOTH_NAME_CHANGED( AR_HANDLE h, const std::string & name ) : SGameMessage( MSG_BOOTH_NAME_CHANGED ), hTarget( h ), strBoothName( name ) {}
|
|
|
|
AR_HANDLE hTarget;
|
|
std::string strBoothName;
|
|
};
|
|
|
|
struct SMSG_BOOTH_CLOSED : public SGameMessage
|
|
{
|
|
SMSG_BOOTH_CLOSED( AR_HANDLE h ) : SGameMessage( MSG_BOOTH_CLOSED ), hTarget( h ) {}
|
|
|
|
AR_HANDLE hTarget;
|
|
};
|
|
|
|
struct SMSG_BOOTH_INFO : public SGameMessage
|
|
{
|
|
SMSG_BOOTH_INFO() : SGameMessage( MSG_BOOTH_INFO ) { bIsWatch = false;}
|
|
|
|
bool bIsWatch;
|
|
bool bIsSell;
|
|
AR_HANDLE hTarget;
|
|
std::vector< TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO > vList;
|
|
};
|
|
|
|
struct SMSG_BOOTH_TRADE_INFO : public SGameMessage
|
|
{
|
|
SMSG_BOOTH_TRADE_INFO() : SGameMessage( MSG_BOOTH_TRADE_INFO ) {}
|
|
|
|
AR_HANDLE hTarget;
|
|
bool bIsSell;
|
|
std::vector< TS_BOOTH_TRADE_ITEM_INFO > vList;
|
|
};
|
|
|
|
struct SMSG_BOOTH_NAME : public SGameMessage
|
|
{
|
|
SMSG_BOOTH_NAME() : SGameMessage( MSG_BOOTH_NAME ) {}
|
|
|
|
std::vector< TS_SC_GET_BOOTHS_NAME::TS_BOOTH_NAME > vBoothName;
|
|
};
|
|
|
|
struct SMSG_STATE : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
OWNER_NONE = 0,
|
|
OWNER_LOCAL_PLAYER,
|
|
OWNER_LOCAL_CREATURE,
|
|
OWNER_LOCAL_PARTY,
|
|
OWNER_LOCAL_GUILD,
|
|
};
|
|
|
|
SMSG_STATE() : SGameMessage(MSG_STATE)
|
|
{
|
|
handle = 0;
|
|
state_handle = 0;
|
|
state_code = 0;
|
|
state_level = 0;
|
|
end_time = 0;
|
|
start_time = 0;
|
|
state_value = 0;
|
|
data_owner = OWNER_NONE;
|
|
isToggle = false;
|
|
/// 2011.07.28 redmine #16797 - prodongi
|
|
disguiseEnhance = 0;
|
|
isNewState = false;
|
|
}
|
|
|
|
AR_HANDLE handle; ///< 대상 크리쳐
|
|
unsigned short state_handle; ///< 상태이상 핸들
|
|
unsigned int state_code; ///< 상태이상 종류
|
|
unsigned short state_level; ///< 상태이상의 레벨 (0이면 풀리는 메세지임)
|
|
AR_TIME end_time; ///< 끝나는 시간 (0이면 영원히)
|
|
AR_TIME start_time;
|
|
unsigned short data_owner;
|
|
int state_value; ///< 지속효과 관련 추가값
|
|
std::string state_string_value;
|
|
/// 2011.07.28 redmine #16797 - prodongi
|
|
int disguiseEnhance; /// 변신할 크리처의 강화 정보
|
|
|
|
bool isToggle; ///< 토글형 스킬?
|
|
|
|
bool isNewState; /// 2012.02.01 새로 걸리는 버프인지 아닌지(기존 버프가 존재하지 않거나 기존에 걸려 있는 버프와의 레벨이 틀리는 경우) - prodongi
|
|
};
|
|
/*
|
|
struct SMSG_HP : public SGameMessage
|
|
{
|
|
SMSG_HP() : SGameMessage(MSG_HP)
|
|
{
|
|
handle = 0;
|
|
hp = 0;
|
|
hp_percentage = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
int hp;
|
|
unsigned char hp_percentage;
|
|
};
|
|
|
|
struct SMSG_MP : public SGameMessage
|
|
{
|
|
SMSG_MP() : SGameMessage(MSG_MP)
|
|
{
|
|
handle = 0;
|
|
mp = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
int mp;
|
|
};
|
|
*/
|
|
struct SMSG_SP : public SGameMessage
|
|
{
|
|
SMSG_SP() : SGameMessage(MSG_SP)
|
|
{
|
|
handle = 0;
|
|
sp = 0;
|
|
max_sp = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
short sp;
|
|
short max_sp;
|
|
};
|
|
|
|
struct SMSG_REGEN_HPMP : public SGameMessage
|
|
{
|
|
SMSG_REGEN_HPMP() : SGameMessage( MSG_REGEN_HPMP )
|
|
{
|
|
handle = 0;
|
|
hp_regen = 0;
|
|
mp_regen = 0;
|
|
hp = 0;
|
|
mp = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
int hp_regen;
|
|
int mp_regen;
|
|
int hp;
|
|
int mp;
|
|
};
|
|
|
|
struct SMSG_PROPERTY : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
PROPERTY_HP, ///< "hp"
|
|
PROPERTY_MP, ///< "mp"
|
|
PROPERTY_MAX_HP, ///< "max_hp"
|
|
PROPERTY_MAX_MP, ///< "max_mp"
|
|
PROPERTY_LOGIN, ///< "login"
|
|
PROPERTY_ACCOUNT, ///< "account"
|
|
PROPERTY_NAME, ///< "name"
|
|
PROPERTY_GOLD, ///< "gold"
|
|
PROPERTY_EXP, ///< "exp"
|
|
PROPERTY_JP, ///< "jp"
|
|
PROPERTY_JOB_LEVEL, ///< "job_level"
|
|
PROPERTY_JOB, ///< "job"
|
|
PROPERTY_JOB_0, ///< "job_0"
|
|
PROPERTY_JLV_0, ///< "jlv_0"
|
|
PROPERTY_JOB_1, ///< "job_1"
|
|
PROPERTY_JLV_1, ///< "jlv_1"
|
|
PROPERTY_JOB_2, ///< "job_2"
|
|
PROPERTY_JLV_2, ///< "jlv_2"
|
|
PROPERTY_LEVEL, ///< "level"
|
|
PROPERTY_WEIGHT, ///< "weight"
|
|
PROPERTY_STR, ///< "str"
|
|
PROPERTY_AGI, ///< "agi"
|
|
PROPERTY_DEX, ///< "dex"
|
|
PROPERTY_INT, ///< "int"
|
|
PROPERTY_LUCK, ///< "luck"
|
|
PROPERTY_VITAL, ///< "vital"
|
|
PROPERTY_MENTAL, ///< "mental"
|
|
PROPERTY_PERMISSION, ///< "permission"
|
|
PROPERTY_PK_COUNT, ///< "pk_count"
|
|
PROPERTY_DK_COUNT, ///< "dkc"
|
|
PROPERTY_RACE, ///< "race"
|
|
PROPERTY_CHARISMA, ///< "charisma"
|
|
PROPERTY_MORAL, ///< "moral"
|
|
PROPERTY_LOGIN_TIME, ///< "login_time"
|
|
PROPERTY_SEX, ///< "sex"
|
|
PROPERTY_X, ///< "x"
|
|
PROPERTY_Y, ///< "y"
|
|
PROPERTY_SPEED, ///< "speed"
|
|
PROPERTY_SP, ///< "sp" ( 소환수에게 온다. )
|
|
PROPERTY_STORAGE_GOLD, ///< "storage_gold" 창고에 저장된 금액
|
|
PROPERTY_STAMINA, ///< "stamina"
|
|
PROPERTY_CHAOS, ///< "chaos"
|
|
PROPERTY_MAX_CHAOS, ///< "max_chaos"
|
|
PROPERTY_MAX_STAMINA, ///< "max_stamina"
|
|
PROPERTY_CHANNEL, ///< "channel"
|
|
PROPERTY_STAMINA_REGEN_RATE, ///< "stamina_regen"
|
|
PROPERTY_PLAYTIME, ///< "playtime"
|
|
PROPERTY_PLAYTIME_LIMIT1, ///< "playtime_limit1"
|
|
PROPERTY_PLAYTIME_LIMIT2, ///< "playtime_limit2"
|
|
PROPERTY_HUNTAHOLIC_ENT, ///< "huntaholic_ent"
|
|
|
|
PROPERTY_ETHEREAL_STONE_DURABILITY, ///< "ethereal_stone_durability"
|
|
PROPERTY_HUNTAHOLICPOINT, // "huntaholicpoint"
|
|
PROPERTY_TP, /// 2011.03.28 "tp" 특성 포인트 - prodongi
|
|
PROPERTY_AP, /// 2012.06.08 "ap" 아레나 포인트 - prodongi
|
|
|
|
PROPERTY_ALIAS, /// 아레나 별칭
|
|
PROPERTY_CLIENT_INFO, ///< "client_info"
|
|
PROPERTY_QUICK_SLOT, ///< "quick_slot"
|
|
PROPERTY_CURRENT_KEY, ///< "current_key_info"
|
|
PROPERTY_SAVED_KEY, ///< "saved_key_info"
|
|
};
|
|
|
|
SMSG_PROPERTY( AR_HANDLE han, int nType, const char* szValue )
|
|
: SGameMessage(MSG_PROPERTY), handle(han), nPropertyType( nType ), strValue( szValue ) { }
|
|
|
|
AR_HANDLE handle;
|
|
int nPropertyType; ///< 위의 프로퍼티 타입 참조
|
|
std::string strValue;
|
|
};
|
|
|
|
struct SMSG_HPMP : public SGameMessage
|
|
{
|
|
SMSG_HPMP() : SGameMessage(MSG_HPMP)
|
|
{
|
|
handle = 0;
|
|
add_hp = 0;
|
|
hp = 0;
|
|
max_hp = 0;
|
|
add_mp = 0;
|
|
mp = 0;
|
|
max_mp = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
int add_hp;
|
|
int hp;
|
|
int max_hp;
|
|
int add_mp;
|
|
int mp;
|
|
int max_mp;
|
|
bool need_to_display;
|
|
|
|
};
|
|
|
|
struct SMSG_TARGET : public SGameMessage
|
|
{
|
|
SMSG_TARGET() : SGameMessage(MSG_TARGET)
|
|
{
|
|
target = 0;
|
|
}
|
|
|
|
AR_HANDLE target;
|
|
};
|
|
|
|
struct SMSG_SHOW_CREATE_GUILD : public SGameMessage
|
|
{
|
|
SMSG_SHOW_CREATE_GUILD() : SGameMessage(MSG_SHOW_CREATE_GUILD)
|
|
{
|
|
|
|
}
|
|
};
|
|
|
|
struct SMSG_SHOW_CREATE_ALLIANCE : public SGameMessage
|
|
{
|
|
SMSG_SHOW_CREATE_ALLIANCE() : SGameMessage(MSG_SHOW_CREATE_ALLIANCE) {}
|
|
};
|
|
|
|
struct SMSG_SEND_DATA : public SGameMessage
|
|
{
|
|
SMSG_SEND_DATA( int n )
|
|
: SGameMessage( MSG_SEND_DATA ), nNumber( n ) { }
|
|
|
|
SMSG_SEND_DATA( const char *pszMessage )
|
|
: SGameMessage( MSG_SEND_DATA ), strMessage( pszMessage ) { }
|
|
|
|
SMSG_SEND_DATA( const char *pszMessage, const char *pszData )
|
|
: SGameMessage( MSG_SEND_DATA ), strMessage( pszMessage ), strData( pszData ){ }
|
|
|
|
SMSG_SEND_DATA( int n, const char *pszMessage )
|
|
: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage ) { }
|
|
|
|
SMSG_SEND_DATA( int n, const char *pszMessage, const char *pszData )
|
|
: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage ), strData( pszData ) { }
|
|
|
|
SMSG_SEND_DATA( int n, const char *pszMessage, int n2, int n3, const char *pszData )
|
|
: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage ), nNumber2( n2 ), nNumber3( n3 ), strData( pszData ) { }
|
|
|
|
SMSG_SEND_DATA( int n, const char *pszMessage, int n2, int n3, int n4, const char *pszData )
|
|
: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage ), nNumber2( n2 ), nNumber3( n3 ), nNumber4(n4), strData( pszData ) { }
|
|
|
|
std::string strMessage;
|
|
std::string strData;
|
|
int nNumber;
|
|
int nNumber2;
|
|
int nNumber3;
|
|
int nNumber4;
|
|
};
|
|
|
|
struct SMSG_ADD_SUMMON_INFO : public SGameMessage
|
|
{
|
|
SMSG_ADD_SUMMON_INFO() : SGameMessage(MSG_ADD_SUMMON_INFO)
|
|
{
|
|
card_handle = 0;
|
|
summon_handle = 0;
|
|
memset( name, 0, sizeof(name) );
|
|
code = 0;
|
|
|
|
// 이하 정보 필요
|
|
level = 0;
|
|
sp = 0;
|
|
|
|
};
|
|
AR_HANDLE card_handle;
|
|
AR_HANDLE summon_handle;
|
|
|
|
char name[19];
|
|
int code; ///< 소환수 코드
|
|
|
|
// 이하 정보 필요
|
|
int level;
|
|
int sp;
|
|
};
|
|
|
|
struct SMSG_REMOVE_SUMMON_INFO : public SGameMessage
|
|
{
|
|
SMSG_REMOVE_SUMMON_INFO() : SGameMessage(MSG_REMOVE_SUMMON_INFO)
|
|
{
|
|
card_handle = 0;
|
|
};
|
|
|
|
AR_HANDLE card_handle;
|
|
};
|
|
|
|
struct SMSG_EQUIP_SUMMON : public SGameMessage
|
|
{
|
|
SMSG_EQUIP_SUMMON() : SGameMessage(MSG_EQUIP_SUMMON)
|
|
{
|
|
for( int i(0); 6>i; i++ ) card_handle[i] = 0;
|
|
};
|
|
|
|
bool open_dialog;
|
|
AR_HANDLE card_handle[ 6 ];
|
|
};
|
|
|
|
struct SMSG_REQUEST_EQUIP_SUMMON : public SGameMessage
|
|
{
|
|
SMSG_REQUEST_EQUIP_SUMMON() : SGameMessage(MSG_REQUEST_EQUIP_SUMMON)
|
|
{
|
|
card_handle = 0;
|
|
};
|
|
|
|
AR_HANDLE card_handle;
|
|
};
|
|
|
|
struct SMSG_CHAT_COMMAND : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
CHAT_NONE,
|
|
CHAT_CASHSTORAGE_OPEN, ///< 캐쉬 창고 열기
|
|
CHAT_CASHSHOP_OPEN, ///< 캐쉬 샵 열기
|
|
};
|
|
|
|
SMSG_CHAT_COMMAND( int mode ) : SGameMessage(MSG_CHAT_COMMAND), nMode(mode)
|
|
{
|
|
}
|
|
int nMode;
|
|
};
|
|
|
|
struct SMSG_AURA : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
OWNER_NONE = 0,
|
|
OWNER_LOCAL_PLAYER,
|
|
OWNER_LOCAL_CREATURE,
|
|
};
|
|
|
|
SMSG_AURA() : SGameMessage(MSG_AURA)
|
|
{
|
|
caster = 0;
|
|
skill_id = 0;
|
|
status = false;
|
|
|
|
data_owner = OWNER_NONE;
|
|
}
|
|
|
|
AR_HANDLE caster;
|
|
int skill_id;
|
|
bool status;
|
|
unsigned short data_owner;
|
|
};
|
|
|
|
struct SMSG_REQ_GUILD_ICON : public SGameMessage
|
|
{
|
|
SMSG_REQ_GUILD_ICON( int guild_id ) : SGameMessage(MSG_REQ_GUILD_ICON), nGuild_id(guild_id)
|
|
{
|
|
}
|
|
int nGuild_id;
|
|
};
|
|
|
|
struct SMSG_CHANGE_NAME : public SGameMessage
|
|
{
|
|
SMSG_CHANGE_NAME() : SGameMessage(MSG_CHANGE_NAME)
|
|
{
|
|
handle = 0;
|
|
IsLocal = false;
|
|
status = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
std::string m_name;
|
|
bool IsLocal;
|
|
unsigned status;
|
|
};
|
|
|
|
|
|
struct SMSG_OPEN_URL : public SGameMessage
|
|
{
|
|
SMSG_OPEN_URL() : SGameMessage(MSG_OPEN_URL)
|
|
, width( 0 )
|
|
, height( 0 )
|
|
{
|
|
|
|
}
|
|
|
|
bool wait_for_event_scene;
|
|
std::string m_strURL;
|
|
|
|
int width;
|
|
int height;
|
|
};
|
|
|
|
struct SMSG_RQ_SUMMON : public SGameMessage
|
|
{
|
|
SMSG_RQ_SUMMON() : SGameMessage(MSG_RQ_SUMMON)
|
|
{
|
|
is_summon = 0; ///< 1이면 소환, 0이면 역소환
|
|
card_handle = 0;
|
|
}
|
|
|
|
unsigned char is_summon; ///< 1이면 소환, 0이면 역소환
|
|
AR_HANDLE card_handle;
|
|
};
|
|
|
|
struct SMSG_UNSUMMON : public SGameMessage
|
|
{
|
|
SMSG_UNSUMMON() : SGameMessage(MSG_UNSUMMON)
|
|
{
|
|
summon_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE summon_handle;
|
|
};
|
|
|
|
struct SMSG_UNSUMMON_NOTICE : public SGameMessage
|
|
{
|
|
SMSG_UNSUMMON_NOTICE() : SGameMessage(MSG_UNSUMMON_NOTICE)
|
|
{
|
|
summon_handle = 0;
|
|
unsummon_duration = 0;
|
|
}
|
|
|
|
AR_HANDLE summon_handle;
|
|
AR_TIME unsummon_duration;
|
|
};
|
|
|
|
struct SMSG_SUMMON_EVOLUTION : public SGameMessage
|
|
{
|
|
SMSG_SUMMON_EVOLUTION() : SGameMessage( MSG_SUMMON_EVOLUTION )
|
|
{
|
|
card_handle = 0;
|
|
summon_handle = 0;
|
|
memset( name, 0, sizeof(name) );
|
|
code = 0;
|
|
}
|
|
|
|
AR_HANDLE card_handle;
|
|
AR_HANDLE summon_handle;
|
|
char name[19];
|
|
int code;
|
|
};
|
|
|
|
struct SMSG_TAMING_INFO : public SGameMessage
|
|
{
|
|
SMSG_TAMING_INFO() : SGameMessage(MSG_TAMING_INFO)
|
|
{
|
|
mode = 0;
|
|
tamer_handle = 0;
|
|
target_handle = 0;
|
|
}
|
|
|
|
enum
|
|
{
|
|
START = 0, ///< tamer 가 target 에게 테이밍 스킬을 걸었음
|
|
CLEAR = 1, ///< 테이밍이 초기화됨 (tamer_handle 은 0)
|
|
SUCCESS = 2, ///< target 이 죽어서 tamer 에게 테이밍됨.
|
|
FAILED = 3, ///< target 이 죽었지만 테이밍은 실패!
|
|
};
|
|
|
|
unsigned char mode;
|
|
|
|
AR_HANDLE tamer_handle;
|
|
AR_HANDLE target_handle;
|
|
};
|
|
|
|
struct SMSG_MOUNT_SUMMON : public SGameMessage
|
|
{
|
|
SMSG_MOUNT_SUMMON() : SGameMessage(MSG_MOUNT_SUMMON)
|
|
{
|
|
handle = 0;
|
|
summon_handle = 0;
|
|
x = 0;
|
|
y = 0;
|
|
success = true;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
AR_HANDLE summon_handle;
|
|
AR_UNIT x, y;
|
|
bool success;
|
|
};
|
|
|
|
struct SMSG_UNMOUNT_SUMMON : public SGameMessage
|
|
{
|
|
SMSG_UNMOUNT_SUMMON() : SGameMessage(MSG_UNMOUNT_SUMMON)
|
|
{
|
|
handle = 0;
|
|
summon_handle = 0;
|
|
flag = NORMAL;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
AR_HANDLE summon_handle;
|
|
|
|
enum
|
|
{
|
|
NORMAL = 0,
|
|
FALL = 1,
|
|
UNSUMMON = 2,
|
|
};
|
|
char flag;
|
|
};
|
|
|
|
struct SMSG_SUMMON_NAME_CHANGE : public SGameMessage
|
|
{
|
|
SMSG_SUMMON_NAME_CHANGE() : SGameMessage(MSG_SUMMON_NAME_CHANGE)
|
|
{
|
|
summon_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE summon_handle;
|
|
};
|
|
|
|
|
|
struct SMSG_SUMMON_CARD : public SGameMessage
|
|
{
|
|
SMSG_SUMMON_CARD() : SGameMessage(MSG_SUMMON_CARD)
|
|
{
|
|
card_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE card_handle;
|
|
};
|
|
|
|
// 2010.08.06 - prodongi
|
|
struct SMSG_BOSS_MONSTER_CARD : public SGameMessage
|
|
{
|
|
SMSG_BOSS_MONSTER_CARD() : SGameMessage(MSG_BOSS_MONSTER_CARD)
|
|
{
|
|
card_handle = 0;
|
|
}
|
|
AR_HANDLE card_handle;
|
|
};
|
|
|
|
struct SMSG_SKILL_LIST : public SGameMessage
|
|
{
|
|
SMSG_SKILL_LIST() : SGameMessage(MSG_SKILL_LIST)
|
|
{
|
|
dwTime = 0;
|
|
target = 0; ///< 플레이어 혹은 크리쳐
|
|
count = 0;
|
|
modification_type = 0; /// 2011.07.04 - prodongi
|
|
pSkillInfo = NULL;
|
|
}
|
|
|
|
virtual ~SMSG_SKILL_LIST()
|
|
{
|
|
SAFE_DELETE_ARRAY( pSkillInfo );
|
|
}
|
|
|
|
struct SkillInfo
|
|
{
|
|
int skill_id; ///< 스킬 ID
|
|
unsigned char base_skill_level; ///< 기본 스킬 레벨
|
|
unsigned char current_skill_level; ///< 현재 스킬 레벨
|
|
AR_TIME total_cool_time; //
|
|
AR_TIME remain_cool_time; ///< 남은 쿨타임 시간 1/100 초
|
|
};
|
|
|
|
/// 2011.07.04 - prodongi
|
|
// 이후 따라오는 스킬 리스트가 어떤 의미를 가지는가를 의미하는열거형
|
|
enum ModificationType
|
|
{
|
|
UPDATE = 0, // 스킬이 업데이트됨 (기존 reset = false)
|
|
REFRESH = 1, // 스킬 리스트를 갱신 (기존 reset = true)
|
|
};
|
|
bool isUpdate() const { return modification_type == UPDATE; }
|
|
bool isRefresh() const { return modification_type == REFRESH; }
|
|
|
|
DWORD dwTime; ///< 발생 현재 시간
|
|
AR_HANDLE target; ///< 플레이어 혹은 크리쳐
|
|
unsigned short count;
|
|
/// 2011.07.04 - prodongi
|
|
unsigned char modification_type; // enum ModificationType
|
|
SkillInfo * pSkillInfo;
|
|
};
|
|
|
|
struct SMSG_SKILL_EVENT : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
OWNER_NONE = 0,
|
|
OWNER_LOCAL_PLAYER,
|
|
OWNER_LOCAL_CREATURE,
|
|
};
|
|
|
|
SMSG_SKILL_EVENT() : SGameMessage(MSG_SKILL_EVENT)
|
|
{
|
|
skill_id = 0;
|
|
skill_level = 0;
|
|
caster = 0;
|
|
target = 0;
|
|
x = 0;
|
|
y = 0;
|
|
z = 0;
|
|
layer = 0;
|
|
status_type = 0;
|
|
hp_cost = 0;
|
|
mp_cost = 0;
|
|
caster_hp = 0;
|
|
caster_mp = 0;
|
|
|
|
data_owner = OWNER_NONE;
|
|
//target_name.clear(); // Fraun performance tweak
|
|
}
|
|
|
|
int skill_id;
|
|
char skill_level;
|
|
AR_HANDLE caster;
|
|
AR_HANDLE target;
|
|
AR_UNIT x,y,z;
|
|
unsigned char layer;
|
|
char status_type;
|
|
int hp_cost;
|
|
int mp_cost;
|
|
int caster_hp;
|
|
int caster_mp;
|
|
|
|
short data_owner;
|
|
//std::string target_name; // Fraun performance tweak
|
|
|
|
struct CancelType
|
|
{
|
|
// 내용 없음
|
|
};
|
|
|
|
struct CompleteType
|
|
{
|
|
// 내용 없음
|
|
};
|
|
|
|
/// Casting 이거나 Casting_update일 경우 날아감.
|
|
struct CastType
|
|
{
|
|
AR_TIME tm; ///< 캐스팅 타임
|
|
unsigned short nErrorCode; ///< 성공 여부 ( 0이면 성공 )
|
|
};
|
|
|
|
/// Region Fire일 경우에도 얘가 날아감.
|
|
struct FireType
|
|
{
|
|
bool bMultiple; ///< true 실시간 연타
|
|
AR_UNIT range; ///< 스킬 효과 범위
|
|
unsigned char target_count;
|
|
unsigned char fire_count;
|
|
unsigned short count;
|
|
};
|
|
|
|
union
|
|
{
|
|
CancelType cancel;
|
|
CompleteType complete;
|
|
CastType cast;
|
|
FireType fire;
|
|
};
|
|
// Fire나 Region Fire일 경우 추가로 뒤에 SkillResult 가 count 만큼 따라간다
|
|
|
|
std::vector<SkillResult> vSkillResult;
|
|
};
|
|
|
|
//struct SMSG_SKILL_EFFECT : public SGameMessage
|
|
//{
|
|
// SMSG_SKILL_EFFECT() : SGameMessage(MSG_SKILL_EFFECT)
|
|
// {
|
|
// caster = 0;
|
|
// target = 0;
|
|
//
|
|
// skill_id = 0;
|
|
// skill_level = 0;
|
|
//
|
|
// var = 0;
|
|
// var2 = 0;
|
|
// }
|
|
//
|
|
// AR_HANDLE caster;
|
|
// AR_HANDLE target;
|
|
//
|
|
// int skill_id;
|
|
// unsigned char skill_level;
|
|
//
|
|
// int var;
|
|
// unsigned char var2;
|
|
//};
|
|
|
|
//struct SMSG_SKILL_CASTING_TIME : public SGameMessage
|
|
//{
|
|
// SMSG_SKILL_CASTING_TIME() : SGameMessage(MSG_SKILL_CASTING_TIME)
|
|
// {
|
|
// caster = 0;
|
|
// tm = 0;
|
|
// }
|
|
//
|
|
// AR_HANDLE caster;
|
|
// AR_TIME tm;
|
|
//};
|
|
|
|
//==========================================================================================
|
|
|
|
struct SMSG_UPDATE_ITEM_COUNT : public SGameMessage
|
|
{
|
|
SMSG_UPDATE_ITEM_COUNT() : SGameMessage(MSG_UPDATE_ITEM_COUNT)
|
|
{
|
|
item_handle = 0;
|
|
count = count_t( 0 );
|
|
}
|
|
AR_HANDLE item_handle;
|
|
count_t count;
|
|
};
|
|
|
|
struct SMSG_TRADE : public SGameMessage
|
|
{
|
|
SMSG_TRADE() : SGameMessage(MSG_TRADE)
|
|
{
|
|
rq_mode = false;
|
|
target_player = 0;
|
|
mode = 0;
|
|
memset( &item_info, 0, sizeof(item_info) );
|
|
bLocalPlyaer = false;
|
|
bIncoming = false;
|
|
}
|
|
|
|
int rq_mode;
|
|
AR_HANDLE target_player;
|
|
std::string target_Name;
|
|
bool bLocalPlyaer;
|
|
bool bIncoming; ///< TRADE::REQUEST의 애매함 때문에 추가 (내가 신청하는 메시지나 신청받는 메시지나 똑같이 REQUEST임) - true면 신청 받는 (서버에서 오는) 메시지
|
|
char mode;
|
|
TS_ITEM_INFO item_info;
|
|
};
|
|
|
|
struct SMSG_REQUEST_BOOTH_NAME : public SGameMessage
|
|
{
|
|
SMSG_REQUEST_BOOTH_NAME() : SGameMessage( MSG_REQUEST_BOOTH_NAME )
|
|
{
|
|
}
|
|
|
|
std::vector< AR_HANDLE > *pvBoothList;
|
|
};
|
|
|
|
struct SMSG_UI_BOOTH : public SGameMessage
|
|
{
|
|
SMSG_UI_BOOTH() : SGameMessage( IMSG_UI_BOOTH )
|
|
{
|
|
nMode = 0;
|
|
}
|
|
|
|
enum BOOTH_TYPE
|
|
{
|
|
START_BOOTH = 0,
|
|
END_BOOTH = 1,
|
|
};
|
|
int nBoothType;
|
|
|
|
std::string strBoothName;
|
|
std::vector< money_t > vPriceList;
|
|
std::vector< count_t > vCountList;
|
|
std::vector< AR_HANDLE > vItemList;
|
|
|
|
int nMode; ///< 0이면 판매, 1이면 구매
|
|
};
|
|
|
|
struct SMSG_USE_ITEM_RESULT : public SGameMessage
|
|
{
|
|
SMSG_USE_ITEM_RESULT() : SGameMessage(MSG_USE_ITEM_RESULT)
|
|
{
|
|
item_handle = 0;
|
|
target_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE item_handle;
|
|
AR_HANDLE target_handle;
|
|
};
|
|
|
|
struct SMSG_TAKE_ITEM_RESULT : public SGameMessage
|
|
{
|
|
SMSG_TAKE_ITEM_RESULT() : SGameMessage( MSG_TAKE_ITEM_RESULT )
|
|
{
|
|
item_handle = 0;
|
|
item_taker = 0;
|
|
}
|
|
|
|
AR_HANDLE item_handle;
|
|
AR_HANDLE item_taker;
|
|
};
|
|
|
|
struct SMSG_SKILLCARD_INFO : public SGameMessage
|
|
{
|
|
SMSG_SKILLCARD_INFO() : SGameMessage(MSG_SKILLCARD_INFO)
|
|
{
|
|
item_handle = 0;
|
|
target_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE item_handle;
|
|
AR_HANDLE target_handle; ///< 0 이면 장착해지
|
|
};
|
|
|
|
struct SMSG_OPEN_STORAGE : public SGameMessage
|
|
{
|
|
SMSG_OPEN_STORAGE() : SGameMessage(MSG_OPEN_STORAGE)
|
|
{
|
|
maxStorageItemCount = 0;
|
|
}
|
|
int maxStorageItemCount;
|
|
};
|
|
|
|
struct SMSG_OPEN_JEWEL_EQUIP : public SGameMessage
|
|
{ SMSG_OPEN_JEWEL_EQUIP() : SGameMessage(MSG_OPEN_JEWEL_EQUIP){} };
|
|
|
|
struct SMSG_OPEN_SOUL_REPAIR : public SGameMessage
|
|
{ SMSG_OPEN_SOUL_REPAIR() : SGameMessage(MSG_OPEN_SOUL_REPAIR){} };
|
|
|
|
struct SMSG_CHANGE_STORAGE : public SGameMessage
|
|
{
|
|
SMSG_CHANGE_STORAGE() : SGameMessage(MSG_CHANGE_STORAGE)
|
|
{
|
|
hItem = 0;
|
|
nCount = count_t( 1 );
|
|
nMode = 0;
|
|
}
|
|
|
|
AR_HANDLE hItem;
|
|
count_t nCount;
|
|
int nMode;
|
|
};
|
|
|
|
|
|
struct SMSG_MIX_RESULT : public SGameMessage
|
|
{
|
|
SMSG_MIX_RESULT() : SGameMessage(MSG_MIX_RESULT)
|
|
{
|
|
count = 0;
|
|
pArHandle = NULL;
|
|
}
|
|
~SMSG_MIX_RESULT()
|
|
{
|
|
SAFE_DELETE_ARRAY( pArHandle );
|
|
}
|
|
unsigned count; ///< 이하 AR_HANDLE 이 count 만큼 붙게 됨. count 가 0 이면 조합 실패.
|
|
unsigned char type;
|
|
|
|
AR_HANDLE * pArHandle;
|
|
};
|
|
|
|
struct SMSG_ITEM_DESTROY : public SGameMessage
|
|
{
|
|
SMSG_ITEM_DESTROY() : SGameMessage(MSG_ITEM_DESTROY)
|
|
{
|
|
item_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE item_handle;
|
|
};
|
|
|
|
|
|
// 아이템파괴 응답.
|
|
struct SMSG_ERASE_ITEM : public SGameMessage
|
|
{
|
|
struct EraseItemInfo
|
|
{
|
|
//ItemBase::ItemCode code;
|
|
AR_HANDLE handle;
|
|
__int64 count;
|
|
};
|
|
|
|
unsigned char item_count;
|
|
|
|
EraseItemInfo * pItemInfo;
|
|
|
|
SMSG_ERASE_ITEM() : SGameMessage(MSG_ITEM_ERASE)
|
|
{}
|
|
|
|
~SMSG_ERASE_ITEM()
|
|
{
|
|
SAFE_DELETE_ARRAY( pItemInfo );
|
|
}
|
|
};
|
|
|
|
struct SMSG_ITEM_INVEN : public SGameMessage
|
|
{
|
|
SMSG_ITEM_INVEN() : SGameMessage(MSG_ITEM_INVEN)
|
|
{
|
|
nItemCnt = 0;
|
|
pItemInfo = NULL;
|
|
}
|
|
|
|
virtual ~SMSG_ITEM_INVEN()
|
|
{
|
|
SAFE_DELETE_ARRAY( pItemInfo );
|
|
}
|
|
|
|
int nItemCnt;
|
|
TS_ITEM_INFO * pItemInfo;
|
|
|
|
AR_HANDLE handle;
|
|
};
|
|
|
|
struct SMSG_ITEM_WEAR : public SGameMessage
|
|
{
|
|
SMSG_ITEM_WEAR() : SGameMessage(MSG_ITEM_WEAR)
|
|
{
|
|
handle = 0;
|
|
for( int i(0); ItemBase::MAX_ITEM_SPARE_WEAR>i; i++ )
|
|
{
|
|
nItemCode[i] = -1;
|
|
nItemEnhance[i] = -1;
|
|
nItemLevel[i] = -1;
|
|
nAppearanceItemCode[i] = -1;
|
|
}
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
ItemBase::ItemCode nItemCode[ItemBase::MAX_ITEM_SPARE_WEAR];
|
|
int nItemEnhance[ItemBase::MAX_ITEM_SPARE_WEAR];
|
|
int nItemLevel[ItemBase::MAX_ITEM_SPARE_WEAR];
|
|
unsigned char elemental_effect_type[ItemBase::MAX_ITEM_SPARE_WEAR];
|
|
ItemBase::ItemCode nAppearanceItemCode[ItemBase::MAX_ITEM_SPARE_WEAR]; // 2012. 7. 24 - marine
|
|
};
|
|
|
|
struct SMSG_ITEM_WEAR_INFO : public SGameMessage
|
|
{
|
|
SMSG_ITEM_WEAR_INFO() : SGameMessage(MSG_ITEM_WEAR_INFO)
|
|
{
|
|
item_handle = 0;
|
|
wear_position = -1;
|
|
target_handle = 0;
|
|
enhance = -1;
|
|
appearance_code = 0;
|
|
}
|
|
|
|
AR_HANDLE item_handle;
|
|
short wear_position; ///< -1이면 장착 안된 아이템, 소환수의 경우는 순서대로 +1000 * n (n은 슬롯 번호)
|
|
AR_HANDLE target_handle; ///< 크리처 핸들
|
|
int enhance;
|
|
unsigned char elemental_effect_type;
|
|
ItemBase::ItemCode appearance_code;
|
|
};
|
|
|
|
|
|
|
|
struct SMSG_ITEM_DROP : public SGameMessage
|
|
{
|
|
SMSG_ITEM_DROP() : SGameMessage(MSG_ITEM_DROP_RESULT)
|
|
{
|
|
item_handle = 0;
|
|
isAccepted = true;
|
|
}
|
|
AR_HANDLE item_handle;
|
|
bool isAccepted;
|
|
};
|
|
|
|
struct SMSG_ITEM_DROP_INFO : public SGameMessage
|
|
{
|
|
SMSG_ITEM_DROP_INFO() : SGameMessage(MSG_ITEM_DROP_INFO)
|
|
{
|
|
monster_handle = 0;
|
|
item_handle = 0;
|
|
}
|
|
|
|
AR_HANDLE monster_handle;
|
|
AR_HANDLE item_handle;
|
|
};
|
|
|
|
struct SMSG_ITEM_TAKE : public SGameMessage
|
|
{
|
|
SMSG_ITEM_TAKE() : SGameMessage(MSG_ITEM_TAKE_RESULT) {}
|
|
|
|
TS_ITEM_INFO item_info;
|
|
};
|
|
|
|
//==========================================================================================
|
|
|
|
//struct SMSG_SKILL_RESULT : public SGameMessage
|
|
//{
|
|
// SMSG_SKILL_RESULT() : SGameMessage(MSG_SKILL_RESULT)
|
|
// {
|
|
// pSrc = NULL;//Src
|
|
// pDst = NULL;//Dest
|
|
// dwStartTime = 0; //Cur Time
|
|
// fSpeed = 1.f; //Speed
|
|
// nCount = 0; //Count
|
|
// }
|
|
//
|
|
// SGameObject * pSrc; //Src
|
|
// SGameObject * pDst; //Dest
|
|
// DWORD dwStartTime; //Cur Time
|
|
// float fSpeed; //Speed
|
|
// unsigned int nCount; //Count
|
|
// std::string strProjectile;//발사체
|
|
// std::string strAniName; //Animation Type
|
|
//};
|
|
//
|
|
//struct SMSG_SPELL_RESULT : public SGameMessage
|
|
//{
|
|
// SMSG_SPELL_RESULT() : SGameMessage(MSG_SPELL_RESULT)
|
|
// {
|
|
// pSrc = NULL;//Src
|
|
// pDst = NULL;//Dest
|
|
// dwStartTime = 0; //Cur Time
|
|
// fSpeed = 1.f; //Speed
|
|
// nCount = 0; //Count
|
|
// nProcessType = 0; //연출 Type
|
|
// }
|
|
//
|
|
// SGameObject * pSrc; //Src
|
|
// SGameObject * pDst; //Dest
|
|
// DWORD dwStartTime; //Cur Time
|
|
// float fSpeed; //Speed
|
|
// unsigned int nCount; //Count
|
|
// std::string strProjectile;//발사체
|
|
// unsigned int nProcessType; //연출 Type
|
|
//};
|
|
|
|
struct SMSG_CMD_RESULT : public SGameMessage
|
|
{
|
|
SMSG_CMD_RESULT() : SGameMessage(MSG_CMD_RESULT)
|
|
{
|
|
|
|
}
|
|
|
|
std::string strAniName; ///< Animation Type
|
|
};
|
|
|
|
//==========================================================================================
|
|
|
|
struct SMSG_CHATTING : public SGameMessage
|
|
{
|
|
SMSG_CHATTING() : SGameMessage(MSG_CHATTING)
|
|
{
|
|
handle = 0;
|
|
len = 0;
|
|
nChatType = 0; ///< CHAT_NORMAL;
|
|
nNoticeOnly = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
unsigned short len;
|
|
int nChatType;
|
|
std::string szSender;
|
|
std::string strText;
|
|
int nNoticeOnly; ///< 공지 채팅만 출력할 것인지 체크, kappamind.
|
|
};
|
|
|
|
struct SMSG_CHATTING_REQUEST : public SGameMessage
|
|
{
|
|
SMSG_CHATTING_REQUEST() : SGameMessage(MSG_CHATTING_REQUEST)
|
|
{
|
|
memset( szTarget, 0, sizeof(szTarget) );
|
|
request_id = 0;
|
|
type = 0; ///< CHAT_NORMAL;
|
|
nSize = sizeof( *this );
|
|
}
|
|
|
|
char szTarget[21];
|
|
unsigned char request_id;
|
|
unsigned char type;
|
|
std::string strText;
|
|
};
|
|
|
|
struct SMSG_MARKET : public SGameMessage
|
|
{
|
|
SMSG_MARKET() : SGameMessage(MSG_MARKET)
|
|
{
|
|
item_count = 0; ///< 수 만큼 ItemInfo이 뒤에 붙음.
|
|
pItemInfo = NULL;
|
|
}
|
|
|
|
~SMSG_MARKET()
|
|
{
|
|
SAFE_DELETE_ARRAY( pItemInfo );
|
|
}
|
|
|
|
struct ItemInfo
|
|
{
|
|
ItemBase::ItemCode code;
|
|
__int64 price;
|
|
int huntaholic_point; // #2.1.2.11.1
|
|
int arena_point; /// 2012.07.20 아레나 포인트 - prodongi
|
|
};
|
|
|
|
AR_HANDLE npc_handle; ///< NULL 일수도 있음. ( NPC가 보내지 않은 특수한 경우 )
|
|
unsigned short item_count;
|
|
ItemInfo * pItemInfo;
|
|
};
|
|
|
|
|
|
struct SMSG_NPC_DIALOG : public SGameMessage
|
|
{
|
|
SMSG_NPC_DIALOG() : SGameMessage(MSG_NPC_DIALOG)
|
|
{
|
|
npc_handle = 0;
|
|
nQuestCode = 0;
|
|
nQuestTextID = 0;
|
|
}
|
|
|
|
enum
|
|
{
|
|
BUTTON_NORMAL = 0,
|
|
BUTTON_QUEST_STARTABLE,
|
|
BUTTON_QUEST_INPROGRESS,
|
|
BUTTON_QUEST_FINISHABLE,
|
|
|
|
BUTTON_DUNGEON_STONE,
|
|
BUTTON_DONATION_PROP,
|
|
};
|
|
|
|
struct DLGMENU
|
|
{
|
|
std::string strMenuName;
|
|
std::string strTrigger;
|
|
int nButtonType;
|
|
|
|
DLGMENU( const char* szMenuName, const char* szTrigger, int nType = BUTTON_NORMAL )
|
|
: strMenuName( szMenuName ), strTrigger( szTrigger ), nButtonType( nType ) { }
|
|
};
|
|
|
|
int nDialogType;
|
|
AR_HANDLE npc_handle; ///< NULL 일수도 있음. ( NPC가 보내지 않은 특수한 경우 )
|
|
int nQuestCode; ///< Quest code...
|
|
int nQuestTextID; ///< Quest text...
|
|
std::string strTitle;
|
|
STRING_VECTOR vtTexts;
|
|
std::vector<DLGMENU> vtMenus;
|
|
};
|
|
|
|
struct SMSG_TOOFAR_AS_CONTACTEDNPC : public SGameMessage
|
|
{
|
|
SMSG_TOOFAR_AS_CONTACTEDNPC() : SGameMessage( MSG_TOOFAR_AS_CONTACTEDNPC ) { }
|
|
};
|
|
|
|
struct SMSG_CAMERA_EFFECT : public SGameMessage
|
|
{
|
|
SMSG_CAMERA_EFFECT() : SGameMessage(MSG_CAMERA_EFFECT)
|
|
{
|
|
nEffect = 0;
|
|
fDeltaX = fDeltaY = 0.f;
|
|
dwKeepTime = 0;
|
|
};
|
|
|
|
int nEffect;
|
|
float fDeltaX;
|
|
float fDeltaY;
|
|
DWORD dwKeepTime;
|
|
};
|
|
|
|
//===================================================================================================
|
|
/// 시스템 메시지
|
|
struct STMSG_TIMESYNC : public SGameMessage
|
|
{
|
|
STMSG_TIMESYNC() : SGameMessage(TMSG_TIMESYNC)
|
|
{
|
|
time = 0;
|
|
}
|
|
|
|
AR_TIME time;
|
|
};
|
|
|
|
struct STMSG_CHANGEAVATAR : public SGameMessage
|
|
{
|
|
STMSG_CHANGEAVATAR( AR_HANDLE hPlayer )
|
|
: SGameMessage( TMSG_CHANGEAVATAR ), handle( hPlayer ) { }
|
|
|
|
AR_HANDLE handle;
|
|
};
|
|
|
|
struct STMSG_REQ_CLOSE : public SGameMessage
|
|
{
|
|
STMSG_REQ_CLOSE( bool bByWndMsg = true )
|
|
: SGameMessage( TMSG_REQ_CLOSE ), m_bByWndMsg( bByWndMsg ) { }
|
|
|
|
bool m_bByWndMsg;
|
|
};
|
|
|
|
struct STMSG_REQ_CLOSE_EX : public SGameMessage
|
|
{
|
|
STMSG_REQ_CLOSE_EX()
|
|
: SGameMessage( TMSG_REQ_CLOSE_EX )
|
|
{
|
|
}
|
|
};
|
|
|
|
struct STMSG_SYSTEM_OPTION : public SGameMessage
|
|
{
|
|
enum _OPTION_TYPE
|
|
{
|
|
SYSOPTION_BLOOMEFFECT,
|
|
SYSOPTION_TEXQUALITY,
|
|
SYSOPTION_BACKGROUND,
|
|
SYSOPTION_BGSOUND,
|
|
SYSOPTION_EFFECTSOUND,
|
|
|
|
// 차후 추가
|
|
SYSOPTION_RESOLUTION,
|
|
SYSOPTION_SCREENBIT,
|
|
SYSOPTION_BRIGHT,
|
|
SYSOPTION_MODELING,
|
|
SYSOPTION_SHADOW,
|
|
SYSOPTION_CHARACTER,
|
|
SYSOPTION_PROP,
|
|
|
|
SYSOPTION_MAINSOUND,
|
|
SYSOPTION_SURROUNDSOUND,
|
|
SYSOPTION_FACECUT,
|
|
SYSOPTION_MINIMAP,
|
|
SYSOPTION_ZOOM,
|
|
};
|
|
STMSG_SYSTEM_OPTION( _OPTION_TYPE Type, int nOption )
|
|
: SGameMessage( TMSG_SYSTEM_OPTION ), m_Type( Type ), m_nOption( nOption ) { }
|
|
|
|
_OPTION_TYPE m_Type;
|
|
int m_nOption;
|
|
};
|
|
|
|
struct STMSG_REQ_SYSTEM_OPTION : public SGameMessage
|
|
{
|
|
STMSG_REQ_SYSTEM_OPTION( STMSG_SYSTEM_OPTION::_OPTION_TYPE Type )
|
|
: SGameMessage( TMSG_REQ_SYSTEM_OPTION ), m_Type( Type ), m_nGetOption( 0 ) { }
|
|
|
|
STMSG_SYSTEM_OPTION::_OPTION_TYPE m_Type;
|
|
int m_nGetOption;
|
|
};
|
|
|
|
//===================================================================================================
|
|
/// Cheating 메세지
|
|
struct SCMSG_WARP : public SGameMessage
|
|
{
|
|
SCMSG_WARP() : SGameMessage(CMSG_WARP)
|
|
{
|
|
x = y = z = 0;
|
|
layer = 0;
|
|
}
|
|
AR_UNIT x,y,z;
|
|
unsigned char layer;
|
|
};
|
|
|
|
struct SMSG_CONSOLE_BUILDER : public SGameMessage
|
|
{
|
|
SMSG_CONSOLE_BUILDER() : SGameMessage(MSG_CONSOLE_BUILDER), m_nValueCount( 0 ), m_bOut( false ), m_nCommandType( 0 )
|
|
{}
|
|
~SMSG_CONSOLE_BUILDER()
|
|
{
|
|
m_vecValueList.clear();
|
|
}
|
|
|
|
enum KEY_TYPE
|
|
{
|
|
TYPE_GAME = 0,
|
|
TYPE_OPTION,
|
|
TYPE_DEBUG,
|
|
TYPE_LUA,
|
|
TYPE_DB,
|
|
};
|
|
|
|
bool m_bOut;
|
|
int m_nCommandType;
|
|
|
|
std::string m_strKey;
|
|
int m_nValueCount;
|
|
std::vector<std::string> m_vecValueList;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// 지역 관련
|
|
struct SMSG_CHANGE_LOCATION : public SGameMessage
|
|
{
|
|
SMSG_CHANGE_LOCATION() : SGameMessage( MSG_CHANGE_LOCATION )
|
|
{
|
|
prev_location_id = 0;
|
|
cur_location_id = 0;
|
|
}
|
|
|
|
int prev_location_id;
|
|
int cur_location_id;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// 날씨 관련
|
|
struct SMSG_GET_WEATHER_INFO : public SGameMessage
|
|
{
|
|
SMSG_GET_WEATHER_INFO() : SGameMessage( MSG_GET_WEATHER_INFO )
|
|
{
|
|
region_id = 0;
|
|
}
|
|
unsigned int region_id;
|
|
};
|
|
|
|
struct SMSG_WEATHER_INFO : public SGameMessage
|
|
{
|
|
SMSG_WEATHER_INFO() : SGameMessage( MSG_WEATHER_INFO )
|
|
{
|
|
region_id = 0;
|
|
weather_id = 0;
|
|
}
|
|
|
|
enum
|
|
{
|
|
CLEAR = 0, CLOUDY = 1, FOGGY = 2, DRIZZLINGLY = 3, RAINY = 4, SNOWY = 5,
|
|
};
|
|
|
|
unsigned int region_id;
|
|
unsigned short weather_id;
|
|
};
|
|
|
|
struct SMSG_TURN_ON_PK_MODE : public SGameMessage
|
|
{
|
|
SMSG_TURN_ON_PK_MODE() : SGameMessage( MSG_TURN_ON_PK_MODE )
|
|
{}
|
|
};
|
|
struct SMSG_TURN_OFF_PK_MODE : public SGameMessage
|
|
{
|
|
SMSG_TURN_OFF_PK_MODE() : SGameMessage( MSG_TURN_OFF_PK_MODE )
|
|
{}
|
|
};
|
|
struct SMSG_EMOTION : public SGameMessage
|
|
{
|
|
SMSG_EMOTION() : SGameMessage( MSG_EMOTION )
|
|
{
|
|
handle = 0;
|
|
emotion = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
int emotion;
|
|
};
|
|
struct SMSG_GAME_TIME : public SGameMessage
|
|
{
|
|
SMSG_GAME_TIME() : SGameMessage( MSG_GAME_TIME )
|
|
{
|
|
t = 0;
|
|
game_time = 0;
|
|
}
|
|
|
|
AR_TIME t;
|
|
time_t game_time;
|
|
};
|
|
|
|
// sonador 3.10.2 PC 방 혜택 관련 라크 획득 시스템 메시지 변경
|
|
struct SMSG_GET_CHAOS : public SGameMessage
|
|
{
|
|
SMSG_GET_CHAOS() : SGameMessage( MSG_GET_CHAOS )
|
|
{
|
|
hPlayer = 0;
|
|
hCorpse = 0;
|
|
nChaos = 0;
|
|
nBonusType = CHAOS_BONUS_NONE;
|
|
nBonusPercent = 0;
|
|
nBonus = 0;
|
|
}
|
|
|
|
enum CHAOS_BONUS_TYPE
|
|
{
|
|
CHAOS_BONUS_NONE = 0,
|
|
CHAOS_BONUS_PCBANG = 1,
|
|
CHAOS_BONUS_PREMIUM_PCBANG = 2,
|
|
};
|
|
|
|
AR_HANDLE hPlayer;
|
|
AR_HANDLE hCorpse;
|
|
int nChaos;
|
|
char nBonusType;
|
|
unsigned char nBonusPercent;
|
|
int nBonus;
|
|
};
|
|
|
|
/// 기공
|
|
struct SMSG_ENERGY : public SGameMessage
|
|
{
|
|
SMSG_ENERGY() : SGameMessage( MSG_ENERGY )
|
|
{
|
|
handle = 0;
|
|
energy = 0;
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
short energy;
|
|
};
|
|
|
|
struct SMSG_ITEM_COOL_TIME : public SGameMessage
|
|
{
|
|
SMSG_ITEM_COOL_TIME() : SGameMessage( MSG_ITEM_COOL_TIME )
|
|
{}
|
|
|
|
AR_TIME cool_time[TS_SC_ITEM_COOL_TIME::MAX_ITEM_COOLTIME_GROUP];
|
|
};
|
|
|
|
struct SMSG_STATE_RESULT : public SGameMessage
|
|
{
|
|
SMSG_STATE_RESULT() : SGameMessage( MSG_STATE_RESULT )
|
|
{}
|
|
|
|
AR_HANDLE caster_handle;
|
|
AR_HANDLE target_handle;
|
|
|
|
int code;
|
|
unsigned short level;
|
|
|
|
unsigned short result_type; ///< 위의 enum 값 중 하나
|
|
int value; ///< enum에 해당하는 종류의 수치
|
|
int target_value; ///< 처리 후 target의 해당 수치
|
|
|
|
bool final;
|
|
int total_amount;
|
|
|
|
/* AR_HANDLE caster_handle;
|
|
AR_HANDLE target_handle;
|
|
int target_hp;
|
|
int code;
|
|
unsigned short level;
|
|
int damage;
|
|
bool final;
|
|
int total_damage;*/
|
|
};
|
|
|
|
struct SMSG_PARTY_COMMAND : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
PARTY_NONE,
|
|
PARTY_CREATE, ///< 파티 생성
|
|
PARTY_INVITE, ///< 파티 초대
|
|
PARTY_KICK, ///< 파티 추방
|
|
PARTY_DESTROY, ///< 파티 파괴
|
|
PARTY_LEAVE, ///< 파티 탈퇴
|
|
PARTY_TRANSFER, ///< 파티 양도
|
|
PARTY_OPTION, ///< 파티 옵션
|
|
};
|
|
|
|
SMSG_PARTY_COMMAND() : SGameMessage( MSG_PARTY_COMMAND )
|
|
{
|
|
mode = PARTY_NONE;
|
|
}
|
|
|
|
SMSG_PARTY_COMMAND( int _mode, const char * pStrName ) : SGameMessage( MSG_PARTY_COMMAND ),
|
|
mode( _mode ), strName( pStrName )
|
|
{
|
|
}
|
|
|
|
int mode;
|
|
std::string strName;
|
|
};
|
|
|
|
struct SMSG_FRIEND_COMMAND : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
FRIEND_NONE,
|
|
FRIEND_ADD, ///< 친구 추가
|
|
FRIEND_DELETE, ///< 친구 삭제
|
|
CUT_ADD, ///< 차단 추가
|
|
CUT_DELETE, ///< 차단 삭제
|
|
};
|
|
|
|
SMSG_FRIEND_COMMAND( int nmode, const char* lpName ) : SGameMessage( MSG_FRIEND_COMMAND ), strName(lpName), mode(nmode)
|
|
, target( 0 )
|
|
{}
|
|
|
|
int mode;
|
|
std::string strName;
|
|
AR_HANDLE target;
|
|
};
|
|
|
|
struct SMSG_ALLIANCE_COMMAND : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
ALLIANCE_NONE,
|
|
ALLIANCE_ADD, ///< 친구 추가
|
|
ALLIANCE_DELETE, ///< 친구 삭제
|
|
};
|
|
|
|
SMSG_ALLIANCE_COMMAND( int nmode, const char* lpName ) : SGameMessage( MSG_ALLIANCE_COMMAND ), strName(lpName), mode(nmode){}
|
|
|
|
int mode;
|
|
std::string strName;
|
|
};
|
|
|
|
struct SMSG_CHAT_RESULT : public SGameMessage
|
|
{
|
|
SMSG_CHAT_RESULT() : SGameMessage( MSG_CHAT_RESULT )
|
|
{}
|
|
|
|
unsigned char type;
|
|
unsigned char percentage;
|
|
int result;
|
|
int reserved;
|
|
};
|
|
|
|
|
|
struct SMSG_SCRIPT_SHOW_WINDOW : public SGameMessage
|
|
{
|
|
SMSG_SCRIPT_SHOW_WINDOW() : SGameMessage( MSG_SCRIPT_SHOW_WINDOW )
|
|
{
|
|
|
|
}
|
|
|
|
std::string strWindow; ///< 윈도우 열어라
|
|
std::string strTrigger; ///< 트리거
|
|
std::string strArgument; ///< 이름이나, 기타 등등
|
|
};
|
|
|
|
|
|
struct SMSG_TAKEOUT_COMMERCIAL_ITEM : public SGameMessage
|
|
{
|
|
SMSG_TAKEOUT_COMMERCIAL_ITEM() : SGameMessage( MSG_TAKEOUT_COMMERCIAL_ITEM )
|
|
{
|
|
commercial_item_uid = 0;
|
|
count = 0;
|
|
}
|
|
|
|
unsigned int commercial_item_uid; ///< 꺼낼아이템cuid
|
|
unsigned short count; ///< 꺼낼갯수
|
|
};
|
|
|
|
struct SMSG_BELT_SLOT_INFO : public SGameMessage
|
|
{
|
|
SMSG_BELT_SLOT_INFO() : SGameMessage( MSG_BELT_SLOT_INFO ) { }
|
|
|
|
AR_HANDLE handle[8];
|
|
};
|
|
|
|
|
|
struct SMSG_COMMERCIAL_STORAGE_INFO : public SGameMessage
|
|
{
|
|
SMSG_COMMERCIAL_STORAGE_INFO() : SGameMessage( MSG_COMMERCIAL_STORAGE_INFO )
|
|
{
|
|
total_item_count = 0;
|
|
new_item_count = 0;
|
|
}
|
|
|
|
unsigned short total_item_count;
|
|
unsigned short new_item_count;
|
|
};
|
|
|
|
struct SMSG_COMMERCIAL_STORAGE_LIST : public SGameMessage
|
|
{
|
|
SMSG_COMMERCIAL_STORAGE_LIST() : SGameMessage( MSG_COMMERCIAL_STORAGE_LIST )
|
|
{
|
|
|
|
}
|
|
|
|
unsigned short count;
|
|
|
|
std::vector<TS_SC_COMMERCIAL_STORAGE_LIST::CommercialItemInfo> vItemList;
|
|
};
|
|
|
|
struct SMSG_QUEST_UPDATA : public SGameMessage
|
|
{
|
|
SMSG_QUEST_UPDATA() : SGameMessage( MSG_QUEST_UPDATA )
|
|
{}
|
|
|
|
int nQuestID;
|
|
int nStatus[QuestInstance::MAX_STATUS];
|
|
std::string strOldQuest;
|
|
unsigned char nProgress;
|
|
};
|
|
|
|
// 2011.07.12 - servantes
|
|
struct SMSG_END_QUEST : public SGameMessage
|
|
{
|
|
SMSG_END_QUEST( int _code, unsigned char _nOptionalReward )
|
|
: SGameMessage( MSG_END_QUEST ), quest_code(_code), nOptionalReward(_nOptionalReward)
|
|
{}
|
|
int quest_code;
|
|
unsigned char nOptionalReward;
|
|
};
|
|
|
|
struct SMSG_RESURRECTION : public SGameMessage
|
|
{
|
|
SMSG_RESURRECTION( AR_HANDLE owner, int useitem, bool compete, bool deathmatch = false ) : SGameMessage( IMSG_RESURRECTION )
|
|
, hOwner( owner )
|
|
, nUseItem( useitem )
|
|
, bCompete( compete )
|
|
, bDeathmatch( deathmatch )
|
|
{
|
|
}
|
|
|
|
AR_HANDLE hOwner; // Normal resurrection
|
|
int nUseItem; // Resurrection by an item
|
|
bool bCompete; // After duel
|
|
bool bDeathmatch; // When dead in deathmatch
|
|
|
|
};
|
|
|
|
/// 플레이어가 타 플레이어에게 대련 요청
|
|
struct SMSG_CS_COMPETE_REQUEST : public SGameMessage
|
|
{
|
|
SMSG_CS_COMPETE_REQUEST() : SGameMessage( MSG_CS_COMPETE_REQUEST )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
char requestee[ 31 ]; ///< 도전 받은 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
|
|
};
|
|
|
|
/// 대련 요청받은 플레이어에게 요청 전달
|
|
struct SMSG_SC_COMPETE_REQUEST : public SGameMessage
|
|
{
|
|
SMSG_SC_COMPETE_REQUEST() : SGameMessage( MSG_SC_COMPETE_REQUEST )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
char requester[ 31 ]; ///< 도전 받은 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
|
|
};
|
|
|
|
/// 대련 요청받은 플레이어가 응답
|
|
struct SMSG_CS_COMPETE_ANSWER : public SGameMessage
|
|
{
|
|
SMSG_CS_COMPETE_ANSWER() : SGameMessage( MSG_CS_COMPETE_ANSWER )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
unsigned char answer_type; ///< _COMPETE_ANSWER_TYPE 값이 사용됨
|
|
};
|
|
|
|
/// 최초 대련 요청에 대한 결과 전달(수락/거부/자동거부)
|
|
struct SMSG_SC_COMPETE_ANSWER : public SGameMessage
|
|
{
|
|
SMSG_SC_COMPETE_ANSWER() : SGameMessage( MSG_SC_COMPETE_ANSWER )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
unsigned char answer_type; ///< _COMPETE_ANSWER_TYPE 값이 사용됨
|
|
char requestee[ 31 ]; ///< 도전 받은 플레이어
|
|
};
|
|
|
|
/// 대련 시작 전 카운트 다운 개시
|
|
struct SMSG_SC_COMPETE_COUNTDOWN : public SGameMessage
|
|
{
|
|
SMSG_SC_COMPETE_COUNTDOWN() : SGameMessage( MSG_SC_COMPETE_COUNTDOWN )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
char competitor[ 31 ]; ///< 도전 받은 플레이어
|
|
AR_HANDLE handle_competitor; ///< 상대방플레이어핸들(1:1 PVP에서만 사용됨)
|
|
};
|
|
|
|
|
|
/// 대련 시작
|
|
struct SMSG_SC_COMPETE_START : public SGameMessage
|
|
{
|
|
SMSG_SC_COMPETE_START() : SGameMessage( MSG_SC_COMPETE_START )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
char competitor[ 31 ]; ///< 도전 받은 플레이어
|
|
};
|
|
|
|
/// 대련 종료(결과 방송)
|
|
struct SMSG_SC_COMPETE_END : public SGameMessage
|
|
{
|
|
SMSG_SC_COMPETE_END() : SGameMessage( MSG_SC_COMPETE_END )
|
|
{
|
|
}
|
|
|
|
unsigned char compete_type; ///< _COMPETE_TYPE 값이 사용됨
|
|
unsigned char end_type; ///< _COMPETE_END_TYPE 값이 사용됨
|
|
char winner[ 31 ]; ///< 승자 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
|
|
char loser[ 31 ]; ///< 패자 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
|
|
};
|
|
|
|
struct SMSG_CS_RANKING_TOP_RECORD : public SGameMessage
|
|
{
|
|
SMSG_CS_RANKING_TOP_RECORD() : SGameMessage( MSG_CS_RANKING_TOP_RECORD )
|
|
{
|
|
}
|
|
|
|
unsigned char ranking_type; ///< _RANKING_TYPE 값이 사용됨
|
|
};
|
|
|
|
struct SMSG_SC_RANKING_TOP_RECORD : public SGameMessage
|
|
{
|
|
SMSG_SC_RANKING_TOP_RECORD() : SGameMessage( MSG_SC_RANKING_TOP_RECORD )
|
|
{
|
|
}
|
|
|
|
unsigned char ranking_type; ///< _RANKING_TYPE 값이 사용됨
|
|
unsigned short requester_rank; ///< 요청자 랭크(0이면 랭킹 미등록)
|
|
__int64 requester_score; ///< 요청자 점수
|
|
|
|
struct RANKING_RECORD
|
|
{
|
|
unsigned short rank;
|
|
char ranker_name[ 31 ];
|
|
__int64 score;
|
|
};
|
|
|
|
unsigned short record_count;
|
|
RANKING_RECORD ranking_record[10];
|
|
};
|
|
|
|
struct SMSG_SC_CREATE_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_SC_CREATE_SECURITY_NO() : SGameMessage( MSG_SC_CREATE_SECURITY_NO )
|
|
{}
|
|
};
|
|
|
|
struct SMSG_REQUEST_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_REQUEST_SECURITY_NO() : SGameMessage( MSG_REQUEST_SECURITY_NO )
|
|
{}
|
|
|
|
enum { SC_NONE, SC_OPEN_STORAGE };
|
|
|
|
int mode; ///< 0 - None, 1 - Storage open
|
|
};
|
|
|
|
struct SMSG_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_SECURITY_NO() : SGameMessage( MSG_SECURITY_NO )
|
|
{}
|
|
|
|
int mode; ///< 0 - None, 1 - Storage open
|
|
char security_no[19];
|
|
};
|
|
|
|
struct SMSG_CS_CREATE_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_CS_CREATE_SECURITY_NO() : SGameMessage( MSG_CS_CREATE_SECURITY_NO )
|
|
{}
|
|
|
|
char password[19];
|
|
char security_no[19];
|
|
};
|
|
|
|
struct SMSG_CHANGE_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_CHANGE_SECURITY_NO() : SGameMessage( MSG_CHANGE_SECURITY_NO )
|
|
{}
|
|
|
|
char security_no_old[19];
|
|
char security_no[19];
|
|
};
|
|
|
|
struct SMSG_CS_REQUEST_SECURITY_NO_CHANGE : public SGameMessage
|
|
{
|
|
SMSG_CS_REQUEST_SECURITY_NO_CHANGE() : SGameMessage( MSG_CS_REQUEST_SECURITY_NO_CHANGE )
|
|
{}
|
|
};
|
|
|
|
struct SMSG_CS_REQUEST_CLEAR_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_CS_REQUEST_CLEAR_SECURITY_NO() : SGameMessage( MSG_CS_REQUEST_CLEAR_SECURITY_NO )
|
|
{}
|
|
|
|
};
|
|
|
|
struct SMSG_SC_CLEAR_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_SC_CLEAR_SECURITY_NO() : SGameMessage( MSG_SC_CLEAR_SECURITY_NO )
|
|
{
|
|
}
|
|
|
|
bool clearable;
|
|
};
|
|
|
|
struct SMSG_CS_CLEAR_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_CS_CLEAR_SECURITY_NO() : SGameMessage( MSG_CS_CLEAR_SECURITY_NO )
|
|
{
|
|
}
|
|
|
|
char password[19];
|
|
char security_no[19];
|
|
};
|
|
/*
|
|
const int MSG_CS_REQUEST_CLEAR_SECURITY_NO = 141;
|
|
const int MSG_SC_CLEAR_SECURITY_NO = 142;
|
|
const int MSG_CS_CLEAR_SECURITY_NO = 143;
|
|
*/
|
|
|
|
struct SMSG_SC_CHANGE_SECURITY_NO : public SGameMessage
|
|
{
|
|
SMSG_SC_CHANGE_SECURITY_NO() : SGameMessage( MSG_SC_CHANGE_SECURITY_NO )
|
|
{
|
|
}
|
|
};
|
|
|
|
struct SMSG_NPC_TRADE_INFO : public SGameMessage
|
|
{
|
|
SMSG_NPC_TRADE_INFO() : SGameMessage( MSG_NPC_TRADE_INFO )
|
|
{
|
|
}
|
|
|
|
bool is_sell;
|
|
ItemBase::ItemCode code;
|
|
count_t count;
|
|
money_t price;
|
|
money_t huntaholic_point; // #2.1.2.11.1
|
|
money_t arena_point;
|
|
|
|
AR_HANDLE target;
|
|
|
|
void operator = ( const TS_SC_NPC_TRADE_INFO& rhs )
|
|
{
|
|
this->is_sell = rhs.is_sell;
|
|
this->code = rhs.code;
|
|
this->count = count_t( rhs.count );
|
|
this->price = money_t( rhs.price );
|
|
this->huntaholic_point = money_t( rhs.huntaholic_point ); // #2.1.2.11.1
|
|
this->arena_point = money_t(rhs.arena_point);
|
|
|
|
this->target = rhs.target;
|
|
}
|
|
};
|
|
|
|
//1:1 대련 관련 챗팅 메시지 수정
|
|
// 2009-01-30:hunee
|
|
// struct SMSG_WHISPER_ADDONWND : public SGameMessage
|
|
// {
|
|
// SMSG_WHISPER_ADDONWND() : SGameMessage( MSG_WHISPER_ADDONWND )
|
|
// {
|
|
// }
|
|
//
|
|
// AR_HANDLE target;
|
|
//
|
|
// struct Challenge
|
|
// {
|
|
// };
|
|
//
|
|
// struct Whisper
|
|
// {
|
|
// };
|
|
// };
|
|
|
|
// 2009.02.24 대련 수정
|
|
struct SMSG_COMMAND_BY_ADDONWND : public SGameMessage
|
|
{
|
|
enum COMMAND_TYPE
|
|
{
|
|
COMMAND_CHALLENGE = 0,
|
|
COMMAND_WHISPER,
|
|
COMMAND_MAX,
|
|
};
|
|
|
|
COMMAND_TYPE command_type;
|
|
|
|
SMSG_COMMAND_BY_ADDONWND( COMMAND_TYPE type ) : SGameMessage( MSG_COMMAND_BY_ADDONWND )
|
|
, command_type( type )
|
|
{
|
|
}
|
|
|
|
AR_HANDLE target;
|
|
|
|
struct Challenge
|
|
{
|
|
};
|
|
|
|
struct Whisper
|
|
{
|
|
};
|
|
};
|
|
|
|
struct SMSG_GAME_OUT : public SGameMessage
|
|
{
|
|
SMSG_GAME_OUT()
|
|
: SGameMessage( MSG_GAME_OUT )
|
|
, character_select( false )
|
|
{}
|
|
|
|
bool character_select; ///< true캐릭 선택 화면 false면 게임 종료
|
|
};
|
|
|
|
|
|
/// sonador 1.8.5 자동 따라가기 구현
|
|
struct SMSG_AUTO_FOLLOW : public SGameMessage
|
|
{
|
|
SMSG_AUTO_FOLLOW() : SGameMessage( MSG_AUTO_FOLLOW ) {}
|
|
};
|
|
|
|
// sonador 10.2.1 팻 시스템 구현
|
|
/**----------------------------------------------------------------------------------------
|
|
@struct SMSG_UNSUMMON_PET
|
|
@brief unsummon pet
|
|
@author sonador
|
|
----------------------------------------------------------------------------------------*/
|
|
struct SMSG_UNSUMMON_PET : public SGameMessage
|
|
{
|
|
SMSG_UNSUMMON_PET() : SGameMessage( MSG_UNSUMMON_PET )
|
|
{
|
|
pet_handle = 0;
|
|
}
|
|
AR_HANDLE pet_handle;
|
|
};
|
|
|
|
/**----------------------------------------------------------------------------------------
|
|
@struct SMSG_ADD_PET_INFO
|
|
@brief add a information about pet to game
|
|
@author sonador
|
|
-----------------------------------------------------------------------------------------*/
|
|
struct SMSG_ADD_PET_INFO : public SGameMessage
|
|
{
|
|
SMSG_ADD_PET_INFO() : SGameMessage( MSG_ADD_PET_INFO )
|
|
{
|
|
pet_handle = 0;
|
|
code = 0;
|
|
memset( name, 0, sizeof(name) );
|
|
};
|
|
AR_HANDLE pet_handle; //!< pet handle
|
|
AR_HANDLE cage_handle; //<! cage handle
|
|
int code; //!< pet code
|
|
char name[19]; //!< name of pet
|
|
};
|
|
|
|
/**----------------------------------------------------------------------------------------
|
|
@struct SMSG_REMOVE_PET_INFO
|
|
@brief remove a information about pet from game
|
|
@author sonador
|
|
-----------------------------------------------------------------------------------------*/
|
|
struct SMSG_REMOVE_PET_INFO : public SGameMessage
|
|
{
|
|
SMSG_REMOVE_PET_INFO() : SGameMessage( MSG_REMOVE_PET_INFO )
|
|
{
|
|
pet_handle = 0;
|
|
};
|
|
AR_HANDLE pet_handle; //<! pet handle which must be removed from game
|
|
};
|
|
|
|
/**----------------------------------------------------------------------------------------
|
|
@struct SMSG_REMOVE_PET_INFO
|
|
@brief message from server means need to show an ui for changing name of pet
|
|
@author sonador
|
|
-----------------------------------------------------------------------------------------*/
|
|
struct SMSG_SHOW_SET_PET_NAME : public SGameMessage
|
|
{
|
|
SMSG_SHOW_SET_PET_NAME() : SGameMessage( MSG_SHOW_SET_PET_NAME )
|
|
{
|
|
pet_handle = 0;
|
|
}
|
|
AR_HANDLE pet_handle; //<! handle
|
|
};
|
|
|
|
// #2.1.2.11.1 {
|
|
// 헌터홀릭 인스턴스 던전 목록
|
|
struct SMSG_HUNTAHOLIC_INSTANCE_LIST : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_INSTANCE_LIST() : SGameMessage( MSG_HUNTAHOLIC_INSTANCE_LIST ), instance_info( 0 ) {}
|
|
~SMSG_HUNTAHOLIC_INSTANCE_LIST()
|
|
{
|
|
SAFE_DELETE_ARRAY( instance_info );
|
|
}
|
|
|
|
int huntaholic_id; ///< 헌터홀릭 ID
|
|
int page; ///< 현재 페이지 번호
|
|
int count; ///< 현재 페이지에 해당하는 인스턴스 던전 개수
|
|
int total_page; ///< 전체 인스턴스 던전 개수
|
|
|
|
TS_HUNTAHOLIC_INSTANCE_INFO* instance_info; ///< 이 뒤로 TS_HUNTAHOLIC_INSTANCE_INFO 가 count 개 만큼 이어 붙음
|
|
};
|
|
|
|
/// 헌터홀릭 인스턴스 던전 정보(현재 소속된 던전만)
|
|
struct SMSG_HUNTAHOLIC_INSTANCE_INFO : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_INSTANCE_INFO() : SGameMessage( MSG_HUNTAHOLIC_INSTANCE_INFO ) {}
|
|
|
|
TS_HUNTAHOLIC_INSTANCE_INFO info;
|
|
};
|
|
|
|
/// 헌터홀릭 인스턴스 던전 사냥 결과
|
|
struct SMSG_HUNTAHOLIC_HUNTING_SCORE : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_HUNTING_SCORE() : SGameMessage( MSG_HUNTAHOLIC_HUNTING_SCORE ) {}
|
|
|
|
int huntaholic_id; ///< 헌터홀릭 ID
|
|
int personal_kill_count;///< 개인 킬수
|
|
int personal_score; ///< 개인 점수
|
|
int kill_count; ///< 킬 수
|
|
int score; ///< 킬수에 따른 점수
|
|
double point_advantage; ///< 방 레벨대에 따른 점수 증폭치
|
|
double point_rate; ///< 올림방 여부에 따른 증폭치(1.0: 일반방, 1.0초과: 올림방)
|
|
int gain_point; ///< 최종 계산된 획득 포인트
|
|
char is_retired; ///< 0: 성공 / 1: 사망 / 2: 실패 // sonador #2.1.2.9.3 헌터홀릭 시스템 수정(사망/실패 구분)
|
|
};
|
|
|
|
/// 헌터홀릭 인스턴스 던전 사냥 중 점수 갱신
|
|
struct SMSG_HUNTAHOLIC_UPDATE_SCORE : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_UPDATE_SCORE() : SGameMessage( MSG_HUNTAHOLIC_UPDATE_SCORE ) {}
|
|
|
|
int kill_count; ///< 킬 수
|
|
int score; ///< 킬 수에 따른 점수
|
|
};
|
|
|
|
/// 헌터홀릭 로비에서 던전으로 입장, 사냥 시작
|
|
struct SMSG_HUNTAHOLIC_BEGIN_HUNTING : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_BEGIN_HUNTING() : SGameMessage( MSG_HUNTAHOLIC_BEGIN_HUNTING ) {}
|
|
AR_TIME begin_time;
|
|
};
|
|
|
|
struct SMSG_HUNTAHOLIC_BEGIN_COUNTDOWN : public SGameMessage
|
|
{
|
|
SMSG_HUNTAHOLIC_BEGIN_COUNTDOWN() : SGameMessage( MSG_HUNTAHOLIC_BEGIN_COUNTDOWN ) {}
|
|
};
|
|
|
|
// #2.1.2.11.1 }
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
struct SMSG_ENTER_EVENTAREA : public SGameMessage
|
|
{
|
|
SMSG_ENTER_EVENTAREA( int _id, int _pNum )
|
|
: SGameMessage( MSG_ENTER_EVENTAREA ), nID(_id), nPolyNum(_pNum)
|
|
{}
|
|
int nID;
|
|
int nPolyNum;
|
|
};
|
|
|
|
struct SMSG_LEAVE_EVENTAREA : public SGameMessage
|
|
{
|
|
SMSG_LEAVE_EVENTAREA( int _id, int _pNum ) // 2011.07.06 - servantes / nPolyNum 추가
|
|
: SGameMessage( MSG_LEAVE_EVENTAREA ), nID(_id), nPolyNum(_pNum) // 2011.07.06 - servantes / nPolyNum 추가
|
|
{}
|
|
int nID;
|
|
int nPolyNum; // 2011.07.06 - servantes / nPolyNum 추가
|
|
};
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
struct SMSG_INSTANCE_GAME_ENTER : public SGameMessage
|
|
{
|
|
enum INSTANCE_TYPE
|
|
{
|
|
HUNTAHOLIC_BEAR_ROAD = 0,
|
|
RANKED_DEATHMATCH = 1,
|
|
FREED_DEATHMATCH = 2,
|
|
};
|
|
|
|
SMSG_INSTANCE_GAME_ENTER ( int _type )
|
|
: SGameMessage( IMSG_INSTANCE_GAME_ENTER )
|
|
, instance_game_type(_type)
|
|
{}
|
|
|
|
int instance_game_type;
|
|
|
|
};
|
|
|
|
|
|
struct SMSG_INSTANCE_GAME_EXIT : public SGameMessage
|
|
{
|
|
SMSG_INSTANCE_GAME_EXIT ()
|
|
: SGameMessage( IMSG_INSTANCE_GAME_EXIT )
|
|
{}
|
|
|
|
};
|
|
|
|
struct SMSG_INSTANCE_GAME_SCORE : public SGameMessage
|
|
{
|
|
SMSG_INSTANCE_GAME_SCORE ( unsigned int _holicpoint,
|
|
unsigned int _bearroad_ranking,
|
|
unsigned int _deathmatch_kill_count,
|
|
unsigned int _deathmatch_death_count
|
|
)
|
|
: SGameMessage( IMSG_INSTANCE_GAME_SCORE )
|
|
, holicpoint(_holicpoint)
|
|
, bearroad_ranking(_bearroad_ranking)
|
|
, deathmatch_kill_count(_deathmatch_kill_count)
|
|
, deathmatch_death_count(_deathmatch_death_count)
|
|
{}
|
|
|
|
unsigned int holicpoint;
|
|
unsigned int bearroad_ranking;
|
|
unsigned int deathmatch_kill_count;
|
|
unsigned int deathmatch_death_count;
|
|
|
|
/// 2012.06.13 배틀 아레나 - prodongi
|
|
unsigned int battle_arena_point;
|
|
unsigned int battle_arena_mvp_count;
|
|
unsigned int battle_arena_record[ 3 /* _BATTLE_ARENA_TYPE */ ][ 2 /* win, lose */ ];
|
|
|
|
};
|
|
|
|
struct SMSG_INSTANCE_GAME_SCORE_REQUEST : public SGameMessage
|
|
{
|
|
SMSG_INSTANCE_GAME_SCORE_REQUEST(bool _activeAddedWnd = false)
|
|
: SGameMessage( MSG_INSTANCE_GAME_SCORE_REQUEST ), activeAddedWnd(_activeAddedWnd)
|
|
{}
|
|
bool activeAddedWnd; /// 2011.05.26 added window 활성화 여부
|
|
};
|
|
|
|
// 스킬레벨의변동이발생
|
|
// 2010.3.9 : hunee
|
|
struct SMSG_ADDED_SKILL_LIST : public SGameMessage
|
|
{
|
|
SMSG_ADDED_SKILL_LIST() : SGameMessage( MSG_ADDED_SKILL_LIST ), pAddedSkillInfo( 0 )
|
|
{
|
|
target = 0; ///< 플레이어 혹은 크리쳐
|
|
count = 0;
|
|
}
|
|
~SMSG_ADDED_SKILL_LIST()
|
|
{
|
|
SAFE_DELETE_ARRAY( pAddedSkillInfo );
|
|
}
|
|
|
|
struct AddedSkillInfo
|
|
{
|
|
int skill_id; // 스킬ID
|
|
bool restricted_to_type;
|
|
char added_skill_level;
|
|
};
|
|
|
|
AR_HANDLE target;
|
|
unsigned short count;
|
|
|
|
AddedSkillInfo * pAddedSkillInfo;
|
|
};
|
|
|
|
struct SMSG_HAIR_INFO : public SGameMessage
|
|
{
|
|
SMSG_HAIR_INFO() : SGameMessage( MSG_HAIR_INFO )
|
|
{
|
|
hPlayer = 0;
|
|
nHairID = 0;
|
|
nHairColorIndex = 0;
|
|
nHairColorRGB = 0;
|
|
}
|
|
|
|
AR_HANDLE hPlayer;
|
|
int nHairID;
|
|
int nHairColorIndex;
|
|
unsigned int nHairColorRGB;
|
|
};
|
|
|
|
|
|
// 2010.05.19 HIDE_EQUIP_INFO - prodongi
|
|
struct SMSG_HIDE_EQUIP_INFO : public SGameMessage
|
|
{
|
|
SMSG_HIDE_EQUIP_INFO() : SGameMessage(MSG_HIDE_EQUIP_INFO)
|
|
{
|
|
hPlayer = 0;
|
|
nHideEquipFlag = 0;
|
|
}
|
|
AR_HANDLE hPlayer;
|
|
unsigned int nHideEquipFlag;
|
|
};
|
|
|
|
|
|
// 길드. Guild bintitle.
|
|
struct SMSG_GUILD_COMMAND : public SGameMessage
|
|
{
|
|
enum
|
|
{
|
|
GUILD_NOTICE, // 길드공지.
|
|
GUILD_MEMBER_MEMO, // 길드원 메모.
|
|
GUILD_AUTHORITY, // 길드원 권한.
|
|
GUILD_AUTHORITY_SET, // 길드권한등급 비트플래그(권한세트)
|
|
GUILD_AUTHORITY_CLASS_NAME, // 길드 등급명.
|
|
GUILD_INVITATION, // 길드 초대.
|
|
GUILD_DESTROY, // 길드 해산.
|
|
GUILD_PROMOTE, // 길드장 인계.
|
|
GUILD_RAID, // 공격대정보.
|
|
GUILD_BUFF,
|
|
GUILD_DONATE,
|
|
GUILD_UPGRADE,
|
|
|
|
};
|
|
|
|
explicit SMSG_GUILD_COMMAND( int mode ) : SGameMessage(MSG_GUILD_COMMAND), nMode( mode )
|
|
{}
|
|
|
|
SMSG_GUILD_COMMAND( int mode, std::string & _strNotice ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strMemo( _strNotice )
|
|
{}
|
|
|
|
SMSG_GUILD_COMMAND( int mode, std::string & _strName, std::string & _strMemo ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strName( _strName ), strMemo( _strMemo )
|
|
{} // 길드 공지. // 길드원 메모.
|
|
|
|
SMSG_GUILD_COMMAND( int mode, std::string & _strName, int _nClass ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strName( _strName ), nClass( _nClass )
|
|
{} // 길드원 권한등급.
|
|
// 길드 등급명.
|
|
|
|
SMSG_GUILD_COMMAND( int mode, int _nClass, int _nClassBitSet ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), nClass( _nClass ), nClassBitSet( _nClassBitSet )
|
|
{} // 권한등급비트셋
|
|
|
|
int nMode;
|
|
int nClass; // 권한등급.
|
|
int nClassBitSet; // 권한등급비트셋.
|
|
std::string strName; // 캐릭터명.
|
|
std::string strMemo; // 메모.
|
|
};
|
|
|
|
/// 2011.01.17 - prodongi
|
|
struct SMSG_MARK_STATUS_CHANGE : public SGameMessage
|
|
{
|
|
enum { PVP = 1 << 0, PK_NORMAL = 1 << 1, PK_DEMONIAC = 1 << 2 };
|
|
SMSG_MARK_STATUS_CHANGE(AR_HANDLE handle, int status) : SGameMessage(IMSG_MARK_STATUS_CHANGE)
|
|
{
|
|
m_status = status;
|
|
m_handle = handle;
|
|
}
|
|
int m_status;
|
|
AR_HANDLE m_handle;
|
|
};
|
|
|
|
struct SMSG_TITLE_LIST : public SGameMessage
|
|
{
|
|
SMSG_TITLE_LIST( ) : SGameMessage(MSG_TITLE_LIST), count(0), pListInfo(NULL){}
|
|
virtual ~SMSG_TITLE_LIST(){ SAFE_DELETE_ARRAY(pListInfo); }
|
|
struct TS_TITLE_INFO
|
|
{
|
|
int code;
|
|
int status;
|
|
};
|
|
|
|
enum{
|
|
TITLE_STATUS_OPEN = ( 1 << 0 ),
|
|
TITLE_STATUS_ACHIEVE = ( 1 << 1 ),
|
|
TITLE_STATUS_BOOKMARK = ( 1 << 2 )
|
|
};
|
|
|
|
unsigned short count;
|
|
// 이하TS_TITLE_INFO가count만큼붙는다.
|
|
TS_TITLE_INFO *pListInfo;
|
|
};
|
|
|
|
struct SMSG_TITLE_CONDITION_LIST : public SGameMessage
|
|
{
|
|
SMSG_TITLE_CONDITION_LIST() : SGameMessage(MSG_TITLE_CONDITION_LIST), count(0), pListInfo(NULL){}
|
|
virtual ~SMSG_TITLE_CONDITION_LIST(){ SAFE_DELETE_ARRAY(pListInfo); }
|
|
|
|
struct TS_TITLE_CONDITION_INFO
|
|
{
|
|
int type;
|
|
__int64 count;
|
|
};
|
|
|
|
unsigned short count;
|
|
// 이하TS_TITLE_CONDITION_INFO가count만큼붙는다.
|
|
TS_TITLE_CONDITION_INFO *pListInfo;
|
|
};
|
|
|
|
struct SMSG_TITLE_REMAIN_TIME : public SGameMessage
|
|
{
|
|
SMSG_TITLE_REMAIN_TIME() : SGameMessage(MSG_TITLE_REAMIN_TIME){}
|
|
|
|
AR_TIME remain_title_time;
|
|
};
|
|
|
|
struct SMSG_TITLE_SET_MAIN_TITLE : public SGameMessage
|
|
{
|
|
SMSG_TITLE_SET_MAIN_TITLE() : SGameMessage(MSG_TITLE_SET_MAIN_TITLE) {}
|
|
|
|
int handle;
|
|
int code;
|
|
};
|
|
|
|
struct SMSG_TITLE_SET_SUB_TITLE : public SGameMessage
|
|
{
|
|
SMSG_TITLE_SET_SUB_TITLE() : SGameMessage(MSG_TITLE_SET_SUB_TITLE) {}
|
|
|
|
int index;
|
|
int code;
|
|
};
|
|
|
|
struct SMSG_TITLE_BOOKMARK_TITLE : public SGameMessage
|
|
{
|
|
SMSG_TITLE_BOOKMARK_TITLE() : SGameMessage(MSG_TITLE_BOOKMARK){}
|
|
|
|
int code;
|
|
bool bookmarked;
|
|
};
|
|
|
|
struct SMSG_TITLE_ACHIEVE_TITLE : public SGameMessage
|
|
{
|
|
SMSG_TITLE_ACHIEVE_TITLE() : SGameMessage(MSG_TITLE_ACHIEVE){}
|
|
|
|
int code;
|
|
};
|
|
|
|
struct SMSG_TITLE_OPEN_TITLE : public SGameMessage
|
|
{
|
|
SMSG_TITLE_OPEN_TITLE() : SGameMessage(MSG_TITILE_OPEN){}
|
|
|
|
int code;
|
|
};
|
|
|
|
struct SMSG_TITLE_CHANGE_CONDITION : public SGameMessage
|
|
{
|
|
SMSG_TITLE_CHANGE_CONDITION() : SGameMessage(MSG_TITLE_CHANGE_CONDITION){}
|
|
|
|
int condition_id;
|
|
__int64 count;
|
|
};
|
|
|
|
|
|
// 크리처 농장 정보 // servantes 2011.02.23
|
|
struct SMSG_CREATURE_FARM_INFO : public SGameMessage
|
|
{
|
|
SMSG_CREATURE_FARM_INFO() : SGameMessage(MSG_CREATURE_FARM_INFO), pInfoList(NULL), creature_count(0) {}
|
|
~SMSG_CREATURE_FARM_INFO()
|
|
{
|
|
SAFE_DELETE_ARRAY(pInfoList);
|
|
}
|
|
|
|
char creature_count;
|
|
|
|
struct SMSG_SUMMON_INFO {
|
|
int index; // 농장슬롯인덱스
|
|
__int64 exp; // 경험치
|
|
char name[19]; // 이름
|
|
int duration; // 맡기는 기간
|
|
int elasped_time; // 경과 시간
|
|
int refresh_time; // 돌보기 할 수 있는 시점까지 남은 시간
|
|
char using_cash; // 캐쉬아이템 사용
|
|
char using_cracker; // 크래커 아이템 사용
|
|
TS_ITEM_BASE_INFO card_info; // 크리처 카드의 아이템 정보
|
|
};
|
|
|
|
// 이후 creature_count 만큼 SUMMON_INFO 구조체가 따라옴.
|
|
SMSG_SUMMON_INFO* pInfoList;
|
|
};
|
|
|
|
// 크리처 맡기기 결과
|
|
struct SMSG_RESULT_FOSTER : public SGameMessage
|
|
{
|
|
SMSG_RESULT_FOSTER() : SGameMessage(MSG_RESULT_FOSTER), result(0) {}
|
|
|
|
char result;
|
|
};
|
|
|
|
// 크리처 돌보기 결과
|
|
struct SMSG_RESULT_NURSE : public SGameMessage
|
|
{
|
|
SMSG_RESULT_NURSE() : SGameMessage(MSG_RESULT_NURSE), result(0) {}
|
|
|
|
char result;
|
|
};
|
|
|
|
// 크리처 꺼내기 결과
|
|
struct SMSG_RESULT_REGAIN : public SGameMessage
|
|
{
|
|
SMSG_RESULT_REGAIN() : SGameMessage(MSG_RESULT_RETRIEVE), result(0) {}
|
|
|
|
char result;
|
|
};
|
|
|
|
/// 2011.03.29 출력에 필요한 아이템 카드 인포가 들어 있다 - prodongi
|
|
struct SMSG_SUMMON_CARD_ITEM_INFO : public SGameMessage
|
|
{
|
|
SMSG_SUMMON_CARD_ITEM_INFO() : SGameMessage(MSG_SUMMON_CARD_ITEM_INFO)
|
|
{
|
|
level = 0;
|
|
}
|
|
|
|
int level;
|
|
TS_ITEM_BASE_INFO item_info;
|
|
};
|
|
|
|
/// 2011.05.12 우클릭 유도 - prodongi
|
|
struct SMSG_SKILL_LEVEL_LIST : public SGameMessage
|
|
{
|
|
SMSG_SKILL_LEVEL_LIST() : SGameMessage(MSG_SKILL_LEVEL_LIST), list(NULL), count(0) {}
|
|
~SMSG_SKILL_LEVEL_LIST()
|
|
{
|
|
SAFE_DELETE_ARRAY(list);
|
|
}
|
|
struct SkillLevelInfo
|
|
{
|
|
int skill_id;
|
|
unsigned char skill_level;
|
|
};
|
|
unsigned short count;
|
|
SkillLevelInfo* list;
|
|
};
|
|
|
|
/// 2011.10.26 - prodongi
|
|
struct SMSG_GENERAL_MESSAGE_BOX : public SGameMessage
|
|
{
|
|
SMSG_GENERAL_MESSAGE_BOX() : SGameMessage(MSG_GENERAL_MESSAGE_BOX) {}
|
|
~SMSG_GENERAL_MESSAGE_BOX() { m_text.clear(); }
|
|
|
|
std::string m_text;
|
|
};
|
|
|
|
/// 2012.06.05 아레나 관련 구조체 추가 - prodongi
|
|
struct SMSG_BATTLE_ARENA_JOIN_QUEUE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_JOIN_QUEUE() : SGameMessage(MSG_BATTLE_ARENA_JOIN_QUEUE) {}
|
|
|
|
int arenaId;
|
|
_BATTLE_GRADE grade; /// 클라에서는 LocalPlayer의 레벨을 판단다면 되기 때문에 굳이 쓰이지는 않고 있다.
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_LEAVE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_LEAVE() : SGameMessage(MSG_BATTLE_ARENA_LEAVE) {}
|
|
|
|
_ARENA_LEAVE_TYPE leaveType;
|
|
char name[ 19 ];
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_BATTLE_INFO : public SGameMessage
|
|
{
|
|
enum { MAX_TEAM_NUM = 2 }; /// 연합군, 마녀군, sArenaSystemInfo::MAX_TEAM_NUM과 같다
|
|
|
|
SMSG_BATTLE_ARENA_BATTLE_INFO() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_INFO)
|
|
{
|
|
for (int i = 0; i < MAX_TEAM_NUM; ++i)
|
|
playerInfo[i] = NULL;
|
|
}
|
|
~SMSG_BATTLE_ARENA_BATTLE_INFO()
|
|
{
|
|
for (int i = 0; i < MAX_TEAM_NUM; ++i)
|
|
SAFE_DELETE_ARRAY(playerInfo[i]);
|
|
}
|
|
|
|
int arenaId;
|
|
// 패킷 수신자 개인 종속적인 내용
|
|
AR_TIME forceEnterTime;
|
|
// 경기 종속적인 내용(점수는 별도의 패킷이 있으므로 제외)
|
|
AR_TIME startTime;
|
|
_BATTLE_GRADE grade;
|
|
AR_TIME endTime;
|
|
unsigned char playerCountPerTeam[MAX_TEAM_NUM];
|
|
|
|
struct sPlayerInfo
|
|
{
|
|
AR_HANDLE handle; // handle == 0 이면 오프라인 유저
|
|
int jobID;
|
|
char name[ 19 ]; // 기존에 AR_HANDLE과 묶인 이름 정보가 있더라도 가명에 의해 다른 이름이 지정될 수 있음
|
|
};
|
|
|
|
sPlayerInfo* playerInfo[MAX_TEAM_NUM];
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_EXERCISE_READY_STATUS : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_EXERCISE_READY_STATUS() : SGameMessage(MSG_BATTLE_ARENA_EXERCISE_READY_STATUS) {}
|
|
int readyState;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_BATTLE_STATUS : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_BATTLE_STATUS() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_STATUS) {}
|
|
_PROP_STATE GetPropState( int nPropIndex ) const { assert( nPropIndex >= 0 && nPropIndex < 9 ); return static_cast< _PROP_STATE >( ( status >> ( nPropIndex * 2 ) ) & 0x3 ); }
|
|
bool IsActivatedBingoLine( int nLineIndex ) { assert( nLineIndex >= 0 && nLineIndex < 8 ); return ( ( status >> 24 ) & ( 1 << nLineIndex ) ) != 0; }
|
|
|
|
int status;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_BATTLE_SCORE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_BATTLE_SCORE() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_SCORE)
|
|
{
|
|
playerScore = NULL;
|
|
}
|
|
~SMSG_BATTLE_ARENA_BATTLE_SCORE()
|
|
{
|
|
SAFE_DELETE_ARRAY(playerScore);
|
|
}
|
|
|
|
struct sTeamScore
|
|
{
|
|
short totalKillCount; // 각 팀별 킬 수 총합
|
|
short totalDeathCount; // 각 팀별 데스 수 총합
|
|
short score; // 각 팀별 현재 점수
|
|
};
|
|
struct sPlayerScore
|
|
{
|
|
char name[ 19 ];
|
|
short killCount;
|
|
short deathCount;
|
|
short propActivateCount;
|
|
int totalGainAP;
|
|
};
|
|
|
|
sTeamScore teamScore[ 2 /* GameRule::BATTLE_ARENA_MAX_TEAM_COUNT */ ];
|
|
unsigned char playerScoreCount;
|
|
sPlayerScore* playerScore;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_JOIN_BATTLE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_JOIN_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_JOIN_BATTLE) {}
|
|
|
|
int teamNo;
|
|
AR_HANDLE handle;
|
|
int jobID;
|
|
char name[ 19 ];
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_DISCONNECT_BATTLE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_DISCONNECT_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_DISCONNECT_BATTLE) {}
|
|
|
|
AR_HANDLE handle;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_RECONNECT_BATTLE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_RECONNECT_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_RECONNECT_BATTLE) {}
|
|
|
|
// 유저가 로그아웃되었다가 다시 접속될 경우 서버에서 AR_HANDLE값이 재부여되기 때문에
|
|
// 클라이언트에서는 기존의 AR_HANDLE 값을 사용하면 안되고 이 패킷으로 받은 값으로 갱신해서 사용해야 함
|
|
// 이 경우 어떤 유저가 재접속했는지는 szName을 기준으로 처리해야 함
|
|
char name[ 19 ];
|
|
AR_HANDLE newHandle;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_RESULT : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_RESULT() : SGameMessage(MSG_BATTLE_ARENA_RESULT), mvp(NULL) {}
|
|
~SMSG_BATTLE_ARENA_RESULT()
|
|
{
|
|
SAFE_DELETE_ARRAY(mvp);
|
|
}
|
|
|
|
/*
|
|
// 아레나 경기 종료 타입
|
|
enum _ARENA_END_TYPE
|
|
{
|
|
AET_UNKNOWN = 0,
|
|
|
|
AET_ONE_TEAM_NO_MEMBER = 1, // 한 팀의 멤버가 모두 이탈하여 경기 종료(종료 유형이지만 보상이 없다는 내용도 포함)
|
|
AET_MAX_SCORE_REACHED = 2, // 목표 점수 도달로 경기 종료
|
|
AET_TIME_OVER = 3, // 시간 초과로 경기 종료
|
|
};
|
|
|
|
// 아레나 경기 보상 타입
|
|
enum _ARENA_REWARD_TYPE
|
|
{
|
|
ART_UNKNOWN = 0,
|
|
|
|
ART_FULL_REWARD = 1, // 값 없음(지정 안하면 이거)
|
|
ART_HALF_REWARD_BY_FEW_MEMBER = 2, // 한 팀의 멤버 수가 팀 최대 인원의 50% 미만이어서 보상이 절반으로 감소
|
|
ART_NO_REWARD_BY_NO_MEMBER = 3, // 한 팀의 멤버가 모두 이탈해서 경기가 중단되어 보상 없음
|
|
ART_NO_REWARD_BY_MIN_TIME = 4, // 최소 경기 시간 미달로 인해 보상 없음
|
|
ART_NO_REWARD_BY_EXERCISE = 5, // 연습 경기는 보상 없음
|
|
};
|
|
*/
|
|
|
|
_ARENA_END_TYPE endType;
|
|
_ARENA_REWARD_TYPE rewardType;
|
|
int winnerTeamNo; // 0: 연합군, 1:마녀군
|
|
|
|
struct sMvp
|
|
{
|
|
char name[19];
|
|
};
|
|
unsigned char mvpCount;
|
|
sMvp* mvp;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_ABSENCE_CHECK : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_ABSENCE_CHECK() : SGameMessage(MSG_BATTLE_ARENA_ABSENCE_CHECK) {}
|
|
|
|
AR_TIME limitTime;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_PENALTY_INFO : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_PENALTY_INFO() : SGameMessage(MSG_BATTLE_ARENA_PENALTY_INFO) {}
|
|
|
|
AR_TIME blockTime;
|
|
int penaltyCount;
|
|
AR_TIME penaltyCountTime;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT() : SGameMessage(MSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT) {}
|
|
|
|
int waitUserCount;
|
|
};
|
|
|
|
struct SMSG_BATTLE_ARENA_PROMOTE : public SGameMessage
|
|
{
|
|
SMSG_BATTLE_ARENA_PROMOTE() : SGameMessage(MSG_BATTLE_ARENA_PROMOTE) {}
|
|
};
|
|
|
|
|
|
struct SMSG_KMOVE : public SGameMessage
|
|
{
|
|
SMSG_KMOVE() : SGameMessage(MSG_KMOVE)
|
|
{
|
|
handle = 0;
|
|
start_time = 0;
|
|
bReqMove = false;
|
|
pos_target = K3DVector(0,0,0);
|
|
speed = 0;
|
|
}
|
|
~SMSG_KMOVE()
|
|
{
|
|
m_vecMoveInfo.clear();
|
|
}
|
|
|
|
AR_HANDLE handle;
|
|
AR_TIME start_time;
|
|
|
|
bool bReqMove;
|
|
|
|
K3DVector pos_target; ///< 이동 할 위치
|
|
|
|
unsigned char speed;
|
|
|
|
std::vector< ArPosition > m_vecMoveInfo;
|
|
};
|
|
|
|
|
|
struct SMSG_DECOMPOSE_DO : public SGameMessage
|
|
{
|
|
SMSG_DECOMPOSE_DO()
|
|
: SGameMessage( IMSG_DECOMPOSE_DO )
|
|
{
|
|
}
|
|
|
|
struct IN_DATA
|
|
{
|
|
IN_DATA() { _handle = 0; _count = 1; }
|
|
AR_HANDLE _handle;
|
|
unsigned int _count;
|
|
};
|
|
|
|
vector<IN_DATA> m_vecItemData;
|
|
};
|
|
|
|
|
|
struct SMSG_DECOMPOSE_RESULT : public SGameMessage
|
|
{
|
|
SMSG_DECOMPOSE_RESULT()
|
|
: SGameMessage( IMSG_DECOMPOSE_RESULT )
|
|
{
|
|
}
|
|
|
|
typedef struct stDecomposeInfo
|
|
{
|
|
AR_HANDLE m_hItem;
|
|
UINT m_nItemCount;
|
|
|
|
stDecomposeInfo()
|
|
: m_hItem( NULL )
|
|
, m_nItemCount( NULL )
|
|
{
|
|
}
|
|
}DECOMPOSE_INFO, *PDECOMPOSE_INFO;
|
|
|
|
vector<DECOMPOSE_INFO> m_vecItemInfo;
|
|
};
|
|
|
|
|
|
struct SMSG_CHANGE_SKIN_COLOR : public SGameMessage
|
|
{
|
|
SMSG_CHANGE_SKIN_COLOR()
|
|
: SGameMessage( MSG_CHANGE_SKIN_COLOR )
|
|
, hPlayer( NULL )
|
|
, dwSkinColor( NULL )
|
|
{
|
|
}
|
|
|
|
AR_HANDLE hPlayer;
|
|
DWORD dwSkinColor;
|
|
};
|
|
|
|
|
|
|
|
|
|
struct SMSG_PARTYMATCH_MEMBER : public SGameMessage
|
|
{
|
|
SMSG_PARTYMATCH_MEMBER(): SGameMessage( MSG_PARTYMATCH_MEMBER )
|
|
{
|
|
}
|
|
|
|
int nRoom;
|
|
AR_HANDLE nMaster; // master ID 아래에 pMeber중 하나가 이와 같은 값이다.
|
|
STRUCT_PARTYMATCH_MEMBER pMember[PARTYMATCH_MEMBER_MAX];
|
|
};
|
|
|
|
struct SMSG_PARTYMATCH_LIST : public SGameMessage
|
|
{
|
|
SMSG_PARTYMATCH_LIST()
|
|
: SGameMessage( MSG_PARTYMATCH_LIST )
|
|
{
|
|
}
|
|
|
|
int nPage;
|
|
int nRoomTotal;
|
|
STRUCT_PARTYMATCH_ROOM pRoom[PARTYMATCH_ROOM_PAGE];
|
|
};
|
|
|
|
|
|
struct SMSG_PARTYMATCH_ACTION : public SGameMessage
|
|
{
|
|
SMSG_PARTYMATCH_ACTION()
|
|
: SGameMessage( MSG_PARTYMATCH_ACTION )
|
|
{
|
|
}
|
|
|
|
int nAction;
|
|
int nPage;
|
|
AR_HANDLE nMaster; // master ID 아래에 pMeber중 하나가 이와 같은 값이다.
|
|
STRUCT_PARTYMATCH_ROOM stRoom;
|
|
};
|
|
|
|
#pragma pack()
|