API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 18th, 2019
162
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 74.28 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.     // PC_BANG_ITEM_ADD
  264.     POINT_PC_BANG_EXP_BONUS,        // 125 PCąć Ŕüżë °ćÇčġ ş¸łĘ˝ş
  265.     POINT_PC_BANG_DROP_BONUS,       // 126 PCąć Ŕüżë µĺ·Ó·ü ş¸łĘ˝ş
  266.     // END_PC_BANG_ITEM_ADD
  267.     POINT_RAMADAN_CANDY_BONUS_EXP,          // ¶ó¸¶´Ü »çĹÁ °ćÇčġ Áő°ˇżë
  268.  
  269.     POINT_ENERGY = 128,                 // 128 ±â·Â
  270.  
  271.     // ±â·Â ui żë.
  272.     // Ľ­ąöżˇĽ­ ľ˛Áö ľĘ±â¸¸, Ŭ¶óŔĚľđĆ®żˇĽ­ ±â·ÂŔÇ łˇ ˝Ă°ŁŔ» POINT·Î °ü¸®Çϱ⠶§ą®żˇ ŔĚ·¸°Ô ÇŃ´Ů.
  273.     // ľĆ şÎ˛ô·´´Ů
  274.     POINT_ENERGY_END_TIME = 129,                    // 129 ±â·Â Áľ·á ˝Ă°Ł
  275.  
  276.     POINT_COSTUME_ATTR_BONUS = 130,
  277.     POINT_MAGIC_ATT_BONUS_PER = 131,
  278.     POINT_MELEE_MAGIC_ATT_BONUS_PER = 132,
  279.  
  280.     // Ăß°ˇ ĽÓĽş ŔúÇ×
  281.     POINT_RESIST_ICE = 133,          //   łĂ±â ŔúÇ×   : ľóŔ˝°ř°Ýżˇ ´ëÇŃ ´ëąĚÁö °¨ĽŇ
  282.     POINT_RESIST_EARTH = 134,        //   ´ëÁö ŔúÇ×   : ľóŔ˝°ř°Ýżˇ ´ëÇŃ ´ëąĚÁö °¨ĽŇ
  283.     POINT_RESIST_DARK = 135,         //   ľîµŇ ŔúÇ×   : ľóŔ˝°ř°Ýżˇ ´ëÇŃ ´ëąĚÁö °¨ĽŇ
  284.  
  285.     POINT_RESIST_CRITICAL = 136,        // Ĺ©¸®ĆĽÄĂ ŔúÇ×    : »ó´ëŔÇ Ĺ©¸®ĆĽÄĂ Č®·üŔ» °¨ĽŇ
  286.     POINT_RESIST_PENETRATE = 137,       // °üĹëŸ°Ý ŔúÇ×    : »ó´ëŔÇ °üĹëŸ°Ý Č®·üŔ» °¨ĽŇ
  287.  
  288. #ifdef ENABLE_CHEQUE_SYSTEM
  289.     POINT_CHEQUE = 145,
  290. #endif
  291.     //POINT_MAX_NUM = 129   common/length.h
  292. };
  293.  
  294. enum EPKModes
  295. {
  296.     PK_MODE_PEACE,
  297.     PK_MODE_REVENGE,
  298.     PK_MODE_FREE,
  299.     PK_MODE_PROTECT,
  300.     PK_MODE_GUILD,
  301.     PK_MODE_MAX_NUM
  302. };
  303.  
  304. enum EPositions
  305. {
  306.     POS_DEAD,
  307.     POS_SLEEPING,
  308.     POS_RESTING,
  309.     POS_SITTING,
  310.     POS_FISHING,
  311.     POS_FIGHTING,
  312.     POS_MOUNTING,
  313.     POS_STANDING
  314. };
  315.  
  316. enum EBlockAction
  317. {
  318.     BLOCK_EXCHANGE      = (1 << 0),
  319.     BLOCK_PARTY_INVITE      = (1 << 1),
  320.     BLOCK_GUILD_INVITE      = (1 << 2),
  321.     BLOCK_WHISPER       = (1 << 3),
  322.     BLOCK_MESSENGER_INVITE  = (1 << 4),
  323.     BLOCK_PARTY_REQUEST     = (1 << 5),
  324. };
  325.  
  326. // <Factor> Dynamically evaluated CHARACTER* equivalent.
  327. // Referring to SCharDeadEventInfo.
  328. struct DynamicCharacterPtr {
  329.     DynamicCharacterPtr() : is_pc(false), id(0) {}
  330.     DynamicCharacterPtr(const DynamicCharacterPtr& o)
  331.         : is_pc(o.is_pc), id(o.id) {}
  332.  
  333.     // Returns the LPCHARACTER found in CHARACTER_MANAGER.
  334.     LPCHARACTER Get() const;
  335.     // Clears the current settings.
  336.     void Reset() {
  337.         is_pc = false;
  338.         id = 0;
  339.     }
  340.  
  341.     // Basic assignment operator.
  342.     DynamicCharacterPtr& operator=(const DynamicCharacterPtr& rhs) {
  343.         is_pc = rhs.is_pc;
  344.         id = rhs.id;
  345.         return *this;
  346.     }
  347.     // Supports assignment with LPCHARACTER type.
  348.     DynamicCharacterPtr& operator=(LPCHARACTER character);
  349.     // Supports type casting to LPCHARACTER.
  350.     operator LPCHARACTER() const {
  351.         return Get();
  352.     }
  353.  
  354.     bool is_pc;
  355.     uint32_t id;
  356. };
  357.  
  358. /* ŔúŔĺÇĎ´Â µĄŔĚĹÍ */
  359. typedef struct character_point
  360. {
  361.     long long       points[POINT_MAX_NUM];
  362.  
  363.     BYTE            job;
  364.     BYTE            voice;
  365.  
  366.     BYTE            level;
  367.     DWORD           exp;
  368.     long long       gold;
  369. #ifdef ENABLE_CHEQUE_SYSTEM
  370.     BYTE            cheque;
  371. #endif
  372.  
  373.     int             hp;
  374.     int             sp;
  375.  
  376.     int             iRandomHP;
  377.     int             iRandomSP;
  378.  
  379.     int             stamina;
  380.  
  381.     BYTE            skill_group;
  382. } CHARACTER_POINT;
  383.  
  384. /* ŔúŔĺµÇÁö ľĘ´Â Äł¸ŻĹÍ µĄŔĚĹÍ */
  385. typedef struct character_point_instant
  386. {
  387.     long long       points[POINT_MAX_NUM];
  388.  
  389.     float           fRot;
  390.  
  391.     int             iMaxHP;
  392.     int             iMaxSP;
  393.  
  394.     long            position;
  395.  
  396.     long            instant_flag;
  397.     DWORD           dwAIFlag;
  398.     DWORD           dwImmuneFlag;
  399.     DWORD           dwLastShoutPulse;
  400.  
  401.     WORD            parts[PART_MAX_NUM];
  402.  
  403.     LPITEM          pItems[INVENTORY_AND_EQUIP_SLOT_MAX];
  404.     UINT            bItemGrid[INVENTORY_AND_EQUIP_SLOT_MAX];
  405.  
  406.     // żëČĄĽ® ŔÎşĄĹ丮.
  407.     LPITEM          pDSItems[DRAGON_SOUL_INVENTORY_MAX_NUM];
  408.     WORD            wDSItemGrid[DRAGON_SOUL_INVENTORY_MAX_NUM];
  409.  
  410.     // by mhh
  411.     LPITEM          pCubeItems[CUBE_MAX_NUM];
  412.     LPCHARACTER     pCubeNpc;
  413.     #ifdef __SASH_SYSTEM__
  414.     LPITEM          pSashMaterials[SASH_WINDOW_MAX_MATERIALS];
  415.     #endif
  416.  
  417.     LPCHARACTER         battle_victim;
  418.  
  419.     BYTE            gm_level;
  420.  
  421.     BYTE            bBasePart;  // Ćň»óşą ąřČŁ
  422.  
  423.     int             iMaxStamina;
  424.  
  425.     BYTE            bBlockMode;
  426.  
  427.     int             iDragonSoulActiveDeck;
  428.     LPENTITY        m_pDragonSoulRefineWindowOpener;
  429. } CHARACTER_POINT_INSTANT;
  430.  
  431. #define TRIGGERPARAM        LPCHARACTER ch, LPCHARACTER causer
  432.  
  433. typedef struct trigger
  434. {
  435.     BYTE    type;
  436.     int     (*func) (TRIGGERPARAM);
  437.     long    value;
  438. } TRIGGER;
  439.  
  440. class CTrigger
  441. {
  442.     public:
  443.         CTrigger() : bType(0), pFunc(NULL)
  444.         {
  445.         }
  446.  
  447.         BYTE    bType;
  448.         int (*pFunc) (TRIGGERPARAM);
  449. };
  450.  
  451. EVENTINFO(char_event_info)
  452. {
  453.     DynamicCharacterPtr ch;
  454. };
  455.  
  456. struct TSkillUseInfo
  457. {
  458.     int     iHitCount;
  459.     int     iMaxHitCount;
  460.     int     iSplashCount;
  461.     DWORD   dwNextSkillUsableTime;
  462.     int     iRange;
  463.     bool    bUsed;
  464.     DWORD   dwVID;
  465.     bool    isGrandMaster;
  466.  
  467.     boost::unordered_map<VID, size_t> TargetVIDMap;
  468.  
  469.     TSkillUseInfo()
  470.         : iHitCount(0), iMaxHitCount(0), iSplashCount(0), dwNextSkillUsableTime(0), iRange(0), bUsed(false),
  471.         dwVID(0), isGrandMaster(false)
  472.     {}
  473.  
  474.     bool    HitOnce(DWORD dwVnum = 0);
  475.  
  476.     bool    UseSkill(bool isGrandMaster, DWORD vid, DWORD dwCooltime, int splashcount = 1, int hitcount = -1, int range = -1);
  477.     DWORD   GetMainTargetVID() const    { return dwVID; }
  478.     void    SetMainTargetVID(DWORD vid) { dwVID=vid; }
  479.     void    ResetHitCount() { if (iSplashCount) { iHitCount = iMaxHitCount; iSplashCount--; } }
  480. };
  481.  
  482. typedef struct packet_party_update TPacketGCPartyUpdate;
  483. class CExchange;
  484. class CSkillProto;
  485. class CParty;
  486. class CDungeon;
  487. class CWarMap;
  488. class CAffect;
  489. class CGuild;
  490. class CSafebox;
  491. class CArena;
  492.  
  493. #ifdef OFFLINE_SHOP
  494. #include "../libgame/include/grid.h"
  495. typedef struct SPrivShop
  496. {
  497.     DWORD   shop_id;
  498.     DWORD   shop_vid;
  499.     char    szSign[SHOP_SIGN_MAX_LEN + 1];
  500.     BYTE    item_count;
  501.     BYTE    rest_count;
  502.     BYTE    days;
  503.     DWORD   date_close;
  504.     long long gold;
  505. #ifdef ENABLE_CHEQUE_SYSTEM
  506.     int cash;
  507. #endif
  508. } TPrivShop;
  509.  
  510. typedef std::map<DWORD, TPrivShop> PSHOP_MAP;
  511. #endif
  512.  
  513. #ifdef GIFT_SYSTEM
  514. typedef struct SGiftItem
  515. {
  516.     DWORD   id;
  517.     WORD    pos;
  518. #ifdef FULL_YANG
  519.     long long    count;
  520. #else
  521.     DWORD count;
  522. #endif
  523.     DWORD   vnum;
  524.     long    alSockets[ITEM_SOCKET_MAX_NUM]; // ĽŇÄĎąřČŁ
  525.  
  526.     TPlayerItemAttribute    aAttr[ITEM_ATTRIBUTE_MAX_NUM];
  527.     char szFrom[101];
  528.     char szReason[101];
  529.     DWORD dwDateAdd;
  530. } TGiftItem;
  531. typedef std::map<int, std::vector<TGiftItem> > GIFT_MAP;
  532. #endif
  533.  
  534. class CShop;
  535. typedef class CShop * LPSHOP;
  536.  
  537. class CMob;
  538. class CMobInstance;
  539. typedef struct SMobSkillInfo TMobSkillInfo;
  540.  
  541. //SKILL_POWER_BY_LEVEL
  542. extern int GetSkillPowerByLevelFromType(int job, int skillgroup, int skilllevel);
  543. //END_SKILL_POWER_BY_LEVEL
  544.  
  545. namespace marriage
  546. {
  547.     class WeddingMap;
  548. }
  549. enum e_overtime
  550. {
  551.     OT_NONE,
  552.     OT_3HOUR,
  553.     OT_5HOUR,
  554. };
  555.  
  556. class CHARACTER : public CEntity, public CFSM, public CHorseRider
  557. {
  558.     protected:
  559.         //////////////////////////////////////////////////////////////////////////////////
  560.         // Entity °ü·Ă
  561.         virtual void    EncodeInsertPacket(LPENTITY entity);
  562.         virtual void    EncodeRemovePacket(LPENTITY entity);
  563.         //////////////////////////////////////////////////////////////////////////////////
  564.  
  565.     public:
  566.         LPCHARACTER         FindCharacterInView(const char * name, bool bFindPCOnly);
  567.         void                UpdatePacket();
  568.  
  569.         //////////////////////////////////////////////////////////////////////////////////
  570.         // FSM (Finite State Machine) °ü·Ă
  571.     protected:
  572.         CStateTemplate<CHARACTER>   m_stateMove;
  573.         CStateTemplate<CHARACTER>   m_stateBattle;
  574.         CStateTemplate<CHARACTER>   m_stateIdle;
  575.  
  576.     public:
  577.         virtual void        StateMove();
  578.         virtual void        StateBattle();
  579.         virtual void        StateIdle();
  580.         virtual void        StateFlag();
  581.         virtual void        StateFlagBase();
  582.         void                StateHorse();
  583.  
  584.     protected:
  585.         // STATE_IDLE_REFACTORING
  586.         void                __StateIdle_Monster();
  587.         void                __StateIdle_Stone();
  588.         void                __StateIdle_NPC();
  589.         // END_OF_STATE_IDLE_REFACTORING
  590.  
  591.     public:
  592.         DWORD GetAIFlag() const { return m_pointsInstant.dwAIFlag; }
  593.    
  594.         void                SetAggressive();
  595.         bool                IsAggressive() const;
  596.  
  597.         void                SetCoward();
  598.         bool                IsCoward() const;
  599.         void                CowardEscape();
  600.  
  601.         void                SetNoAttackShinsu();
  602.         bool                IsNoAttackShinsu() const;
  603.  
  604.         void                SetNoAttackChunjo();
  605.         bool                IsNoAttackChunjo() const;
  606.  
  607.         void                SetNoAttackJinno();
  608.         bool                IsNoAttackJinno() const;
  609.  
  610.         void                SetAttackMob();
  611.         bool                IsAttackMob() const;
  612.  
  613.         virtual void            BeginStateEmpty();
  614.         virtual void            EndStateEmpty() {}
  615.  
  616.         void                RestartAtSamePos();
  617.  
  618.     protected:
  619.         DWORD               m_dwStateDuration;
  620.         //////////////////////////////////////////////////////////////////////////////////
  621.  
  622.     public:
  623.         CHARACTER();
  624.         virtual ~CHARACTER();
  625.  
  626.         void            Create(const char * c_pszName, DWORD vid, bool isPC);
  627.         void            Destroy();
  628.  
  629.         void            Disconnect(const char * c_pszReason);
  630.  
  631.     protected:
  632.         void            Initialize();
  633.  
  634.         //////////////////////////////////////////////////////////////////////////////////
  635.         // Basic Points
  636. #ifdef __SEND_TARGET_INFO__
  637.     private:
  638.         DWORD           dwLastTargetInfoPulse;
  639.  
  640.     public:
  641.         DWORD           GetLastTargetInfoPulse() const  { return dwLastTargetInfoPulse; }
  642.         void            SetLastTargetInfoPulse(DWORD pulse) { dwLastTargetInfoPulse = pulse; }
  643. #endif
  644.  
  645.     public:
  646.         DWORD           GetPlayerID() const { return m_dwPlayerID; }
  647.  
  648.         void            SetPlayerProto(const TPlayerTable * table);
  649.         void            CreatePlayerProto(TPlayerTable & tab);  // ŔúŔĺ ˝Ă »çżë
  650.  
  651.         void            SetProto(const CMob * c_pkMob);
  652.         WORD            GetRaceNum() const;
  653.  
  654.         void            Save();     // DelayedSave
  655.         void            SaveReal(); // ˝ÇÁ¦ ŔúŔĺ
  656.         void            FlushDelayedSaveItem();
  657. #ifdef ENABLE_NEW_AFFECT_POTION
  658.         void            SetAffectPotion(LPITEM item);
  659. #endif 
  660.  
  661.         const char *    GetName() const;
  662.         const VID &     GetVID() const      { return m_vid;     }
  663.  
  664.         void            SetName(const std::string& name) { m_stName = name; }
  665.  
  666.         void            SetRace(BYTE race);
  667.         bool            ChangeSex();
  668.  
  669.         DWORD           GetAID() const;
  670.         int             GetChangeEmpireCount() const;
  671.         void            SetChangeEmpireCount();
  672.         int             ChangeEmpire(BYTE empire);
  673.  
  674.         BYTE            GetJob() const;
  675.         BYTE            GetCharType() const;
  676.  
  677.         bool            IsPC() const        { return GetDesc() ? true : false; }
  678.         bool            IsNPC() const       { return m_bCharType != CHAR_TYPE_PC; }
  679.         bool            IsMonster() const   { return m_bCharType == CHAR_TYPE_MONSTER; }
  680.         bool            IsStone() const     { return m_bCharType == CHAR_TYPE_STONE; }
  681.         bool            IsDoor() const      { return m_bCharType == CHAR_TYPE_DOOR; }
  682.         bool            IsBuilding() const  { return m_bCharType == CHAR_TYPE_BUILDING;  }
  683.         bool            IsWarp() const      { return m_bCharType == CHAR_TYPE_WARP; }
  684.         bool            IsGoto() const      { return m_bCharType == CHAR_TYPE_GOTO; }
  685. //      bool            IsPet() const       { return m_bCharType == CHAR_TYPE_PET; }
  686.  
  687.         DWORD           GetLastShoutPulse() const   { return m_pointsInstant.dwLastShoutPulse; }
  688.         void            SetLastShoutPulse(DWORD pulse) { m_pointsInstant.dwLastShoutPulse = pulse; }
  689.         int             GetLevel() const        { return m_points.level;    }
  690.         void            SetLevel(BYTE level);
  691.  
  692.         BYTE            GetGMLevel() const;
  693.         BOOL            IsGM() const;
  694.         void            SetGMLevel();
  695.  
  696.         DWORD           GetExp() const      { return m_points.exp;  }
  697.         void            SetExp(DWORD exp)   { m_points.exp = exp;   }
  698.         DWORD           GetNextExp() const;
  699.         LPCHARACTER     DistributeExp();    // Á¦ŔĎ ¸ąŔĚ ¶§¸° »ç¶÷Ŕ» ¸®ĹĎÇŃ´Ů.
  700.         void            DistributeHP(LPCHARACTER pkKiller);
  701.         void            DistributeSP(LPCHARACTER pkKiller, int iMethod=0);
  702.  
  703.         void            SetPosition(int pos);
  704.         bool            IsPosition(int pos) const   { return m_pointsInstant.position == pos ? true : false; }
  705.         int             GetPosition() const     { return m_pointsInstant.position; }
  706.  
  707.         void            SetPart(BYTE bPartPos, WORD wVal);
  708.         WORD            GetPart(BYTE bPartPos) const;
  709.         WORD            GetOriginalPart(BYTE bPartPos) const;
  710.  
  711.         void            SetHP(int hp)       { m_points.hp = hp; }
  712.         int             GetHP() const       { return m_points.hp; }
  713.  
  714.         void            SetSP(int sp)       { m_points.sp = sp; }
  715.         int             GetSP() const       { return m_points.sp; }
  716.  
  717.         void            SetStamina(int stamina) { m_points.stamina = stamina; }
  718.         int             GetStamina() const      { return m_points.stamina; }
  719.  
  720.         void            SetMaxHP(int iVal)  { m_pointsInstant.iMaxHP = iVal; }
  721.         int             GetMaxHP() const    { return m_pointsInstant.iMaxHP; }
  722.  
  723.         void            SetMaxSP(int iVal)  { m_pointsInstant.iMaxSP = iVal; }
  724.         int             GetMaxSP() const    { return m_pointsInstant.iMaxSP; }
  725.  
  726.         void            SetMaxStamina(int iVal) { m_pointsInstant.iMaxStamina = iVal; }
  727.         int             GetMaxStamina() const   { return m_pointsInstant.iMaxStamina; }
  728.  
  729.         void            SetRandomHP(int v)  { m_points.iRandomHP = v; }
  730.         void            SetRandomSP(int v)  { m_points.iRandomSP = v; }
  731.  
  732.         int             GetRandomHP() const { return m_points.iRandomHP; }
  733.         int             GetRandomSP() const { return m_points.iRandomSP; }
  734.  
  735.         int             GetHPPct() const;
  736.  
  737.         void            SetRealPoint(BYTE idx, int val);
  738.         int             GetRealPoint(BYTE idx) const;
  739.  
  740.         void            SetPoint(BYTE idx, long long val);
  741.         long long       GetPoint(BYTE idx) const;
  742.         int             GetLimitPoint(BYTE idx) const;
  743.         int             GetPolymorphPoint(BYTE idx) const; 
  744.        
  745.         //void ClearInfoCounter(void)       { infoCounter = 0; }
  746.         //void IncreaseInfoCounter(void)    { infoCounter++; }
  747.         //int  GetInfoCounter(void) const { return infoCounter; }
  748.         const TMobTable &   GetMobTable() const;
  749.         BYTE                GetMobRank() const;
  750.         BYTE                GetMobBattleType() const;
  751.         BYTE                GetMobSize() const;
  752.         DWORD               GetMobDamageMin() const;
  753.         DWORD               GetMobDamageMax() const;
  754.         WORD                GetMobAttackRange() const;
  755.         DWORD               GetMobDropItemVnum() const;
  756.         float               GetMobDamageMultiply() const;
  757.  
  758.         // NEWAI
  759.         bool            IsBerserker() const;
  760.         bool            IsBerserk() const;
  761.         void            SetBerserk(bool mode);
  762.  
  763.         bool            IsStoneSkinner() const;
  764.  
  765.         bool            IsGodSpeeder() const;
  766.         bool            IsGodSpeed() const;
  767.         void            SetGodSpeed(bool mode);
  768.  
  769.         bool            IsDeathBlower() const;
  770.         bool            IsDeathBlow() const;
  771.  
  772.         bool            IsReviver() const;
  773.         bool            HasReviverInParty() const;
  774.         bool            IsRevive() const;
  775.         void            SetRevive(bool mode);
  776.         // NEWAI END
  777.  
  778.         bool            IsRaceFlag(DWORD dwBit) const;
  779.         bool            IsSummonMonster() const;
  780.         DWORD           GetSummonVnum() const;
  781.  
  782.         DWORD           GetPolymorphItemVnum() const;
  783.         DWORD           GetMonsterDrainSPPoint() const;
  784.  
  785.         void            MainCharacterPacket();  // ł»°ˇ ¸ŢŔÎÄł¸ŻĹͶó°í ş¸ł»ÁŘ´Ů.
  786.  
  787.         void            ComputePoints();
  788.         void            ComputeBattlePoints();
  789.         void            PointChange(BYTE type, long long amount, bool bAmount = false, bool bBroadcast = false);
  790.         void            PointsPacket();
  791.         void            ApplyPoint(BYTE bApplyType, int iVal);
  792.         void            CheckMaximumPoints();   // HP, SP µîŔÇ ÇöŔç °ŞŔĚ ĂÖ´ë°Ş ş¸´Ů łôŔşÁö °Ë»çÇĎ°í łô´Ů¸é ł·Ăá´Ů.
  793.  
  794.         bool            Show(long lMapIndex, long x, long y, long z = LONG_MAX, bool bShowSpawnMotion = false);
  795.  
  796.         void            Sitdown(int is_ground);
  797.         void            Standup();
  798.  
  799.         void            SetRotation(float fRot);
  800.         void            SetRotationToXY(long x, long y);
  801.         float           GetRotation() const { return m_pointsInstant.fRot; }
  802.  
  803.         void            MotionPacketEncode(BYTE motion, LPCHARACTER victim, struct packet_motion * packet);
  804.         void            Motion(BYTE motion, LPCHARACTER victim = NULL);
  805.  
  806.         void            ChatPacket(BYTE type, const char *format, ...);
  807.         void            MonsterChat(BYTE bMonsterChatType);
  808.         void            SendGreetMessage();
  809.  
  810.         void            ResetPoint(int iLv);
  811.  
  812.         void            SetBlockMode(BYTE bFlag);
  813.         void            SetBlockModeForce(BYTE bFlag);
  814.         bool            IsBlockMode(BYTE bFlag) const   { return (m_pointsInstant.bBlockMode & bFlag)?true:false; }
  815.  
  816.         bool            IsPolymorphed() const       { return m_dwPolymorphRace>0; }
  817.         bool            IsPolyMaintainStat() const  { return m_bPolyMaintainStat; } // ŔĚŔü ˝şĹÝŔ» ŔŻÁöÇĎ´Â Ćú¸®¸đÇÁ.
  818.         void            SetPolymorph(DWORD dwRaceNum, bool bMaintainStat = false);
  819.         DWORD           GetPolymorphVnum() const    { return m_dwPolymorphRace; }
  820.         int             GetPolymorphPower() const;
  821.  
  822.         // FISING  
  823.         void            fishing();
  824.         void            fishing_take();
  825.         // END_OF_FISHING
  826.  
  827.         // MINING
  828.         void            mining(LPCHARACTER chLoad);
  829.         void            mining_cancel();
  830.         void            mining_take();
  831.         // END_OF_MINING
  832.  
  833.         void            ResetPlayTime(DWORD dwTimeRemain = 0);
  834.  
  835.         void            CreateFly(BYTE bType, LPCHARACTER pkVictim);
  836.  
  837.         void            ResetChatCounter();
  838.         BYTE            IncreaseChatCounter();
  839.         BYTE            GetChatCounter() const;
  840.  
  841.     protected:
  842.         DWORD           m_dwPolymorphRace;
  843.         bool            m_bPolyMaintainStat;
  844.         DWORD           m_dwLoginPlayTime;
  845.         DWORD           m_dwPlayerID;
  846.         VID             m_vid;
  847.         std::string     m_stName;
  848.         BYTE            m_bCharType;
  849.  
  850.         CHARACTER_POINT     m_points;
  851.         CHARACTER_POINT_INSTANT m_pointsInstant;
  852.  
  853.         int             m_iMoveCount;
  854.         DWORD           m_dwPlayStartTime;
  855.         BYTE            m_bAddChrState;
  856.         bool            m_bSkipSave;
  857.         std::string     m_stMobile;
  858.         char            m_szMobileAuth[5];
  859.         BYTE            m_bChatCounter;
  860.  
  861.         // End of Basic Points
  862.  
  863.         //////////////////////////////////////////////////////////////////////////////////
  864.         // Move & Synchronize Positions
  865.         //////////////////////////////////////////////////////////////////////////////////
  866.     public:
  867.         bool            IsStateMove() const         { return IsState((CState&)m_stateMove); }
  868.         bool            IsStateIdle() const         { return IsState((CState&)m_stateIdle); }
  869.         bool            IsWalking() const           { return m_bNowWalking || GetStamina()<=0; }
  870.         void            SetWalking(bool bWalkFlag)  { m_bWalking=bWalkFlag; }
  871.         void            SetNowWalking(bool bWalkFlag); 
  872.         void            ResetWalking()          { SetNowWalking(m_bWalking); }
  873.  
  874.         bool            Goto(long x, long y);   // ąŮ·Î Ŕ̵ż ˝ĂĹ°Áö ľĘ°í ¸ńÇĄ Ŕ§Äˇ·Î BLENDING ˝ĂŲ´Ů.
  875.         void            Stop();
  876.  
  877.         bool            CanMove() const;        // Ŕ̵żÇŇ Ľö Ŕִ°ˇ?
  878.  
  879.         void            SyncPacket();
  880.         bool            Sync(long x, long y);   // ˝ÇÁ¦ ŔĚ ¸ŢĽŇµĺ·Î Ŕ̵ż ÇŃ´Ů (°˘ Áľ Á¶°Çżˇ ŔÇÇŃ Ŕ̵ż şŇ°ˇ°ˇ ľřŔ˝)
  881.         bool            Move(long x, long y);   // Á¶°ÇŔ» °Ë»çÇĎ°í Sync ¸ŢĽŇµĺ¸¦ ĹëÇŘ Ŕ̵ż ÇŃ´Ů.
  882.         void            OnMove(bool bIsAttack = false); // żňÁ÷Ŕ϶§ şŇ¸°´Ů. Move() ¸ŢĽŇµĺ Ŕ̿ܿˇĽ­µµ şŇ¸± Ľö ŔÖ´Ů.
  883.         DWORD           GetMotionMode() const;
  884.         float           GetMoveMotionSpeed() const;
  885.         float           GetMoveSpeed() const;
  886.         void            CalculateMoveDuration();
  887.         void            SendMovePacket(BYTE bFunc, BYTE bArg, DWORD x, DWORD y, DWORD dwDuration, DWORD dwTime=0, int iRot=-1);
  888.         DWORD           GetCurrentMoveDuration() const  { return m_dwMoveDuration; }
  889.         DWORD           GetWalkStartTime() const    { return m_dwWalkStartTime; }
  890.         DWORD           GetLastMoveTime() const     { return m_dwLastMoveTime; }       
  891.         DWORD           GetLastAttackTime() const   { return m_dwLastAttackTime; }
  892.  
  893.         void            SetLastAttacked(DWORD time);    // ¸¶Áö¸·Ŕ¸·Î °ř°ÝąŢŔş ˝Ă°Ł ą× Ŕ§Äˇ¸¦ ŔúŔĺÇÔ
  894.  
  895.         bool            SetSyncOwner(LPCHARACTER ch, bool bRemoveFromList = true);
  896.         bool            IsSyncOwner(LPCHARACTER ch) const;
  897.  
  898.         bool            WarpSet(long x, long y, long lRealMapIndex = 0);
  899.         void            SetWarpLocation(long lMapIndex, long x, long y);
  900.         void            WarpEnd();
  901.         const PIXEL_POSITION & GetWarpPosition() const { return m_posWarp; }
  902.         bool            WarpToPID(DWORD dwPID);
  903.  
  904.         void            SaveExitLocation();
  905.         void            ExitToSavedLocation();
  906.  
  907.         void            StartStaminaConsume();
  908.         void            StopStaminaConsume();
  909.         bool            IsStaminaConsume() const;
  910.         bool            IsStaminaHalfConsume() const;
  911.  
  912.         void            ResetStopTime();
  913.         DWORD           GetStopTime() const;
  914.  
  915.     protected:
  916.         void            ClearSync();
  917.  
  918.         float           m_fSyncTime;
  919.         LPCHARACTER     m_pkChrSyncOwner;
  920.         CHARACTER_LIST  m_kLst_pkChrSyncOwned;  // ł»°ˇ SyncOwnerŔÎ ŔÚµé
  921.  
  922.         PIXEL_POSITION  m_posDest;
  923.         PIXEL_POSITION  m_posStart;
  924.         PIXEL_POSITION  m_posWarp;
  925.         long            m_lWarpMapIndex;
  926.  
  927.         PIXEL_POSITION  m_posExit;
  928.         long            m_lExitMapIndex;
  929.  
  930.         DWORD           m_dwMoveStartTime;
  931.         DWORD           m_dwMoveDuration;
  932.  
  933.         DWORD           m_dwLastMoveTime;
  934.         DWORD           m_dwLastAttackTime;
  935.         DWORD           m_dwWalkStartTime;
  936.         DWORD           m_dwStopTime;
  937.  
  938.         bool            m_bWalking;
  939.         bool            m_bNowWalking;
  940.         bool            m_bStaminaConsume;
  941.         // End
  942.  
  943.         // Quickslot °ü·Ă
  944.     public:
  945.         /////////////// STRONY
  946.         void            SyncQuickslot(BYTE bType, UINT bOldPos, UINT bNewPos);
  947.         bool            GetQuickslot(UINT pos, TQuickslot ** ppSlot);
  948.         bool            SetQuickslot(UINT pos, TQuickslot & rSlot);
  949.         bool            DelQuickslot(UINT pos);
  950.         bool            SwapQuickslot(UINT a, UINT b);
  951.         void            ChainQuickslotItem(LPITEM pItem, BYTE bType, UINT bOldPos);
  952.         ////////////////////////
  953.     protected:
  954.         TQuickslot      m_quickslot[QUICKSLOT_MAX_NUM];
  955.  
  956.         ////////////////////////////////////////////////////////////////////////////////////////
  957.         // Affect
  958.     public:
  959.         void            StartAffectEvent();
  960.         void            ClearAffect(bool bSave=false);
  961.         void            ComputeAffect(CAffect * pkAff, bool bAdd);
  962.         bool            AddAffect(DWORD dwType, BYTE bApplyOn, long lApplyValue, DWORD dwFlag, long lDuration, long lSPCost, bool bOverride, bool IsCube = false);
  963.         void            RefreshAffect();
  964.         bool            RemoveAffect(DWORD dwType);
  965.         bool            IsAffectFlag(DWORD dwAff) const;
  966.  
  967.         bool            UpdateAffect(); // called from EVENT
  968.         int             ProcessAffect();
  969.  
  970.         void            LoadAffect(DWORD dwCount, TPacketAffectElement * pElements);
  971.         void            SaveAffect();
  972.  
  973.         // Affect loadingŔĚ łˇł­ »óĹÂŔΰˇ?
  974.         bool            IsLoadedAffect() const  { return m_bIsLoadedAffect; }      
  975.  
  976.         bool            IsGoodAffect(BYTE bAffectType) const;
  977.  
  978.         void            RemoveGoodAffect();
  979.         void            RemoveBadAffect();
  980.  
  981.         CAffect *       FindAffect(DWORD dwType, BYTE bApply=APPLY_NONE) const;
  982.         const std::list<CAffect *> & GetAffectContainer() const { return m_list_pkAffect; }
  983.         bool            RemoveAffect(CAffect * pkAff);
  984.  
  985.     protected:
  986.         bool            m_bIsLoadedAffect;
  987.         TAffectFlag     m_afAffectFlag;
  988.         std::list<CAffect *>    m_list_pkAffect;
  989.  
  990.     public:
  991.         // PARTY_JOIN_BUG_FIX
  992.         void            SetParty(LPPARTY pkParty);
  993.         LPPARTY         GetParty() const    { return m_pkParty; }
  994.  
  995.         bool            RequestToParty(LPCHARACTER leader);
  996.         void            DenyToParty(LPCHARACTER member);
  997.         void            AcceptToParty(LPCHARACTER member);
  998.  
  999.         /// ŔÚ˝ĹŔÇ ĆÄĆĽżˇ ´Ů¸Ą character ¸¦ ĂĘ´ëÇŃ´Ů.
  1000.         /**
  1001.          * @param   pchInvitee ĂĘ´ëÇŇ ´ë»ó character. ĆÄĆĽżˇ Âüż© °ˇ´ÉÇŃ »óĹÂŔĚľîľß ÇŃ´Ů.
  1002.          *
  1003.          * ľçĂř character ŔÇ »óĹ°ˇ ĆÄĆĽżˇ ĂĘ´ëÇĎ°í ĂĘ´ëąŢŔ» Ľö ŔÖ´Â »óĹ°ˇ ľĆ´Ď¶ó¸é ĂĘ´ëÇĎ´Â Äł¸ŻĹÍżˇ°Ô ÇŘ´çÇϴ äĆĂ ¸ŢĽĽÁö¸¦ ŔüĽŰÇŃ´Ů.
  1004.          */
  1005.         void            PartyInvite(LPCHARACTER pchInvitee);
  1006.  
  1007.         /// ĂĘ´ëÇß´ř character ŔÇ Ľö¶ôŔ» Ăł¸®ÇŃ´Ů.
  1008.         /**
  1009.          * @param   pchInvitee ĆÄĆĽżˇ Âüż©ÇŇ character. ĆÄĆĽżˇ Âüż©°ˇ´ÉÇŃ »óĹÂŔĚľîľß ÇŃ´Ů.
  1010.          *
  1011.          * pchInvitee °ˇ ĆÄĆĽżˇ °ˇŔÔÇŇ Ľö ŔÖ´Â »óȲŔĚ ľĆ´Ď¶ó¸é ÇŘ´çÇϴ äĆĂ ¸ŢĽĽÁö¸¦ ŔüĽŰÇŃ´Ů.
  1012.          */
  1013.         void            PartyInviteAccept(LPCHARACTER pchInvitee);
  1014.  
  1015.         /// ĂĘ´ëÇß´ř character ŔÇ ĂĘ´ë °ĹşÎ¸¦ Ăł¸®ÇŃ´Ů.
  1016.         /**
  1017.          * @param [in]  dwPID ĂĘ´ë Çß´ř character ŔÇ PID
  1018.          */
  1019.         void            PartyInviteDeny(DWORD dwPID);
  1020.  
  1021.         bool            BuildUpdatePartyPacket(TPacketGCPartyUpdate & out);
  1022.         int             GetLeadershipSkillLevel() const;
  1023.  
  1024.         bool            CanSummon(int iLeaderShip);
  1025.  
  1026.         void            SetPartyRequestEvent(LPEVENT pkEvent) { m_pkPartyRequestEvent = pkEvent; }
  1027.  
  1028.     protected:
  1029.  
  1030.         /// ĆÄĆĽżˇ °ˇŔÔÇŃ´Ů.
  1031.         /**
  1032.          * @param   pkLeader °ˇŔÔÇŇ ĆÄĆĽŔÇ ¸®´ő
  1033.          */
  1034.         void            PartyJoin(LPCHARACTER pkLeader);
  1035.  
  1036.         /**
  1037.          * ĆÄĆĽ °ˇŔÔŔ» ÇŇ Ľö ľřŔ» °ćżěŔÇ żˇ·ŻÄÚµĺ.
  1038.          * Error code ´Â ˝Ă°Łżˇ ŔÇÁ¸ŔűŔΰˇżˇ µű¶ó şŻ°ć°ˇ´ÉÇŃ(mutable) type °ú Á¤Ŕű(static) type Ŕ¸·Î łŞ´¶´Ů.
  1039.          * Error code ŔÇ °ŞŔĚ PERR_SEPARATOR ş¸´Ů ł·Ŕ¸¸é şŻ°ć°ˇ´ÉÇŃ type ŔĚ°í łôŔ¸¸é Á¤Ŕű type ŔĚ´Ů.
  1040.          */
  1041.         enum PartyJoinErrCode {
  1042.             PERR_NONE       = 0,    ///< Ăł¸®Ľş°ř
  1043.             PERR_SERVER,            ///< Ľ­ąöą®Á¦·Î ĆÄĆĽ°ü·Ă Ăł¸® şŇ°ˇ
  1044.             PERR_DUNGEON,           ///< Äł¸ŻĹÍ°ˇ ´řŔüżˇ ŔÖŔ˝
  1045.             PERR_OBSERVER,          ///< °üŔü¸đµĺŔÓ
  1046.             PERR_LVBOUNDARY,        ///< »ó´ë Äł¸ŻĹÍżÍ ·ąş§Â÷ŔĚ°ˇ ł˛
  1047.             PERR_LOWLEVEL,          ///< »ó´ëĆÄĆĽŔÇ ĂÖ°í·ąş§ş¸´Ů 30·ąş§ ł·Ŕ˝
  1048.             PERR_HILEVEL,           ///< »ó´ëĆÄĆĽŔÇ ĂÖŔú·ąş§ş¸´Ů 30·ąş§ łôŔ˝
  1049.             PERR_ALREADYJOIN,       ///< ĆÄĆĽ°ˇŔÔ ´ë»ó Äł¸ŻĹÍ°ˇ ŔĚąĚ ĆÄĆĽÁß
  1050.             PERR_PARTYISFULL,       ///< ĆÄĆĽŔÎżř Á¦ÇŃ ĂĘ°ú
  1051.             PERR_SEPARATOR,         ///< Error type separator.
  1052.             PERR_DIFFEMPIRE,        ///< »ó´ë Äł¸ŻĹÍżÍ ´Ů¸Ą Á¦±ąŔÓ
  1053.             PERR_MAX                ///< Error code ĂÖ°íġ. ŔĚ ľŐżˇ Error code ¸¦ Ăß°ˇÇŃ´Ů.
  1054.         };
  1055.  
  1056.         /// ĆÄĆĽ °ˇŔÔŔĚłŞ °áĽş °ˇ´ÉÇŃ Á¶°ÇŔ» °Ë»çÇŃ´Ů.
  1057.         /**
  1058.          * @param   pchLeader ĆÄĆĽŔÇ leader ŔĚ°ĹłŞ ĂĘ´ëÇŃ character
  1059.          * @param   pchGuest ĂĘ´ëąŢ´Â character
  1060.          * @return  ¸đµç PartyJoinErrCode °ˇ ąÝČŻµÉ Ľö ŔÖ´Ů.
  1061.          */
  1062.         static PartyJoinErrCode IsPartyJoinableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest);
  1063.  
  1064.         /// ĆÄĆĽ °ˇŔÔŔĚłŞ °áĽş °ˇ´ÉÇŃ µżŔűŔÎ Á¶°ÇŔ» °Ë»çÇŃ´Ů.
  1065.         /**
  1066.          * @param   pchLeader ĆÄĆĽŔÇ leader ŔĚ°ĹłŞ ĂĘ´ëÇŃ character
  1067.          * @param   pchGuest ĂĘ´ëąŢ´Â character
  1068.          * @return  mutable type ŔÇ code ¸¸ ąÝČŻÇŃ´Ů.
  1069.          */
  1070.         static PartyJoinErrCode IsPartyJoinableMutableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest);
  1071.  
  1072.         LPPARTY         m_pkParty;
  1073.         DWORD           m_dwLastDeadTime;
  1074.         LPEVENT         m_pkPartyRequestEvent;
  1075.  
  1076.         /**
  1077.          * ĆÄĆĽĂĘĂ» Event map.
  1078.          * key: ĂĘ´ëąŢŔş Äł¸ŻĹÍŔÇ PID
  1079.          * value: eventŔÇ pointer
  1080.          *
  1081.          * ĂĘ´ëÇŃ Äł¸ŻĹ͵鿡 ´ëÇŃ event map.
  1082.          */
  1083.         typedef std::map< DWORD, LPEVENT >  EventMap;
  1084.         EventMap        m_PartyInviteEventMap;
  1085.  
  1086.         // END_OF_PARTY_JOIN_BUG_FIX
  1087.  
  1088.         ////////////////////////////////////////////////////////////////////////////////////////
  1089.         // Dungeon
  1090.     public:
  1091.         void            SetDungeon(LPDUNGEON pkDungeon);
  1092.         LPDUNGEON       GetDungeon() const  { return m_pkDungeon; }
  1093.         LPDUNGEON       GetDungeonForce() const;
  1094.     protected:
  1095.         LPDUNGEON   m_pkDungeon;
  1096.         int         m_iEventAttr;
  1097.  
  1098.         ////////////////////////////////////////////////////////////////////////////////////////
  1099.         // Guild
  1100.     public:
  1101.         void            SetGuild(CGuild * pGuild);
  1102.         CGuild*         GetGuild() const    { return m_pGuild; }
  1103.  
  1104.         void            SetWarMap(CWarMap* pWarMap);
  1105.         CWarMap*        GetWarMap() const   { return m_pWarMap; }
  1106.  
  1107.     protected:
  1108.         CGuild *        m_pGuild;
  1109.         DWORD           m_dwUnderGuildWarInfoMessageTime;
  1110.         CWarMap *       m_pWarMap;
  1111.  
  1112.         ////////////////////////////////////////////////////////////////////////////////////////
  1113.         // Item related
  1114.     public:
  1115.         bool            CanHandleItem(bool bSkipRefineCheck = false, bool bSkipObserver = false); // ľĆŔĚĹŰ °ü·Ă ÇŕŔ§¸¦ ÇŇ Ľö Ŕִ°ˇ?
  1116.  
  1117.         bool            IsItemLoaded() const    { return m_bItemLoaded; }
  1118.         void            SetItemLoaded() { m_bItemLoaded = true; }
  1119.  
  1120.         void            ClearItem();
  1121.         void            SetItem(TItemPos Cell, LPITEM item);
  1122.         LPITEM          GetItem(TItemPos Cell) const;
  1123.         LPITEM          GetInventoryItem(WORD wCell) const;
  1124.         bool            IsEmptyItemGrid(TItemPos Cell, BYTE size, int iExceptionCell = -1) const;
  1125.  
  1126.         void            SetWear(UINT bCell, LPITEM item);
  1127.         LPITEM          GetWear(UINT bCell) const;
  1128.  
  1129.         // MYSHOP_PRICE_LIST
  1130.         void            UseSilkBotary(void);        /// şń´Ü ş¸µű¸® ľĆŔĚĹŰŔÇ »çżë
  1131.  
  1132.         /// DB Äł˝Ă·Î şÎĹÍ ąŢľĆżÂ °ˇ°ÝÁ¤ş¸ ¸®˝şĆ®¸¦ ŔŻŔúżˇ°Ô ŔüĽŰÇĎ°í ş¸µű¸® ľĆŔĚĹŰ »çżëŔ» Ăł¸®ÇŃ´Ů.
  1133.         /**
  1134.          * @param [in] p    °ˇ°ÝÁ¤ş¸ ¸®˝şĆ® ĆĐŶ
  1135.          *
  1136.          * Á˘ĽÓÇŃ ČÄ ĂłŔ˝ şń´Ü ş¸µű¸® ľĆŔĚĹŰ »çżë ˝Ă UseSilkBotary żˇĽ­ DB Äł˝Ă·Î °ˇ°ÝÁ¤ş¸ ¸®˝şĆ®¸¦ żäĂ»ÇĎ°í
  1137.          * ŔŔ´äąŢŔş ˝ĂÁˇżˇ ŔĚ ÇÔĽöżˇĽ­ ˝ÇÁ¦ şń´Üş¸µű¸® »çżëŔ» Ăł¸®ÇŃ´Ů.
  1138.          */
  1139.         void            UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p);
  1140.         // END_OF_MYSHOP_PRICE_LIST
  1141.  
  1142.         bool            UseItemEx(LPITEM item, TItemPos DestCell);
  1143.         bool            UseItem(TItemPos Cell, TItemPos DestCell = NPOS);
  1144.  
  1145.         // ADD_REFINE_BUILDING
  1146.         bool            IsRefineThroughGuild() const;
  1147.         CGuild *        GetRefineGuild() const;
  1148.         int             ComputeRefineFee(int iCost, int iMultiply = 5) const;
  1149.         void            PayRefineFee(int iTotalMoney);
  1150.         void            SetRefineNPC(LPCHARACTER ch);
  1151.         // END_OF_ADD_REFINE_BUILDING
  1152.  
  1153.         bool            RefineItem(LPITEM pkItem, LPITEM pkTarget);
  1154.         bool            DropItem(TItemPos Cell,  BYTE bCount=0);
  1155.         bool            GiveRecallItem(LPITEM item);
  1156.         void            ProcessRecallItem(LPITEM item);
  1157.  
  1158.         //  void            PotionPacket(int iPotionType);
  1159.         void            EffectPacket(int enumEffectType);
  1160.         void            SpecificEffectPacket(const char filename[128]);
  1161.  
  1162.         // ADD_MONSTER_REFINE
  1163.         bool            DoRefine(LPITEM item, bool bMoneyOnly = false);
  1164.         // END_OF_ADD_MONSTER_REFINE
  1165.  
  1166.         bool            DoRefineWithScroll(LPITEM item);
  1167.         /////////// STRONY
  1168.         bool            RefineInformation(UINT bCell, BYTE bType, int iAdditionalCell = -1);
  1169.  
  1170.         void            SetRefineMode(int iAdditionalCell = -1);
  1171.         void            ClearRefineMode();
  1172.  
  1173.         bool            GiveItem(LPCHARACTER victim, TItemPos Cell);
  1174.         bool            CanReceiveItem(LPCHARACTER from, LPITEM item) const;
  1175.         void            ReceiveItem(LPCHARACTER from, LPITEM item);
  1176.         bool            GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector <DWORD> &dwItemVnums,
  1177.                             std::vector <DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count);
  1178.  
  1179.         bool            MoveItem(TItemPos pos, TItemPos change_pos, BYTE num);
  1180.         bool            PickupItem(DWORD vid);
  1181.         bool            EquipItem(LPITEM item, int iCandidateCell = -1);
  1182.         bool            UnequipItem(LPITEM item);
  1183.  
  1184.         // ÇöŔç itemŔ» ÂřżëÇŇ Ľö ŔÖ´Â Áö Č®ŔÎÇĎ°í, şŇ°ˇ´É Çϴٸé Äł¸ŻĹÍżˇ°Ô ŔĚŔŻ¸¦ ľË·ÁÁÖ´Â ÇÔĽö
  1185.         bool            CanEquipNow(const LPITEM item, const TItemPos& srcCell = NPOS, const TItemPos& destCell = NPOS);
  1186.  
  1187.         // ÂřżëÁßŔÎ itemŔ» ąţŔ» Ľö ŔÖ´Â Áö Č®ŔÎÇĎ°í, şŇ°ˇ´É Çϴٸé Äł¸ŻĹÍżˇ°Ô ŔĚŔŻ¸¦ ľË·ÁÁÖ´Â ÇÔĽö
  1188.         bool            CanUnequipNow(const LPITEM item, const TItemPos& srcCell = NPOS, const TItemPos& destCell = NPOS);
  1189.         ////////// STRONY
  1190.         bool            SwapItem(UINT bCell, UINT bDestCell);
  1191.         LPITEM          AutoGiveItem(DWORD dwItemVnum, BYTE bCount=1, int iRarePct = -1, bool bMsg = true);
  1192.         void            AutoGiveItem(LPITEM item, bool longOwnerShip = false);
  1193.        
  1194.         int             GetEmptyInventory(BYTE size) const;
  1195.         int             GetEmptyDragonSoulInventory(LPITEM pItem) const;
  1196.         void            CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const;
  1197.  
  1198.         int             CountEmptyInventory() const;
  1199.  
  1200.         int             CountSpecifyItem(DWORD vnum) const;
  1201.         void            RemoveSpecifyItem(DWORD vnum, DWORD count = 1);
  1202.         LPITEM          FindSpecifyItem(DWORD vnum) const;
  1203.         LPITEM          FindItemByID(DWORD id) const;
  1204.  
  1205.         int             CountSpecifyTypeItem(BYTE type) const;
  1206.         void            RemoveSpecifyTypeItem(BYTE type, DWORD count = 1);
  1207.  
  1208.         bool            IsEquipUniqueItem(DWORD dwItemVnum) const;
  1209.  
  1210.         // CHECK_UNIQUE_GROUP
  1211.         bool            IsEquipUniqueGroup(DWORD dwGroupVnum) const;
  1212.         // END_OF_CHECK_UNIQUE_GROUP
  1213.  
  1214.         void            SendEquipment(LPCHARACTER ch);
  1215.         // End of Item
  1216.  
  1217.     protected:
  1218.  
  1219.         /// ÇŃ ľĆŔĚĹŰżˇ ´ëÇŃ °ˇ°ÝÁ¤ş¸¸¦ ŔüĽŰÇŃ´Ů.
  1220.         /**
  1221.          * @param [in]  dwItemVnum ľĆŔĚĹŰ vnum
  1222.          * @param [in]  dwItemPrice ľĆŔĚĹŰ °ˇ°Ý
  1223.          */
  1224. #ifdef ENABLE_CHEQUE_SYSTEM
  1225.         void            SendMyShopPriceListCmd(DWORD dwItemVnum, TItemPriceType ItemPrice);
  1226. #else
  1227.         void            SendMyShopPriceListCmd(DWORD dwItemVnum, long long dwItemPrice);
  1228. #endif
  1229.         bool            m_bNoOpenedShop;    ///< ŔĚąř Á˘ĽÓ ČÄ °łŔλóÁˇŔ» ż¬ ŔűŔĚ ŔÖ´ÂÁöŔÇ ż©şÎ(ż­ľú´ř ŔűŔĚ ľř´Ů¸é true)
  1230.  
  1231.         bool            m_bItemLoaded;
  1232.         int             m_iRefineAdditionalCell;
  1233.         bool            m_bUnderRefine;
  1234.         DWORD           m_dwRefineNPCVID;
  1235.  
  1236.     public:
  1237.         ////////////////////////////////////////////////////////////////////////////////////////
  1238.         // Money related
  1239.         long long       GetGold() const     { return m_points.gold; }
  1240.         void            SetGold(long long gold) { m_points.gold = gold; }
  1241.         bool            DropGold(INT gold);
  1242.         long long       GetAllowedGold() const;
  1243.         void            GiveGold(long long iAmount);
  1244. #ifdef ENABLE_CHEQUE_SYSTEM
  1245.         int             GetCheque() const       { return m_points.cheque;   }
  1246.         void            SetCheque(BYTE cheque)  { m_points.cheque = cheque; }
  1247. #endif
  1248.         // End of Money
  1249.  
  1250.         ////////////////////////////////////////////////////////////////////////////////////////
  1251.         // Shop related
  1252.     public:
  1253.         void            SetShop(LPSHOP pkShop);
  1254.         LPSHOP          GetShop() const { return m_pkShop; }
  1255.         void            ShopPacket(BYTE bSubHeader);
  1256.  
  1257.         void            SetShopOwner(LPCHARACTER ch) { m_pkChrShopOwner = ch; }
  1258.         LPCHARACTER     GetShopOwner() const { return m_pkChrShopOwner;}
  1259.  
  1260.         void            OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount);
  1261.         LPSHOP          GetMyShop() const { return m_pkMyShop; }
  1262.         void            CloseMyShop();
  1263.  
  1264.     protected:
  1265.  
  1266.         LPSHOP          m_pkShop;
  1267.         LPSHOP          m_pkMyShop;
  1268.         std::string     m_stShopSign;
  1269.         LPCHARACTER     m_pkChrShopOwner;
  1270.         // End of shop
  1271.  
  1272.         ////////////////////////////////////////////////////////////////////////////////////////
  1273.         // Exchange related
  1274.     public:
  1275.         bool            ExchangeStart(LPCHARACTER victim);
  1276.         void            SetExchange(CExchange * pkExchange);
  1277.         CExchange *     GetExchange() const { return m_pkExchange;  }
  1278.  
  1279.     protected:
  1280.         CExchange *     m_pkExchange;
  1281.         // End of Exchange
  1282.  
  1283.         ////////////////////////////////////////////////////////////////////////////////////////
  1284.         // Battle
  1285.     public:
  1286.         struct TBattleInfo
  1287.         {
  1288.             int iTotalDamage;
  1289.             int iAggro;
  1290.  
  1291.             TBattleInfo(int iTot, int iAggr)
  1292.                 : iTotalDamage(iTot), iAggro(iAggr)
  1293.                 {}
  1294.         };
  1295.         typedef std::map<VID, TBattleInfo>  TDamageMap;
  1296.  
  1297.         typedef struct SAttackLog
  1298.         {
  1299.             DWORD   dwVID;
  1300.             DWORD   dwTime;
  1301.         } AttackLog;
  1302.  
  1303.         bool                Damage(LPCHARACTER pAttacker, int dam, EDamageType type = DAMAGE_TYPE_NORMAL);
  1304.         bool                __Profile__Damage(LPCHARACTER pAttacker, int dam, EDamageType type = DAMAGE_TYPE_NORMAL);
  1305.         void                DeathPenalty(BYTE bExpLossPercent);
  1306.         void                ReviveInvisible(int iDur);
  1307.  
  1308.         bool                Attack(LPCHARACTER pkVictim, BYTE bType = 0);
  1309.         bool                IsAlive() const     { return m_pointsInstant.position == POS_DEAD ? false : true; }
  1310.         bool                CanFight() const;
  1311.  
  1312.         bool                CanBeginFight() const;
  1313.         void                BeginFight(LPCHARACTER pkVictim); // pkVictimr°ú ˝Îżě±â ˝ĂŔŰÇŃ´Ů. (°­Á¦ŔűŔÓ, ˝ĂŔŰÇŇ Ľö ŔÖłŞ ĂĽĹ©ÇĎ·Á¸é CanBeginFightŔ» »çżë)
  1314.  
  1315.         bool                CounterAttack(LPCHARACTER pkChr); // ąÝ°ÝÇϱâ (¸ó˝şĹ͸¸ »çżë)
  1316.  
  1317.         bool                IsStun() const;
  1318.         void                Stun();
  1319.         bool                IsDead() const;
  1320.         void                Dead(LPCHARACTER pkKiller = NULL, bool bImmediateDead=false);
  1321.  
  1322.         void                Reward(bool bItemDrop);
  1323.         void                RewardGold(LPCHARACTER pkAttacker);
  1324.  
  1325.         bool                Shoot(BYTE bType);
  1326.         void                FlyTarget(DWORD dwTargetVID, long x, long y, BYTE bHeader);
  1327.  
  1328.         void                ForgetMyAttacker();
  1329.         void                AggregateMonster();
  1330.         void                AttractRanger();
  1331.         void                PullMonster();
  1332.  
  1333.         int                 GetArrowAndBow(LPITEM * ppkBow, LPITEM * ppkArrow, int iArrowCount = 1);
  1334.         void                UseArrow(LPITEM pkArrow, DWORD dwArrowCount);
  1335.  
  1336.         void                AttackedByPoison(LPCHARACTER pkAttacker);
  1337.         void                RemovePoison();
  1338.  
  1339.         void                AttackedByFire(LPCHARACTER pkAttacker, int amount, int count);
  1340.         void                RemoveFire();
  1341.  
  1342.         void                UpdateAlignment(int iAmount);
  1343.         int                 GetAlignment() const;
  1344.  
  1345.         //Ľ±ľÇġ ľň±â
  1346.         int                 GetRealAlignment() const;
  1347.         void                ShowAlignment(bool bShow);
  1348.  
  1349.         void                SetKillerMode(bool bOn);
  1350.         bool                IsKillerMode() const;
  1351.         void                UpdateKillerMode();
  1352.  
  1353.         BYTE                GetPKMode() const;
  1354.         void                SetPKMode(BYTE bPKMode);
  1355.  
  1356.         void                ItemDropPenalty(LPCHARACTER pkKiller);
  1357.  
  1358.         void                UpdateAggrPoint(LPCHARACTER ch, EDamageType type, int dam);
  1359.  
  1360.         //
  1361.         // HACK
  1362.         //
  1363.     public:
  1364.         void SetComboSequence(BYTE seq);
  1365.         BYTE GetComboSequence() const;
  1366. #ifdef ANTYDMG
  1367.         DWORD   GetBowTime() {return bow_time;}
  1368.         void    SetBowTime(DWORD t) {bow_time = t;}
  1369. #endif
  1370.  
  1371.         void SetLastComboTime(DWORD time);
  1372.         DWORD GetLastComboTime() const;
  1373.  
  1374.         int GetValidComboInterval() const;
  1375.         void SetValidComboInterval(int interval);
  1376.  
  1377.         BYTE GetComboIndex() const;
  1378.  
  1379.         void IncreaseComboHackCount(int k = 1);
  1380.         void ResetComboHackCount();
  1381.         void SkipComboAttackByTime(int interval);
  1382.         DWORD GetSkipComboAttackByTime() const;
  1383.  
  1384.     protected:
  1385.         BYTE m_bComboSequence;
  1386.         DWORD m_dwLastComboTime;
  1387.         int m_iValidComboInterval;
  1388.         BYTE m_bComboIndex;
  1389.         int m_iComboHackCount;
  1390.         DWORD m_dwSkipComboAttackByTime;
  1391. #ifdef ANTYDMG
  1392.         DWORD bow_time;
  1393. #endif
  1394.  
  1395.     protected:
  1396.         void                UpdateAggrPointEx(LPCHARACTER ch, EDamageType type, int dam, TBattleInfo & info);
  1397.         void                ChangeVictimByAggro(int iNewAggro, LPCHARACTER pNewVictim);
  1398.  
  1399.         DWORD               m_dwFlyTargetID;
  1400.         std::vector<DWORD>  m_vec_dwFlyTargets;
  1401.         TDamageMap          m_map_kDamage;  // ľî¶˛ Äł¸ŻĹÍ°ˇ łŞżˇ°Ô ľó¸¶¸¸Ĺ­ŔÇ µĄąĚÁö¸¦ ÁÖľú´Â°ˇ?
  1402. //      AttackLog           m_kAttackLog;
  1403.         DWORD               m_dwKillerPID;
  1404.  
  1405.         int                 m_iAlignment;       // Lawful/Chaotic value -200000 ~ 200000
  1406.         int                 m_iRealAlignment;
  1407.         int                 m_iKillerModePulse;
  1408.         BYTE                m_bPKMode;
  1409.  
  1410.         // Aggro
  1411.         DWORD               m_dwLastVictimSetTime;
  1412.         int                 m_iMaxAggro;
  1413.         // End of Battle
  1414.  
  1415.         // Stone
  1416.     public:
  1417.         void                SetStone(LPCHARACTER pkChrStone);
  1418.         void                ClearStone();
  1419.         void                DetermineDropMetinStone();
  1420.         DWORD               GetDropMetinStoneVnum() const { return m_dwDropMetinStone; }
  1421.         BYTE                GetDropMetinStonePct() const { return m_bDropMetinStonePct; }
  1422.  
  1423.     protected:
  1424.         LPCHARACTER         m_pkChrStone;       // łŞ¸¦ ˝şĆůÇŃ µą
  1425.         CHARACTER_SET       m_set_pkChrSpawnedBy;   // ł»°ˇ ˝şĆůÇŃ łđµé
  1426.         DWORD               m_dwDropMetinStone;
  1427.         BYTE                m_bDropMetinStonePct;
  1428.         // End of Stone
  1429.  
  1430.     public:
  1431.         enum
  1432.         {
  1433.             SKILL_UP_BY_POINT,
  1434.             SKILL_UP_BY_BOOK,
  1435.             SKILL_UP_BY_TRAIN,
  1436.  
  1437.             // ADD_GRANDMASTER_SKILL
  1438.             SKILL_UP_BY_QUEST,
  1439.             // END_OF_ADD_GRANDMASTER_SKILL
  1440.         };
  1441.  
  1442.         void                SkillLevelPacket();
  1443.         void                SkillLevelUp(DWORD dwVnum, BYTE bMethod = SKILL_UP_BY_POINT);
  1444.         bool                SkillLevelDown(DWORD dwVnum);
  1445.         // ADD_GRANDMASTER_SKILL
  1446.         bool                UseSkill(DWORD dwVnum, LPCHARACTER pkVictim, bool bUseGrandMaster = true);
  1447.         void                ResetSkill();
  1448.         void                SetSkillLevel(DWORD dwVnum, BYTE bLev);
  1449.         int                 GetUsedSkillMasterType(DWORD dwVnum);
  1450.  
  1451.         bool                IsLearnableSkill(DWORD dwSkillVnum) const;
  1452.         // END_OF_ADD_GRANDMASTER_SKILL
  1453.  
  1454.         bool                CheckSkillHitCount(const BYTE SkillID, const VID dwTargetVID);
  1455.         bool                CanUseSkill(DWORD dwSkillVnum) const;
  1456.         bool                IsUsableSkillMotion(DWORD dwMotionIndex) const;
  1457.         int                 GetSkillLevel(DWORD dwVnum) const;
  1458.         int                 GetSkillMasterType(DWORD dwVnum) const;
  1459.         int                 GetSkillPower(DWORD dwVnum, BYTE bLevel = 0) const;
  1460.  
  1461.         time_t              GetSkillNextReadTime(DWORD dwVnum) const;
  1462.         void                SetSkillNextReadTime(DWORD dwVnum, time_t time);
  1463.         void                SkillLearnWaitMoreTimeMessage(DWORD dwVnum);
  1464.  
  1465.         void                ComputePassiveSkill(DWORD dwVnum);
  1466.         int                 ComputeSkill(DWORD dwVnum, LPCHARACTER pkVictim, BYTE bSkillLevel = 0);
  1467.         int                 ComputeSkillAtPosition(DWORD dwVnum, const PIXEL_POSITION& posTarget, BYTE bSkillLevel = 0);
  1468.         void                ComputeSkillPoints();
  1469.  
  1470.         void                SetSkillGroup(BYTE bSkillGroup);
  1471.         BYTE                GetSkillGroup() const       { return m_points.skill_group; }
  1472.  
  1473.         int                 ComputeCooltime(int time);
  1474.  
  1475.         void                GiveRandomSkillBook();
  1476.  
  1477.         void                DisableCooltime();
  1478.         bool                LearnSkillByBook(DWORD dwSkillVnum, BYTE bProb = 0);
  1479.         bool                LearnGrandMasterSkill(DWORD dwSkillVnum);
  1480.  
  1481.     private:
  1482.         bool                m_bDisableCooltime;
  1483.         DWORD               m_dwLastSkillTime;  ///< ¸¶Áö¸·Ŕ¸·Î skill Ŕ» ľ´ ˝Ă°Ł(millisecond).
  1484.         // End of Skill
  1485.  
  1486.         // MOB_SKILL
  1487.     public:
  1488.         bool                HasMobSkill() const;
  1489.         size_t              CountMobSkill() const;
  1490.         const TMobSkillInfo * GetMobSkill(unsigned int idx) const;
  1491.         bool                CanUseMobSkill(unsigned int idx) const;
  1492.         bool                UseMobSkill(unsigned int idx);
  1493.         void                ResetMobSkillCooltime();
  1494.     protected:
  1495.         DWORD               m_adwMobSkillCooltime[MOB_SKILL_MAX_NUM];
  1496.         // END_OF_MOB_SKILL
  1497.  
  1498.         // for SKILL_MUYEONG
  1499.     public:
  1500.         void                StartMuyeongEvent();
  1501.         void                StopMuyeongEvent();
  1502.  
  1503.     private:
  1504.         LPEVENT             m_pkMuyeongEvent;
  1505.  
  1506.         // for SKILL_CHAIN lighting
  1507.     public:
  1508.         int                 GetChainLightningIndex() const { return m_iChainLightingIndex; }
  1509.         void                IncChainLightningIndex() { ++m_iChainLightingIndex; }
  1510.         void                AddChainLightningExcept(LPCHARACTER ch) { m_setExceptChainLighting.insert(ch); }
  1511.         void                ResetChainLightningIndex() { m_iChainLightingIndex = 0; m_setExceptChainLighting.clear(); }
  1512.         int                 GetChainLightningMaxCount() const;
  1513.         const CHARACTER_SET& GetChainLightingExcept() const { return m_setExceptChainLighting; }
  1514.  
  1515.     private:
  1516.         int                 m_iChainLightingIndex;
  1517.         CHARACTER_SET m_setExceptChainLighting;
  1518.  
  1519.         // for SKILL_EUNHYUNG
  1520.     public:
  1521.         void                SetAffectedEunhyung();
  1522.         void                ClearAffectedEunhyung() { m_dwAffectedEunhyungLevel = 0; }
  1523.         bool                GetAffectedEunhyung() const { return m_dwAffectedEunhyungLevel; }
  1524.  
  1525.     private:
  1526.         DWORD               m_dwAffectedEunhyungLevel;
  1527.  
  1528.         //
  1529.         // Skill levels
  1530.         //
  1531.     protected:
  1532.         TPlayerSkill*                   m_pSkillLevels;
  1533.         boost::unordered_map<BYTE, int>     m_SkillDamageBonus;
  1534.         std::map<int, TSkillUseInfo>    m_SkillUseInfo;
  1535.  
  1536.         ////////////////////////////////////////////////////////////////////////////////////////
  1537.         // AI related
  1538.     public:
  1539.         void            AssignTriggers(const TMobTable * table);
  1540.         LPCHARACTER     GetVictim() const;  // °ř°ÝÇŇ ´ë»ó ¸®ĹĎ
  1541.         void            SetVictim(LPCHARACTER pkVictim);
  1542.         LPCHARACTER     GetNearestVictim(LPCHARACTER pkChr);
  1543.         LPCHARACTER     GetProtege() const; // ş¸ČŁÇŘľß ÇŇ ´ë»ó ¸®ĹĎ
  1544.  
  1545.         bool            Follow(LPCHARACTER pkChr, float fMinimumDistance = 150.0f);
  1546.         bool            Return();
  1547.         bool            IsGuardNPC() const;
  1548.         bool            IsChangeAttackPosition(LPCHARACTER target) const;
  1549.         void            ResetChangeAttackPositionTime() { m_dwLastChangeAttackPositionTime = get_dword_time() - AI_CHANGE_ATTACK_POISITION_TIME_NEAR;}
  1550.         void            SetChangeAttackPositionTime() { m_dwLastChangeAttackPositionTime = get_dword_time();}
  1551.  
  1552.         bool            OnIdle();
  1553.  
  1554.         void            OnAttack(LPCHARACTER pkChrAttacker);
  1555.         void            OnClick(LPCHARACTER pkChrCauser);
  1556.  
  1557.         VID             m_kVIDVictim;
  1558.  
  1559.     protected:
  1560.         DWORD           m_dwLastChangeAttackPositionTime;
  1561.         CTrigger        m_triggerOnClick;
  1562.         // End of AI
  1563.  
  1564.         ////////////////////////////////////////////////////////////////////////////////////////
  1565.         // Target
  1566.     protected:
  1567.         LPCHARACTER             m_pkChrTarget;      // ł» Ÿ°Ů
  1568.         CHARACTER_SET   m_set_pkChrTargetedBy;  // łŞ¸¦ Ÿ°ŮŔ¸·Î °ˇÁö°í ŔÖ´Â »ç¶÷µé
  1569.  
  1570.     public:
  1571.         void                SetTarget(LPCHARACTER pkChrTarget);
  1572.         void                BroadcastTargetPacket();
  1573.         void                ClearTarget();
  1574.         void                CheckTarget();
  1575.         LPCHARACTER         GetTarget() const { return m_pkChrTarget; }
  1576.  
  1577.         ////////////////////////////////////////////////////////////////////////////////////////
  1578.         // Safebox
  1579.     public:
  1580.         int                 GetSafeboxSize() const;
  1581.         void                QuerySafeboxSize();
  1582.         void                SetSafeboxSize(int size);
  1583.  
  1584.         CSafebox *          GetSafebox() const;
  1585.         void                LoadSafebox(int iSize, DWORD dwGold, int iItemCount, TPlayerItem * pItems);
  1586.         void                ChangeSafeboxSize(BYTE bSize);
  1587.         void                CloseSafebox();
  1588.  
  1589.         /// â°í ż­±â żäĂ»
  1590.         /**
  1591.          * @param [in]  pszPassword 1ŔÚ ŔĚ»ó 6ŔÚ ŔĚÇĎŔÇ Ă˘°í şńąĐąřČŁ
  1592.          *
  1593.          * DB żˇ â°íż­±â¸¦ żäĂ»ÇŃ´Ů.
  1594.          * â°í´Â ÁßşąŔ¸·Î ż­Áö ¸řÇϸç, Ăֱ٠â°í¸¦ ´ÝŔş ˝Ă°ŁŔ¸·Î şÎĹÍ 10ĂĘ ŔĚł»żˇ´Â ż­ Áö ¸řÇŃ´Ů.
  1595.          */
  1596.         void                ReqSafeboxLoad(const char* pszPassword);
  1597.  
  1598.         /// â°í ż­±â żäĂ»ŔÇ ĂëĽŇ
  1599.         /**
  1600.          * ReqSafeboxLoad ¸¦ ČŁĂâÇĎ°í CloseSafebox ÇĎÁö ľĘľŇŔ» ¶§ ŔĚ ÇÔĽö¸¦ ČŁĂâÇϸé â°í¸¦ ż­ Ľö ŔÖ´Ů.
  1601.          * â°íż­±âŔÇ żäĂ»ŔĚ DB Ľ­ąöżˇĽ­ ˝ÇĆĐŔŔ´äŔ» ąŢľŇŔ» °ćżě ŔĚ ÇÔĽö¸¦ »çżëÇŘĽ­ żäĂ»Ŕ» ÇŇ Ľö ŔÖ°Ô ÇŘÁŘ´Ů.
  1602.          */
  1603.         void                CancelSafeboxLoad( void ) { m_bOpeningSafebox = false; }
  1604.  
  1605.         void                SetMallLoadTime(int t) { m_iMallLoadTime = t; }
  1606.         int                 GetMallLoadTime() const { return m_iMallLoadTime; }
  1607.  
  1608.         CSafebox *          GetMall() const;
  1609.         void                LoadMall(int iItemCount, TPlayerItem * pItems);
  1610.         void                CloseMall();
  1611.  
  1612.         void                SetSafeboxOpenPosition();
  1613.         float               GetDistanceFromSafeboxOpen() const;
  1614.  
  1615.     protected:
  1616.         CSafebox *          m_pkSafebox;
  1617.         int                 m_iSafeboxSize;
  1618.         int                 m_iSafeboxLoadTime;
  1619.         bool                m_bOpeningSafebox;  ///< â°í°ˇ ż­±â żäĂ» ÁßŔĚ°ĹłŞ ż­·ÁŔִ°ˇ ż©şÎ, true ŔĎ °ćżě ż­±âżäĂ»ŔĚ°ĹłŞ ż­·ÁŔÖŔ˝.
  1620.  
  1621.         CSafebox *          m_pkMall;
  1622.         int                 m_iMallLoadTime;
  1623.  
  1624.         PIXEL_POSITION      m_posSafeboxOpen;
  1625.  
  1626.         ////////////////////////////////////////////////////////////////////////////////////////
  1627.  
  1628.         ////////////////////////////////////////////////////////////////////////////////////////
  1629.         // Mounting
  1630.     public:
  1631.         void                MountVnum(DWORD vnum);
  1632.         DWORD               GetMountVnum() const { return m_dwMountVnum; }
  1633.         DWORD               GetLastMountTime() const { return m_dwMountTime; }
  1634.  
  1635.         bool                CanUseHorseSkill();
  1636.  
  1637.         // Horse
  1638.         virtual void        SetHorseLevel(int iLevel);
  1639.  
  1640.         virtual bool        StartRiding();
  1641.         virtual bool        StopRiding();
  1642.  
  1643.         virtual DWORD       GetMyHorseVnum() const;
  1644.  
  1645.         virtual void        HorseDie();
  1646.         virtual bool        ReviveHorse();
  1647.  
  1648.         virtual void        SendHorseInfo();
  1649.         virtual void        ClearHorseInfo();
  1650.  
  1651.         void                HorseSummon(bool bSummon, bool bFromFar = false, DWORD dwVnum = 0, const char* name = 0);
  1652.  
  1653.         LPCHARACTER         GetHorse() const            { return m_chHorse; }    // ÇöŔç ĽŇČŻÁßŔÎ ¸»
  1654.         LPCHARACTER         GetRider() const; // rider on horse
  1655.         void                SetRider(LPCHARACTER ch);
  1656.  
  1657.         bool                IsRiding() const;
  1658.  
  1659. #ifdef __PET_SYSTEM__
  1660.     public:
  1661.         CPetSystem*         GetPetSystem()              { return m_petSystem; }
  1662.  
  1663.     protected:
  1664.         CPetSystem*         m_petSystem;
  1665.  
  1666.     public:
  1667. #endif
  1668.  
  1669.     protected:
  1670.         LPCHARACTER         m_chHorse;
  1671.         LPCHARACTER         m_chRider;
  1672.  
  1673.         DWORD               m_dwMountVnum;
  1674.         DWORD               m_dwMountTime;
  1675.  
  1676.         BYTE                m_bSendHorseLevel;
  1677.         BYTE                m_bSendHorseHealthGrade;
  1678.         BYTE                m_bSendHorseStaminaGrade;
  1679.  
  1680.         ////////////////////////////////////////////////////////////////////////////////////////
  1681.         // Detailed Log
  1682.     public:
  1683.         void                DetailLog() { m_bDetailLog = !m_bDetailLog; }
  1684.         void                ToggleMonsterLog();
  1685.         void                MonsterLog(const char* format, ...);
  1686.     private:
  1687.         bool                m_bDetailLog;
  1688.         bool                m_bMonsterLog;
  1689.  
  1690.         ////////////////////////////////////////////////////////////////////////////////////////
  1691.         // Empire
  1692.  
  1693.     public:
  1694.         void                SetEmpire(BYTE bEmpire);
  1695.         BYTE                GetEmpire() const { return m_bEmpire; }
  1696.  
  1697.     protected:
  1698.         BYTE                m_bEmpire;
  1699.  
  1700.         ////////////////////////////////////////////////////////////////////////////////////////
  1701.         // Regen
  1702.     public:
  1703.         void                SetRegen(LPREGEN pkRegen);
  1704.  
  1705.     protected:
  1706.         PIXEL_POSITION          m_posRegen;
  1707.         float               m_fRegenAngle;
  1708.         LPREGEN             m_pkRegen;
  1709.         size_t              regen_id_; // to help dungeon regen identification
  1710.         // End of Regen
  1711.  
  1712.         ////////////////////////////////////////////////////////////////////////////////////////
  1713.         // Resists & Proofs
  1714.     public:
  1715.         bool                CannotMoveByAffect() const; // ĆŻÁ¤ Čż°úżˇ ŔÇÇŘ żňÁ÷ŔĎ Ľö ľř´Â »óĹÂŔΰˇ?
  1716.         bool                IsImmune(DWORD dwImmuneFlag);
  1717.         void                UpdateImmuneFlags();
  1718.         void                SetImmuneFlag(DWORD dw) { m_pointsInstant.dwImmuneFlag = dw; }
  1719.  
  1720.     protected:
  1721.         void                ApplyMobAttribute(const TMobTable* table);
  1722.         // End of Resists & Proofs
  1723.  
  1724.         ////////////////////////////////////////////////////////////////////////////////////////
  1725.         // QUEST
  1726.         //
  1727.     public:
  1728.         void                SetQuestNPCID(DWORD vid);
  1729.         DWORD               GetQuestNPCID() const { return m_dwQuestNPCVID; }
  1730.         LPCHARACTER         GetQuestNPC() const;
  1731. #ifdef ANTYDMG
  1732.         int GetLastTimeDmg(std::string name);
  1733.         void    SetLastTimeDmg(std::string name, int value);
  1734.         void    ClearLastTimeDmg();
  1735.         //DMG_HACK_END
  1736. #endif     
  1737.         void                SetQuestItemPtr(LPITEM item);
  1738.         void                ClearQuestItemPtr();
  1739.         LPITEM              GetQuestItemPtr() const;
  1740.  
  1741.         void                SetQuestBy(DWORD dwQuestVnum)   { m_dwQuestByVnum = dwQuestVnum; }
  1742.         DWORD               GetQuestBy() const          { return m_dwQuestByVnum; }
  1743.  
  1744.         int                 GetQuestFlag(const std::string& flag) const;
  1745.         void                SetQuestFlag(const std::string& flag, int value);
  1746.     #ifdef FIX_SYNC_HACK
  1747.         void    SetSyncPosition(long x, long y);
  1748.         bool    CheckSyncPosition(bool sync_check = false);
  1749.         void    SetSyncCount(int count) { sync_count += count; }
  1750.     #endif
  1751.  
  1752.         void                ConfirmWithMsg(const char* szMsg, int iTimeout, DWORD dwRequestPID);
  1753.  
  1754.     private:
  1755.         DWORD               m_dwQuestNPCVID;
  1756.         DWORD               m_dwQuestByVnum;
  1757.     #ifdef FIX_SYNC_HACK
  1758.         DWORD sync_hack;
  1759.         int sync_count;
  1760.         unsigned int sync_time;
  1761.     #endif
  1762.         LPITEM              m_pQuestItem;
  1763.     #ifdef ANTYDMG
  1764.         std::map<std::string, int>  m_map_DmgTime;
  1765.     #endif
  1766.         // Events
  1767.     public:
  1768.         bool                StartStateMachine(int iPulse = 1);
  1769.         void                StopStateMachine();
  1770.         void                UpdateStateMachine(DWORD dwPulse);
  1771.         void                SetNextStatePulse(int iPulseNext);
  1772.  
  1773.         // Äł¸ŻĹÍ ŔνşĹĎ˝ş ľ÷µĄŔĚĆ® ÇÔĽö. ±âÁ¸żŁ ŔĚ»óÇŃ »óĽÓ±¸Á¶·Î CFSM::Update ÇÔĽö¸¦ ČŁĂâÇĎ°ĹłŞ UpdateStateMachine ÇÔĽö¸¦ »çżëÇߴµĄ, ş°°łŔÇ ľ÷µĄŔĚĆ® ÇÔĽö Ăß°ˇÇÔ.
  1774.         void                UpdateCharacter(DWORD dwPulse);
  1775.  
  1776.     protected:
  1777.         DWORD               m_dwNextStatePulse;
  1778.  
  1779.         // Marriage
  1780.     public:
  1781.         LPCHARACTER         GetMarryPartner() const;
  1782.         void                SetMarryPartner(LPCHARACTER ch);
  1783.         int                 GetMarriageBonus(DWORD dwItemVnum, bool bSum = true);
  1784.  
  1785.         void                SetWeddingMap(marriage::WeddingMap* pMap);
  1786.         marriage::WeddingMap* GetWeddingMap() const { return m_pWeddingMap; }
  1787.  
  1788.     private:
  1789.         marriage::WeddingMap* m_pWeddingMap;
  1790.         LPCHARACTER         m_pkChrMarried;
  1791.  
  1792.         // Warp Character
  1793.     public:
  1794.         void                StartWarpNPCEvent();
  1795.         void                ChannelSwitch(int new_ch);
  1796.  
  1797.     public:
  1798.         void                StartSaveEvent();
  1799.         void                StartRecoveryEvent();
  1800.         void                StartCheckSpeedHackEvent();
  1801.         void                StartDestroyWhenIdleEvent();
  1802.  
  1803.         LPEVENT             m_pkDeadEvent;
  1804.         LPEVENT             m_pkStunEvent;
  1805.         LPEVENT             m_pkSaveEvent;
  1806.         LPEVENT             m_pkRecoveryEvent;
  1807.         LPEVENT             m_pkTimedEvent;
  1808.         LPEVENT             m_pkFishingEvent;
  1809.         LPEVENT             m_pkAffectEvent;
  1810.         LPEVENT             m_pkPoisonEvent;
  1811.         LPEVENT             m_pkFireEvent;
  1812.         LPEVENT             m_pkWarpNPCEvent;
  1813.         LPEVENT             m_pkChannelEvent;
  1814.         //DELAYED_WARP
  1815.         //END_DELAYED_WARP
  1816.  
  1817.         // MINING
  1818.         LPEVENT             m_pkMiningEvent;
  1819.         // END_OF_MINING
  1820.         LPEVENT             m_pkWarpEvent;
  1821.         LPEVENT             m_pkCheckSpeedHackEvent;
  1822.         LPEVENT             m_pkDestroyWhenIdleEvent;
  1823.         LPEVENT             m_pkPetSystemUpdateEvent;
  1824.  
  1825.         bool IsWarping() const { return m_pkWarpEvent ? true : false; }
  1826.  
  1827.         bool                m_bHasPoisoned;
  1828.  
  1829.         const CMob *        m_pkMobData;
  1830.         CMobInstance *      m_pkMobInst;
  1831.  
  1832.         std::map<int, LPEVENT> m_mapMobSkillEvent;
  1833.  
  1834.         friend struct FuncSplashDamage;
  1835.         friend struct FuncSplashAffect;
  1836.         friend class CFuncShoot;
  1837.  
  1838.     public:
  1839.         int             GetPremiumRemainSeconds(BYTE bType) const;
  1840.  
  1841.     private:
  1842.         int             m_aiPremiumTimes[PREMIUM_MAX_NUM];
  1843.  
  1844.         // CHANGE_ITEM_ATTRIBUTES
  1845.         static const DWORD      msc_dwDefaultChangeItemAttrCycle;   ///< µđĆúĆ® ľĆŔĚĹŰ ĽÓĽşşŻ°ć °ˇ´É ÁÖ±â
  1846.         static const char       msc_szLastChangeItemAttrFlag[];     ///< Ăֱ٠ľĆŔĚĹŰ ĽÓĽşŔ» şŻ°ćÇŃ ˝Ă°ŁŔÇ Quest Flag Ŕ̸§
  1847.         static const char       msc_szChangeItemAttrCycleFlag[];        ///< ľĆŔĚĹŰ ĽÓĽşş´°ć °ˇ´É ÁÖ±âŔÇ Quest Flag Ŕ̸§
  1848.         // END_OF_CHANGE_ITEM_ATTRIBUTES
  1849.  
  1850.         // PC_BANG_ITEM_ADD
  1851.     private :
  1852.         bool m_isinPCBang;
  1853.  
  1854.     public :
  1855.         bool SetPCBang(bool flag) { m_isinPCBang = flag; return m_isinPCBang; }
  1856.         bool IsPCBang() const { return m_isinPCBang; }
  1857.         // END_PC_BANG_ITEM_ADD
  1858.  
  1859.         // NEW_HAIR_STYLE_ADD
  1860.     public :
  1861.         bool ItemProcess_Hair(LPITEM item, int iDestCell);
  1862.         // END_NEW_HAIR_STYLE_ADD
  1863.  
  1864.     public :
  1865.         void ClearSkill();
  1866.         void ClearSubSkill();
  1867.  
  1868.         // RESET_ONE_SKILL
  1869.         bool ResetOneSkill(DWORD dwVnum);
  1870.         void JewelryStatus();
  1871.         void GetCostumeStatus();
  1872.         void UpdateSavePositionWindow();
  1873.         bool CanSavePosition();
  1874.         // END_RESET_ONE_SKILL
  1875.  
  1876.     private :
  1877.         void SendDamagePacket(LPCHARACTER pAttacker, int Damage, BYTE DamageFlag);
  1878.  
  1879.     // ARENA
  1880.     private :
  1881.         CArena *m_pArena;
  1882.         bool m_ArenaObserver;
  1883.         int m_nPotionLimit;
  1884.  
  1885.     public :
  1886.         void    SetArena(CArena* pArena) { m_pArena = pArena; }
  1887.         void    SetArenaObserverMode(bool flag) { m_ArenaObserver = flag; }
  1888.  
  1889.         CArena* GetArena() const { return m_pArena; }
  1890.         bool    GetArenaObserverMode() const { return m_ArenaObserver; }
  1891.  
  1892.         void    SetPotionLimit(int count) { m_nPotionLimit = count; }
  1893.         int     GetPotionLimit() const { return m_nPotionLimit; }
  1894.     // END_ARENA
  1895.  
  1896.         //PREVENT_TRADE_WINDOW
  1897.     public:
  1898.         bool    IsOpenSafebox() const { return m_isOpenSafebox ? true : false; }
  1899.         void    SetOpenSafebox(bool b) { m_isOpenSafebox = b; }
  1900.  
  1901.         int     GetSafeboxLoadTime() const { return m_iSafeboxLoadTime; }
  1902.         void    SetSafeboxLoadTime() { m_iSafeboxLoadTime = thecore_pulse(); }
  1903.         //END_PREVENT_TRADE_WINDOW
  1904.     private:
  1905.         bool    m_isOpenSafebox;
  1906.  
  1907.     public:
  1908.         int     GetSkillPowerByLevel(int level, bool bMob = false) const;
  1909.        
  1910.         //PREVENT_REFINE_HACK
  1911.         int     GetRefineTime() const { return m_iRefineTime; }
  1912.         void    SetRefineTime() { m_iRefineTime = thecore_pulse(); }
  1913.         int     m_iRefineTime;
  1914.         //END_PREVENT_REFINE_HACK
  1915.  
  1916.         //RESTRICT_USE_SEED_OR_MOONBOTTLE
  1917.         int     GetUseSeedOrMoonBottleTime() const { return m_iSeedTime; }
  1918.         void    SetUseSeedOrMoonBottleTime() { m_iSeedTime = thecore_pulse(); }
  1919.         int     m_iSeedTime;
  1920.         //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  1921.        
  1922.         //PREVENT_PORTAL_AFTER_EXCHANGE
  1923.         int     GetExchangeTime() const { return m_iExchangeTime; }
  1924.         void    SetExchangeTime() { m_iExchangeTime = thecore_pulse(); }
  1925.         int     m_iExchangeTime;
  1926.         //END_PREVENT_PORTAL_AFTER_EXCHANGE
  1927.        
  1928.         int     m_iMyShopTime;
  1929.         int     GetMyShopTime() const   { return m_iMyShopTime; }
  1930.         void    SetMyShopTime() { m_iMyShopTime = thecore_pulse(); }
  1931.  
  1932.         // Hack ąćÁö¸¦ Ŕ§ÇŃ ĂĽĹ©.
  1933.         bool    IsHack(bool bSendMsg = true, bool bCheckShopOwner = true, int limittime = g_nPortalLimitTime);
  1934.  
  1935.         // MONARCH
  1936.         BOOL    IsMonarch() const;
  1937.         // END_MONARCH
  1938.         void Say(const std::string & s);
  1939.  
  1940.         enum MONARCH_COOLTIME
  1941.         {
  1942.             MC_HEAL = 10,
  1943.             MC_WARP = 60,
  1944.             MC_TRANSFER = 60,
  1945.             MC_TAX = (60 * 60 * 24 * 7),
  1946.             MC_SUMMON = (60 * 60),
  1947.         };
  1948.  
  1949.         enum MONARCH_INDEX
  1950.         {
  1951.             MI_HEAL = 0,
  1952.             MI_WARP,
  1953.             MI_TRANSFER,
  1954.             MI_TAX,
  1955.             MI_SUMMON,
  1956.             MI_MAX
  1957.         };
  1958.  
  1959.         DWORD m_dwMonarchCooltime[MI_MAX];
  1960.         DWORD m_dwMonarchCooltimelimit[MI_MAX];
  1961.  
  1962.         void  InitMC();
  1963.         DWORD GetMC(enum MONARCH_INDEX e) const;
  1964.         void SetMC(enum MONARCH_INDEX e);
  1965.         bool IsMCOK(enum MONARCH_INDEX e) const;
  1966.         DWORD GetMCL(enum MONARCH_INDEX e) const;
  1967.         DWORD GetMCLTime(enum MONARCH_INDEX e) const;
  1968.  
  1969.     public:
  1970.         bool ItemProcess_Polymorph(LPITEM item);
  1971.  
  1972.         // by mhh
  1973.         LPITEM* GetCubeItem() { return m_pointsInstant.pCubeItems; }
  1974.         bool IsCubeOpen () const    { return (m_pointsInstant.pCubeNpc?true:false); }
  1975.         void SetCubeNpc(LPCHARACTER npc)    { m_pointsInstant.pCubeNpc = npc; }
  1976.         bool CanDoCube() const;
  1977.  
  1978.     public:
  1979.         bool IsSiegeNPC() const;
  1980.  
  1981.     private:
  1982.         //Áß±ą Ŕüżë
  1983.         //18ĽĽ ąĚ¸¸ Ŕüżë
  1984.         //3˝Ă°Ł : 50 % 5 ˝Ă°Ł 0%
  1985.         e_overtime m_eOverTime;
  1986.  
  1987.     public:
  1988.         bool IsOverTime(e_overtime e) const { return (e == m_eOverTime); }
  1989.         void SetOverTime(e_overtime e) { m_eOverTime = e; }
  1990.  
  1991.     private:
  1992.         int     m_deposit_pulse;
  1993.  
  1994.     public:
  1995.         void    UpdateDepositPulse();
  1996.         bool    CanDeposit() const;
  1997.  
  1998.     private:
  1999.         void    __OpenPrivateShop();
  2000.  
  2001.     public:
  2002.         struct AttackedLog
  2003.         {
  2004.             DWORD   dwPID;
  2005.             DWORD   dwAttackedTime;
  2006.            
  2007.             AttackedLog() : dwPID(0), dwAttackedTime(0)
  2008.             {
  2009.             }
  2010.         };
  2011.  
  2012.         AttackLog   m_kAttackLog;
  2013.         AttackedLog m_AttackedLog;
  2014.         int         m_speed_hack_count;
  2015.  
  2016.     private :
  2017.         std::string m_strNewName;
  2018.  
  2019.     public :
  2020.         const std::string GetNewName() const { return this->m_strNewName; }
  2021.         void SetNewName(const std::string name) { this->m_strNewName = name; }
  2022.  
  2023.     public :
  2024.         void GoHome();
  2025.  
  2026.     private :
  2027.         std::set<DWORD> m_known_guild;
  2028.  
  2029.     public :
  2030.         void SendGuildName(CGuild* pGuild);
  2031.         void SendGuildName(DWORD dwGuildID);
  2032.  
  2033.     private :
  2034.         DWORD m_dwLogOffInterval;
  2035.  
  2036.     public :
  2037.         DWORD GetLogOffInterval() const { return m_dwLogOffInterval; }
  2038.  
  2039.     public:
  2040.         bool UnEquipSpecialRideUniqueItem ();
  2041.  
  2042.         bool CanWarp () const;
  2043.  
  2044.     private:
  2045.         DWORD m_dwLastGoldDropTime;
  2046.  
  2047.     public:
  2048.         void StartHackShieldCheckCycle(int seconds);
  2049.         void StopHackShieldCheckCycle();
  2050.  
  2051.         bool GetHackShieldCheckMode() const { return m_HackShieldCheckMode; }
  2052.         void SetHackShieldCheckMode(bool m) { m_HackShieldCheckMode = m; }
  2053.  
  2054.         LPEVENT m_HackShieldCheckEvent;
  2055.  
  2056.     private:
  2057.         bool    m_HackShieldCheckMode;
  2058.  
  2059.     public:
  2060.         void AutoRecoveryItemProcess (const EAffectTypes);
  2061.  
  2062.     public:
  2063.         void BuffOnAttr_AddBuffsFromItem(LPITEM pItem);
  2064.         void BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem);
  2065.  
  2066.     private:
  2067.         void BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue);
  2068.         void BuffOnAttr_ClearAll();
  2069.  
  2070.         typedef std::map <BYTE, CBuffOnAttributes*> TMapBuffOnAttrs;
  2071.         TMapBuffOnAttrs m_map_buff_on_attrs;
  2072.         // ą«Ŕű : żřČ°ÇŃ Ĺ×˝şĆ®¸¦ Ŕ§ÇĎż©.
  2073.     public:
  2074.         void SetArmada() { cannot_dead = true; }
  2075.         void ResetArmada() { cannot_dead = false; }
  2076.     private:
  2077.         bool cannot_dead;
  2078.  
  2079. #ifdef __PET_SYSTEM__
  2080.     private:
  2081.         bool m_bIsPet;
  2082.     public:
  2083.         void SetPet() { m_bIsPet = true; }
  2084.         bool IsPet() { return m_bIsPet; }
  2085. #endif
  2086.  
  2087.     //ĂÖÁľ µĄąĚÁö ş¸Á¤.
  2088.     private:
  2089.         float m_fAttMul;
  2090.         float m_fDamMul;
  2091.     public:
  2092.         float GetAttMul() { return this->m_fAttMul; }
  2093.         void SetAttMul(float newAttMul) {this->m_fAttMul = newAttMul; }
  2094.         float GetDamMul() { return this->m_fDamMul; }
  2095.         void SetDamMul(float newDamMul) {this->m_fDamMul = newDamMul; }
  2096.  
  2097.     private:
  2098.         bool IsValidItemPosition(TItemPos Pos) const;
  2099.  
  2100.         //µ¶ŔĎ Ľ±ą° ±â´É ĆĐŶ Ŕӽà ŔúŔĺ
  2101.     private:
  2102.         unsigned int itemAward_vnum;
  2103.         char         itemAward_cmd[20];
  2104.         //bool       itemAward_flag;
  2105.     public:
  2106.         unsigned int GetItemAward_vnum() { return itemAward_vnum; }
  2107.         char*        GetItemAward_cmd() { return itemAward_cmd;   }
  2108.         //bool       GetItemAward_flag() { return itemAward_flag; }
  2109.         void         SetItemAward_vnum(unsigned int vnum) { itemAward_vnum = vnum; }
  2110.         void         SetItemAward_cmd(char* cmd) { strcpy(itemAward_cmd,cmd); }
  2111.         //void       SetItemAward_flag(bool flag) { itemAward_flag = flag; }
  2112.  
  2113.     public:
  2114.         //żëČĄĽ®
  2115.        
  2116.         // Äł¸ŻĹÍŔÇ affect, quest°ˇ load µÇ±â Ŕüżˇ DragonSoul_Initialize¸¦ ČŁĂâÇĎ¸é ľČµČ´Ů.
  2117.         // affect°ˇ °ˇŔĺ ¸¶Áö¸·żˇ ·ÎµĺµÇľî LoadAffectżˇĽ­ ČŁĂâÇÔ.
  2118.         void    DragonSoul_Initialize();
  2119.  
  2120.         bool    DragonSoul_IsQualified() const;
  2121.         void    DragonSoul_GiveQualification();
  2122.  
  2123.         int     DragonSoul_GetActiveDeck() const;
  2124.         bool    DragonSoul_IsDeckActivated() const;
  2125.         bool    DragonSoul_ActivateDeck(int deck_idx);
  2126.  
  2127.         void    DragonSoul_DeactivateAll();
  2128.         // ąÝµĺ˝Ă ClearItem Ŕüżˇ şŇ·Żľß ÇŃ´Ů.
  2129.         // żÖłÄÇϸé....
  2130.         // żëČĄĽ® ÇĎłŞ ÇĎłŞ¸¦ deactivateÇŇ ¶§¸¶´Ů µ¦żˇ activeŔÎ żëČĄĽ®ŔĚ ŔÖ´ÂÁö Č®ŔÎÇĎ°í,
  2131.         // activeŔÎ żëČĄĽ®ŔĚ ÇĎłŞµµ ľř´Ů¸é, Äł¸ŻĹÍŔÇ żëČĄĽ® affectżÍ, Č°Ľş »óŸ¦ Á¦°ĹÇŃ´Ů.
  2132.         //
  2133.         // ÇĎÁö¸¸ ClearItem ˝Ă, Äł¸ŻĹÍ°ˇ ÂřżëÇĎ°í ŔÖ´Â ¸đµç ľĆŔĚĹŰŔ» unequipÇĎ´Â ąŮ¶÷żˇ,
  2134.         // żëČĄĽ® Affect°ˇ Á¦°ĹµÇ°í, °á±ą ·Î±×ŔÎ ˝Ă, żëČĄĽ®ŔĚ Č°ĽşČ­µÇÁö ľĘ´Â´Ů.
  2135.         // (UnequipÇŇ ¶§żˇ´Â ·Î±×ľĆżô »óĹÂŔÎÁö, ľĆ´ŃÁö ľË Ľö ľř´Ů.)
  2136.         // żëČĄĽ®¸¸ deactivate˝ĂĹ°°í Äł¸ŻĹÍŔÇ żëČĄĽ® µ¦ Č°Ľş »óĹ´ °Çµĺ¸®Áö ľĘ´Â´Ů.
  2137.         void    DragonSoul_CleanUp();
  2138.         // żëČĄĽ® °­Č­Ă˘
  2139.     public:
  2140.         bool        DragonSoul_RefineWindow_Open(LPENTITY pEntity);
  2141.         bool        DragonSoul_RefineWindow_Close();
  2142.         LPENTITY    DragonSoul_RefineWindow_GetOpener() { return  m_pointsInstant.m_pDragonSoulRefineWindowOpener; }
  2143.         bool        DragonSoul_RefineWindow_CanRefine();
  2144.  
  2145.     private:
  2146.         // SyncPositionŔ» ľÇżëÇĎż© ŸŔŻŔú¸¦ ŔĚ»óÇŃ °÷Ŕ¸·Î ş¸ł»´Â ÇŮ ąćľîÇϱâ Ŕ§ÇĎż©,
  2147.         // SyncPositionŔĚ ŔϾ ¶§¸¦ ±â·Ď.
  2148.         timeval     m_tvLastSyncTime;
  2149.         int         m_iSyncHackCount;
  2150.     public:
  2151.         void            SetLastSyncTime(const timeval &tv) { memcpy(&m_tvLastSyncTime, &tv, sizeof(timeval)); }
  2152.         const timeval&  GetLastSyncTime() { return m_tvLastSyncTime; }
  2153.         void            SetSyncHackCount(int iCount) { m_iSyncHackCount = iCount;}
  2154.         int             GetSyncHackCount() { return m_iSyncHackCount; }
  2155. #ifdef COOLDOWN_SASH_HAIR_COSTUME_PET_WEAPON_COSTUME
  2156.     public:
  2157.         time_t              SashCooldown;
  2158.         time_t              HairCooldown;
  2159.         time_t              CostumeCooldown;
  2160.         time_t              PetCooldown;
  2161.         time_t              CostumeWeaponCooldown;
  2162.         time_t              AutoPotionCooldown;
  2163. #endif
  2164. #ifdef COOLDOWN_PETARDY
  2165.         time_t              PetardyCooldown;
  2166. #endif
  2167.  
  2168.     public:
  2169.         void        ClearPMCounter(void)       { m_iPMCounter = 0;      }
  2170.         void        IncreasePMCounter(void)    { m_iPMCounter++;        }
  2171.         void        SetLastPMPulse(void);
  2172.         int         GetPMCounter(void)   const { return m_iPMCounter;   }
  2173.         int         GetLastPMPulse(void) const { return m_iLastPMPulse; }
  2174.     protected:
  2175.         int         m_iLastPMPulse;
  2176.         int         m_iPMCounter;
  2177.        
  2178.     public:
  2179.         int         GetChannelLastChange(void) { return LastChangeChannel; }
  2180.         void        SetChannelLastChange(int time);
  2181.         int         GetShopSearchCount(void) { return ShopSearchCount; }
  2182.         void        SetShopSearchCount(int count);
  2183.         int         GetShopSearchTime(void) { return ShopSearchTime; }
  2184.         void        SetShopSearchTime(int time);
  2185.        
  2186.         //hide_costume
  2187.         int         GetCostumeHairTime(void) { return CostumeHairTime; }
  2188.         void        SetCostumeHairTime(int time);
  2189.         int         GetCostumeArmorTime(void) { return CostumeArmorTime; }
  2190.         void        SetCostumeArmorTime(int time);
  2191.         int         GetCostumeWeaponTime(void) { return CostumeWeaponTime; }
  2192.         void        SetCostumeWeaponTime(int time);
  2193.         int         GetCostumeSashTime(void) { return CostumeSashTime; }
  2194.         void        SetCostumeSashTime(int time);
  2195.        
  2196.     protected:
  2197.         int         LastChangeChannel;
  2198.         int         ShopSearchCount;
  2199.         int         ShopSearchTime;
  2200.        
  2201.         int         CostumeHairTime;
  2202.         int         CostumeArmorTime;
  2203.         int         CostumeWeaponTime;
  2204.         int         CostumeSashTime;
  2205.        
  2206.     public:
  2207.         int         GetShopCreateTime(void) { return ShopCreateTime; }
  2208.         void        SetShopCreateTime(int time);
  2209.         int         GetShopEditTime(void) { return ShopEditTime; }
  2210.         void        SetShopEditTime(int time);
  2211.        
  2212.     protected:
  2213.         int         ShopCreateTime;
  2214.         int         ShopEditTime;
  2215.  
  2216. #ifdef COOLDOWN_WYRZUCANIE_ITEMOW  
  2217.     public:
  2218.         int         GetDropLastTime(void) { return LastDropTime; }
  2219.         void        SetDropLastTime(int time);
  2220.        
  2221.     protected:
  2222.         int         LastDropTime;
  2223. #endif
  2224.  
  2225. #ifdef COOLDOWN_SHOW_SHOP
  2226.     public:
  2227.         int         GetShowShopLastTime(void) { return LastShowShopTime; }
  2228.         void        SetShowShopLastTime(int time);
  2229.        
  2230.     protected:
  2231.         int         LastShowShopTime;
  2232. #endif
  2233.    
  2234.     #ifdef __SASH_SYSTEM__
  2235.     protected:
  2236.         bool    m_bSashCombination, m_bSashAbsorption;
  2237.    
  2238.     public:
  2239.         bool    isSashOpened(bool bCombination) {return bCombination ? m_bSashCombination : m_bSashAbsorption;}
  2240.         void    OpenSash(bool bCombination);
  2241.         void    CloseSash();
  2242.         void    ClearSashMaterials();
  2243.         bool    CleanSashAttr(LPITEM pkItem, LPITEM pkTarget);
  2244.         LPITEM* GetSashMaterials() {return m_pointsInstant.pSashMaterials;}
  2245.         bool    SashIsSameGrade(long lGrade);
  2246.         long long   GetSashCombinePrice(long lGrade);
  2247.         void    GetSashCombineResult(DWORD & dwItemVnum, DWORD & dwMinAbs, DWORD & dwMaxAbs);
  2248.         BYTE    CheckEmptyMaterialSlot();
  2249.         void    AddSashMaterial(TItemPos tPos, BYTE bPos);
  2250.         void    RemoveSashMaterial(BYTE bPos);
  2251.         BYTE    CanRefineSashMaterials();
  2252.         void    RefineSashMaterials();
  2253.     #endif
  2254.    
  2255.     public:
  2256.         void            SendGMHackLog(const char * reason, int type = 0);
  2257.    
  2258. #ifdef OFFLINE_SHOP
  2259.     public:
  2260.         void            OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount, DWORD days);
  2261.         void            SendShops(bool isGm = false);
  2262.         void            OpenShop(DWORD id, const char *name, bool onboot = false);
  2263.         void            SetPrivShop(DWORD shop_id) { bprivShop = shop_id; }
  2264.         BOOL            IsPrivShop(void)  const { return bprivShop>0; }
  2265.         DWORD           GetPrivShop()  const { return bprivShop; }
  2266.         void            SetPrivShopOwner(DWORD id) { bprivShopOwner = id; }
  2267.         DWORD           GetPrivShopOwner()  const { return bprivShopOwner; }
  2268.         void            DeleteMyShop();
  2269.         DWORD           GetShopTime()  const { return dw_ShopTime; }
  2270.         void            SetShopTime(DWORD time) { dw_ShopTime = time; }
  2271.         void            SetShopSign(const char * name);
  2272.         void            LoadPrivShops();
  2273.         void            SendShopBank();
  2274.         TPrivShop       GetPrivShopTable(DWORD id);
  2275.         void            RemovePrivShopTable(DWORD id);
  2276.         void            UpdatePrivShopTable(DWORD id, TPrivShop shop);
  2277.         void            UpdateShopItems();
  2278.         void            SendShopCost();
  2279.         bool            CheckOfflineShopPos(int id);
  2280.     private:
  2281.         PSHOP_MAP       m_mapshops;
  2282.         DWORD           bprivShop;
  2283.         DWORD           bprivShopOwner;
  2284.         DWORD           dw_ShopTime;
  2285.     public:
  2286.         void            StartRefreshShopEvent();
  2287.     protected:
  2288.         LPEVENT         m_pkRefreshShopEvent;
  2289. #endif 
  2290.  
  2291. #ifdef GIFT_SYSTEM
  2292.     protected:
  2293.         void            AddGiftGrid(int page);
  2294.         int             AddGiftGridItem(int page, int size);
  2295.         GIFT_MAP        m_mapGiftGrid;
  2296.         LPEVENT         m_pkGiftRefresh;
  2297.         DWORD           m_dwLastGiftPage;
  2298.     public:
  2299.         void            StartRefreshGift();
  2300.         void            LoadGiftPage(int page);
  2301.         void            RefreshGift();
  2302.         int             GetGiftPages() { return m_mapGiftGrid.size(); }
  2303.         int             GetLastGiftPage() { return m_dwLastGiftPage; }
  2304. #endif
  2305.  
  2306. #ifdef ANTY_DMG_ADAMS
  2307.     private:
  2308.         typedef struct SAttackCounter {
  2309.             DWORD dwValue;
  2310.             DWORD dwMaxValue;
  2311.             DWORD dwLastHitTime;
  2312.            
  2313.             SAttackCounter() :
  2314.                 dwValue(0), dwMaxValue(0), dwLastHitTime(0) {}
  2315.            
  2316.             void Update()
  2317.             {
  2318.                 if (++dwValue > dwMaxValue)
  2319.                     dwMaxValue = dwValue;
  2320.                
  2321.                 DWORD dwCurrentTime = get_dword_time() / 1000;
  2322.                
  2323.                 if (dwCurrentTime > dwLastHitTime)
  2324.                 {
  2325.                     dwValue = 0;
  2326.                     dwLastHitTime = dwCurrentTime;
  2327.                 }
  2328.             }
  2329.         } TAttackCounter;
  2330.  
  2331.         typedef std::map<DWORD, TAttackCounter *> TAttackCounterMap;
  2332.         typedef TAttackCounterMap::iterator TAttackCounterMapIterator;
  2333.  
  2334.         TAttackCounterMap m_map_attack_counter;
  2335.  
  2336.     public:
  2337.         void CleanOutdatedAttackCounters(bool bForce = false);
  2338.         void UpdateAttackCounter(DWORD dwVID);
  2339.         float CalculateAttacksPerSecond();
  2340.         float GetAllowedAttacksPerSecond();
  2341.         bool IsAttackHack();
  2342. #endif
  2343. };
  2344.  
  2345. ESex GET_SEX(LPCHARACTER ch);
  2346.  
  2347. #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!