API tools faq
paste
Advertisement
Ionutdev

Untitled

Ionutdev
Jan 23rd, 2020
383
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 65.42 KB | None | 0 0
raw download clone embed print report
  1. #ifndef __INC_METIN_II_CHAR_H__
  2. #define __INC_METIN_II_CHAR_H__
  3.  
  4. #include <boost/unordered_map.hpp>
  5.  
  6. #include "../../common/stl.h"
  7. #include "entity.h"
  8. #include "FSM.h"
  9. #include "horse_rider.h"
  10. #include "vid.h"
  11. #include "constants.h"
  12. #include "affect.h"
  13. #include "affect_flag.h"
  14. #include "cube.h"
  15. #include "mining.h"
  16.  
  17. class CBuffOnAttributes;
  18. class CPetSystem;
  19.  
  20. #define INSTANT_FLAG_DEATH_PENALTY (1 << 0)
  21. #define INSTANT_FLAG_SHOP (1 << 1)
  22. #define INSTANT_FLAG_EXCHANGE (1 << 2)
  23. #define INSTANT_FLAG_STUN (1 << 3)
  24. #define INSTANT_FLAG_NO_REWARD (1 << 4)
  25.  
  26. #define AI_FLAG_NPC (1 << 0)
  27. #define AI_FLAG_AGGRESSIVE (1 << 1)
  28. #define AI_FLAG_HELPER (1 << 2)
  29. #define AI_FLAG_STAYZONE (1 << 3)
  30.  
  31.  
  32. #define SET_OVER_TIME(ch, time) (ch)->SetOverTime(time)
  33.  
  34. extern int g_nPortalLimitTime;
  35.  
  36. enum
  37. {
  38. MAIN_RACE_WARRIOR_M,
  39. MAIN_RACE_ASSASSIN_W,
  40. MAIN_RACE_SURA_M,
  41. MAIN_RACE_SHAMAN_W,
  42. MAIN_RACE_WARRIOR_W,
  43. MAIN_RACE_ASSASSIN_M,
  44. MAIN_RACE_SURA_W,
  45. MAIN_RACE_SHAMAN_M,
  46. MAIN_RACE_MAX_NUM,
  47. };
  48.  
  49. enum
  50. {
  51. POISON_LENGTH = 30,
  52. STAMINA_PER_STEP = 1,
  53. SAFEBOX_PAGE_SIZE = 9,
  54. AI_CHANGE_ATTACK_POISITION_TIME_NEAR = 10000,
  55. AI_CHANGE_ATTACK_POISITION_TIME_FAR = 1000,
  56. AI_CHANGE_ATTACK_POISITION_DISTANCE = 100,
  57. SUMMON_MONSTER_COUNT = 3,
  58. };
  59.  
  60. enum
  61. {
  62. FLY_NONE,
  63. FLY_EXP,
  64. FLY_HP_MEDIUM,
  65. FLY_HP_BIG,
  66. FLY_SP_SMALL,
  67. FLY_SP_MEDIUM,
  68. FLY_SP_BIG,
  69. FLY_FIREWORK1,
  70. FLY_FIREWORK2,
  71. FLY_FIREWORK3,
  72. FLY_FIREWORK4,
  73. FLY_FIREWORK5,
  74. FLY_FIREWORK6,
  75. FLY_FIREWORK_CHRISTMAS,
  76. FLY_CHAIN_LIGHTNING,
  77. FLY_HP_SMALL,
  78. FLY_SKILL_MUYEONG,
  79. };
  80.  
  81. enum EDamageType
  82. {
  83. DAMAGE_TYPE_NONE,
  84. DAMAGE_TYPE_NORMAL,
  85. DAMAGE_TYPE_NORMAL_RANGE,
  86. //스킬
  87. DAMAGE_TYPE_MELEE,
  88. DAMAGE_TYPE_RANGE,
  89. DAMAGE_TYPE_FIRE,
  90. DAMAGE_TYPE_ICE,
  91. DAMAGE_TYPE_ELEC,
  92. DAMAGE_TYPE_MAGIC,
  93. DAMAGE_TYPE_POISON,
  94. DAMAGE_TYPE_SPECIAL,
  95. };
  96.  
  97. enum EPointTypes
  98. {
  99. POINT_NONE, // 0
  100. POINT_LEVEL, // 1
  101. POINT_VOICE, // 2
  102. POINT_EXP, // 3
  103. POINT_NEXT_EXP, // 4
  104. POINT_HP, // 5
  105. POINT_MAX_HP, // 6
  106. POINT_SP, // 7
  107. POINT_MAX_SP, // 8
  108. POINT_STAMINA, // 9 스테미너
  109. POINT_MAX_STAMINA, // 10 최대 스테미너
  110.  
  111. POINT_GOLD, // 11
  112. POINT_ST, // 12 근력
  113. POINT_HT, // 13 체력
  114. POINT_DX, // 14 민첩성
  115. POINT_IQ, // 15 정신력
  116. POINT_DEF_GRADE, // 16 ...
  117. POINT_ATT_SPEED, // 17 공격속도
  118. POINT_ATT_GRADE, // 18 공격력 MAX
  119. POINT_MOV_SPEED, // 19 이동속도
  120. POINT_CLIENT_DEF_GRADE, // 20 방어등급
  121. POINT_CASTING_SPEED, // 21 주문속도 (쿨다운타임*100) / (100 + 이값) = 최종 쿨다운 타임
  122. POINT_MAGIC_ATT_GRADE, // 22 마법공격력
  123. POINT_MAGIC_DEF_GRADE, // 23 마법방어력
  124. POINT_EMPIRE_POINT, // 24 제국점수
  125. POINT_LEVEL_STEP, // 25 한 레벨에서의 단계.. (1 2 3 될 때 보상, 4 되면 레벨 업)
  126. POINT_STAT, // 26 능력치 올릴 수 있는 개수
  127. POINT_SUB_SKILL, // 27 보조 스킬 포인트
  128. POINT_SKILL, // 28 액티브 스킬 포인트
  129. POINT_WEAPON_MIN, // 29 무기 최소 데미지
  130. POINT_WEAPON_MAX, // 30 무기 최대 데미지
  131. POINT_PLAYTIME, // 31 플레이시간
  132. POINT_HP_REGEN, // 32 HP 회복률
  133. POINT_SP_REGEN, // 33 SP 회복률
  134.  
  135. POINT_BOW_DISTANCE, // 34 활 사정거리 증가치 (meter)
  136.  
  137. POINT_HP_RECOVERY, // 35 체력 회복 증가량
  138. POINT_SP_RECOVERY, // 36 정신력 회복 증가량
  139.  
  140. POINT_POISON_PCT, // 37 독 확률
  141. POINT_STUN_PCT, // 38 기절 확률
  142. POINT_SLOW_PCT, // 39 슬로우 확률
  143. POINT_CRITICAL_PCT, // 40 크리티컬 확률
  144. POINT_PENETRATE_PCT, // 41 관통타격 확률
  145. POINT_CURSE_PCT, // 42 저주 확률
  146.  
  147. POINT_ATTBONUS_HUMAN, // 43 인간에게 강함
  148. POINT_ATTBONUS_ANIMAL, // 44 동물에게 데미지 % 증가
  149. POINT_ATTBONUS_ORC, // 45 웅귀에게 데미지 % 증가
  150. POINT_ATTBONUS_MILGYO, // 46 밀교에게 데미지 % 증가
  151. POINT_ATTBONUS_UNDEAD, // 47 시체에게 데미지 % 증가
  152. POINT_ATTBONUS_DEVIL, // 48 마귀(악마)에게 데미지 % 증가
  153. POINT_ATTBONUS_INSECT, // 49 벌레족
  154. POINT_ATTBONUS_FIRE, // 50 화염족
  155. POINT_ATTBONUS_ICE, // 51 빙설족
  156. POINT_ATTBONUS_DESERT, // 52 사막족
  157. POINT_ATTBONUS_MONSTER, // 53 모든 몬스터에게 강함
  158. POINT_ATTBONUS_WARRIOR, // 54 무사에게 강함
  159. POINT_ATTBONUS_ASSASSIN, // 55 자객에게 강함
  160. POINT_ATTBONUS_SURA, // 56 수라에게 강함
  161. POINT_ATTBONUS_SHAMAN, // 57 무당에게 강함
  162. POINT_ATTBONUS_TREE, // 58 나무에게 강함 20050729.myevan UNUSED5
  163.  
  164. POINT_RESIST_WARRIOR, // 59 무사에게 저항
  165. POINT_RESIST_ASSASSIN, // 60 자객에게 저항
  166. POINT_RESIST_SURA, // 61 수라에게 저항
  167. POINT_RESIST_SHAMAN, // 62 무당에게 저항
  168.  
  169. POINT_STEAL_HP, // 63 생명력 흡수
  170. POINT_STEAL_SP, // 64 정신력 흡수
  171.  
  172. POINT_MANA_BURN_PCT, // 65 마나 번
  173.  
  174. /// 피해시 보너스 ///
  175.  
  176. POINT_DAMAGE_SP_RECOVER, // 66 공격당할 시 정신력 회복 확률
  177.  
  178. POINT_BLOCK, // 67 블럭율
  179. POINT_DODGE, // 68 회피율
  180.  
  181. POINT_RESIST_SWORD, // 69
  182. POINT_RESIST_TWOHAND, // 70
  183. POINT_RESIST_DAGGER, // 71
  184. POINT_RESIST_BELL, // 72
  185. POINT_RESIST_FAN, // 73
  186. POINT_RESIST_BOW, // 74 화살 저항 : 대미지 감소
  187. POINT_RESIST_FIRE, // 75 화염 저항 : 화염공격에 대한 대미지 감소
  188. POINT_RESIST_ELEC, // 76 전기 저항 : 전기공격에 대한 대미지 감소
  189. POINT_RESIST_MAGIC, // 77 술법 저항 : 모든술법에 대한 대미지 감소
  190. POINT_RESIST_WIND, // 78 바람 저항 : 바람공격에 대한 대미지 감소
  191.  
  192. POINT_REFLECT_MELEE, // 79 공격 반사
  193.  
  194. /// 특수 피해시 ///
  195. POINT_REFLECT_CURSE, // 80 저주 반사
  196. POINT_POISON_REDUCE, // 81 독데미지 감소
  197.  
  198. /// 적 소멸시 ///
  199. POINT_KILL_SP_RECOVER, // 82 적 소멸시 MP 회복
  200. POINT_EXP_DOUBLE_BONUS, // 83
  201. POINT_GOLD_DOUBLE_BONUS, // 84
  202. POINT_ITEM_DROP_BONUS, // 85
  203.  
  204. /// 회복 관련 ///
  205. POINT_POTION_BONUS, // 86
  206. POINT_KILL_HP_RECOVERY, // 87
  207.  
  208. POINT_IMMUNE_STUN, // 88
  209. POINT_IMMUNE_SLOW, // 89
  210. POINT_IMMUNE_FALL, // 90
  211. //////////////////
  212.  
  213. POINT_PARTY_ATTACKER_BONUS, // 91
  214. POINT_PARTY_TANKER_BONUS, // 92
  215.  
  216. POINT_ATT_BONUS, // 93
  217. POINT_DEF_BONUS, // 94
  218.  
  219. POINT_ATT_GRADE_BONUS, // 95
  220. POINT_DEF_GRADE_BONUS, // 96
  221. POINT_MAGIC_ATT_GRADE_BONUS, // 97
  222. POINT_MAGIC_DEF_GRADE_BONUS, // 98
  223.  
  224. POINT_RESIST_NORMAL_DAMAGE, // 99
  225.  
  226. POINT_HIT_HP_RECOVERY, // 100
  227. POINT_HIT_SP_RECOVERY, // 101
  228. POINT_MANASHIELD, // 102 흑신수호 스킬에 의한 마나쉴드 효과 정도
  229.  
  230. POINT_PARTY_BUFFER_BONUS, // 103
  231. POINT_PARTY_SKILL_MASTER_BONUS, // 104
  232.  
  233. POINT_HP_RECOVER_CONTINUE, // 105
  234. POINT_SP_RECOVER_CONTINUE, // 106
  235.  
  236. POINT_STEAL_GOLD, // 107
  237. POINT_POLYMORPH, // 108 변신한 몬스터 번호
  238. POINT_MOUNT, // 109 타고있는 몬스터 번호
  239.  
  240. POINT_PARTY_HASTE_BONUS, // 110
  241. POINT_PARTY_DEFENDER_BONUS, // 111
  242. POINT_STAT_RESET_COUNT, // 112 피의 단약 사용을 통한 스텟 리셋 포인트 (1당 1포인트 리셋가능)
  243.  
  244. POINT_HORSE_SKILL, // 113
  245.  
  246. POINT_MALL_ATTBONUS, // 114 공격력 +x%
  247. POINT_MALL_DEFBONUS, // 115 방어력 +x%
  248. POINT_MALL_EXPBONUS, // 116 경험치 +x%
  249. POINT_MALL_ITEMBONUS, // 117 아이템 드롭율 x/10배
  250. POINT_MALL_GOLDBONUS, // 118 돈 드롭율 x/10배
  251.  
  252. POINT_MAX_HP_PCT, // 119 최대생명력 +x%
  253. POINT_MAX_SP_PCT, // 120 최대정신력 +x%
  254.  
  255. POINT_SKILL_DAMAGE_BONUS, // 121 스킬 데미지 *(100+x)%
  256. POINT_NORMAL_HIT_DAMAGE_BONUS, // 122 평타 데미지 *(100+x)%
  257.  
  258. // DEFEND_BONUS_ATTRIBUTES
  259. POINT_SKILL_DEFEND_BONUS, // 123 스킬 방어 데미지
  260. POINT_NORMAL_HIT_DEFEND_BONUS, // 124 평타 방어 데미지
  261. // END_OF_DEFEND_BONUS_ATTRIBUTES
  262.  
  263. POINT_RAMADAN_CANDY_BONUS_EXP, // 라마단 사탕 경험치 증가용
  264.  
  265. POINT_ENERGY = 128, // 128 기력
  266.  
  267. // 기력 ui 용.
  268. // 서버에서 쓰지 않기만, 클라이언트에서 기력의 끝 시간을 POINT로 관리하기 때문에 이렇게 한다.
  269. // 아 부끄럽다
  270. POINT_ENERGY_END_TIME = 129, // 129 기력 종료 시간
  271.  
  272. POINT_COSTUME_ATTR_BONUS = 130,
  273. POINT_MAGIC_ATT_BONUS_PER = 131,
  274. POINT_MELEE_MAGIC_ATT_BONUS_PER = 132,
  275.  
  276. // 추가 속성 저항
  277. POINT_RESIST_ICE = 133, // 냉기 저항 : 얼음공격에 대한 대미지 감소
  278. POINT_RESIST_EARTH = 134, // 대지 저항 : 얼음공격에 대한 대미지 감소
  279. POINT_RESIST_DARK = 135, // 어둠 저항 : 얼음공격에 대한 대미지 감소
  280.  
  281. POINT_RESIST_CRITICAL = 136, // 크리티컬 저항 : 상대의 크리티컬 확률을 감소
  282. POINT_RESIST_PENETRATE = 137, // 관통타격 저항 : 상대의 관통타격 확률을 감소
  283.  
  284. //POINT_MAX_NUM = 129 common/length.h
  285. };
  286.  
  287. enum EPKModes
  288. {
  289. PK_MODE_PEACE,
  290. PK_MODE_REVENGE,
  291. PK_MODE_FREE,
  292. PK_MODE_PROTECT,
  293. PK_MODE_GUILD,
  294. PK_MODE_MAX_NUM
  295. };
  296.  
  297. enum EPositions
  298. {
  299. POS_DEAD,
  300. POS_SLEEPING,
  301. POS_RESTING,
  302. POS_SITTING,
  303. POS_FISHING,
  304. POS_FIGHTING,
  305. POS_MOUNTING,
  306. POS_STANDING
  307. };
  308.  
  309. enum EBlockAction
  310. {
  311. BLOCK_EXCHANGE = (1 << 0),
  312. BLOCK_PARTY_INVITE = (1 << 1),
  313. BLOCK_GUILD_INVITE = (1 << 2),
  314. BLOCK_WHISPER = (1 << 3),
  315. BLOCK_MESSENGER_INVITE = (1 << 4),
  316. BLOCK_PARTY_REQUEST = (1 << 5),
  317. };
  318.  
  319. // <Factor> Dynamically evaluated CHARACTER* equivalent.
  320. // Referring to SCharDeadEventInfo.
  321. struct DynamicCharacterPtr {
  322. DynamicCharacterPtr() : is_pc(false), id(0) {}
  323. DynamicCharacterPtr(const DynamicCharacterPtr& o)
  324. : is_pc(o.is_pc), id(o.id) {}
  325.  
  326. // Returns the LPCHARACTER found in CHARACTER_MANAGER.
  327. LPCHARACTER Get() const;
  328. // Clears the current settings.
  329. void Reset() {
  330. is_pc = false;
  331. id = 0;
  332. }
  333.  
  334. // Basic assignment operator.
  335. DynamicCharacterPtr& operator=(const DynamicCharacterPtr& rhs) {
  336. is_pc = rhs.is_pc;
  337. id = rhs.id;
  338. return *this;
  339. }
  340. // Supports assignment with LPCHARACTER type.
  341. DynamicCharacterPtr& operator=(LPCHARACTER character);
  342. // Supports type casting to LPCHARACTER.
  343. operator LPCHARACTER() const {
  344. return Get();
  345. }
  346.  
  347. bool is_pc;
  348. uint32_t id;
  349. };
  350.  
  351. /* 저장하는 데이터 */
  352. typedef struct character_point
  353. {
  354. long long points[POINT_MAX_NUM];
  355.  
  356. BYTE job;
  357. BYTE voice;
  358.  
  359. BYTE level;
  360. DWORD exp;
  361. long long gold;
  362.  
  363. int hp;
  364. int sp;
  365.  
  366. int iRandomHP;
  367. int iRandomSP;
  368.  
  369. int stamina;
  370.  
  371. BYTE skill_group;
  372. } CHARACTER_POINT;
  373.  
  374. /* 저장되지 않는 캐릭터 데이터 */
  375. typedef struct character_point_instant
  376. {
  377. long long points[POINT_MAX_NUM];
  378.  
  379. float fRot;
  380.  
  381. int iMaxHP;
  382. int iMaxSP;
  383.  
  384. long position;
  385.  
  386. long instant_flag;
  387. DWORD dwAIFlag;
  388. DWORD dwImmuneFlag;
  389. DWORD dwLastShoutPulse;
  390.  
  391. WORD parts[PART_MAX_NUM];
  392.  
  393. LPITEM pItems[INVENTORY_AND_EQUIP_SLOT_MAX];
  394. BYTE bItemGrid[INVENTORY_AND_EQUIP_SLOT_MAX];
  395.  
  396. // 용혼석 인벤토리.
  397. LPITEM pDSItems[DRAGON_SOUL_INVENTORY_MAX_NUM];
  398. WORD wDSItemGrid[DRAGON_SOUL_INVENTORY_MAX_NUM];
  399.  
  400. // by mhh
  401. LPITEM pCubeItems[CUBE_MAX_NUM];
  402. LPCHARACTER pCubeNpc;
  403.  
  404. LPCHARACTER battle_victim;
  405.  
  406. BYTE gm_level;
  407.  
  408. BYTE bBasePart; // 평상복 번호
  409.  
  410. int iMaxStamina;
  411.  
  412. BYTE bBlockMode;
  413.  
  414. int iDragonSoulActiveDeck;
  415. LPENTITY m_pDragonSoulRefineWindowOpener;
  416. } CHARACTER_POINT_INSTANT;
  417.  
  418. #define TRIGGERPARAM LPCHARACTER ch, LPCHARACTER causer
  419.  
  420. typedef struct trigger
  421. {
  422. BYTE type;
  423. int (*func) (TRIGGERPARAM);
  424. long value;
  425. } TRIGGER;
  426.  
  427. class CTrigger
  428. {
  429. public:
  430. CTrigger() : bType(0), pFunc(NULL)
  431. {
  432. }
  433.  
  434. BYTE bType;
  435. int (*pFunc) (TRIGGERPARAM);
  436. };
  437.  
  438. EVENTINFO(char_event_info)
  439. {
  440. DynamicCharacterPtr ch;
  441. };
  442.  
  443. struct TSkillUseInfo
  444. {
  445. int iHitCount;
  446. int iMaxHitCount;
  447. int iSplashCount;
  448. DWORD dwNextSkillUsableTime;
  449. int iRange;
  450. bool bUsed;
  451. DWORD dwVID;
  452. bool isGrandMaster;
  453.  
  454. boost::unordered_map<DWORD, size_t> TargetVIDMap;
  455.  
  456. TSkillUseInfo()
  457. : iHitCount(0), iMaxHitCount(0), iSplashCount(0), dwNextSkillUsableTime(0), iRange(0), bUsed(false),
  458. dwVID(0), isGrandMaster(false)
  459. {}
  460.  
  461. bool HitOnce(DWORD dwVnum = 0);
  462.  
  463. bool UseSkill(bool isGrandMaster, DWORD vid, DWORD dwCooltime, int splashcount = 1, int hitcount = -1, int range = -1);
  464. DWORD GetMainTargetVID() const { return dwVID; }
  465. void SetMainTargetVID(DWORD vid) { dwVID=vid; }
  466. void ResetHitCount() { if (iSplashCount) { iHitCount = iMaxHitCount; iSplashCount--; } }
  467. };
  468.  
  469. typedef struct packet_party_update TPacketGCPartyUpdate;
  470. class CExchange;
  471. class CSkillProto;
  472. class CParty;
  473. class CDungeon;
  474. class CWarMap;
  475. class CAffect;
  476. class CGuild;
  477. class CSafebox;
  478. class CArena;
  479.  
  480. #ifdef OFFLINE_SHOP
  481. #include "../libgame/include/grid.h"
  482. typedef struct SPrivShop
  483. {
  484. DWORD shop_id;
  485. DWORD shop_vid;
  486. char szSign[SHOP_SIGN_MAX_LEN + 1];
  487. BYTE item_count;
  488. BYTE rest_count;
  489. BYTE days;
  490. DWORD date_close;
  491. long long gold;
  492.  
  493. } TPrivShop;
  494.  
  495. typedef std::map<DWORD, TPrivShop> PSHOP_MAP;
  496. #endif
  497.  
  498. #ifdef GIFT_SYSTEM
  499. typedef struct SGiftItem
  500. {
  501. DWORD id;
  502. WORD pos;
  503. #ifdef FULL_YANG
  504. long long count;
  505. #else
  506. DWORD count;
  507. #endif
  508. DWORD vnum;
  509. long alSockets[ITEM_SOCKET_MAX_NUM]; // ??A????Ł
  510.  
  511. TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
  512. char szFrom[101];
  513. char szReason[101];
  514. DWORD dwDateAdd;
  515. } TGiftItem;
  516. typedef std::map<int, std::vector<TGiftItem> > GIFT_MAP;
  517. #endif
  518.  
  519. class CShop;
  520. typedef class CShop * LPSHOP;
  521.  
  522. class CMob;
  523. class CMobInstance;
  524. typedef struct SMobSkillInfo TMobSkillInfo;
  525.  
  526. //SKILL_POWER_BY_LEVEL
  527. extern int GetSkillPowerByLevelFromType(int job, int skillgroup, int skilllevel);
  528. //END_SKILL_POWER_BY_LEVEL
  529.  
  530. namespace marriage
  531. {
  532. class WeddingMap;
  533. }
  534. enum e_overtime
  535. {
  536. OT_NONE,
  537. OT_3HOUR,
  538. OT_5HOUR,
  539. };
  540.  
  541. class CHARACTER : public CEntity, public CFSM, public CHorseRider
  542. {
  543. protected:
  544. //////////////////////////////////////////////////////////////////////////////////
  545. // Entity 관련
  546. virtual void EncodeInsertPacket(LPENTITY entity);
  547. virtual void EncodeRemovePacket(LPENTITY entity);
  548. //////////////////////////////////////////////////////////////////////////////////
  549.  
  550. public:
  551. LPCHARACTER FindCharacterInView(const char * name, bool bFindPCOnly);
  552. void UpdatePacket();
  553.  
  554. //////////////////////////////////////////////////////////////////////////////////
  555. // FSM (Finite State Machine) 관련
  556. protected:
  557. CStateTemplate<CHARACTER> m_stateMove;
  558. CStateTemplate<CHARACTER> m_stateBattle;
  559. CStateTemplate<CHARACTER> m_stateIdle;
  560.  
  561. public:
  562. virtual void StateMove();
  563. virtual void StateBattle();
  564. virtual void StateIdle();
  565. virtual void StateFlag();
  566. virtual void StateFlagBase();
  567. void StateHorse();
  568.  
  569. protected:
  570. // STATE_IDLE_REFACTORING
  571. void __StateIdle_Monster();
  572. void __StateIdle_Stone();
  573. void __StateIdle_NPC();
  574. // END_OF_STATE_IDLE_REFACTORING
  575.  
  576. public:
  577. DWORD GetAIFlag() const { return m_pointsInstant.dwAIFlag; }
  578.  
  579. void SetAggressive();
  580. bool IsAggressive() const;
  581.  
  582. void SetCoward();
  583. bool IsCoward() const;
  584. void CowardEscape();
  585.  
  586. void SetNoAttackShinsu();
  587. bool IsNoAttackShinsu() const;
  588.  
  589. void SetNoAttackChunjo();
  590. bool IsNoAttackChunjo() const;
  591.  
  592. void SetNoAttackJinno();
  593. bool IsNoAttackJinno() const;
  594.  
  595. void SetAttackMob();
  596. bool IsAttackMob() const;
  597.  
  598. virtual void BeginStateEmpty() {}
  599. virtual void EndStateEmpty() {}
  600.  
  601. void RestartAtSamePos();
  602.  
  603. protected:
  604. DWORD m_dwStateDuration;
  605. //////////////////////////////////////////////////////////////////////////////////
  606.  
  607. public:
  608. CHARACTER();
  609. virtual ~CHARACTER();
  610.  
  611. void Create(const char * c_pszName, DWORD vid, bool isPC);
  612. void Destroy();
  613.  
  614. void Disconnect(const char * c_pszReason);
  615.  
  616. protected:
  617. void Initialize();
  618.  
  619. //////////////////////////////////////////////////////////////////////////////////
  620. // Basic Points
  621. #ifdef __SEND_TARGET_INFO__
  622. private:
  623. DWORD dwLastTargetInfoPulse;
  624.  
  625. public:
  626. DWORD GetLastTargetInfoPulse() const { return dwLastTargetInfoPulse; }
  627. void SetLastTargetInfoPulse(DWORD pulse) { dwLastTargetInfoPulse = pulse; }
  628. #endif
  629. public:
  630. DWORD GetPlayerID() const { return m_dwPlayerID; }
  631.  
  632. void SetPlayerProto(const TPlayerTable * table);
  633. void CreatePlayerProto(TPlayerTable & tab); // 저장 시 사용
  634.  
  635. void SetProto(const CMob * c_pkMob);
  636. WORD GetRaceNum() const;
  637.  
  638. void Save(); // DelayedSave
  639. void SaveReal(); // 실제 저장
  640. void FlushDelayedSaveItem();
  641.  
  642. const char * GetName() const;
  643. const VID & GetVID() const { return m_vid; }
  644.  
  645. void SetName(const std::string& name) { m_stName = name; }
  646.  
  647. void SetRace(BYTE race);
  648. bool ChangeSex();
  649.  
  650. DWORD GetAID() const;
  651. int GetChangeEmpireCount() const;
  652. void SetChangeEmpireCount();
  653. int ChangeEmpire(BYTE empire);
  654.  
  655. BYTE GetJob() const;
  656. BYTE GetCharType() const;
  657.  
  658. bool IsPC() const { return GetDesc() ? true : false; }
  659. bool IsNPC() const { return m_bCharType != CHAR_TYPE_PC; }
  660. bool IsMonster() const { return m_bCharType == CHAR_TYPE_MONSTER; }
  661. bool IsStone() const { return m_bCharType == CHAR_TYPE_STONE; }
  662. bool IsDoor() const { return m_bCharType == CHAR_TYPE_DOOR; }
  663. bool IsBuilding() const { return m_bCharType == CHAR_TYPE_BUILDING; }
  664. bool IsWarp() const { return m_bCharType == CHAR_TYPE_WARP; }
  665. bool IsGoto() const { return m_bCharType == CHAR_TYPE_GOTO; }
  666. // bool IsPet() const { return m_bCharType == CHAR_TYPE_PET; }
  667.  
  668. DWORD GetLastShoutPulse() const { return m_pointsInstant.dwLastShoutPulse; }
  669. void SetLastShoutPulse(DWORD pulse) { m_pointsInstant.dwLastShoutPulse = pulse; }
  670. int GetLevel() const { return m_points.level; }
  671. void SetLevel(BYTE level);
  672.  
  673. BYTE GetGMLevel() const;
  674. BOOL IsGM() const;
  675. void SetGMLevel();
  676.  
  677. DWORD GetExp() const { return m_points.exp; }
  678. void SetExp(DWORD exp) { m_points.exp = exp; }
  679. DWORD GetNextExp() const;
  680. LPCHARACTER DistributeExp(); // 제일 많이 때린 사람을 리턴한다.
  681. void DistributeHP(LPCHARACTER pkKiller);
  682. void DistributeSP(LPCHARACTER pkKiller, int iMethod=0);
  683.  
  684. void SetPosition(int pos);
  685. bool IsPosition(int pos) const { return m_pointsInstant.position == pos ? true : false; }
  686. int GetPosition() const { return m_pointsInstant.position; }
  687.  
  688. void SetPart(BYTE bPartPos, WORD wVal);
  689. WORD GetPart(BYTE bPartPos) const;
  690. WORD GetOriginalPart(BYTE bPartPos) const;
  691.  
  692. void SetHP(int hp) { m_points.hp = hp; }
  693. int GetHP() const { return m_points.hp; }
  694.  
  695. void SetSP(int sp) { m_points.sp = sp; }
  696. int GetSP() const { return m_points.sp; }
  697.  
  698. void SetStamina(int stamina) { m_points.stamina = stamina; }
  699. int GetStamina() const { return m_points.stamina; }
  700.  
  701. void SetMaxHP(int iVal) { m_pointsInstant.iMaxHP = iVal; }
  702. int GetMaxHP() const { return m_pointsInstant.iMaxHP; }
  703.  
  704. void SetMaxSP(int iVal) { m_pointsInstant.iMaxSP = iVal; }
  705. int GetMaxSP() const { return m_pointsInstant.iMaxSP; }
  706.  
  707. void SetMaxStamina(int iVal) { m_pointsInstant.iMaxStamina = iVal; }
  708. int GetMaxStamina() const { return m_pointsInstant.iMaxStamina; }
  709.  
  710. void SetRandomHP(int v) { m_points.iRandomHP = v; }
  711. void SetRandomSP(int v) { m_points.iRandomSP = v; }
  712.  
  713. int GetRandomHP() const { return m_points.iRandomHP; }
  714. int GetRandomSP() const { return m_points.iRandomSP; }
  715.  
  716. int GetHPPct() const;
  717.  
  718. void SetRealPoint(BYTE idx, int val);
  719. int GetRealPoint(BYTE idx) const;
  720.  
  721. void SetPoint(BYTE idx, long long val);
  722. long long GetPoint(BYTE idx) const;
  723. int GetLimitPoint(BYTE idx) const;
  724. int GetPolymorphPoint(BYTE idx) const;
  725.  
  726. const TMobTable & GetMobTable() const;
  727. BYTE GetMobRank() const;
  728. BYTE GetMobBattleType() const;
  729. BYTE GetMobSize() const;
  730. DWORD GetMobDamageMin() const;
  731. DWORD GetMobDamageMax() const;
  732. WORD GetMobAttackRange() const;
  733. DWORD GetMobDropItemVnum() const;
  734. float GetMobDamageMultiply() const;
  735.  
  736. // NEWAI
  737. bool IsBerserker() const;
  738. bool IsBerserk() const;
  739. void SetBerserk(bool mode);
  740.  
  741. bool IsStoneSkinner() const;
  742.  
  743. bool IsGodSpeeder() const;
  744. bool IsGodSpeed() const;
  745. void SetGodSpeed(bool mode);
  746.  
  747. bool IsDeathBlower() const;
  748. bool IsDeathBlow() const;
  749.  
  750. bool IsReviver() const;
  751. bool HasReviverInParty() const;
  752. bool IsRevive() const;
  753. void SetRevive(bool mode);
  754. // NEWAI END
  755.  
  756. bool IsRaceFlag(DWORD dwBit) const;
  757. bool IsSummonMonster() const;
  758. DWORD GetSummonVnum() const;
  759.  
  760. DWORD GetPolymorphItemVnum() const;
  761. DWORD GetMonsterDrainSPPoint() const;
  762.  
  763. void MainCharacterPacket(); // 내가 메인캐릭터라고 보내준다.
  764.  
  765. void ComputePoints();
  766. void ComputeBattlePoints();
  767. void PointChange(BYTE type, long long amount, bool bAmount = false, bool bBroadcast = false);
  768. void PointsPacket();
  769. void ApplyPoint(BYTE bApplyType, int iVal);
  770. void CheckMaximumPoints(); // HP, SP 등의 현재 값이 최대값 보다 높은지 검사하고 높다면 낮춘다.
  771.  
  772. bool Show(long lMapIndex, long x, long y, long z = LONG_MAX, bool bShowSpawnMotion = false);
  773.  
  774. void Sitdown(int is_ground);
  775. void Standup();
  776.  
  777. void SetRotation(float fRot);
  778. void SetRotationToXY(long x, long y);
  779. float GetRotation() const { return m_pointsInstant.fRot; }
  780.  
  781. void MotionPacketEncode(BYTE motion, LPCHARACTER victim, struct packet_motion * packet);
  782. void Motion(BYTE motion, LPCHARACTER victim = NULL);
  783.  
  784. void ChatPacket(BYTE type, const char *format, ...);
  785. void MonsterChat(BYTE bMonsterChatType);
  786. void SendGreetMessage();
  787. void SaveOfflineMessage(const char* szMsg, DWORD dwTargetPID);
  788. void ClearOfflineMessageBox(DWORD dwTargetPID);
  789. void ReadOfflineMessageBox();
  790.  
  791.  
  792. void ResetPoint(int iLv);
  793.  
  794. void SetBlockMode(BYTE bFlag);
  795. void SetBlockModeForce(BYTE bFlag);
  796. bool IsBlockMode(BYTE bFlag) const { return (m_pointsInstant.bBlockMode & bFlag)?true:false; }
  797.  
  798. bool IsPolymorphed() const { return m_dwPolymorphRace>0; }
  799. bool IsPolyMaintainStat() const { return m_bPolyMaintainStat; } // 이전 스텟을 유지하는 폴리모프.
  800. void SetPolymorph(DWORD dwRaceNum, bool bMaintainStat = false);
  801. DWORD GetPolymorphVnum() const { return m_dwPolymorphRace; }
  802. int GetPolymorphPower() const;
  803.  
  804. // FISING
  805. void fishing();
  806. void fishing_take();
  807. // END_OF_FISHING
  808.  
  809. // MINING
  810. void mining(LPCHARACTER chLoad);
  811. void mining_cancel();
  812. void mining_take();
  813. // END_OF_MINING
  814.  
  815. void ResetPlayTime(DWORD dwTimeRemain = 0);
  816.  
  817. void CreateFly(BYTE bType, LPCHARACTER pkVictim);
  818.  
  819. void ResetChatCounter();
  820. BYTE IncreaseChatCounter();
  821. BYTE GetChatCounter() const;
  822.  
  823. protected:
  824. DWORD m_dwPolymorphRace;
  825. bool m_bPolyMaintainStat;
  826. DWORD m_dwLoginPlayTime;
  827. DWORD m_dwPlayerID;
  828. VID m_vid;
  829. std::string m_stName;
  830. BYTE m_bCharType;
  831.  
  832. CHARACTER_POINT m_points;
  833. CHARACTER_POINT_INSTANT m_pointsInstant;
  834.  
  835. int m_iMoveCount;
  836. DWORD m_dwPlayStartTime;
  837. BYTE m_bAddChrState;
  838. bool m_bSkipSave;
  839. std::string m_stMobile;
  840. char m_szMobileAuth[5];
  841. BYTE m_bChatCounter;
  842.  
  843. // End of Basic Points
  844.  
  845. //////////////////////////////////////////////////////////////////////////////////
  846. // Move & Synchronize Positions
  847. //////////////////////////////////////////////////////////////////////////////////
  848. public:
  849. bool IsStateMove() const { return IsState((CState&)m_stateMove); }
  850. bool IsStateIdle() const { return IsState((CState&)m_stateIdle); }
  851. bool IsWalking() const { return m_bNowWalking || GetStamina()<=0; }
  852. void SetWalking(bool bWalkFlag) { m_bWalking=bWalkFlag; }
  853. void SetNowWalking(bool bWalkFlag);
  854. void ResetWalking() { SetNowWalking(m_bWalking); }
  855.  
  856. bool Goto(long x, long y); // 바로 이동 시키지 않고 목표 위치로 BLENDING 시킨다.
  857. void Stop();
  858.  
  859. bool CanMove() const; // 이동할 수 있는가?
  860.  
  861. void SyncPacket();
  862. bool Sync(long x, long y); // 실제 이 메소드로 이동 한다 (각 종 조건에 의한 이동 불가가 없음)
  863. bool Move(long x, long y); // 조건을 검사하고 Sync 메소드를 통해 이동 한다.
  864. void OnMove(bool bIsAttack = false); // 움직일때 불린다. Move() 메소드 이외에서도 불릴 수 있다.
  865. DWORD GetMotionMode() const;
  866. float GetMoveMotionSpeed() const;
  867. float GetMoveSpeed() const;
  868. void CalculateMoveDuration();
  869. void SendMovePacket(BYTE bFunc, BYTE bArg, DWORD x, DWORD y, DWORD dwDuration, DWORD dwTime=0, int iRot=-1);
  870. DWORD GetCurrentMoveDuration() const { return m_dwMoveDuration; }
  871. DWORD GetWalkStartTime() const { return m_dwWalkStartTime; }
  872. DWORD GetLastMoveTime() const { return m_dwLastMoveTime; }
  873. DWORD GetLastAttackTime() const { return m_dwLastAttackTime; }
  874.  
  875. void SetLastAttacked(DWORD time); // 마지막으로 공격받은 시간 및 위치를 저장함
  876.  
  877. bool SetSyncOwner(LPCHARACTER ch, bool bRemoveFromList = true);
  878. bool IsSyncOwner(LPCHARACTER ch) const;
  879.  
  880. bool WarpSet(long x, long y, long lRealMapIndex = 0);
  881. void SetWarpLocation(long lMapIndex, long x, long y);
  882. void WarpEnd();
  883. const PIXEL_POSITION & GetWarpPosition() const { return m_posWarp; }
  884. bool WarpToPID(DWORD dwPID);
  885.  
  886. void SaveExitLocation();
  887. void ExitToSavedLocation();
  888.  
  889. void StartStaminaConsume();
  890. void StopStaminaConsume();
  891. bool IsStaminaConsume() const;
  892. bool IsStaminaHalfConsume() const;
  893.  
  894. void ResetStopTime();
  895. DWORD GetStopTime() const;
  896.  
  897. protected:
  898. void ClearSync();
  899.  
  900. float m_fSyncTime;
  901. LPCHARACTER m_pkChrSyncOwner;
  902. CHARACTER_LIST m_kLst_pkChrSyncOwned; // 내가 SyncOwner인 자들
  903.  
  904. PIXEL_POSITION m_posDest;
  905. PIXEL_POSITION m_posStart;
  906. PIXEL_POSITION m_posWarp;
  907. long m_lWarpMapIndex;
  908.  
  909. PIXEL_POSITION m_posExit;
  910. long m_lExitMapIndex;
  911.  
  912. DWORD m_dwMoveStartTime;
  913. DWORD m_dwMoveDuration;
  914.  
  915. DWORD m_dwLastMoveTime;
  916. DWORD m_dwLastAttackTime;
  917. DWORD m_dwWalkStartTime;
  918. DWORD m_dwStopTime;
  919.  
  920. bool m_bWalking;
  921. bool m_bNowWalking;
  922. bool m_bStaminaConsume;
  923. // End
  924.  
  925. // Quickslot 관련
  926. public:
  927. void SyncQuickslot(BYTE bType, BYTE bOldPos, BYTE bNewPos);
  928. bool GetQuickslot(BYTE pos, TQuickslot ** ppSlot);
  929. bool SetQuickslot(BYTE pos, TQuickslot & rSlot);
  930. bool DelQuickslot(BYTE pos);
  931. bool SwapQuickslot(BYTE a, BYTE b);
  932. void ChainQuickslotItem(LPITEM pItem, BYTE bType, BYTE bOldPos);
  933.  
  934. protected:
  935. TQuickslot m_quickslot[QUICKSLOT_MAX_NUM];
  936.  
  937. ////////////////////////////////////////////////////////////////////////////////////////
  938. // Affect
  939. public:
  940. void StartAffectEvent();
  941. void ClearAffect(bool bSave=false);
  942. void ComputeAffect(CAffect * pkAff, bool bAdd);
  943. bool AddAffect(DWORD dwType, BYTE bApplyOn, long lApplyValue, DWORD dwFlag, long lDuration, long lSPCost, bool bOverride, bool IsCube = false);
  944. void RefreshAffect();
  945. bool RemoveAffect(DWORD dwType);
  946. bool IsAffectFlag(DWORD dwAff) const;
  947.  
  948. bool UpdateAffect(); // called from EVENT
  949. int ProcessAffect();
  950.  
  951. void LoadAffect(DWORD dwCount, TPacketAffectElement * pElements);
  952. void SaveAffect();
  953.  
  954. // Affect loading이 끝난 상태인가?
  955. bool IsLoadedAffect() const { return m_bIsLoadedAffect; }
  956.  
  957. bool IsGoodAffect(BYTE bAffectType) const;
  958.  
  959. void RemoveGoodAffect();
  960. void RemoveBadAffect();
  961.  
  962. CAffect * FindAffect(DWORD dwType, BYTE bApply=APPLY_NONE) const;
  963. const std::list<CAffect *> & GetAffectContainer() const { return m_list_pkAffect; }
  964. bool RemoveAffect(CAffect * pkAff);
  965.  
  966. protected:
  967. bool m_bIsLoadedAffect;
  968. TAffectFlag m_afAffectFlag;
  969. std::list<CAffect *> m_list_pkAffect;
  970.  
  971. public:
  972. // PARTY_JOIN_BUG_FIX
  973. void SetParty(LPPARTY pkParty);
  974. LPPARTY GetParty() const { return m_pkParty; }
  975.  
  976. bool RequestToParty(LPCHARACTER leader);
  977. void DenyToParty(LPCHARACTER member);
  978. void AcceptToParty(LPCHARACTER member);
  979.  
  980. /// 자신의 파티에 다른 character 를 초대한다.
  981. /**
  982. * @param pchInvitee 초대할 대상 character. 파티에 참여 가능한 상태이어야 한다.
  983. *
  984. * 양측 character 의 상태가 파티에 초대하고 초대받을 수 있는 상태가 아니라면 초대하는 캐릭터에게 해당하는 채팅 메세지를 전송한다.
  985. */
  986. void PartyInvite(LPCHARACTER pchInvitee);
  987.  
  988. /// 초대했던 character 의 수락을 처리한다.
  989. /**
  990. * @param pchInvitee 파티에 참여할 character. 파티에 참여가능한 상태이어야 한다.
  991. *
  992. * pchInvitee 가 파티에 가입할 수 있는 상황이 아니라면 해당하는 채팅 메세지를 전송한다.
  993. */
  994. void PartyInviteAccept(LPCHARACTER pchInvitee);
  995.  
  996. /// 초대했던 character 의 초대 거부를 처리한다.
  997. /**
  998. * @param [in] dwPID 초대 했던 character 의 PID
  999. */
  1000. void PartyInviteDeny(DWORD dwPID);
  1001.  
  1002. bool BuildUpdatePartyPacket(TPacketGCPartyUpdate & out);
  1003. int GetLeadershipSkillLevel() const;
  1004.  
  1005. bool CanSummon(int iLeaderShip);
  1006.  
  1007. void SetPartyRequestEvent(LPEVENT pkEvent) { m_pkPartyRequestEvent = pkEvent; }
  1008.  
  1009. protected:
  1010.  
  1011. /// 파티에 가입한다.
  1012. /**
  1013. * @param pkLeader 가입할 파티의 리더
  1014. */
  1015. void PartyJoin(LPCHARACTER pkLeader);
  1016.  
  1017. /**
  1018. * 파티 가입을 할 수 없을 경우의 에러코드.
  1019. * Error code 는 시간에 의존적인가에 따라 변경가능한(mutable) type 과 정적(static) type 으로 나뉜다.
  1020. * Error code 의 값이 PERR_SEPARATOR 보다 낮으면 변경가능한 type 이고 높으면 정적 type 이다.
  1021. */
  1022. enum PartyJoinErrCode {
  1023. PERR_NONE = 0, ///< 처리성공
  1024. PERR_SERVER, ///< 서버문제로 파티관련 처리 불가
  1025. PERR_DUNGEON, ///< 캐릭터가 던전에 있음
  1026. PERR_OBSERVER, ///< 관전모드임
  1027. PERR_LVBOUNDARY, ///< 상대 캐릭터와 레벨차이가 남
  1028. PERR_LOWLEVEL, ///< 상대파티의 최고레벨보다 30레벨 낮음
  1029. PERR_HILEVEL, ///< 상대파티의 최저레벨보다 30레벨 높음
  1030. PERR_ALREADYJOIN, ///< 파티가입 대상 캐릭터가 이미 파티중
  1031. PERR_PARTYISFULL, ///< 파티인원 제한 초과
  1032. PERR_SEPARATOR, ///< Error type separator.
  1033. PERR_DIFFEMPIRE, ///< 상대 캐릭터와 다른 제국임
  1034. PERR_MAX ///< Error code 최고치. 이 앞에 Error code 를 추가한다.
  1035. };
  1036.  
  1037. /// 파티 가입이나 결성 가능한 조건을 검사한다.
  1038. /**
  1039. * @param pchLeader 파티의 leader 이거나 초대한 character
  1040. * @param pchGuest 초대받는 character
  1041. * @return 모든 PartyJoinErrCode 가 반환될 수 있다.
  1042. */
  1043. static PartyJoinErrCode IsPartyJoinableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest);
  1044.  
  1045. /// 파티 가입이나 결성 가능한 동적인 조건을 검사한다.
  1046. /**
  1047. * @param pchLeader 파티의 leader 이거나 초대한 character
  1048. * @param pchGuest 초대받는 character
  1049. * @return mutable type 의 code 만 반환한다.
  1050. */
  1051. static PartyJoinErrCode IsPartyJoinableMutableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest);
  1052.  
  1053. LPPARTY m_pkParty;
  1054. DWORD m_dwLastDeadTime;
  1055. LPEVENT m_pkPartyRequestEvent;
  1056.  
  1057. /**
  1058. * 파티초청 Event map.
  1059. * key: 초대받은 캐릭터의 PID
  1060. * value: event의 pointer
  1061. *
  1062. * 초대한 캐릭터들에 대한 event map.
  1063. */
  1064. typedef std::map< DWORD, LPEVENT > EventMap;
  1065. EventMap m_PartyInviteEventMap;
  1066.  
  1067. // END_OF_PARTY_JOIN_BUG_FIX
  1068.  
  1069. ////////////////////////////////////////////////////////////////////////////////////////
  1070. // Dungeon
  1071. public:
  1072. void SetDungeon(LPDUNGEON pkDungeon);
  1073. LPDUNGEON GetDungeon() const { return m_pkDungeon; }
  1074. LPDUNGEON GetDungeonForce() const;
  1075. protected:
  1076. LPDUNGEON m_pkDungeon;
  1077. int m_iEventAttr;
  1078.  
  1079. ////////////////////////////////////////////////////////////////////////////////////////
  1080. // Guild
  1081. public:
  1082. void SetGuild(CGuild * pGuild);
  1083. CGuild* GetGuild() const { return m_pGuild; }
  1084.  
  1085. void SetWarMap(CWarMap* pWarMap);
  1086. CWarMap* GetWarMap() const { return m_pWarMap; }
  1087.  
  1088. protected:
  1089. CGuild * m_pGuild;
  1090. DWORD m_dwUnderGuildWarInfoMessageTime;
  1091. CWarMap * m_pWarMap;
  1092.  
  1093. ////////////////////////////////////////////////////////////////////////////////////////
  1094. // Item related
  1095. public:
  1096. bool CanHandleItem(bool bSkipRefineCheck = false, bool bSkipObserver = false); // 아이템 관련 행위를 할 수 있는가?
  1097.  
  1098. bool IsItemLoaded() const { return m_bItemLoaded; }
  1099. void SetItemLoaded() { m_bItemLoaded = true; }
  1100.  
  1101. void ClearItem();
  1102. void SetItem(TItemPos Cell, LPITEM item);
  1103. LPITEM GetItem(TItemPos Cell) const;
  1104. LPITEM GetInventoryItem(WORD wCell) const;
  1105. bool IsEmptyItemGrid(TItemPos Cell, BYTE size, int iExceptionCell = -1) const;
  1106.  
  1107. void SetWear(BYTE bCell, LPITEM item);
  1108. LPITEM GetWear(BYTE bCell) const;
  1109.  
  1110. // MYSHOP_PRICE_LIST
  1111. void UseSilkBotary(void); /// 비단 보따리 아이템의 사용
  1112.  
  1113. /// DB 캐시로 부터 받아온 가격정보 리스트를 유저에게 전송하고 보따리 아이템 사용을 처리한다.
  1114. /**
  1115. * @param [in] p 가격정보 리스트 패킷
  1116. *
  1117. * 접속한 후 처음 비단 보따리 아이템 사용 시 UseSilkBotary 에서 DB 캐시로 가격정보 리스트를 요청하고
  1118. * 응답받은 시점에 이 함수에서 실제 비단보따리 사용을 처리한다.
  1119. */
  1120. void UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p);
  1121. // END_OF_MYSHOP_PRICE_LIST
  1122.  
  1123. bool UseItemEx(LPITEM item, TItemPos DestCell);
  1124. bool UseItem(TItemPos Cell, TItemPos DestCell = NPOS);
  1125.  
  1126. // ADD_REFINE_BUILDING
  1127. bool IsRefineThroughGuild() const;
  1128. CGuild * GetRefineGuild() const;
  1129. int ComputeRefineFee(int iCost, int iMultiply = 5) const;
  1130. void PayRefineFee(int iTotalMoney);
  1131. void SetRefineNPC(LPCHARACTER ch);
  1132. // END_OF_ADD_REFINE_BUILDING
  1133.  
  1134. bool RefineItem(LPITEM pkItem, LPITEM pkTarget);
  1135. bool DropItem(TItemPos Cell, BYTE bCount=0);
  1136. bool GiveRecallItem(LPITEM item);
  1137. void ProcessRecallItem(LPITEM item);
  1138.  
  1139. // void PotionPacket(int iPotionType);
  1140. void EffectPacket(int enumEffectType);
  1141. void SpecificEffectPacket(const char filename[128]);
  1142.  
  1143. // ADD_MONSTER_REFINE
  1144. bool DoRefine(LPITEM item, bool bMoneyOnly = false);
  1145. // END_OF_ADD_MONSTER_REFINE
  1146.  
  1147. bool DoRefineWithScroll(LPITEM item);
  1148. bool RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell = -1);
  1149.  
  1150. void SetRefineMode(int iAdditionalCell = -1);
  1151. void ClearRefineMode();
  1152.  
  1153. bool GiveItem(LPCHARACTER victim, TItemPos Cell);
  1154. bool CanReceiveItem(LPCHARACTER from, LPITEM item) const;
  1155. void ReceiveItem(LPCHARACTER from, LPITEM item);
  1156. bool GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector <DWORD> &dwItemVnums,
  1157. std::vector <DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count);
  1158.  
  1159. bool MoveItem(TItemPos pos, TItemPos change_pos, BYTE num);
  1160. bool PickupItem(DWORD vid);
  1161. bool EquipItem(LPITEM item, int iCandidateCell = -1);
  1162. bool UnequipItem(LPITEM item);
  1163.  
  1164. // 현재 item을 착용할 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
  1165. bool CanEquipNow(const LPITEM item, const TItemPos& srcCell = NPOS, const TItemPos& destCell = NPOS);
  1166.  
  1167. // 착용중인 item을 벗을 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
  1168. bool CanUnequipNow(const LPITEM item, const TItemPos& srcCell = NPOS, const TItemPos& destCell = NPOS);
  1169.  
  1170. bool SwapItem(BYTE bCell, BYTE bDestCell);
  1171. LPITEM AutoGiveItem(DWORD dwItemVnum, BYTE bCount=1, int iRarePct = -1, bool bMsg = true);
  1172. void AutoGiveItem(LPITEM item, bool longOwnerShip = false);
  1173.  
  1174. int GetEmptyInventory(BYTE size) const;
  1175. int GetEmptyDragonSoulInventory(LPITEM pItem) const;
  1176. void CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const;
  1177.  
  1178. int CountEmptyInventory() const;
  1179.  
  1180. int CountSpecifyItem(DWORD vnum) const;
  1181. void RemoveSpecifyItem(DWORD vnum, DWORD count = 1);
  1182. LPITEM FindSpecifyItem(DWORD vnum) const;
  1183. LPITEM FindItemByID(DWORD id) const;
  1184.  
  1185. int CountSpecifyTypeItem(BYTE type) const;
  1186. void RemoveSpecifyTypeItem(BYTE type, DWORD count = 1);
  1187.  
  1188. bool IsEquipUniqueItem(DWORD dwItemVnum) const;
  1189.  
  1190. // CHECK_UNIQUE_GROUP
  1191. bool IsEquipUniqueGroup(DWORD dwGroupVnum) const;
  1192. // END_OF_CHECK_UNIQUE_GROUP
  1193.  
  1194. void SendEquipment(LPCHARACTER ch);
  1195. // End of Item
  1196.  
  1197. protected:
  1198.  
  1199. /// 한 아이템에 대한 가격정보를 전송한다.
  1200. /**
  1201. * @param [in] dwItemVnum 아이템 vnum
  1202. * @param [in] dwItemPrice 아이템 가격
  1203. */
  1204. void SendMyShopPriceListCmd(DWORD dwItemVnum, long long dwItemPrice);
  1205.  
  1206. bool m_bNoOpenedShop; ///< 이번 접속 후 개인상점을 연 적이 있는지의 여부(열었던 적이 없다면 true)
  1207.  
  1208. bool m_bItemLoaded;
  1209. int m_iRefineAdditionalCell;
  1210. bool m_bUnderRefine;
  1211. DWORD m_dwRefineNPCVID;
  1212.  
  1213. public:
  1214. ////////////////////////////////////////////////////////////////////////////////////////
  1215. // Money related
  1216. long long GetGold() const { return m_points.gold; }
  1217. void SetGold(long long gold) { m_points.gold = gold; }
  1218. bool DropGold(INT gold);
  1219. long long GetAllowedGold() const;
  1220. void GiveGold(long long iAmount); // 파티가 있으면 파티 분배, 로그 등의 처리
  1221. // End of Money
  1222.  
  1223. ////////////////////////////////////////////////////////////////////////////////////////
  1224. // Shop related
  1225. public:
  1226. void SetShop(LPSHOP pkShop);
  1227. LPSHOP GetShop() const { return m_pkShop; }
  1228. void ShopPacket(BYTE bSubHeader);
  1229.  
  1230. void SetShopOwner(LPCHARACTER ch) { m_pkChrShopOwner = ch; }
  1231. LPCHARACTER GetShopOwner() const { return m_pkChrShopOwner;}
  1232.  
  1233. void OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount);
  1234. LPSHOP GetMyShop() const { return m_pkMyShop; }
  1235. void CloseMyShop();
  1236.  
  1237. protected:
  1238.  
  1239. LPSHOP m_pkShop;
  1240. LPSHOP m_pkMyShop;
  1241. std::string m_stShopSign;
  1242. LPCHARACTER m_pkChrShopOwner;
  1243. // End of shop
  1244.  
  1245. ////////////////////////////////////////////////////////////////////////////////////////
  1246. // Exchange related
  1247. public:
  1248. bool ExchangeStart(LPCHARACTER victim);
  1249. void SetExchange(CExchange * pkExchange);
  1250. CExchange * GetExchange() const { return m_pkExchange; }
  1251.  
  1252. protected:
  1253. CExchange * m_pkExchange;
  1254. // End of Exchange
  1255.  
  1256. ////////////////////////////////////////////////////////////////////////////////////////
  1257. // Battle
  1258. public:
  1259. struct TBattleInfo
  1260. {
  1261. int iTotalDamage;
  1262. int iAggro;
  1263.  
  1264. TBattleInfo(int iTot, int iAggr)
  1265. : iTotalDamage(iTot), iAggro(iAggr)
  1266. {}
  1267. };
  1268. typedef std::map<VID, TBattleInfo> TDamageMap;
  1269.  
  1270. typedef struct SAttackLog
  1271. {
  1272. DWORD dwVID;
  1273. DWORD dwTime;
  1274. } AttackLog;
  1275.  
  1276. bool Damage(LPCHARACTER pAttacker, int dam, EDamageType type = DAMAGE_TYPE_NORMAL);
  1277. bool __Profile__Damage(LPCHARACTER pAttacker, int dam, EDamageType type = DAMAGE_TYPE_NORMAL);
  1278. void DeathPenalty(BYTE bExpLossPercent);
  1279. void ReviveInvisible(int iDur);
  1280.  
  1281. bool Attack(LPCHARACTER pkVictim, BYTE bType = 0);
  1282. bool IsAlive() const { return m_pointsInstant.position == POS_DEAD ? false : true; }
  1283. bool CanFight() const;
  1284.  
  1285. bool CanBeginFight() const;
  1286. void BeginFight(LPCHARACTER pkVictim); // pkVictimr과 싸우기 시작한다. (강제적임, 시작할 수 있나 체크하려면 CanBeginFight을 사용)
  1287.  
  1288. bool CounterAttack(LPCHARACTER pkChr); // 반격하기 (몬스터만 사용)
  1289.  
  1290. bool IsStun() const;
  1291. void Stun();
  1292. bool IsDead() const;
  1293. void Dead(LPCHARACTER pkKiller = NULL, bool bImmediateDead=false);
  1294.  
  1295. void Reward(bool bItemDrop);
  1296. void RewardGold(LPCHARACTER pkAttacker);
  1297.  
  1298. bool Shoot(BYTE bType);
  1299. void FlyTarget(DWORD dwTargetVID, long x, long y, BYTE bHeader);
  1300.  
  1301. void ForgetMyAttacker();
  1302. void AggregateMonster();
  1303. void AttractRanger();
  1304. void PullMonster();
  1305.  
  1306. int GetArrowAndBow(LPITEM * ppkBow, LPITEM * ppkArrow, int iArrowCount = 1);
  1307. void UseArrow(LPITEM pkArrow, DWORD dwArrowCount);
  1308.  
  1309. void AttackedByPoison(LPCHARACTER pkAttacker);
  1310. void RemovePoison();
  1311.  
  1312. void AttackedByFire(LPCHARACTER pkAttacker, int amount, int count);
  1313. void RemoveFire();
  1314.  
  1315. void UpdateAlignment(int iAmount);
  1316. int GetAlignment() const;
  1317.  
  1318. //선악치 얻기
  1319. int GetRealAlignment() const;
  1320. void ShowAlignment(bool bShow);
  1321.  
  1322. void SetKillerMode(bool bOn);
  1323. bool IsKillerMode() const;
  1324. void UpdateKillerMode();
  1325.  
  1326. BYTE GetPKMode() const;
  1327. void SetPKMode(BYTE bPKMode);
  1328.  
  1329. void ItemDropPenalty(LPCHARACTER pkKiller);
  1330.  
  1331. void UpdateAggrPoint(LPCHARACTER ch, EDamageType type, int dam);
  1332.  
  1333. //
  1334. // HACK
  1335. //
  1336. public:
  1337. void SetComboSequence(BYTE seq);
  1338. BYTE GetComboSequence() const;
  1339.  
  1340. void SetLastComboTime(DWORD time);
  1341. DWORD GetLastComboTime() const;
  1342.  
  1343. int GetValidComboInterval() const;
  1344. void SetValidComboInterval(int interval);
  1345.  
  1346. BYTE GetComboIndex() const;
  1347.  
  1348. void IncreaseComboHackCount(int k = 1);
  1349. void ResetComboHackCount();
  1350. void SkipComboAttackByTime(int interval);
  1351. DWORD GetSkipComboAttackByTime() const;
  1352.  
  1353. protected:
  1354. BYTE m_bComboSequence;
  1355. DWORD m_dwLastComboTime;
  1356. int m_iValidComboInterval;
  1357. BYTE m_bComboIndex;
  1358. int m_iComboHackCount;
  1359. DWORD m_dwSkipComboAttackByTime;
  1360.  
  1361. protected:
  1362. void UpdateAggrPointEx(LPCHARACTER ch, EDamageType type, int dam, TBattleInfo & info);
  1363. void ChangeVictimByAggro(int iNewAggro, LPCHARACTER pNewVictim);
  1364.  
  1365. DWORD m_dwFlyTargetID;
  1366. std::vector<DWORD> m_vec_dwFlyTargets;
  1367. TDamageMap m_map_kDamage; // 어떤 캐릭터가 나에게 얼마만큼의 데미지를 주었는가?
  1368. // AttackLog m_kAttackLog;
  1369. DWORD m_dwKillerPID;
  1370.  
  1371. int m_iAlignment; // Lawful/Chaotic value -200000 ~ 200000
  1372. int m_iRealAlignment;
  1373. int m_iKillerModePulse;
  1374. BYTE m_bPKMode;
  1375.  
  1376. // Aggro
  1377. DWORD m_dwLastVictimSetTime;
  1378. int m_iMaxAggro;
  1379. // End of Battle
  1380.  
  1381. // Stone
  1382. public:
  1383. void SetStone(LPCHARACTER pkChrStone);
  1384. void ClearStone();
  1385. void DetermineDropMetinStone();
  1386. DWORD GetDropMetinStoneVnum() const { return m_dwDropMetinStone; }
  1387. BYTE GetDropMetinStonePct() const { return m_bDropMetinStonePct; }
  1388.  
  1389. protected:
  1390. LPCHARACTER m_pkChrStone; // 나를 스폰한 돌
  1391. CHARACTER_SET m_set_pkChrSpawnedBy; // 내가 스폰한 놈들
  1392. DWORD m_dwDropMetinStone;
  1393. BYTE m_bDropMetinStonePct;
  1394. // End of Stone
  1395.  
  1396. public:
  1397. enum
  1398. {
  1399. SKILL_UP_BY_POINT,
  1400. SKILL_UP_BY_BOOK,
  1401. SKILL_UP_BY_TRAIN,
  1402.  
  1403. // ADD_GRANDMASTER_SKILL
  1404. SKILL_UP_BY_QUEST,
  1405. // END_OF_ADD_GRANDMASTER_SKILL
  1406. };
  1407.  
  1408. void SkillLevelPacket();
  1409. void SkillLevelUp(DWORD dwVnum, BYTE bMethod = SKILL_UP_BY_POINT);
  1410. bool SkillLevelDown(DWORD dwVnum);
  1411. // ADD_GRANDMASTER_SKILL
  1412. bool UseSkill(DWORD dwVnum, LPCHARACTER pkVictim, bool bUseGrandMaster = true);
  1413. void ResetSkill();
  1414. void SetSkillLevel(DWORD dwVnum, BYTE bLev);
  1415. int GetUsedSkillMasterType(DWORD dwVnum);
  1416.  
  1417. bool IsLearnableSkill(DWORD dwSkillVnum) const;
  1418. // END_OF_ADD_GRANDMASTER_SKILL
  1419.  
  1420. bool CheckSkillHitCount(const BYTE SkillID, const VID dwTargetVID);
  1421. bool CanUseSkill(DWORD dwSkillVnum) const;
  1422. bool IsUsableSkillMotion(DWORD dwMotionIndex) const;
  1423. int GetSkillLevel(DWORD dwVnum) const;
  1424. int GetSkillMasterType(DWORD dwVnum) const;
  1425. int GetSkillPower(DWORD dwVnum, BYTE bLevel = 0) const;
  1426.  
  1427. time_t GetSkillNextReadTime(DWORD dwVnum) const;
  1428. void SetSkillNextReadTime(DWORD dwVnum, time_t time);
  1429. void SkillLearnWaitMoreTimeMessage(DWORD dwVnum);
  1430.  
  1431. void ComputePassiveSkill(DWORD dwVnum);
  1432. int ComputeSkill(DWORD dwVnum, LPCHARACTER pkVictim, BYTE bSkillLevel = 0);
  1433. int ComputeSkillAtPosition(DWORD dwVnum, const PIXEL_POSITION& posTarget, BYTE bSkillLevel = 0);
  1434. void ComputeSkillPoints();
  1435.  
  1436. void SetSkillGroup(BYTE bSkillGroup);
  1437. BYTE GetSkillGroup() const { return m_points.skill_group; }
  1438.  
  1439. int ComputeCooltime(int time);
  1440.  
  1441. void GiveRandomSkillBook();
  1442.  
  1443. void DisableCooltime();
  1444. bool LearnSkillByBook(DWORD dwSkillVnum, BYTE bProb = 0);
  1445. bool LearnGrandMasterSkill(DWORD dwSkillVnum);
  1446.  
  1447. private:
  1448. bool m_bDisableCooltime;
  1449. DWORD m_dwLastSkillTime; ///< 마지막으로 skill 을 쓴 시간(millisecond).
  1450. // End of Skill
  1451.  
  1452. // MOB_SKILL
  1453. public:
  1454. bool HasMobSkill() const;
  1455. size_t CountMobSkill() const;
  1456. const TMobSkillInfo * GetMobSkill(unsigned int idx) const;
  1457. bool CanUseMobSkill(unsigned int idx) const;
  1458. bool UseMobSkill(unsigned int idx);
  1459. void ResetMobSkillCooltime();
  1460. protected:
  1461. DWORD m_adwMobSkillCooltime[MOB_SKILL_MAX_NUM];
  1462. // END_OF_MOB_SKILL
  1463.  
  1464. // for SKILL_MUYEONG
  1465. public:
  1466. void StartMuyeongEvent();
  1467. void StopMuyeongEvent();
  1468.  
  1469. private:
  1470. LPEVENT m_pkMuyeongEvent;
  1471.  
  1472. // for SKILL_CHAIN lighting
  1473. public:
  1474. int GetChainLightningIndex() const { return m_iChainLightingIndex; }
  1475. void IncChainLightningIndex() { ++m_iChainLightingIndex; }
  1476. void AddChainLightningExcept(LPCHARACTER ch) { m_setExceptChainLighting.insert(ch); }
  1477. void ResetChainLightningIndex() { m_iChainLightingIndex = 0; m_setExceptChainLighting.clear(); }
  1478. int GetChainLightningMaxCount() const;
  1479. const CHARACTER_SET& GetChainLightingExcept() const { return m_setExceptChainLighting; }
  1480.  
  1481. private:
  1482. int m_iChainLightingIndex;
  1483. CHARACTER_SET m_setExceptChainLighting;
  1484.  
  1485. // for SKILL_EUNHYUNG
  1486. public:
  1487. void SetAffectedEunhyung();
  1488. void ClearAffectedEunhyung() { m_dwAffectedEunhyungLevel = 0; }
  1489. bool GetAffectedEunhyung() const { return m_dwAffectedEunhyungLevel; }
  1490.  
  1491. private:
  1492. DWORD m_dwAffectedEunhyungLevel;
  1493.  
  1494. //
  1495. // Skill levels
  1496. //
  1497. protected:
  1498. TPlayerSkill* m_pSkillLevels;
  1499. boost::unordered_map<BYTE, int> m_SkillDamageBonus;
  1500. std::map<int, TSkillUseInfo> m_SkillUseInfo;
  1501.  
  1502. ////////////////////////////////////////////////////////////////////////////////////////
  1503. // AI related
  1504. public:
  1505. void AssignTriggers(const TMobTable * table);
  1506. LPCHARACTER GetVictim() const; // 공격할 대상 리턴
  1507. void SetVictim(LPCHARACTER pkVictim);
  1508. LPCHARACTER GetNearestVictim(LPCHARACTER pkChr);
  1509. LPCHARACTER GetProtege() const; // 보호해야 할 대상 리턴
  1510.  
  1511. bool Follow(LPCHARACTER pkChr, float fMinimumDistance = 150.0f);
  1512. bool Return();
  1513. bool IsGuardNPC() const;
  1514. bool IsChangeAttackPosition(LPCHARACTER target) const;
  1515. void ResetChangeAttackPositionTime() { m_dwLastChangeAttackPositionTime = get_dword_time() - AI_CHANGE_ATTACK_POISITION_TIME_NEAR;}
  1516. void SetChangeAttackPositionTime() { m_dwLastChangeAttackPositionTime = get_dword_time();}
  1517.  
  1518. bool OnIdle();
  1519.  
  1520. void OnAttack(LPCHARACTER pkChrAttacker);
  1521. void OnClick(LPCHARACTER pkChrCauser);
  1522.  
  1523. VID m_kVIDVictim;
  1524.  
  1525. protected:
  1526. DWORD m_dwLastChangeAttackPositionTime;
  1527. CTrigger m_triggerOnClick;
  1528. // End of AI
  1529.  
  1530. ////////////////////////////////////////////////////////////////////////////////////////
  1531. // Target
  1532. protected:
  1533. LPCHARACTER m_pkChrTarget; // 내 타겟
  1534. CHARACTER_SET m_set_pkChrTargetedBy; // 나를 타겟으로 가지고 있는 사람들
  1535.  
  1536. public:
  1537. void SetTarget(LPCHARACTER pkChrTarget);
  1538. void BroadcastTargetPacket();
  1539. void ClearTarget();
  1540. void CheckTarget();
  1541. LPCHARACTER GetTarget() const { return m_pkChrTarget; }
  1542.  
  1543. ////////////////////////////////////////////////////////////////////////////////////////
  1544. // Safebox
  1545. public:
  1546. int GetSafeboxSize() const;
  1547. void QuerySafeboxSize();
  1548. void SetSafeboxSize(int size);
  1549.  
  1550. CSafebox * GetSafebox() const;
  1551. void LoadSafebox(int iSize, DWORD dwGold, int iItemCount, TPlayerItem * pItems);
  1552. void ChangeSafeboxSize(BYTE bSize);
  1553. void CloseSafebox();
  1554.  
  1555. /// 창고 열기 요청
  1556. /**
  1557. * @param [in] pszPassword 1자 이상 6자 이하의 창고 비밀번호
  1558. *
  1559. * DB 에 창고열기를 요청한다.
  1560. * 창고는 중복으로 열지 못하며, 최근 창고를 닫은 시간으로 부터 10초 이내에는 열 지 못한다.
  1561. */
  1562. void ReqSafeboxLoad(const char* pszPassword);
  1563.  
  1564. /// 창고 열기 요청의 취소
  1565. /**
  1566. * ReqSafeboxLoad 를 호출하고 CloseSafebox 하지 않았을 때 이 함수를 호출하면 창고를 열 수 있다.
  1567. * 창고열기의 요청이 DB 서버에서 실패응답을 받았을 경우 이 함수를 사용해서 요청을 할 수 있게 해준다.
  1568. */
  1569. void CancelSafeboxLoad( void ) { m_bOpeningSafebox = false; }
  1570.  
  1571. void SetMallLoadTime(int t) { m_iMallLoadTime = t; }
  1572. int GetMallLoadTime() const { return m_iMallLoadTime; }
  1573.  
  1574. CSafebox * GetMall() const;
  1575. void LoadMall(int iItemCount, TPlayerItem * pItems);
  1576. void CloseMall();
  1577.  
  1578. void SetSafeboxOpenPosition();
  1579. float GetDistanceFromSafeboxOpen() const;
  1580.  
  1581. protected:
  1582. CSafebox * m_pkSafebox;
  1583. int m_iSafeboxSize;
  1584. int m_iSafeboxLoadTime;
  1585. bool m_bOpeningSafebox; ///< 창고가 열기 요청 중이거나 열려있는가 여부, true 일 경우 열기요청이거나 열려있음.
  1586.  
  1587. CSafebox * m_pkMall;
  1588. int m_iMallLoadTime;
  1589.  
  1590. PIXEL_POSITION m_posSafeboxOpen;
  1591.  
  1592. ////////////////////////////////////////////////////////////////////////////////////////
  1593.  
  1594. ////////////////////////////////////////////////////////////////////////////////////////
  1595. // Mounting
  1596. public:
  1597. void MountVnum(DWORD vnum);
  1598. DWORD GetMountVnum() const { return m_dwMountVnum; }
  1599. DWORD GetLastMountTime() const { return m_dwMountTime; }
  1600.  
  1601. bool CanUseHorseSkill();
  1602.  
  1603. // Horse
  1604. virtual void SetHorseLevel(int iLevel);
  1605.  
  1606. virtual bool StartRiding();
  1607. virtual bool StopRiding();
  1608.  
  1609. virtual DWORD GetMyHorseVnum() const;
  1610.  
  1611. virtual void HorseDie();
  1612. virtual bool ReviveHorse();
  1613.  
  1614. virtual void SendHorseInfo();
  1615. virtual void ClearHorseInfo();
  1616.  
  1617. void HorseSummon(bool bSummon, bool bFromFar = false, DWORD dwVnum = 0, const char* name = 0);
  1618.  
  1619. LPCHARACTER GetHorse() const { return m_chHorse; } // 현재 소환중인 말
  1620. LPCHARACTER GetRider() const; // rider on horse
  1621. void SetRider(LPCHARACTER ch);
  1622.  
  1623. bool IsRiding() const;
  1624.  
  1625. #ifdef __PET_SYSTEM__
  1626. public:
  1627. CPetSystem* GetPetSystem() { return m_petSystem; }
  1628.  
  1629. protected:
  1630. CPetSystem* m_petSystem;
  1631.  
  1632. public:
  1633. #endif
  1634.  
  1635. protected:
  1636. LPCHARACTER m_chHorse;
  1637. LPCHARACTER m_chRider;
  1638.  
  1639. DWORD m_dwMountVnum;
  1640. DWORD m_dwMountTime;
  1641.  
  1642. BYTE m_bSendHorseLevel;
  1643. BYTE m_bSendHorseHealthGrade;
  1644. BYTE m_bSendHorseStaminaGrade;
  1645.  
  1646. ////////////////////////////////////////////////////////////////////////////////////////
  1647. // Detailed Log
  1648. public:
  1649. void DetailLog() { m_bDetailLog = !m_bDetailLog; }
  1650. private:
  1651. bool m_bDetailLog;
  1652.  
  1653. ////////////////////////////////////////////////////////////////////////////////////////
  1654. // Empire
  1655.  
  1656. public:
  1657. void SetEmpire(BYTE bEmpire);
  1658. BYTE GetEmpire() const { return m_bEmpire; }
  1659.  
  1660. protected:
  1661. BYTE m_bEmpire;
  1662.  
  1663. ////////////////////////////////////////////////////////////////////////////////////////
  1664. // Regen
  1665. public:
  1666. void SetRegen(LPREGEN pkRegen);
  1667.  
  1668. protected:
  1669. PIXEL_POSITION m_posRegen;
  1670. float m_fRegenAngle;
  1671. LPREGEN m_pkRegen;
  1672. size_t regen_id_; // to help dungeon regen identification
  1673. // End of Regen
  1674.  
  1675. ////////////////////////////////////////////////////////////////////////////////////////
  1676. // Resists & Proofs
  1677. public:
  1678. bool CannotMoveByAffect() const; // 특정 효과에 의해 움직일 수 없는 상태인가?
  1679. bool IsImmune(DWORD dwImmuneFlag);
  1680. void SetImmuneFlag(DWORD dw) { m_pointsInstant.dwImmuneFlag = dw; }
  1681.  
  1682. protected:
  1683. void ApplyMobAttribute(const TMobTable* table);
  1684. // End of Resists & Proofs
  1685.  
  1686. ////////////////////////////////////////////////////////////////////////////////////////
  1687. // QUEST
  1688. //
  1689. public:
  1690. void SetQuestNPCID(DWORD vid);
  1691. DWORD GetQuestNPCID() const { return m_dwQuestNPCVID; }
  1692. LPCHARACTER GetQuestNPC() const;
  1693.  
  1694. void SetQuestItemPtr(LPITEM item);
  1695. void ClearQuestItemPtr();
  1696. #ifdef ENABLE_BIOLOG_SYSTEM
  1697. int GetBiologState(const std::string& state) const;
  1698. void SetBiologState(const std::string& state, int szValue);
  1699. #endif
  1700. LPITEM GetQuestItemPtr() const;
  1701.  
  1702. void SetQuestBy(DWORD dwQuestVnum) { m_dwQuestByVnum = dwQuestVnum; }
  1703. DWORD GetQuestBy() const { return m_dwQuestByVnum; }
  1704.  
  1705. int GetQuestFlag(const std::string& flag) const;
  1706. void SetQuestFlag(const std::string& flag, int value);
  1707.  
  1708. void ConfirmWithMsg(const char* szMsg, int iTimeout, DWORD dwRequestPID);
  1709.  
  1710. private:
  1711. DWORD m_dwQuestNPCVID;
  1712. DWORD m_dwQuestByVnum;
  1713. LPITEM m_pQuestItem;
  1714.  
  1715. // Events
  1716. public:
  1717. bool StartStateMachine(int iPulse = 1);
  1718. void StopStateMachine();
  1719. void UpdateStateMachine(DWORD dwPulse);
  1720. void SetNextStatePulse(int iPulseNext);
  1721.  
  1722. // 캐릭터 인스턴스 업데이트 함수. 기존엔 이상한 상속구조로 CFSM::Update 함수를 호출하거나 UpdateStateMachine 함수를 사용했는데, 별개의 업데이트 함수 추가함.
  1723. void UpdateCharacter(DWORD dwPulse);
  1724.  
  1725. protected:
  1726. DWORD m_dwNextStatePulse;
  1727.  
  1728. // Marriage
  1729. public:
  1730. LPCHARACTER GetMarryPartner() const;
  1731. void SetMarryPartner(LPCHARACTER ch);
  1732. int GetMarriageBonus(DWORD dwItemVnum, bool bSum = true);
  1733.  
  1734. void SetWeddingMap(marriage::WeddingMap* pMap);
  1735. marriage::WeddingMap* GetWeddingMap() const { return m_pWeddingMap; }
  1736.  
  1737. private:
  1738. marriage::WeddingMap* m_pWeddingMap;
  1739. LPCHARACTER m_pkChrMarried;
  1740.  
  1741. // Warp Character
  1742. public:
  1743. void StartWarpNPCEvent();
  1744.  
  1745. public:
  1746. void StartSaveEvent();
  1747. void StartRecoveryEvent();
  1748. void StartCheckSpeedHackEvent();
  1749. void StartDestroyWhenIdleEvent();
  1750.  
  1751. LPEVENT m_pkDeadEvent;
  1752. LPEVENT m_pkStunEvent;
  1753. LPEVENT m_pkSaveEvent;
  1754. LPEVENT m_pkRecoveryEvent;
  1755. LPEVENT m_pkTimedEvent;
  1756. LPEVENT m_pkFishingEvent;
  1757. LPEVENT m_pkAffectEvent;
  1758. LPEVENT m_pkPoisonEvent;
  1759. LPEVENT m_pkFireEvent;
  1760. LPEVENT m_pkWarpNPCEvent;
  1761. //DELAYED_WARP
  1762. //END_DELAYED_WARP
  1763.  
  1764. // MINING
  1765. LPEVENT m_pkMiningEvent;
  1766. // END_OF_MINING
  1767. LPEVENT m_pkWarpEvent;
  1768. LPEVENT m_pkCheckSpeedHackEvent;
  1769. LPEVENT m_pkDestroyWhenIdleEvent;
  1770. LPEVENT m_pkPetSystemUpdateEvent;
  1771.  
  1772. bool IsWarping() const { return m_pkWarpEvent ? true : false; }
  1773.  
  1774. bool m_bHasPoisoned;
  1775.  
  1776. const CMob * m_pkMobData;
  1777. CMobInstance * m_pkMobInst;
  1778.  
  1779. std::map<int, LPEVENT> m_mapMobSkillEvent;
  1780.  
  1781. friend struct FuncSplashDamage;
  1782. friend struct FuncSplashAffect;
  1783. friend class CFuncShoot;
  1784.  
  1785. public:
  1786. int GetPremiumRemainSeconds(BYTE bType) const;
  1787.  
  1788. private:
  1789. int m_aiPremiumTimes[PREMIUM_MAX_NUM];
  1790.  
  1791. // CHANGE_ITEM_ATTRIBUTES
  1792. static const DWORD msc_dwDefaultChangeItemAttrCycle; ///< 디폴트 아이템 속성변경 가능 주기
  1793. static const char msc_szLastChangeItemAttrFlag[]; ///< 최근 아이템 속성을 변경한 시간의 Quest Flag 이름
  1794. static const char msc_szChangeItemAttrCycleFlag[]; ///< 아이템 속성병경 가능 주기의 Quest Flag 이름
  1795. // END_OF_CHANGE_ITEM_ATTRIBUTES
  1796.  
  1797. // NEW_HAIR_STYLE_ADD
  1798. public :
  1799. bool ItemProcess_Hair(LPITEM item, int iDestCell);
  1800. // END_NEW_HAIR_STYLE_ADD
  1801.  
  1802. public :
  1803. void ClearSkill();
  1804. void ClearSubSkill();
  1805.  
  1806. // RESET_ONE_SKILL
  1807. bool ResetOneSkill(DWORD dwVnum);
  1808. // END_RESET_ONE_SKILL
  1809.  
  1810. private :
  1811. void SendDamagePacket(LPCHARACTER pAttacker, int Damage, BYTE DamageFlag);
  1812.  
  1813. // ARENA
  1814. private :
  1815. CArena *m_pArena;
  1816. bool m_ArenaObserver;
  1817. int m_nPotionLimit;
  1818.  
  1819. public :
  1820. void SetArena(CArena* pArena) { m_pArena = pArena; }
  1821. void SetArenaObserverMode(bool flag) { m_ArenaObserver = flag; }
  1822.  
  1823. CArena* GetArena() const { return m_pArena; }
  1824. bool GetArenaObserverMode() const { return m_ArenaObserver; }
  1825.  
  1826. void SetPotionLimit(int count) { m_nPotionLimit = count; }
  1827. int GetPotionLimit() const { return m_nPotionLimit; }
  1828. // END_ARENA
  1829.  
  1830. //PREVENT_TRADE_WINDOW
  1831. public:
  1832. bool IsOpenSafebox() const { return m_isOpenSafebox ? true : false; }
  1833. void SetOpenSafebox(bool b) { m_isOpenSafebox = b; }
  1834.  
  1835. int GetSafeboxLoadTime() const { return m_iSafeboxLoadTime; }
  1836. void SetSafeboxLoadTime() { m_iSafeboxLoadTime = thecore_pulse(); }
  1837. //END_PREVENT_TRADE_WINDOW
  1838. private:
  1839. bool m_isOpenSafebox;
  1840.  
  1841. public:
  1842. int GetSkillPowerByLevel(int level, bool bMob = false) const;
  1843.  
  1844. //PREVENT_REFINE_HACK
  1845. int GetRefineTime() const { return m_iRefineTime; }
  1846. void SetRefineTime() { m_iRefineTime = thecore_pulse(); }
  1847. int m_iRefineTime;
  1848. //END_PREVENT_REFINE_HACK
  1849.  
  1850. //RESTRICT_USE_SEED_OR_MOONBOTTLE
  1851. int GetUseSeedOrMoonBottleTime() const { return m_iSeedTime; }
  1852. void SetUseSeedOrMoonBottleTime() { m_iSeedTime = thecore_pulse(); }
  1853. int m_iSeedTime;
  1854. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  1855.  
  1856. //PREVENT_PORTAL_AFTER_EXCHANGE
  1857. int GetExchangeTime() const { return m_iExchangeTime; }
  1858. void SetExchangeTime() { m_iExchangeTime = thecore_pulse(); }
  1859. int m_iExchangeTime;
  1860. //END_PREVENT_PORTAL_AFTER_EXCHANGE
  1861.  
  1862. int m_iMyShopTime;
  1863. int GetMyShopTime() const { return m_iMyShopTime; }
  1864. void SetMyShopTime() { m_iMyShopTime = thecore_pulse(); }
  1865.  
  1866. // Hack 방지를 위한 체크.
  1867. bool IsHack(bool bSendMsg = true, bool bCheckShopOwner = true, int limittime = g_nPortalLimitTime);
  1868.  
  1869. // MONARCH
  1870. BOOL IsMonarch() const;
  1871. // END_MONARCH
  1872. void Say(const std::string & s);
  1873.  
  1874. enum MONARCH_COOLTIME
  1875. {
  1876. MC_HEAL = 10,
  1877. MC_WARP = 60,
  1878. MC_TRANSFER = 60,
  1879. MC_TAX = (60 * 60 * 24 * 7),
  1880. MC_SUMMON = (60 * 60),
  1881. };
  1882.  
  1883. enum MONARCH_INDEX
  1884. {
  1885. MI_HEAL = 0,
  1886. MI_WARP,
  1887. MI_TRANSFER,
  1888. MI_TAX,
  1889. MI_SUMMON,
  1890. MI_MAX
  1891. };
  1892.  
  1893. DWORD m_dwMonarchCooltime[MI_MAX];
  1894. DWORD m_dwMonarchCooltimelimit[MI_MAX];
  1895.  
  1896. void InitMC();
  1897. DWORD GetMC(enum MONARCH_INDEX e) const;
  1898. void SetMC(enum MONARCH_INDEX e);
  1899. bool IsMCOK(enum MONARCH_INDEX e) const;
  1900. DWORD GetMCL(enum MONARCH_INDEX e) const;
  1901. DWORD GetMCLTime(enum MONARCH_INDEX e) const;
  1902.  
  1903. public:
  1904. bool ItemProcess_Polymorph(LPITEM item);
  1905.  
  1906. // by mhh
  1907. LPITEM* GetCubeItem() { return m_pointsInstant.pCubeItems; }
  1908. bool IsCubeOpen () const { return (m_pointsInstant.pCubeNpc?true:false); }
  1909. void SetCubeNpc(LPCHARACTER npc) { m_pointsInstant.pCubeNpc = npc; }
  1910. bool CanDoCube() const;
  1911.  
  1912. public:
  1913. bool IsSiegeNPC() const;
  1914.  
  1915. private:
  1916. //중국 전용
  1917. //18세 미만 전용
  1918. //3시간 : 50 % 5 시간 0%
  1919. e_overtime m_eOverTime;
  1920.  
  1921. public:
  1922. bool IsOverTime(e_overtime e) const { return (e == m_eOverTime); }
  1923. void SetOverTime(e_overtime e) { m_eOverTime = e; }
  1924.  
  1925. private:
  1926. int m_deposit_pulse;
  1927.  
  1928. public:
  1929. void UpdateDepositPulse();
  1930. bool CanDeposit() const;
  1931.  
  1932. private:
  1933. void __OpenPrivateShop();
  1934.  
  1935. public:
  1936. struct AttackedLog
  1937. {
  1938. DWORD dwPID;
  1939. DWORD dwAttackedTime;
  1940.  
  1941. AttackedLog() : dwPID(0), dwAttackedTime(0)
  1942. {
  1943. }
  1944. };
  1945.  
  1946. AttackLog m_kAttackLog;
  1947. AttackedLog m_AttackedLog;
  1948. int m_speed_hack_count;
  1949.  
  1950. private :
  1951. std::string m_strNewName;
  1952.  
  1953. public :
  1954. const std::string GetNewName() const { return this->m_strNewName; }
  1955. void SetNewName(const std::string name) { this->m_strNewName = name; }
  1956.  
  1957. public :
  1958. void GoHome();
  1959.  
  1960. private :
  1961. std::set<DWORD> m_known_guild;
  1962.  
  1963. public :
  1964. void SendGuildName(CGuild* pGuild);
  1965. void SendGuildName(DWORD dwGuildID);
  1966.  
  1967. private :
  1968. DWORD m_dwLogOffInterval;
  1969.  
  1970. public :
  1971. DWORD GetLogOffInterval() const { return m_dwLogOffInterval; }
  1972.  
  1973. public:
  1974. bool UnEquipSpecialRideUniqueItem ();
  1975.  
  1976. bool CanWarp () const;
  1977.  
  1978. private:
  1979. DWORD m_dwLastGoldDropTime;
  1980.  
  1981. public:
  1982. void AutoRecoveryItemProcess (const EAffectTypes);
  1983.  
  1984. public:
  1985. void BuffOnAttr_AddBuffsFromItem(LPITEM pItem);
  1986. void BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem);
  1987.  
  1988. private:
  1989. void BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue);
  1990. void BuffOnAttr_ClearAll();
  1991.  
  1992. typedef std::map <BYTE, CBuffOnAttributes*> TMapBuffOnAttrs;
  1993. TMapBuffOnAttrs m_map_buff_on_attrs;
  1994. // 무적 : 원활한 테스트를 위하여.
  1995. public:
  1996. void SetArmada() { cannot_dead = true; }
  1997. void ResetArmada() { cannot_dead = false; }
  1998. private:
  1999. bool cannot_dead;
  2000.  
  2001. #ifdef __PET_SYSTEM__
  2002. private:
  2003. bool m_bIsPet;
  2004. public:
  2005. void SetPet() { m_bIsPet = true; }
  2006. bool IsPet() { return m_bIsPet; }
  2007. #endif
  2008.  
  2009. //최종 데미지 보정.
  2010. private:
  2011. float m_fAttMul;
  2012. float m_fDamMul;
  2013. public:
  2014. float GetAttMul() { return this->m_fAttMul; }
  2015. void SetAttMul(float newAttMul) {this->m_fAttMul = newAttMul; }
  2016. float GetDamMul() { return this->m_fDamMul; }
  2017. void SetDamMul(float newDamMul) {this->m_fDamMul = newDamMul; }
  2018.  
  2019. private:
  2020. bool IsValidItemPosition(TItemPos Pos) const;
  2021.  
  2022. //독일 선물 기능 패킷 임시 저장
  2023. private:
  2024. unsigned int itemAward_vnum;
  2025. char itemAward_cmd[20];
  2026. //bool itemAward_flag;
  2027. public:
  2028. unsigned int GetItemAward_vnum() { return itemAward_vnum; }
  2029. char* GetItemAward_cmd() { return itemAward_cmd; }
  2030. //bool GetItemAward_flag() { return itemAward_flag; }
  2031. void SetItemAward_vnum(unsigned int vnum) { itemAward_vnum = vnum; }
  2032. void SetItemAward_cmd(char* cmd) { strcpy(itemAward_cmd,cmd); }
  2033. //void SetItemAward_flag(bool flag) { itemAward_flag = flag; }
  2034.  
  2035. public:
  2036. //용혼석
  2037.  
  2038. // 캐릭터의 affect, quest가 load 되기 전에 DragonSoul_Initialize를 호출하면 안된다.
  2039. // affect가 가장 마지막에 로드되어 LoadAffect에서 호출함.
  2040. void DragonSoul_Initialize();
  2041.  
  2042. bool DragonSoul_IsQualified() const;
  2043. void DragonSoul_GiveQualification();
  2044.  
  2045. int DragonSoul_GetActiveDeck() const;
  2046. bool DragonSoul_IsDeckActivated() const;
  2047. bool DragonSoul_ActivateDeck(int deck_idx);
  2048.  
  2049. void DragonSoul_DeactivateAll();
  2050. // 반드시 ClearItem 전에 불러야 한다.
  2051. // 왜냐하면....
  2052. // 용혼석 하나 하나를 deactivate할 때마다 덱에 active인 용혼석이 있는지 확인하고,
  2053. // active인 용혼석이 하나도 없다면, 캐릭터의 용혼석 affect와, 활성 상태를 제거한다.
  2054. //
  2055. // 하지만 ClearItem 시, 캐릭터가 착용하고 있는 모든 아이템을 unequip하는 바람에,
  2056. // 용혼석 Affect가 제거되고, 결국 로그인 시, 용혼석이 활성화되지 않는다.
  2057. // (Unequip할 때에는 로그아웃 상태인지, 아닌지 알 수 없다.)
  2058. // 용혼석만 deactivate시키고 캐릭터의 용혼석 덱 활성 상태는 건드리지 않는다.
  2059. void DragonSoul_CleanUp();
  2060. // 용혼석 강화창
  2061. public:
  2062. bool DragonSoul_RefineWindow_Open(LPENTITY pEntity);
  2063. bool DragonSoul_RefineWindow_Close();
  2064. LPENTITY DragonSoul_RefineWindow_GetOpener() { return m_pointsInstant.m_pDragonSoulRefineWindowOpener; }
  2065. bool DragonSoul_RefineWindow_CanRefine();
  2066.  
  2067. private:
  2068. // SyncPosition을 악용하여 타유저를 이상한 곳으로 보내는 핵 방어하기 위하여,
  2069. // SyncPosition이 일어날 때를 기록.
  2070. timeval m_tvLastSyncTime;
  2071. int m_iSyncHackCount;
  2072. public:
  2073. void SetLastSyncTime(const timeval &tv) { memcpy(&m_tvLastSyncTime, &tv, sizeof(timeval)); }
  2074. const timeval& GetLastSyncTime() { return m_tvLastSyncTime; }
  2075. void SetSyncHackCount(int iCount) { m_iSyncHackCount = iCount;}
  2076. int GetSyncHackCount() { return m_iSyncHackCount; }
  2077.  
  2078. #ifdef OFFLINE_SHOP
  2079. public:
  2080. void OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount, DWORD days);
  2081. void SendShops(bool isGm = false);
  2082. void OpenShop(DWORD id, const char *name, bool onboot = false);
  2083. void SetPrivShop(DWORD shop_id) { bprivShop = shop_id; }
  2084. BOOL IsPrivShop(void) const { return bprivShop>0; }
  2085. DWORD GetPrivShop() const { return bprivShop; }
  2086. void SetPrivShopOwner(DWORD id) { bprivShopOwner = id; }
  2087. DWORD GetPrivShopOwner() const { return bprivShopOwner; }
  2088. void DeleteMyShop();
  2089. DWORD GetShopTime() const { return dw_ShopTime; }
  2090. void SetShopTime(DWORD time) { dw_ShopTime = time; }
  2091. void SetShopSign(const char * name);
  2092. void LoadPrivShops();
  2093. TPrivShop GetPrivShopTable(DWORD id);
  2094. void RemovePrivShopTable(DWORD id);
  2095. void UpdatePrivShopTable(DWORD id, TPrivShop shop);
  2096. void UpdateShopItems();
  2097. void SendShopCost();
  2098. private:
  2099. PSHOP_MAP m_mapshops;
  2100. DWORD bprivShop;
  2101. DWORD bprivShopOwner;
  2102. DWORD dw_ShopTime;
  2103. public:
  2104. void StartRefreshShopEvent();
  2105. protected:
  2106. LPEVENT m_pkRefreshShopEvent;
  2107. #endif
  2108.  
  2109. #ifdef GIFT_SYSTEM
  2110. protected:
  2111. void AddGiftGrid(int page);
  2112. int AddGiftGridItem(int page, int size);
  2113. GIFT_MAP m_mapGiftGrid;
  2114. LPEVENT m_pkGiftRefresh;
  2115. DWORD m_dwLastGiftPage;
  2116. public:
  2117. void StartRefreshGift();
  2118. void LoadGiftPage(int page);
  2119. void RefreshGift();
  2120. int GetGiftPages() { return m_mapGiftGrid.size(); }
  2121. int GetLastGiftPage() { return m_dwLastGiftPage; }
  2122. #endif
  2123. };
  2124.  
  2125. ESex GET_SEX(LPCHARACTER ch);
  2126.  
  2127. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!