Help fastt

Diamondz · November 28, 2017

Hy , i try to add mount system ( mount like horse) and after i compile source i have this error

char.cpp:5964:1: error: unterminated #else
char.cpp:907:1: error: unterminated #else
char.cpp: In member function 'virtual void CHARACTER::EncodeInsertPacket(CEntity*)':
char.cpp:908: error: expected statement at end of input
char.cpp:908: error: expected `}' at end of input
gmake: *** [OBJDIR/char.o] Error 1

Zor · November 28, 2017

Paste your char.cpp

Diamondz · November 29, 2017

Acum 9 ore, Zor a spus:

Paste your char.cpp

ok :

Spoiler

#include "stdafx.h"
#include "../../common/teen_packet.h"
#include "../../common/VnumHelper.h"
#include "char.h"
#include "config.h"
#include "utils.h"
#include "crc32.h"
#include "char_manager.h"
#include "desc_client.h"
#include "desc_manager.h"
#include "buffer_manager.h"
#include "item_manager.h"
#include "motion.h"
#include "vector.h"
#include "packet.h"
#include "cmd.h"
#include "fishing.h"
#include "exchange.h"
#include "battle.h"
#include "affect.h"
#include "shop.h"
#include "shop_manager.h"
#include "safebox.h"
#include "regen.h"
#include "pvp.h"
#include "party.h"
#include "start_position.h"
#include "questmanager.h"
#include "log.h"
#include "p2p.h"
#include "guild.h"
#include "guild_manager.h"
#include "dungeon.h"
#include "messenger_manager.h"
#include "unique_item.h"
#include "priv_manager.h"
#include "war_map.h"
#include "xmas_event.h"
#include "banword.h"
#include "target.h"
#include "wedding.h"
#include "mob_manager.h"
#include "mining.h"
#include "monarch.h"
#include "castle.h"
#include "arena.h"
#include "dev_log.h"
#include "horsename_manager.h"
#include "pcbang.h"
#include "gm.h"
#include "map_location.h"
#include "BlueDragon_Binder.h"
#include "HackShield.h"
#include "skill_power.h"
#include "XTrapManager.h"
#include "buff_on_attributes.h"
#include "OXEvent.h"

#ifdef __PET_SYSTEM__
#include "PetSystem.h"
#endif
#ifdef ENABLE_MOUNT_SYSTEM
#include "MountSystem.h"
#endif
#include "DragonSoul.h"

#ifdef NEW_PET_SYSTEM
#include "New_PetSystem.h"
#endif

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
#include "offline_shop.h"
#include "offlineshop_manager.h"
#include "offlineshop_config.h"
#endif

extern bool offlineshop_map_allow_find(int mapIndex);
extern const BYTE g_aBuffOnAttrPoints;
extern bool RaceToJob(unsigned race, unsigned *ret_job);

extern int g_nPortalLimitTime;
extern int test_server;

extern bool IS_SUMMONABLE_ZONE(int map_index); // char_item.cpp
bool CAN_ENTER_ZONE(const LPCHARACTER& ch, int map_index);

bool CAN_ENTER_ZONE(const LPCHARACTER& ch, int map_index)
{
   switch (map_index)
   {
   case 301:
   case 302:
   case 303:
   case 304:
       if (ch->GetLevel() < 90)
           return false;
   }
   return true;
}

// <Factor> DynamicCharacterPtr member function definitions

LPCHARACTER DynamicCharacterPtr::Get() const {
   LPCHARACTER p = NULL;
   if (is_pc) {
       p = CHARACTER_MANAGER::instance().FindByPID(id);
   } else {
       p = CHARACTER_MANAGER::instance().Find(id);
   }
   return p;
}

DynamicCharacterPtr& DynamicCharacterPtr::operator=(LPCHARACTER character) {
   if (character == NULL) {
       Reset();
       return *this;
   }
   if (character->IsPC()) {
       is_pc = true;
       id = character->GetPlayerID();
   } else {
       is_pc = false;
       id = character->GetVID();
   }
   return *this;
}

CHARACTER::CHARACTER()
{
   m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateIdle, &CHARACTER::EndStateEmpty);
   m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateMove, &CHARACTER::EndStateEmpty);
   m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateBattle, &CHARACTER::EndStateEmpty);

Initialize();
}

CHARACTER::~CHARACTER()
{
Destroy();
}

void CHARACTER::Initialize()
{
CEntity::Initialize(ENTITY_CHARACTER);

   m_pkTimedEventPvP = NULL;
   m_TimeStartPvP = false;
   m_bNoOpenedShop = true;

m_bOpeningSafebox = false;

   m_fSyncTime = get_float_time()-3;
   m_dwPlayerID = 0;
   m_dwKillerPID = 0;
#ifdef NEW_PET_SYSTEM
   m_stImmortalSt = 0;

   m_newpetskillcd[0] = 0;
   m_newpetskillcd[1] = 0;
   m_newpetskillcd[2] = 0;
#endif
   m_iMoveCount = 0;

   m_pkRegen = NULL;
   regen_id_ = 0;
   m_posRegen.x = m_posRegen.y = m_posRegen.z = 0;
   m_posStart.x = m_posStart.y = 0;
   m_posDest.x = m_posDest.y = 0;
   m_fRegenAngle = 0.0f;

m_pkMobData = NULL;
m_pkMobInst = NULL;

   m_pkShop       = NULL;
   m_pkChrShopOwner   = NULL;
   m_pkMyShop       = NULL;
   m_pkExchange   = NULL;
   m_pkParty       = NULL;
   m_pkPartyRequestEvent = NULL;

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
   // Offline Shop
   m_pkOfflineShop = NULL;
   m_pkChrOfflineShopOwner = NULL;
   m_pkOfflineShopUpdateEvent = NULL;
   // End Of Offline Shop
#endif

m_pGuild = NULL;

m_pkChrTarget = NULL;

m_pkMuyeongEvent = NULL;

   m_pkWarpNPCEvent = NULL;
   m_pkDeadEvent = NULL;
   m_pkStunEvent = NULL;
   m_pkSaveEvent = NULL;
   m_pkRecoveryEvent = NULL;
   m_pkTimedEvent = NULL;
   m_pkFishingEvent = NULL;
   m_pkWarpEvent = NULL;

   // MINING
   m_pkMiningEvent = NULL;
   // END_OF_MINING

   m_pkPoisonEvent = NULL;
   m_pkBleedEvent = NULL;
   m_pkFireEvent = NULL;
   m_pkCheckSpeedHackEvent   = NULL;
   m_speed_hack_count   = 0;

m_pkAffectEvent = NULL;
m_afAffectFlag = TAffectFlag(0, 0);

m_pkDestroyWhenIdleEvent = NULL;

m_pkChrSyncOwner = NULL;

   memset(&m_points, 0, sizeof(m_points));
   memset(&m_pointsInstant, 0, sizeof(m_pointsInstant));
   memset(&m_quickslot, 0, sizeof(m_quickslot));

m_bCharType = CHAR_TYPE_MONSTER;

SetPosition(POS_STANDING);

m_dwPlayStartTime = m_dwLastMoveTime = get_dword_time();

GotoState(m_stateIdle);
m_dwStateDuration = 1;

m_dwLastAttackTime = get_dword_time() - 20000;

m_bAddChrState = 0;

m_pkChrStone = NULL;

   m_pkSafebox = NULL;
   m_iSafeboxSize = -1;
   m_iSafeboxLoadTime = 0;

m_pkMall = NULL;
m_iMallLoadTime = 0;

m_posWarp.x = m_posWarp.y = m_posWarp.z = 0;
m_lWarpMapIndex = 0;

m_posExit.x = m_posExit.y = m_posExit.z = 0;
m_lExitMapIndex = 0;

m_pSkillLevels = NULL;

m_dwMoveStartTime = 0;
m_dwMoveDuration = 0;

m_dwFlyTargetID = 0;

m_dwNextStatePulse = 0;

m_dwLastDeadTime = get_dword_time()-180000;

m_bSkipSave = false;

m_bItemLoaded = false;

m_bHasPoisoned = false;
m_bHasBleeded = false;

m_pkDungeon = NULL;
m_iEventAttr = 0;

m_kAttackLog.dwVID = 0;
m_kAttackLog.dwTime = 0;

m_bNowWalking = m_bWalking = false;
ResetChangeAttackPositionTime();

m_bDetailLog = false;
m_bMonsterLog = false;

m_bDisableCooltime = false;

m_iAlignment = 0;
m_iRealAlignment = 0;

m_iKillerModePulse = 0;
m_bPKMode = PK_MODE_PEACE;

   m_dwQuestNPCVID = 0;
   m_dwQuestByVnum = 0;
   m_pQuestItem = NULL;

m_szMobileAuth[0] = '\0';

m_dwUnderGuildWarInfoMessageTime = get_dword_time()-60000;

m_bUnderRefine = false;

   // REFINE_NPC
   m_dwRefineNPCVID = 0;
   // END_OF_REFINE_NPC

m_dwPolymorphRace = 0;

m_bStaminaConsume = false;

ResetChainLightningIndex();

   m_dwMountVnum = 0;
   m_chHorse = NULL;
   m_chRider = NULL;

   m_pWarMap = NULL;
   m_pWeddingMap = NULL;
   m_bChatCounter = 0;

ResetStopTime();

m_dwLastVictimSetTime = get_dword_time() - 3000;
m_iMaxAggro = -100;

   m_bSendHorseLevel = 0;
   m_bSendHorseHealthGrade = 0;
   m_bSendHorseStaminaGrade = 0;

m_dwLoginPlayTime = 0;

m_pkChrMarried = NULL;

m_posSafeboxOpen.x = -1000;
m_posSafeboxOpen.y = -1000;

   // EQUIP_LAST_SKILL_DELAY
   m_dwLastSkillTime = get_dword_time();
   // END_OF_EQUIP_LAST_SKILL_DELAY

   // MOB_SKILL_COOLTIME
   memset(m_adwMobSkillCooltime, 0, sizeof(m_adwMobSkillCooltime));
   // END_OF_MOB_SKILL_COOLTIME

m_isinPCBang = false;

   // ARENA
   m_pArena = NULL;
   m_nPotionLimit = quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count");
   // END_ARENA

   //PREVENT_TRADE_WINDOW
   m_isOpenSafebox = 0;
   //END_PREVENT_TRADE_WINDOW

   //PREVENT_REFINE_HACK
   m_iRefineTime = 0;
   //END_PREVENT_REFINE_HACK

   //RESTRICT_USE_SEED_OR_MOONBOTTLE
   m_iSeedTime = 0;
   //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
   //PREVENT_PORTAL_AFTER_EXCHANGE
   m_iExchangeTime = 0;
   //END_PREVENT_PORTAL_AFTER_EXCHANGE
   //
   m_iSafeboxLoadTime = 0;

m_iMyShopTime = 0;

InitMC();

m_deposit_pulse = 0;

SET_OVER_TIME(this, OT_NONE);

m_strNewName = "";

m_known_guild.clear();

m_dwLogOffInterval = 0;

   m_bComboSequence = 0;
   m_dwLastComboTime = 0;
   m_bComboIndex = 0;
   m_iComboHackCount = 0;
   m_dwSkipComboAttackByTime = 0;

m_dwMountTime = 0;

m_dwLastGoldDropTime = 0;

m_HackShieldCheckEvent = NULL;
m_HackShieldCheckMode = false;

m_bIsLoadedAffect = false;
cannot_dead = false;

#ifdef __PET_SYSTEM__
m_petSystem = 0;
m_bIsPet = false;
#endif

#ifdef ENABLE_MOUNT_SYSTEM
m_MountSystem = 0;
m_bIsMountSystem = false;
#endif

#ifdef NEW_PET_SYSTEM
   m_newpetSystem = 0;
   m_bIsNewPet = false;
   m_eggvid = 0;
#endif

m_fAttMul = 1.0f;
m_fDamMul = 1.0f;

m_pointsInstant.iDragonSoulActiveDeck = -1;

memset(&m_tvLastSyncTime, 0, sizeof(m_tvLastSyncTime));
m_iSyncHackCount = 0;
}

void CHARACTER::Create(const char * c_pszName, DWORD vid, bool isPC)
{
static int s_crc = 172814;

   char crc_string[128+1];
   snprintf(crc_string, sizeof(crc_string), "%s%p%d", c_pszName, this, ++s_crc);
   m_vid = VID(vid, GetCRC32(crc_string, strlen(crc_string)));

if (isPC)
m_stName = c_pszName;
}

void CHARACTER::Destroy()
{
CloseMyShop();

   if (m_pkRegen)
   {
       if (m_pkDungeon) {
           // Dungeon regen may not be valid at this point
           if (m_pkDungeon->IsValidRegen(m_pkRegen, regen_id_)) {
               --m_pkRegen->count;
           }
       } else {
           // Is this really safe?
           --m_pkRegen->count;
       }
       m_pkRegen = NULL;
   }

   if (m_pkDungeon)
   {
       SetDungeon(NULL);
   }

#ifdef __PET_SYSTEM__
   if (m_petSystem)
   {
       m_petSystem->Destroy();
       delete m_petSystem;

m_petSystem = 0;
}
#endif

#ifdef ENABLE_MOUNT_SYSTEM
   if (m_MountSystem)
   {
       m_MountSystem->Destroy();
       delete m_MountSystem;

m_MountSystem = 0;
}
#endif

#ifdef NEW_PET_SYSTEM
   if (m_newpetSystem)
   {
       m_newpetSystem->Destroy();
       delete m_newpetSystem;

m_newpetSystem = 0;
}
#endif

HorseSummon(false);

if (GetRider())
GetRider()->ClearHorseInfo();

   if( IsPC() )
   {
       if (isHackShieldEnable)
       {
           CHackShieldManager::instance().DeleteClientHandle(GetPlayerID());
       }
   }

   if (GetDesc())
   {
       GetDesc()->BindCharacter(NULL);
//       BindDesc(NULL);
   }

if (m_pkExchange)
m_pkExchange->Cancel();

SetVictim(NULL);

   if (GetShop())
   {
       GetShop()->RemoveGuest(this);
       SetShop(NULL);
   }

   ClearStone();
   ClearSync();
   ClearTarget();

   if (NULL == m_pkMobData)
   {
       DragonSoul_CleanUp();
       ClearItem();
   }

   // <Factor> m_pkParty becomes NULL after CParty destructor call!
   LPPARTY party = m_pkParty;
   if (party)
   {
       if (party->GetLeaderPID() == GetVID() && !IsPC())
       {
           M2_DELETE(party);
       }
       else
       {
           party->Unlink(this);

           if (!IsPC())
               party->Quit(GetVID());
       }

SetParty(NULL); // 안해도 되지만 안전하게.
}

   if (m_pkMobInst)
   {
       M2_DELETE(m_pkMobInst);
       m_pkMobInst = NULL;
   }

m_pkMobData = NULL;

   if (m_pkSafebox)
   {
       M2_DELETE(m_pkSafebox);
       m_pkSafebox = NULL;
   }

   if (m_pkMall)
   {
       M2_DELETE(m_pkMall);
       m_pkMall = NULL;
   }

   for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
   {
       if (NULL != it->second)
       {
           M2_DELETE(it->second);
       }
   }
   m_map_buff_on_attrs.clear();

m_set_pkChrSpawnedBy.clear();

   StopMuyeongEvent();
   event_cancel(&m_pkWarpNPCEvent);
   event_cancel(&m_pkRecoveryEvent);
   event_cancel(&m_pkDeadEvent);
   event_cancel(&m_pkSaveEvent);
   event_cancel(&m_pkTimedEvent);
   event_cancel(&m_pkStunEvent);
   event_cancel(&m_pkFishingEvent);
   event_cancel(&m_pkPoisonEvent);
   event_cancel(&m_pkBleedEvent);
   event_cancel(&m_pkFireEvent);
   event_cancel(&m_pkPartyRequestEvent);
   //DELAYED_WARP
   event_cancel(&m_pkWarpEvent);
   event_cancel(&m_pkCheckSpeedHackEvent);
   //END_DELAYED_WARP

   // RECALL_DELAY
   //event_cancel(&m_pkRecallEvent);
   // END_OF_RECALL_DELAY

   // MINING
   event_cancel(&m_pkMiningEvent);
   // END_OF_MINING

StopHackShieldCheckCycle();

   for (itertype(m_mapMobSkillEvent) it = m_mapMobSkillEvent.begin(); it != m_mapMobSkillEvent.end(); ++it)
   {
       LPEVENT pkEvent = it->second;
       event_cancel(&pkEvent);
   }
   m_mapMobSkillEvent.clear();

//event_cancel(&m_pkAffectEvent);
ClearAffect();

event_cancel(&m_pkDestroyWhenIdleEvent);

   if (m_pSkillLevels)
   {
       M2_DELETE_ARRAY(m_pSkillLevels);
       m_pSkillLevels = NULL;
   }

CEntity::Destroy();

if (GetSectree())
GetSectree()->RemoveEntity(this);

if (m_bMonsterLog)
CHARACTER_MANAGER::instance().UnregisterForMonsterLog(this);
}

const char * CHARACTER::GetName() const
{
return m_stName.empty() ? (m_pkMobData ? m_pkMobData->m_table.szLocaleName : "") : m_stName.c_str();
}

void CHARACTER::OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount)
{
   if (GetPart(PART_MAIN) > 2)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("갑옷을 벗어야 개인 상점을 열 수 있습니다."));
       return;
   }

   if (GetMyShop())   // 이미 샵이 열려 있으면 닫는다.
   {
       CloseMyShop();
       return;
   }

   if (IsRidingMount())
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Pentru a deschide un shop coboara de pe mount."));
       return;
   }

   // 진행중인 퀘스트가 있으면 상점을 열 수 없다.
   quest::PC * pPC = quest::CQuestManager::instance().GetPCForce(GetPlayerID());

   // GetPCForce는 NULL일 수 없으므로 따로 확인하지 않음
   if (pPC->IsRunning())
       return;

if (bItemCount == 0)
return;

int64_t nTotalMoney = 0;

   for (int n = 0; n < bItemCount; ++n)
   {
       nTotalMoney += static_cast<int64_t>((pTable+n)->price);
   }

nTotalMoney += static_cast<int64_t>(GetGold());

   if (GOLD_MAX <= nTotalMoney)
   {
       sys_err("[OVERFLOW_GOLD] Overflow (GOLD_MAX) id %u name %s", GetPlayerID(), GetName());
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("20억 냥을 초과하여 상점을 열수가 없습니다"));
       return;
   }

char szSign[SHOP_SIGN_MAX_LEN+1];
strlcpy(szSign, c_pszSign, sizeof(szSign));

m_stShopSign = szSign;

if (m_stShopSign.length() == 0)
return;

   if (LC_IsCanada() == false)
   {
       if (CBanwordManager::instance().CheckString(m_stShopSign.c_str(), m_stShopSign.length()))
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("비속어나 은어가 포함된 상점 이름으로 상점을 열 수 없습니다."));
           return;
       }
   }

   // MYSHOP_PRICE_LIST
   std::map<DWORD, DWORD> itemkind; // 아이템 종류별 가격, first: vnum, second: 단일 수량 가격
   // END_OF_MYSHOP_PRICE_LIST

   std::set<TItemPos> cont;
   for (BYTE i = 0; i < bItemCount; ++i)
   {
       if (cont.find((pTable + i)->pos) != cont.end())
       {
           sys_err("MYSHOP: duplicate shop item detected! (name: %s)", GetName());
           return;
       }

// ANTI_GIVE, ANTI_MYSHOP check
LPITEM pkItem = GetItem((pTable + i)->pos);

       if (pkItem)
       {
           const TItemTable * item_table = pkItem->GetProto();

           if (item_table && (IS_SET(item_table->dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP)))
           {
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("유료화 아이템은 개인상점에서 판매할 수 없습니다."));
               return;
           }

           if (pkItem->IsEquipped() == true)
           {
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장비중인 아이템은 개인상점에서 판매할 수 없습니다."));
               return;
           }

           if (true == pkItem->isLocked())
           {
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용중인 아이템은 개인상점에서 판매할 수 없습니다."));
               return;
           }

           // MYSHOP_PRICE_LIST
           itemkind[pkItem->GetVnum()] = (pTable + i)->price / pkItem->GetCount();
           // END_OF_MYSHOP_PRICE_LIST
       }

cont.insert((pTable + i)->pos);
}

   // MYSHOP_PRICE_LIST
   // 보따리 개수를 감소시킨다.
   if (CountSpecifyItem(71049)) { // 비단 보따리는 없애지 않고 가격정보를 저장한다.

       //
       // 아이템 가격정보를 저장하기 위해 아이템 가격정보 패킷을 만들어 DB 캐시에 보낸다.
       //
       TPacketMyshopPricelistHeader header;
       TItemPriceInfo info;

       header.dwOwnerID = GetPlayerID();
       header.byCount = itemkind.size();

TEMP_BUFFER buf;
buf.write(&header, sizeof(header));

       for (itertype(itemkind) it = itemkind.begin(); it != itemkind.end(); ++it)
       {
           info.dwVnum = it->first;
           info.dwPrice = it->second;

buf.write(&info, sizeof(info));
}

       db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_UPDATE, 0, buf.read_peek(), buf.size());
   }
   // END_OF_MYSHOP_PRICE_LIST
   else if (CountSpecifyItem(50200))
       RemoveSpecifyItem(50200, 1);
   else
       return; // 보따리가 없으면 중단.

if (m_pkExchange)
m_pkExchange->Cancel();

TPacketGCShopSign p;

   p.bHeader = HEADER_GC_SHOP_SIGN;
   p.dwVID = GetVID();
   strlcpy(p.szSign, c_pszSign, sizeof(p.szSign));

PacketAround(&p, sizeof(TPacketGCShopSign));

m_pkMyShop = CShopManager::instance().CreatePCShop(this, pTable, bItemCount);

   if (IsPolymorphed() == true)
   {
       RemoveAffect(AFFECT_POLYMORPH);
   }

   if (GetHorse())
   {
       HorseSummon( false, true );
   }
   // new mount 이용 중에, 개인 상점 열면 자동 unmount
   // StopRiding으로 뉴마운트까지 처리하면 좋은데 왜 그렇게 안해놨는지 알 수 없다.
   else if (GetMountVnum())
   {
       RemoveAffect(AFFECT_MOUNT);
       RemoveAffect(AFFECT_MOUNT_BONUS);
   }
   //if (!LC_IsNewCIBN())
       SetPolymorph(30000, true);

}

void CHARACTER::CloseMyShop()
{
   if (GetMyShop())
   {
       m_stShopSign.clear();
       CShopManager::instance().DestroyPCShop(this);
       m_pkMyShop = NULL;

TPacketGCShopSign p;

       p.bHeader = HEADER_GC_SHOP_SIGN;
       p.dwVID = GetVID();
       p.szSign[0] = '\0';

       PacketAround(&p, sizeof(p));

       //if (!LC_IsNewCIBN())
           SetPolymorph(GetJob(), true);
   }
}

void EncodeMovePacket(TPacketGCMove & pack, DWORD dwVID, BYTE bFunc, BYTE bArg, DWORD x, DWORD y, DWORD dwDuration, DWORD dwTime, BYTE bRot)
{
   pack.bHeader = HEADER_GC_MOVE;
   pack.bFunc = bFunc;
   pack.bArg = bArg;
   pack.dwVID = dwVID;
   pack.dwTime = dwTime ? dwTime : get_dword_time();
   pack.bRot = bRot;
   pack.lX       = x;
   pack.lY       = y;
   pack.dwDuration   = dwDuration;
}

void CHARACTER::RestartAtSamePos()
{
if (m_bIsObserver)
return;

EncodeRemovePacket(this);
EncodeInsertPacket(this);

ENTITY_MAP::iterator it = m_map_view.begin();

   while (it != m_map_view.end())
   {
       LPENTITY entity = (it++)->first;

       EncodeRemovePacket(entity);
       if (!m_bIsObserver)
           EncodeInsertPacket(entity);

       if( entity->IsType(ENTITY_CHARACTER) )
       {
           LPCHARACTER lpChar = (LPCHARACTER)entity;
           if( lpChar->IsPC() || lpChar->IsNPC() || lpChar->IsMonster() )
           {
               if (!entity->IsObserverMode())
                   entity->EncodeInsertPacket(this);
           }
       }
       else
       {
           if( !entity->IsObserverMode())
           {
               entity->EncodeInsertPacket(this);
           }
       }
   }
}

// Entity에 내가 나타났다고 패킷을 보낸다.
void CHARACTER::EncodeInsertPacket(LPENTITY entity)
{

LPDESC d;

if (!(d = entity->GetDesc()))
return;

   // 길드이름 버그 수정 코드
   LPCHARACTER ch = (LPCHARACTER) entity;
   ch->SendGuildName(GetGuild());
   // 길드이름 버그 수정 코드

TPacketGCCharacterAdd pack;

   pack.header       = HEADER_GC_CHARACTER_ADD;
   pack.dwVID       = m_vid;
   pack.bType       = GetCharType();
   pack.angle       = GetRotation();
   pack.x       = GetX();
   pack.y       = GetY();
   pack.z       = GetZ();
   pack.wRaceNum   = GetRaceNum();
#ifdef NEW_PET_SYSTEM
   if (IsPet() || IsNewPet())
#else

#ifdef ENABLE_MOUNT_SYSTEM
   if (IsPet() || IsMountSystem())
#else
   if (IsPet())
#endif
   {
       pack.bMovingSpeed   = 200;
   }
   else
   {
       pack.bMovingSpeed   = GetLimitPoint(POINT_MOV_SPEED);
   }
   pack.bAttackSpeed   = GetLimitPoint(POINT_ATT_SPEED);
   pack.dwAffectFlag[0] = m_afAffectFlag.bits[0];
   pack.dwAffectFlag[1] = m_afAffectFlag.bits[1];

pack.bStateFlag = m_bAddChrState;

int iDur = 0;

   if (m_posDest.x != pack.x || m_posDest.y != pack.y)
   {
       iDur = (m_dwMoveStartTime + m_dwMoveDuration) - get_dword_time();

       if (iDur <= 0)
       {
           pack.x = m_posDest.x;
           pack.y = m_posDest.y;
       }
   }

d->Packet(&pack, sizeof(pack));

   if (IsPC() == true || m_bCharType == CHAR_TYPE_NPC)
   {
       TPacketGCCharacterAdditionalInfo addPacket;
       memset(&addPacket, 0, sizeof(TPacketGCCharacterAdditionalInfo));

addPacket.header = HEADER_GC_CHAR_ADDITIONAL_INFO;
addPacket.dwVID = m_vid;

       addPacket.awPart[CHR_EQUIPPART_ARMOR] = GetPart(PART_MAIN);
       addPacket.awPart[CHR_EQUIPPART_WEAPON] = GetPart(PART_WEAPON);
       addPacket.awPart[CHR_EQUIPPART_HEAD] = GetPart(PART_HEAD);
       addPacket.awPart[CHR_EQUIPPART_HAIR] = GetPart(PART_HAIR);
       addPacket.awPart[CHR_EQUIPPART_ACCE] = GetPart(PART_ACCE);

       addPacket.bPKMode = m_bPKMode;
       addPacket.dwMountVnum = GetMountVnum();
       addPacket.bEmpire = m_bEmpire;

#ifdef NEW_PET_SYSTEM
       if (IsPC() == true || IsNewPet() == true)
#else
       if (IsPC() == true && (LC_IsEurope() == true || LC_IsCanada() == true || LC_IsSingapore() == true))
#endif
       {
           addPacket.dwLevel = GetLevel();
       }
       else
       {
           addPacket.dwLevel = 0;
       }

       if (false)
       {
           LPCHARACTER ch = (LPCHARACTER) entity;

           if (GetEmpire() == ch->GetEmpire() || ch->GetGMLevel() > GM_PLAYER || m_bCharType == CHAR_TYPE_NPC)
           {
               goto show_all_info;
           }
           else
           {
               memset(addPacket.name, 0, CHARACTER_NAME_MAX_LEN);
               addPacket.dwGuildID = 0;
               addPacket.sAlignment = 0;
           }
       }
       else
       {
       show_all_info:
           strlcpy(addPacket.name, GetName(), sizeof(addPacket.name));

           if (GetGuild() != NULL)
           {
               addPacket.dwGuildID = GetGuild()->GetID();
           }
           else
           {
               addPacket.dwGuildID = 0;
           }

addPacket.sAlignment = m_iAlignment / 10;
}

d->Packet(&addPacket, sizeof(TPacketGCCharacterAdditionalInfo));
}

   if (iDur)
   {
       TPacketGCMove pack;
       EncodeMovePacket(pack, GetVID(), FUNC_MOVE, 0, m_posDest.x, m_posDest.y, iDur, 0, (BYTE) (GetRotation() / 5));
       d->Packet(&pack, sizeof(pack));

       TPacketGCWalkMode p;
       p.vid = GetVID();
       p.header = HEADER_GC_WALK_MODE;
       p.mode = m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;

d->Packet(&p, sizeof(p));
}

   if (entity->IsType(ENTITY_CHARACTER) && GetDesc())
   {
       LPCHARACTER ch = (LPCHARACTER) entity;
       if (ch->IsWalking())
       {
           TPacketGCWalkMode p;
           p.vid = ch->GetVID();
           p.header = HEADER_GC_WALK_MODE;
           p.mode = ch->m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;
           GetDesc()->Packet(&p, sizeof(p));
       }
   }

   if (GetMyShop())
   {
       TPacketGCShopSign p;

       p.bHeader = HEADER_GC_SHOP_SIGN;
       p.dwVID = GetVID();
       strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));

d->Packet(&p, sizeof(TPacketGCShopSign));
}

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
   if (IsOfflineShopNPC() && GetRaceNum() == 30000)
   {
       TPacketGCShopSign p;

       p.bHeader = HEADER_GC_OFFLINE_SHOP_SIGN;
       p.dwVID = GetVID();
       if (m_stOfflineShopSign.empty())
       {
           std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT sign FROM player.offline_shop_npc WHERE owner_id = %u", GetOfflineShopRealOwner()));
           if (pMsg->Get()->uiNumRows > 0)
           {
               MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
               strlcpy(p.szSign, row[0], sizeof(p.szSign));
           }
       }
       else
       {
           strlcpy(p.szSign, m_stOfflineShopSign.c_str(), sizeof(p.szSign));
       }

       d->Packet(&p, sizeof(TPacketGCShopSign));
   }
#endif

   if (entity->IsType(ENTITY_CHARACTER))
   {
       sys_log(3, "EntityInsert %s (RaceNum %d) (%d %d) TO %s",
               GetName(), GetRaceNum(), GetX() / SECTREE_SIZE, GetY() / SECTREE_SIZE, ((LPCHARACTER)entity)->GetName());
   }
}

void CHARACTER::EncodeRemovePacket(LPENTITY entity)
{
if (entity->GetType() != ENTITY_CHARACTER)
return;

LPDESC d;

if (!(d = entity->GetDesc()))
return;

TPacketGCCharacterDelete pack;

pack.header = HEADER_GC_CHARACTER_DEL;
pack.id = m_vid;

d->Packet(&pack, sizeof(TPacketGCCharacterDelete));

if (entity->IsType(ENTITY_CHARACTER))
sys_log(3, "EntityRemove %s(%d) FROM %s", GetName(), (DWORD) m_vid, ((LPCHARACTER) entity)->GetName());
}

void CHARACTER::UpdatePacket()
{
if (GetSectree() == NULL) return;

TPacketGCCharacterUpdate pack;
TPacketGCCharacterUpdate pack2;

pack.header = HEADER_GC_CHARACTER_UPDATE;
pack.dwVID = m_vid;

   pack.awPart[CHR_EQUIPPART_ARMOR] = GetPart(PART_MAIN);
   pack.awPart[CHR_EQUIPPART_WEAPON] = GetPart(PART_WEAPON);
   pack.awPart[CHR_EQUIPPART_HEAD] = GetPart(PART_HEAD);
   pack.awPart[CHR_EQUIPPART_HAIR] = GetPart(PART_HAIR);
   pack.awPart[CHR_EQUIPPART_ACCE] = GetPart(PART_ACCE);

   pack.bMovingSpeed   = GetLimitPoint(POINT_MOV_SPEED);
   pack.bAttackSpeed   = GetLimitPoint(POINT_ATT_SPEED);
   pack.bStateFlag   = m_bAddChrState;
   pack.dwAffectFlag[0] = m_afAffectFlag.bits[0];
   pack.dwAffectFlag[1] = m_afAffectFlag.bits[1];
   pack.dwGuildID   = 0;
   pack.sAlignment   = m_iAlignment / 10;
#ifdef NEW_PET_SYSTEM
   pack.dwLevel = GetLevel();
#endif
   pack.bPKMode   = m_bPKMode;

if (GetGuild())
pack.dwGuildID = GetGuild()->GetID();

pack.dwMountVnum = GetMountVnum();

   pack2 = pack;
   pack2.dwGuildID = 0;
   pack2.sAlignment = 0;
#ifdef NEW_PET_SYSTEM
   pack2.dwLevel = 0;
#endif

   if (false)
   {
       if (m_bIsObserver != true)
       {
           for (ENTITY_MAP::iterator iter = m_map_view.begin(); iter != m_map_view.end(); iter++)
           {
               LPENTITY pEntity = iter->first;

               if (pEntity != NULL)
               {
                   if (pEntity->IsType(ENTITY_CHARACTER) == true)
                   {
                       if (pEntity->GetDesc() != NULL)
                       {
                           LPCHARACTER pChar = (LPCHARACTER)pEntity;

                           if (GetEmpire() == pChar->GetEmpire() || pChar->GetGMLevel() > GM_PLAYER)
                           {
                               pEntity->GetDesc()->Packet(&pack, sizeof(pack));
                           }
                           else
                           {
                               pEntity->GetDesc()->Packet(&pack2, sizeof(pack2));
                           }
                       }
                   }
                   else
                   {
                       if (pEntity->GetDesc() != NULL)
                       {
                           pEntity->GetDesc()->Packet(&pack, sizeof(pack));
                       }
                   }
               }
           }
       }

       if (GetDesc() != NULL)
       {
           GetDesc()->Packet(&pack, sizeof(pack));
       }
   }
   else
   {
       PacketAround(&pack, sizeof(pack));
   }
}

LPCHARACTER CHARACTER::FindCharacterInView(const char * c_pszName, bool bFindPCOnly)
{
ENTITY_MAP::iterator it = m_map_view.begin();

   for (; it != m_map_view.end(); ++it)
   {
       if (!it->first->IsType(ENTITY_CHARACTER))
           continue;

LPCHARACTER tch = (LPCHARACTER) it->first;

if (bFindPCOnly && tch->IsNPC())
continue;

       if (!strcasecmp(tch->GetName(), c_pszName))
           return (tch);
   }

return NULL;
}

void CHARACTER::SetPosition(int pos)
{
   if (pos == POS_STANDING)
   {
       REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_DEAD);
       REMOVE_BIT(m_pointsInstant.instant_flag, INSTANT_FLAG_STUN);

       event_cancel(&m_pkDeadEvent);
       event_cancel(&m_pkStunEvent);
       event_cancel(&m_pkTimedEventPvP);
   }
   else if (pos == POS_DEAD)
       SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_DEAD);

   if (!IsStone())
   {
       switch (pos)
       {
           case POS_FIGHTING:
               if (!IsState(m_stateBattle))
                   MonsterLog("[BATTLE] 싸우는 상태");

GotoState(m_stateBattle);
break;

           default:
               if (!IsState(m_stateIdle))
                   MonsterLog("[IDLE] 쉬는 상태");

               GotoState(m_stateIdle);
               break;
       }
   }

m_pointsInstant.position = pos;
}

void CHARACTER::Save()
{
if (!m_bSkipSave)
CHARACTER_MANAGER::instance().DelayedSave(this);
}

void CHARACTER::CreatePlayerProto(TPlayerTable & tab)
{
memset(&tab, 0, sizeof(TPlayerTable));

   if (GetNewName().empty())
   {
       strlcpy(tab.name, GetName(), sizeof(tab.name));
   }
   else
   {
       strlcpy(tab.name, GetNewName().c_str(), sizeof(tab.name));
   }

strlcpy(tab.ip, GetDesc()->GetHostName(), sizeof(tab.ip));

   tab.id           = m_dwPlayerID;
   tab.voice       = GetPoint(POINT_VOICE);
   tab.level       = GetLevel();
   tab.level_step   = GetPoint(POINT_LEVEL_STEP);
   tab.exp           = GetExp();
   tab.gold       = GetGold();
   tab.job           = m_points.job;
   tab.part_base   = m_pointsInstant.bBasePart;
   tab.skill_group   = m_points.skill_group;

DWORD dwPlayedTime = (get_dword_time() - m_dwPlayStartTime);

   if (dwPlayedTime > 60000)
   {
       if (GetSectree() && !GetSectree()->IsAttr(GetX(), GetY(), ATTR_BANPK))
       {
           if (GetRealAlignment() < 0)
           {
               if (IsEquipUniqueItem(UNIQUE_ITEM_FASTER_ALIGNMENT_UP_BY_TIME))
                   UpdateAlignment(120 * (dwPlayedTime / 60000));
               else
                   UpdateAlignment(60 * (dwPlayedTime / 60000));
           }
           else
               UpdateAlignment(5 * (dwPlayedTime / 60000));
       }

       SetRealPoint(POINT_PLAYTIME, GetRealPoint(POINT_PLAYTIME) + dwPlayedTime / 60000);
       ResetPlayTime(dwPlayedTime % 60000);
   }

tab.playtime = GetRealPoint(POINT_PLAYTIME);
tab.lAlignment = m_iRealAlignment;

   if (m_posWarp.x != 0 || m_posWarp.y != 0)
   {
       tab.x = m_posWarp.x;
       tab.y = m_posWarp.y;
       tab.z = 0;
       tab.lMapIndex = m_lWarpMapIndex;
   }
   else
   {
       tab.x = GetX();
       tab.y = GetY();
       tab.z = GetZ();
       tab.lMapIndex   = GetMapIndex();
   }

   if (m_lExitMapIndex == 0)
   {
       tab.lExitMapIndex   = tab.lMapIndex;
       tab.lExitX       = tab.x;
       tab.lExitY       = tab.y;
   }
   else
   {
       tab.lExitMapIndex   = m_lExitMapIndex;
       tab.lExitX       = m_posExit.x;
       tab.lExitY       = m_posExit.y;
   }

sys_log(0, "SAVE: %s %dx%d", GetName(), tab.x, tab.y);

   tab.st = GetRealPoint(POINT_ST);
   tab.ht = GetRealPoint(POINT_HT);
   tab.dx = GetRealPoint(POINT_DX);
   tab.iq = GetRealPoint(POINT_IQ);

   tab.stat_point = GetPoint(POINT_STAT);
   tab.skill_point = GetPoint(POINT_SKILL);
   tab.sub_skill_point = GetPoint(POINT_SUB_SKILL);
   tab.horse_skill_point = GetPoint(POINT_HORSE_SKILL);

tab.stat_reset_count = GetPoint(POINT_STAT_RESET_COUNT);

tab.hp = GetHP();
tab.sp = GetSP();

tab.stamina = GetStamina();

tab.sRandomHP = m_points.iRandomHP;
tab.sRandomSP = m_points.iRandomSP;

for (int i = 0; i < QUICKSLOT_MAX_NUM; ++i)
tab.quickslot = m_quickslot;

if (m_stMobile.length() && !*m_szMobileAuth)
strlcpy(tab.szMobile, m_stMobile.c_str(), sizeof(tab.szMobile));

thecore_memcpy(tab.parts, m_pointsInstant.parts, sizeof(tab.parts));

   // REMOVE_REAL_SKILL_LEVLES
   thecore_memcpy(tab.skills, m_pSkillLevels, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
   // END_OF_REMOVE_REAL_SKILL_LEVLES

tab.horse = GetHorseData();
}

void CHARACTER::SaveReal()
{
if (m_bSkipSave)
return;

   if (!GetDesc())
   {
       sys_err("Character::Save : no descriptor when saving (name: %s)", GetName());
       return;
   }

TPlayerTable table;
CreatePlayerProto(table);

db_clientdesc->DBPacket(HEADER_GD_PLAYER_SAVE, GetDesc()->GetHandle(), &table, sizeof(TPlayerTable));

quest::PC * pkQuestPC = quest::CQuestManager::instance().GetPCForce(GetPlayerID());

   if (!pkQuestPC)
       sys_err("CHARACTER::Save : null quest::PC pointer! (name %s)", GetName());
   else
   {
       pkQuestPC->Save();
   }

   marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
   if (pMarriage)
       pMarriage->Save();
}

void CHARACTER::FlushDelayedSaveItem()
{
// 저장 안된 소지품을 전부 저장시킨다.
LPITEM item;

   for (int i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i)
       if ((item = GetInventoryItem(i)))
           ITEM_MANAGER::instance().FlushDelayedSave(item);
}

void CHARACTER::Disconnect(const char * c_pszReason)
{
assert(GetDesc() != NULL);

sys_log(0, "DISCONNECT: %s (%s)", GetName(), c_pszReason ? c_pszReason : "unset" );

   if (GetShop())
   {
       GetShop()->RemoveGuest(this);
       SetShop(NULL);
   }

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
   if (GetOfflineShop())
   {
       GetOfflineShop()->RemoveGuest(this);
       SetOfflineShop(NULL);
   }
#endif

   if (GetArena() != NULL)
   {
       GetArena()->OnDisconnect(GetPlayerID());
   }

   if (GetParty() != NULL)
   {
       GetParty()->UpdateOfflineState(GetPlayerID());
   }

marriage::CManager::instance().Logout(this);

   // P2P Logout
   TPacketGGLogout p;
   p.bHeader = HEADER_GG_LOGOUT;
   strlcpy(p.szName, GetName(), sizeof(p.szName));
   P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGLogout));
   char buf[51];
   snprintf(buf, sizeof(buf), "%s %d %d %ld %d",
       inet_ntoa(GetDesc()->GetAddr().sin_addr), GetGold(), g_bChannel, GetMapIndex(), GetAlignment());

LogManager::instance().CharLog(this, 0, "LOGOUT", buf);

   if (LC_IsYMIR() || LC_IsKorea() || LC_IsBrazil())
   {
       long playTime = GetRealPoint(POINT_PLAYTIME) - m_dwLoginPlayTime;
       LogManager::instance().LoginLog(false, GetDesc()->GetAccountTable().id, GetPlayerID(), GetLevel(), GetJob(), playTime);

       if (LC_IsBrazil() != true)
           CPCBangManager::instance().Log(GetDesc()->GetHostName(), GetPlayerID(), playTime);
   }

if (m_pWarMap)
SetWarMap(NULL);

   if (m_pWeddingMap)
   {
       SetWeddingMap(NULL);
   }

if (GetGuild())
GetGuild()->LogoutMember(this);

quest::CQuestManager::instance().LogoutPC(this);

if (GetParty())
GetParty()->Unlink(this);

   // 죽었을 때 접속끊으면 경험치 줄게 하기
   if (IsStun() || IsDead())
   {
       DeathPenalty(0);
       PointChange(POINT_HP, 50 - GetHP());
   }

   if (!CHARACTER_MANAGER::instance().FlushDelayedSave(this))
   {
       SaveReal();
   }

FlushDelayedSaveItem();

SaveAffect();
m_bIsLoadedAffect = false;

m_bSkipSave = true; // 이 이후에는 더이상 저장하면 안된다.

quest::CQuestManager::instance().DisconnectPC(this);

CloseSafebox();

CloseMall();

CPVPManager::instance().Disconnect(this);

CTargetManager::instance().Logout(GetPlayerID());

   MessengerManager::instance().Logout(GetName());

   if (GetMapIndex() == OXEVENT_MAP_INDEX)
       COXEventManager::instance().RemoveFromIpList(GetDesc()->GetHostName());

   if (g_TeenDesc)
   {
       int       offset = 0;
       char   buf[245] = {0};

buf[0] = HEADER_GT_LOGOUT;
offset += 1;

memset(buf+offset, 0x00, 2);
offset += 2;

       TAccountTable   &acc_table = GetDesc()->GetAccountTable();
       memcpy(buf+offset, &acc_table.id, 4);
       offset += 4;

g_TeenDesc->Packet(buf, offset);
}

   if (GetDesc())
   {
       GetDesc()->BindCharacter(NULL);
//       BindDesc(NULL);
   }

CXTrapManager::instance().DestroyClientSession(this);

M2_DESTROY_CHARACTER(this);
}

bool CHARACTER::Show(long lMapIndex, long x, long y, long z, bool bShowSpawnMotion/* = false */)
{
LPSECTREE sectree = SECTREE_MANAGER::instance().Get(lMapIndex, x, y);

   if (!sectree)
   {
       sys_log(0, "cannot find sectree by %dx%d mapindex %d", x, y, lMapIndex);
       return false;
   }

SetMapIndex(lMapIndex);

bool bChangeTree = false;

if (!GetSectree() || GetSectree() != sectree)
bChangeTree = true;

   if (bChangeTree)
   {
       if (GetSectree())
           GetSectree()->RemoveEntity(this);

ViewCleanup();
}

   if (!IsNPC())
   {
       sys_log(0, "SHOW: %s %dx%dx%d", GetName(), x, y, z);
       if (GetStamina() < GetMaxStamina())
           StartAffectEvent();
   }
   else if (m_pkMobData)
   {
       m_pkMobInst->m_posLastAttacked.x = x;
       m_pkMobInst->m_posLastAttacked.y = y;
       m_pkMobInst->m_posLastAttacked.z = z;
   }

   if (bShowSpawnMotion)
   {
       SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);
       m_afAffectFlag.Set(AFF_SPAWN);
   }

SetXYZ(x, y, z);

   m_posDest.x = x;
   m_posDest.y = y;
   m_posDest.z = z;

   m_posStart.x = x;
   m_posStart.y = y;
   m_posStart.z = z;

   if (bChangeTree)
   {
       EncodeInsertPacket(this);
       sectree->InsertEntity(this);

       UpdateSectree();
   }
   else
   {
       ViewReencode();
       sys_log(0, " in same sectree");
   }

   REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

   SetValidComboInterval(0);
   return true;
}

// BGM_INFO
struct BGMInfo
{
std::string name;
float vol;
};

typedef std::map<unsigned, BGMInfo> BGMInfoMap;

static BGMInfoMap gs_bgmInfoMap;
static bool gs_bgmVolEnable = false;

void CHARACTER_SetBGMVolumeEnable()
{
gs_bgmVolEnable = true;
sys_log(0, "bgm_info.set_bgm_volume_enable");
}

void CHARACTER_AddBGMInfo(unsigned mapIndex, const char* name, float vol)
{
   BGMInfo newInfo;
   newInfo.name = name;
   newInfo.vol = vol;

gs_bgmInfoMap[mapIndex] = newInfo;

//sys_log(0, "bgm_info.add_info(%d, '%s', %f)", mapIndex, name, vol);
}

const BGMInfo& CHARACTER_GetBGMInfo(unsigned mapIndex)
{
   BGMInfoMap::iterator f = gs_bgmInfoMap.find(mapIndex);
   if (gs_bgmInfoMap.end() == f)
   {
       static BGMInfo s_empty = {"", 0.0f};
       return s_empty;
   }
   return f->second;
}

bool CHARACTER_IsBGMVolumeEnable()
{
return gs_bgmVolEnable;
}
// END_OF_BGM_INFO

void CHARACTER::MainCharacterPacket()
{
const unsigned mapIndex = GetMapIndex();
const BGMInfo& bgmInfo = CHARACTER_GetBGMInfo(mapIndex);

   // SUPPORT_BGM
   if (!bgmInfo.name.empty())
   {
       if (CHARACTER_IsBGMVolumeEnable())
       {
           sys_log(1, "bgm_info.play_bgm_vol(%d, name='%s', vol=%f)", mapIndex, bgmInfo.name.c_str(), bgmInfo.vol);
           TPacketGCMainCharacter4_BGM_VOL mainChrPacket;
           mainChrPacket.header = HEADER_GC_MAIN_CHARACTER4_BGM_VOL;
           mainChrPacket.dwVID = m_vid;
           mainChrPacket.wRaceNum = GetRaceNum();
           mainChrPacket.lx = GetX();
           mainChrPacket.ly = GetY();
           mainChrPacket.lz = GetZ();
           mainChrPacket.empire = GetDesc()->GetEmpire();
           mainChrPacket.skill_group = GetSkillGroup();
           strlcpy(mainChrPacket.szChrName, GetName(), sizeof(mainChrPacket.szChrName));

           mainChrPacket.fBGMVol = bgmInfo.vol;
           strlcpy(mainChrPacket.szBGMName, bgmInfo.name.c_str(), sizeof(mainChrPacket.szBGMName));
           GetDesc()->Packet(&mainChrPacket, sizeof(TPacketGCMainCharacter4_BGM_VOL));
       }
       else
       {
           sys_log(1, "bgm_info.play(%d, '%s')", mapIndex, bgmInfo.name.c_str());
           TPacketGCMainCharacter3_BGM mainChrPacket;
           mainChrPacket.header = HEADER_GC_MAIN_CHARACTER3_BGM;
           mainChrPacket.dwVID = m_vid;
           mainChrPacket.wRaceNum = GetRaceNum();
           mainChrPacket.lx = GetX();
           mainChrPacket.ly = GetY();
           mainChrPacket.lz = GetZ();
           mainChrPacket.empire = GetDesc()->GetEmpire();
           mainChrPacket.skill_group = GetSkillGroup();
           strlcpy(mainChrPacket.szChrName, GetName(), sizeof(mainChrPacket.szChrName));
           strlcpy(mainChrPacket.szBGMName, bgmInfo.name.c_str(), sizeof(mainChrPacket.szBGMName));
           GetDesc()->Packet(&mainChrPacket, sizeof(TPacketGCMainCharacter3_BGM));
       }
       //if (m_stMobile.length())
       //       ChatPacket(CHAT_TYPE_COMMAND, "sms");
   }
   // END_OF_SUPPORT_BGM
   else
   {
       sys_log(0, "bgm_info.play(%d, DEFAULT_BGM_NAME)", mapIndex);

       TPacketGCMainCharacter pack;
       pack.header = HEADER_GC_MAIN_CHARACTER;
       pack.dwVID = m_vid;
       pack.wRaceNum = GetRaceNum();
       pack.lx = GetX();
       pack.ly = GetY();
       pack.lz = GetZ();
       pack.empire = GetDesc()->GetEmpire();
       pack.skill_group = GetSkillGroup();
       strlcpy(pack.szName, GetName(), sizeof(pack.szName));
       GetDesc()->Packet(&pack, sizeof(TPacketGCMainCharacter));

       if (m_stMobile.length())
           ChatPacket(CHAT_TYPE_COMMAND, "sms");
   }
}

void CHARACTER::PointsPacket()
{
   if (!GetDesc())
       return;

   TPacketGCPoints pack;
   pack.header   = HEADER_GC_CHARACTER_POINTS;
   pack.points[POINT_LEVEL] = GetLevel();
   pack.points[POINT_EXP] = GetExp();
   pack.points[POINT_NEXT_EXP] = GetNextExp();
   pack.points[POINT_HP] = GetHP();
   pack.points[POINT_MAX_HP] = GetMaxHP();
   pack.points[POINT_SP] = GetSP();
   pack.points[POINT_MAX_SP] = GetMaxSP();
   pack.points[POINT_GOLD] = GetGold();
   pack.points[POINT_STAMINA] = GetStamina();
   pack.points[POINT_MAX_STAMINA] = GetMaxStamina();
   for (int i = POINT_ST; i < POINT_MAX_NUM; ++i)
       pack.points = GetPoint(i);

   GetDesc()->Packet(&pack, sizeof(TPacketGCPoints));

   if (!IsAcceOpen())
   {
       LPITEM item;
       for (int j = 0; j < INVENTORY_AND_EQUIP_SLOT_MAX; ++j)
       {
           if ((item = GetInventoryItem(j)))
               if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_ACCE && item->GetSocket(0) == 1)
                   item->SetSocket(0, 0);
       }
   }
}

bool CHARACTER::ChangeSex()
{
int src_race = GetRaceNum();

   switch (src_race)
   {
       case MAIN_RACE_WARRIOR_M:
           m_points.job = MAIN_RACE_WARRIOR_W;
           break;

       case MAIN_RACE_WARRIOR_W:
           m_points.job = MAIN_RACE_WARRIOR_M;
           break;

       case MAIN_RACE_ASSASSIN_M:
           m_points.job = MAIN_RACE_ASSASSIN_W;
           break;

       case MAIN_RACE_ASSASSIN_W:
           m_points.job = MAIN_RACE_ASSASSIN_M;
           break;

       case MAIN_RACE_SURA_M:
           m_points.job = MAIN_RACE_SURA_W;
           break;

       case MAIN_RACE_SURA_W:
           m_points.job = MAIN_RACE_SURA_M;
           break;

       case MAIN_RACE_SHAMAN_M:
           m_points.job = MAIN_RACE_SHAMAN_W;
           break;

       case MAIN_RACE_SHAMAN_W:
           m_points.job = MAIN_RACE_SHAMAN_M;
           break;

       case MAIN_RACE_WOLFMAN_M:
           m_points.job = MAIN_RACE_WOLFMAN_M;
           break;

       default:
           sys_err("CHANGE_SEX: %s unknown race %d", GetName(), src_race);
           return false;
   }

sys_log(0, "CHANGE_SEX: %s (%d -> %d)", GetName(), src_race, m_points.job);
return true;
}

WORD CHARACTER::GetRaceNum() const
{
if (m_dwPolymorphRace)
return m_dwPolymorphRace;

if (m_pkMobData)
return m_pkMobData->m_table.dwVnum;

return m_points.job;
}

void CHARACTER::SetRace(BYTE race)
{
   if (race >= MAIN_RACE_MAX_NUM)
   {
       sys_err("CHARACTER::SetRace(name=%s, race=%d).OUT_OF_RACE_RANGE", GetName(), race);
       return;
   }

m_points.job = race;
}

BYTE CHARACTER::GetJob() const
{
unsigned race = m_points.job;
unsigned job;

if (RaceToJob(race, &job))
return job;

sys_err("CHARACTER::GetJob(name=%s, race=%d).OUT_OF_RACE_RANGE", GetName(), race);
return JOB_WARRIOR;
}

void CHARACTER::SetLevel(BYTE level)
{
m_points.level = level;

   if (IsPC())
   {
       if (level < PK_PROTECT_LEVEL)
           SetPKMode(PK_MODE_PROTECT);
       else if (GetGMLevel() != GM_PLAYER)
           SetPKMode(PK_MODE_PROTECT);
       else if (m_bPKMode == PK_MODE_PROTECT)
           SetPKMode(PK_MODE_PEACE);
   }
}

void CHARACTER::SetEmpire(BYTE bEmpire)
{
m_bEmpire = bEmpire;
}

void CHARACTER::SetPlayerProto(const TPlayerTable * t)
{
   if (!GetDesc() || !*GetDesc()->GetHostName())
       sys_err("cannot get desc or hostname");
   else
       SetGMLevel();

m_bCharType = CHAR_TYPE_PC;

m_dwPlayerID = t->id;

m_iAlignment = t->lAlignment;
m_iRealAlignment = t->lAlignment;

m_points.voice = t->voice;

m_points.skill_group = t->skill_group;

   m_pointsInstant.bBasePart = t->part_base;
   SetPart(PART_HAIR, t->parts[PART_HAIR]);

   SetPart(PART_ACCE, t->parts[PART_ACCE]);

m_points.iRandomHP = t->sRandomHP;
m_points.iRandomSP = t->sRandomSP;

   // REMOVE_REAL_SKILL_LEVLES
   if (m_pSkillLevels)
       M2_DELETE_ARRAY(m_pSkillLevels);

   m_pSkillLevels = M2_NEW TPlayerSkill[SKILL_MAX_NUM];
   thecore_memcpy(m_pSkillLevels, t->skills, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
   // END_OF_REMOVE_REAL_SKILL_LEVLES

   if (t->lMapIndex >= 10000)
   {
       m_posWarp.x = t->lExitX;
       m_posWarp.y = t->lExitY;
       m_lWarpMapIndex = t->lExitMapIndex;
   }

   SetRealPoint(POINT_PLAYTIME, t->playtime);
   m_dwLoginPlayTime = t->playtime;
   SetRealPoint(POINT_ST, t->st);
   SetRealPoint(POINT_HT, t->ht);
   SetRealPoint(POINT_DX, t->dx);
   SetRealPoint(POINT_IQ, t->iq);

   SetPoint(POINT_ST, t->st);
   SetPoint(POINT_HT, t->ht);
   SetPoint(POINT_DX, t->dx);
   SetPoint(POINT_IQ, t->iq);

   SetPoint(POINT_STAT, t->stat_point);
   SetPoint(POINT_SKILL, t->skill_point);
   SetPoint(POINT_SUB_SKILL, t->sub_skill_point);
   SetPoint(POINT_HORSE_SKILL, t->horse_skill_point);

SetPoint(POINT_STAT_RESET_COUNT, t->stat_reset_count);

SetPoint(POINT_LEVEL_STEP, t->level_step);
SetRealPoint(POINT_LEVEL_STEP, t->level_step);

SetRace(t->job);

   SetLevel(t->level);
   SetExp(t->exp);
   SetGold(t->gold);

SetMapIndex(t->lMapIndex);
SetXYZ(t->x, t->y, t->z);

ComputePoints();

   SetHP(t->hp);
   SetSP(t->sp);
   SetStamina(t->stamina);

   //GM일때 보호모드
   if (!test_server)
   {
       if (GetGMLevel() > GM_LOW_WIZARD)
       {
           m_afAffectFlag.Set(AFF_YMIR);
           m_bPKMode = PK_MODE_PROTECT;
       }
   }

if (GetLevel() < PK_PROTECT_LEVEL)
m_bPKMode = PK_MODE_PROTECT;

m_stMobile = t->szMobile;

SetHorseData(t->horse);

if (GetHorseLevel() > 0)
UpdateHorseDataByLogoff(t->logoff_interval);

thecore_memcpy(m_aiPremiumTimes, t->aiPremiumTimes, sizeof(t->aiPremiumTimes));

m_dwLogOffInterval = t->logoff_interval;

sys_log(0, "PLAYER_LOAD: %s PREMIUM %d %d, LOGGOFF_INTERVAL %u PTR: %p", t->name, m_aiPremiumTimes[0], m_aiPremiumTimes[1], t->logoff_interval, this);

   if (GetGMLevel() != GM_PLAYER)
   {
       LogManager::instance().CharLog(this, GetGMLevel(), "GM_LOGIN", "");
       sys_log(0, "GM_LOGIN(gmlevel=%d, name=%s(%d), pos=(%d, %d)", GetGMLevel(), GetName(), GetPlayerID(), GetX(), GetY());
   }

#ifdef __PET_SYSTEM__
   // NOTE: 일단 캐릭터가 PC인 경우에만 PetSystem을 갖도록 함. 유럽 머신당 메모리 사용률때문에 NPC까지 하긴 좀..
   if (m_petSystem)
   {
       m_petSystem->Destroy();
       delete m_petSystem;
   }

m_petSystem = M2_NEW CPetSystem(this);
#endif

#ifdef ENABLE_MOUNT_SYSTEM
   if (m_MountSystem)
   {
       m_MountSystem->Destroy();
       delete m_MountSystem;
   }

m_MountSystem = M2_NEW CMountSystem(this);
#endif

#ifdef NEW_PET_SYSTEM
   if (m_newpetSystem)
   {
       m_newpetSystem->Destroy();
       delete m_newpetSystem;
   }

m_newpetSystem = M2_NEW CNewPetSystem(this);
#endif
}

EVENTFUNC(kill_ore_load_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "kill_ore_load_even> <Factor> Null pointer" );
       return 0;
   }

   LPCHARACTER   ch = info->ch;
   if (ch == NULL) { // <Factor>
       return 0;
   }

   ch->m_pkMiningEvent = NULL;
   M2_DESTROY_CHARACTER(ch);
   return 0;
}

void CHARACTER::SetProto(const CMob * pkMob)
{
if (m_pkMobInst)
M2_DELETE(m_pkMobInst);

m_pkMobData = pkMob;
m_pkMobInst = M2_NEW CMobInstance;

m_bPKMode = PK_MODE_FREE;

const TMobTable * t = &m_pkMobData->m_table;

m_bCharType = t->bType;

SetLevel(t->bLevel);
SetEmpire(t->bEmpire);

   SetExp(t->dwExp);
   SetRealPoint(POINT_ST, t->bStr);
   SetRealPoint(POINT_DX, t->bDex);
   SetRealPoint(POINT_HT, t->bCon);
   SetRealPoint(POINT_IQ, t->bInt);

ComputePoints();

SetHP(GetMaxHP());
SetSP(GetMaxSP());

   ////////////////////
   m_pointsInstant.dwAIFlag = t->dwAIFlag;
   SetImmuneFlag(t->dwImmuneFlag);

AssignTriggers(t);

ApplyMobAttribute(t);

   if (IsStone())
   {
       DetermineDropMetinStone();
   }

   if (IsWarp() || IsGoto())
   {
       StartWarpNPCEvent();
   }

CHARACTER_MANAGER::instance().RegisterRaceNumMap(this);

   // XXX X-mas santa hardcoding
   if (GetRaceNum() == xmas::MOB_SANTA_VNUM)
   {
       SetPoint(POINT_ATT_GRADE_BONUS, 10);
       if (g_iUseLocale)
           SetPoint(POINT_DEF_GRADE_BONUS, 6);
       else
           SetPoint(POINT_DEF_GRADE_BONUS, 15);

       //산타용
       //m_dwPlayStartTime = get_dword_time() + 10 * 60 * 1000;
       //신선자 노해
       m_dwPlayStartTime = get_dword_time() + 30 * 1000;
       if (test_server)
           m_dwPlayStartTime = get_dword_time() + 30 * 1000;
   }

   // XXX CTF GuildWar hardcoding
   if (warmap::IsWarFlag(GetRaceNum()))
   {
       m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);
       m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);
       m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);
   }

   if (warmap::IsWarFlagBase(GetRaceNum()))
   {
       m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);
       m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);
       m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);
   }

   if (m_bCharType == CHAR_TYPE_HORSE ||
           GetRaceNum() == 20101 ||
           GetRaceNum() == 20102 ||
           GetRaceNum() == 20103 ||
           GetRaceNum() == 20104 ||
           GetRaceNum() == 20105 ||
           GetRaceNum() == 20106 ||
           GetRaceNum() == 20107 ||
           GetRaceNum() == 20108 ||
           GetRaceNum() == 20109
   )
   {
       m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateHorse, &CHARACTER::EndStateEmpty);
       m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateMove, &CHARACTER::EndStateEmpty);
       m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateHorse, &CHARACTER::EndStateEmpty);
   }

   // MINING
   if (mining::IsVeinOfOre (GetRaceNum()))
   {
       char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

       m_pkMiningEvent = event_create(kill_ore_load_event, info, PASSES_PER_SEC(number(7 * 60, 15 * 60)));
   }
   // END_OF_MINING
   SetOfflineShopVID(COfflineShopManager::instance().FindMyOfflineShop(GetPlayerID()));
}

const TMobTable & CHARACTER::GetMobTable() const
{
return m_pkMobData->m_table;
}

bool CHARACTER::IsRaceFlag(DWORD dwBit) const
{
return m_pkMobData ? IS_SET(m_pkMobData->m_table.dwRaceFlag, dwBit) : 0;
}

DWORD CHARACTER::GetMobDamageMin() const
{
return m_pkMobData->m_table.dwDamageRange[0];
}

DWORD CHARACTER::GetMobDamageMax() const
{
return m_pkMobData->m_table.dwDamageRange[1];
}

float CHARACTER::GetMobDamageMultiply() const
{
float fDamMultiply = GetMobTable().fDamMultiply;

if (IsBerserk())
fDamMultiply = fDamMultiply * 2.0f; // BALANCE: 광폭화 시 두배

return fDamMultiply;
}

DWORD CHARACTER::GetMobDropItemVnum() const
{
return m_pkMobData->m_table.dwDropItemVnum;
}

bool CHARACTER::IsSummonMonster() const
{
return GetSummonVnum() != 0;
}

DWORD CHARACTER::GetSummonVnum() const
{
return m_pkMobData ? m_pkMobData->m_table.dwSummonVnum : 0;
}

DWORD CHARACTER::GetPolymorphItemVnum() const
{
return m_pkMobData ? m_pkMobData->m_table.dwPolymorphItemVnum : 0;
}

DWORD CHARACTER::GetMonsterDrainSPPoint() const
{
return m_pkMobData ? m_pkMobData->m_table.dwDrainSP : 0;
}

BYTE CHARACTER::GetMobRank() const
{
if (!m_pkMobData)
return MOB_RANK_KNIGHT; // PC일 경우 KNIGHT급

return m_pkMobData->m_table.bRank;
}

BYTE CHARACTER::GetMobSize() const
{
if (!m_pkMobData)
return MOBSIZE_MEDIUM;

return m_pkMobData->m_table.bSize;
}

WORD CHARACTER::GetMobAttackRange() const
{
   switch (GetMobBattleType())
   {
       case BATTLE_TYPE_RANGE:
       case BATTLE_TYPE_MAGIC:
           return m_pkMobData->m_table.wAttackRange + GetPoint(POINT_BOW_DISTANCE);
       default:
           return m_pkMobData->m_table.wAttackRange;
   }
}

BYTE CHARACTER::GetMobBattleType() const
{
if (!m_pkMobData)
return BATTLE_TYPE_MELEE;

return (m_pkMobData->m_table.bBattleType);
}

void CHARACTER::ComputeBattlePoints()
{
   if (IsPolymorphed())
   {
       DWORD dwMobVnum = GetPolymorphVnum();
       const CMob * pMob = CMobManager::instance().Get(dwMobVnum);
       int iAtt = 0;
       int iDef = 0;

       if (pMob)
       {
           iAtt = GetLevel() * 2 + GetPolymorphPoint(POINT_ST) * 2;
           iDef = GetLevel() + GetPolymorphPoint(POINT_HT) + pMob->m_table.wDef;
       }

       SetPoint(POINT_ATT_GRADE, iAtt);
       SetPoint(POINT_DEF_GRADE, iDef);
       SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));
       SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));
   }
   else if (IsPC())
   {
       SetPoint(POINT_ATT_GRADE, 0);
       SetPoint(POINT_DEF_GRADE, 0);
       SetPoint(POINT_CLIENT_DEF_GRADE, 0);
       SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));
       SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));

       int iAtk = GetLevel() * 2;
       int iStatAtk = 0;
       switch (GetJob())
       {
           case JOB_WARRIOR:
           case JOB_SURA:
               iStatAtk = (2 * GetPoint(POINT_ST));
               break;

           case JOB_ASSASSIN:
               iStatAtk = (4 * GetPoint(POINT_ST) + 2 * GetPoint(POINT_DX)) / 3;
               break;

           case JOB_SHAMAN:
               iStatAtk = (4 * GetPoint(POINT_ST) + 2 * GetPoint(POINT_IQ)) / 3;
               break;

           case JOB_WOLFMAN:
               iStatAtk = (2 * GetPoint(POINT_ST));
               break;

           default:
               sys_err("invalid job %d", GetJob());
               iStatAtk = (2 * GetPoint(POINT_ST));
               break;
       }

if (GetMountVnum() && iStatAtk < 2 * GetPoint(POINT_ST))
iStatAtk = (2 * GetPoint(POINT_ST));

       iAtk += iStatAtk;
       if (GetMountVnum())
       {
           if (GetJob() == JOB_SURA && GetSkillGroup() == 1)
           {
               iAtk += (iAtk * GetHorseLevel()) / 60;
           }
           else
           {
               iAtk += (iAtk * GetHorseLevel()) / 30;
           }
       }

iAtk += GetPoint(POINT_ATT_GRADE_BONUS);
PointChange(POINT_ATT_GRADE, iAtk);

       int iShowDef = GetLevel() + GetPoint(POINT_HT);
       int iDef = GetLevel() + (int) (GetPoint(POINT_HT) / 1.25);
       int iArmor = 0;

       LPITEM pkItem;
       for (int i = 0; i < WEAR_MAX_NUM; ++i)
           if ((pkItem = GetWear(i)) && pkItem->GetType() == ITEM_ARMOR)
           {
               if (pkItem->GetSubType() == ARMOR_BODY || pkItem->GetSubType() == ARMOR_HEAD || pkItem->GetSubType() == ARMOR_FOOTS || pkItem->GetSubType() == ARMOR_SHIELD)
               {
                   iArmor += pkItem->GetValue(1);
                   iArmor += (2 * pkItem->GetValue(5));
               }
           }

       if( true == IsHorseRiding() )
       {
           if (iArmor < GetHorseArmor())
               iArmor = GetHorseArmor();

           const char* pHorseName = CHorseNameManager::instance().GetHorseName(GetPlayerID());
           if (pHorseName != NULL && strlen(pHorseName))
           {
               iArmor += 20;
           }
       }

       iArmor += GetPoint(POINT_DEF_GRADE_BONUS);
       iArmor += GetPoint(POINT_PARTY_DEFENDER_BONUS);
       if (LC_IsYMIR())
       {
           PointChange(POINT_DEF_GRADE, iShowDef + iArmor);
       }
       else
       {
           PointChange(POINT_DEF_GRADE, iDef + iArmor);
           PointChange(POINT_CLIENT_DEF_GRADE, (iShowDef + iArmor) - GetPoint(POINT_DEF_GRADE));
       }

       PointChange(POINT_MAGIC_ATT_GRADE, GetLevel() * 2 + GetPoint(POINT_IQ) * 2 + GetPoint(POINT_MAGIC_ATT_GRADE_BONUS));
       PointChange(POINT_MAGIC_DEF_GRADE, GetLevel() + (GetPoint(POINT_IQ) * 3 + GetPoint(POINT_HT)) / 3 + iArmor / 2 + GetPoint(POINT_MAGIC_DEF_GRADE_BONUS));
   }
   else
   {
       int iAtt = GetLevel() * 2 + GetPoint(POINT_ST) * 2;
       int iDef = GetLevel() + GetPoint(POINT_HT) + GetMobTable().wDef;

       SetPoint(POINT_ATT_GRADE, iAtt);
       SetPoint(POINT_DEF_GRADE, iDef);
       SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));
       SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));
   }
}

void CHARACTER::ComputePoints()
{
   long lStat = GetPoint(POINT_STAT);
   long lStatResetCount = GetPoint(POINT_STAT_RESET_COUNT);
   long lSkillActive = GetPoint(POINT_SKILL);
   long lSkillSub = GetPoint(POINT_SUB_SKILL);
   long lSkillHorse = GetPoint(POINT_HORSE_SKILL);
   long lLevelStep = GetPoint(POINT_LEVEL_STEP);

   long lAttackerBonus = GetPoint(POINT_PARTY_ATTACKER_BONUS);
   long lTankerBonus = GetPoint(POINT_PARTY_TANKER_BONUS);
   long lBufferBonus = GetPoint(POINT_PARTY_BUFFER_BONUS);
   long lSkillMasterBonus = GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);
   long lHasteBonus = GetPoint(POINT_PARTY_HASTE_BONUS);
   long lDefenderBonus = GetPoint(POINT_PARTY_DEFENDER_BONUS);

long lHPRecovery = GetPoint(POINT_HP_RECOVERY);
long lSPRecovery = GetPoint(POINT_SP_RECOVERY);

   memset(m_pointsInstant.points, 0, sizeof(m_pointsInstant.points));
   BuffOnAttr_ClearAll();
   m_SkillDamageBonus.clear();

   SetPoint(POINT_STAT, lStat);
   SetPoint(POINT_SKILL, lSkillActive);
   SetPoint(POINT_SUB_SKILL, lSkillSub);
   SetPoint(POINT_HORSE_SKILL, lSkillHorse);
   SetPoint(POINT_LEVEL_STEP, lLevelStep);
   SetPoint(POINT_STAT_RESET_COUNT, lStatResetCount);

   SetPoint(POINT_ST, GetRealPoint(POINT_ST));
   SetPoint(POINT_HT, GetRealPoint(POINT_HT));
   SetPoint(POINT_DX, GetRealPoint(POINT_DX));
   SetPoint(POINT_IQ, GetRealPoint(POINT_IQ));

   SetPart(PART_MAIN, GetOriginalPart(PART_MAIN));
   SetPart(PART_WEAPON, GetOriginalPart(PART_WEAPON));
   SetPart(PART_HEAD, GetOriginalPart(PART_HEAD));
   SetPart(PART_HAIR, GetOriginalPart(PART_HAIR));
   SetPart(PART_ACCE, GetOriginalPart(PART_ACCE));

   SetPoint(POINT_PARTY_ATTACKER_BONUS, lAttackerBonus);
   SetPoint(POINT_PARTY_TANKER_BONUS, lTankerBonus);
   SetPoint(POINT_PARTY_BUFFER_BONUS, lBufferBonus);
   SetPoint(POINT_PARTY_SKILL_MASTER_BONUS, lSkillMasterBonus);
   SetPoint(POINT_PARTY_HASTE_BONUS, lHasteBonus);
   SetPoint(POINT_PARTY_DEFENDER_BONUS, lDefenderBonus);

SetPoint(POINT_HP_RECOVERY, lHPRecovery);
SetPoint(POINT_SP_RECOVERY, lSPRecovery);

   // PC_BANG_ITEM_ADD
   SetPoint(POINT_PC_BANG_EXP_BONUS, 0);
   SetPoint(POINT_PC_BANG_DROP_BONUS, 0);
   // END_PC_BANG_ITEM_ADD

int iMaxHP, iMaxSP;
int iMaxStamina;

   if (IsPC())
   {
       // 최대 생명력/정신력
       iMaxHP = JobInitialPoints[GetJob()].max_hp + m_points.iRandomHP + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].hp_per_ht;
       iMaxSP = JobInitialPoints[GetJob()].max_sp + m_points.iRandomSP + GetPoint(POINT_IQ) * JobInitialPoints[GetJob()].sp_per_iq;
       iMaxStamina = JobInitialPoints[GetJob()].max_stamina + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].stamina_per_con;

{
CSkillProto* pkSk = CSkillManager::instance().Get(SKILL_ADD_HP);

           if (NULL != pkSk)
           {
               pkSk->SetPointVar("k", 1.0f * GetSkillPower(SKILL_ADD_HP) / 100.0f);

               iMaxHP += static_cast<int>(pkSk->kPointPoly.Eval());
           }
       }

       // 기본 값들
       SetPoint(POINT_MOV_SPEED,   100);
       SetPoint(POINT_ATT_SPEED,   100);
       PointChange(POINT_ATT_SPEED, GetPoint(POINT_PARTY_HASTE_BONUS));
       SetPoint(POINT_CASTING_SPEED,   100);
   }
   else
   {
       iMaxHP = m_pkMobData->m_table.dwMaxHP;
       iMaxSP = 0;
       iMaxStamina = 0;

       SetPoint(POINT_ATT_SPEED, m_pkMobData->m_table.sAttackSpeed);
       SetPoint(POINT_MOV_SPEED, m_pkMobData->m_table.sMovingSpeed);
       SetPoint(POINT_CASTING_SPEED, m_pkMobData->m_table.sAttackSpeed);
   }

   if (IsPC())
   {
       // 말 타고 있을 때는 기본 스탯이 말의 기준 스탯보다 낮으면 높게 만든다.
       // 따라서 말의 기준 스탯이 무사 기준이므로, 수라/무당은 전체 스탯 합이
       // 대채적으로 더 올라가게 될 것이다.
       if (GetMountVnum())
       {
           if (GetHorseST() > GetPoint(POINT_ST))
               PointChange(POINT_ST, GetHorseST() - GetPoint(POINT_ST));

if (GetHorseDX() > GetPoint(POINT_DX))
PointChange(POINT_DX, GetHorseDX() - GetPoint(POINT_DX));

if (GetHorseHT() > GetPoint(POINT_HT))
PointChange(POINT_HT, GetHorseHT() - GetPoint(POINT_HT));

           if (GetHorseIQ() > GetPoint(POINT_IQ))
               PointChange(POINT_IQ, GetHorseIQ() - GetPoint(POINT_IQ));
       }

}

ComputeBattlePoints();

   // 기본 HP/SP 설정
   if (iMaxHP != GetMaxHP())
   {
       SetRealPoint(POINT_MAX_HP, iMaxHP); // 기본HP를 RealPoint에 저장해 놓는다.
   }

PointChange(POINT_MAX_HP, 0);

   if (iMaxSP != GetMaxSP())
   {
       SetRealPoint(POINT_MAX_SP, iMaxSP); // 기본SP를 RealPoint에 저장해 놓는다.
   }

PointChange(POINT_MAX_SP, 0);

SetMaxStamina(iMaxStamina);

m_pointsInstant.dwImmuneFlag = 0;

   for (int i = 0 ; i < WEAR_MAX_NUM; i++)
   {
       LPITEM pItem = GetWear(i);
       if (pItem)
       {
           pItem->ModifyPoints(true);
           SET_BIT(m_pointsInstant.dwImmuneFlag, GetWear(i)->GetImmuneFlag());
       }
   }

   // 용혼석 시스템
   // ComputePoints에서는 케릭터의 모든 속성값을 초기화하고,
   // 아이템, 버프 등에 관련된 모든 속성값을 재계산하기 때문에,
   // 용혼석 시스템도 ActiveDeck에 있는 모든 용혼석의 속성값을 다시 적용시켜야 한다.
   if (DragonSoul_IsDeckActivated())
   {
       for (int i = WEAR_MAX_NUM + DS_SLOT_MAX * DragonSoul_GetActiveDeck();
           i < WEAR_MAX_NUM + DS_SLOT_MAX * (DragonSoul_GetActiveDeck() + 1); i++)
       {
           LPITEM pItem = GetWear(i);
           if (pItem)
           {
               if (DSManager::instance().IsTimeLeftDragonSoul(pItem))
                   pItem->ModifyPoints(true);
           }
       }
   }

if (GetHP() > GetMaxHP())
PointChange(POINT_HP, GetMaxHP() - GetHP());

if (GetSP() > GetMaxSP())
PointChange(POINT_SP, GetMaxSP() - GetSP());

ComputeSkillPoints();

   RefreshAffect();
   CPetSystem* pPetSystem = GetPetSystem();
   if (NULL != pPetSystem)
   {
       pPetSystem->RefreshBuff();
   }

UpdatePacket();
}

// m_dwPlayStartTime의 단위는 milisecond다. 데이터베이스에는 분단위로 기록하기
// 때문에 플레이시간을 계산할 때 / 60000 으로 나눠서 하는데, 그 나머지 값이 남았
// 을 때 여기에 dwTimeRemain으로 넣어서 제대로 계산되도록 해주어야 한다.
void CHARACTER::ResetPlayTime(DWORD dwTimeRemain)
{
m_dwPlayStartTime = get_dword_time() - dwTimeRemain;
}

const int aiRecoveryPercents[10] = { 1, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

EVENTFUNC(recovery_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "recovery_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER ch = info->ch;

   if (ch == NULL) { // <Factor>
       return 0;
   }

   if (!ch->IsPC())
   {
       //
       // 몬스터 회복
       //
       if (ch->IsAffectFlag(AFF_POISON) || ch->IsAffectFlag(AFF_BLEEDING))
           return PASSES_PER_SEC(MAX(1, ch->GetMobTable().bRegenCycle));

       if (2493 == ch->GetMobTable().dwVnum)
       {
           int regenPct = BlueDragon_GetRangeFactor("hp_regen", ch->GetHPPct());
           regenPct += ch->GetMobTable().bRegenPercent;

           for (int i=1 ; i <= 4 ; ++i)
           {
               if (REGEN_PECT_BONUS == BlueDragon_GetIndexFactor("DragonStone", i, "effect_type"))
               {
                   DWORD dwDragonStoneID = BlueDragon_GetIndexFactor("DragonStone", i, "vnum");
                   size_t val = BlueDragon_GetIndexFactor("DragonStone", i, "val");
                   size_t cnt = SECTREE_MANAGER::instance().GetMonsterCountInMap( ch->GetMapIndex(), dwDragonStoneID );

regenPct += (val*cnt);

                   break;
               }
           }

           ch->PointChange(POINT_HP, MAX(1, (ch->GetMaxHP() * regenPct) / 100));
       }
       else if (!ch->IsDoor())
       {
           ch->MonsterLog("HP_REGEN +%d", MAX(1, (ch->GetMaxHP() * ch->GetMobTable().bRegenPercent) / 100));
           ch->PointChange(POINT_HP, MAX(1, (ch->GetMaxHP() * ch->GetMobTable().bRegenPercent) / 100));
       }

       if (ch->GetHP() >= ch->GetMaxHP())
       {
           ch->m_pkRecoveryEvent = NULL;
           return 0;
       }

       if (2493 == ch->GetMobTable().dwVnum)
       {
           for (int i=1 ; i <= 4 ; ++i)
           {
               if (REGEN_TIME_BONUS == BlueDragon_GetIndexFactor("DragonStone", i, "effect_type"))
               {
                   DWORD dwDragonStoneID = BlueDragon_GetIndexFactor("DragonStone", i, "vnum");
                   size_t val = BlueDragon_GetIndexFactor("DragonStone", i, "val");
                   size_t cnt = SECTREE_MANAGER::instance().GetMonsterCountInMap( ch->GetMapIndex(), dwDragonStoneID );

                   return PASSES_PER_SEC(MAX(1, (ch->GetMobTable().bRegenCycle - (val*cnt))));
               }
           }
       }

       return PASSES_PER_SEC(MAX(1, ch->GetMobTable().bRegenCycle));
   }
   else
   {
       //
       // PC 회복
       //
       ch->CheckTarget();
       //ch->UpdateSectree(); // 여기서 이걸 왜하지?
       ch->UpdateKillerMode();

       if (ch->IsAffectFlag(AFF_POISON) == true || ch->IsAffectFlag(AFF_BLEEDING))
       {
           // 중독인 경우 자동회복 금지
           // 파법술인 경우 자동회복 금지
           return 3;
       }

int iSec = (get_dword_time() - ch->GetLastMoveTime()) / 3000;

       // SP 회복 루틴.
       // 왜 이걸로 해서 함수로 빼놨는가 ?!
       ch->DistributeSP(ch);

if (ch->GetMaxHP() <= ch->GetHP())
return PASSES_PER_SEC(3);

       int iPercent = 0;
       int iAmount = 0;

       {
           iPercent = aiRecoveryPercents[MIN(9, iSec)];
           iAmount = 15 + (ch->GetMaxHP() * iPercent) / 100;
       }

       iAmount += (iAmount * ch->GetPoint(POINT_HP_REGEN)) / 100;

sys_log(1, "RECOVERY_EVENT: %s %d HP_REGEN %d HP +%d", ch->GetName(), iPercent, ch->GetPoint(POINT_HP_REGEN), iAmount);

       ch->PointChange(POINT_HP, iAmount, false);
       return PASSES_PER_SEC(3);
   }
}

void CHARACTER::StartRecoveryEvent()
{
if (m_pkRecoveryEvent)
return;

if (IsDead() || IsStun())
return;

if (IsNPC() && GetHP() >= GetMaxHP()) // 몬스터는 체력이 다 차있으면 시작 안한다.
return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

int iSec = IsPC() ? 3 : (MAX(1, GetMobTable().bRegenCycle));
m_pkRecoveryEvent = event_create(recovery_event, info, PASSES_PER_SEC(iSec));
}

void CHARACTER::Standup()
{
struct packet_position pack_position;

if (!IsPosition(POS_SITTING))
return;

SetPosition(POS_STANDING);

sys_log(1, "STANDUP: %s", GetName());

   pack_position.header   = HEADER_GC_CHARACTER_POSITION;
   pack_position.vid       = GetVID();
   pack_position.position   = POSITION_GENERAL;

PacketAround(&pack_position, sizeof(pack_position));
}

void CHARACTER::Sitdown(int is_ground)
{
struct packet_position pack_position;

if (IsPosition(POS_SITTING))
return;

SetPosition(POS_SITTING);
sys_log(1, "SITDOWN: %s", GetName());

   pack_position.header   = HEADER_GC_CHARACTER_POSITION;
   pack_position.vid       = GetVID();
   pack_position.position   = POSITION_SITTING_GROUND;
   PacketAround(&pack_position, sizeof(pack_position));
}

void CHARACTER::SetRotation(float fRot)
{
m_pointsInstant.fRot = fRot;
}

// x, y 방향으로 보고 선다.
void CHARACTER::SetRotationToXY(long x, long y)
{
SetRotation(GetDegreeFromPositionXY(GetX(), GetY(), x, y));
}

bool CHARACTER::CannotMoveByAffect() const
{
return (IsAffectFlag(AFF_STUN));
}

bool CHARACTER::CanMove() const
{
if (CannotMoveByAffect())
return false;

if (GetMyShop()) // 상점 연 상태에서는 움직일 수 없음
return false;

   // 0.2초 전이라면 움직일 수 없다.
   /*
   if (get_float_time() - m_fSyncTime < 0.2f)
   return false;
   */
   return true;
}

// 무조건 x, y 위치로 이동 시킨다.
bool CHARACTER::Sync(long x, long y)
{
if (!GetSectree())
return false;

LPSECTREE new_tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), x, y);

   if (!new_tree)
   {
       if (GetDesc())
       {
           sys_err("cannot find tree at %d %d (name: %s)", x, y, GetName());
           GetDesc()->SetPhase(PHASE_CLOSE);
       }
       else
       {
           sys_err("no tree: %s %d %d %d", GetName(), x, y, GetMapIndex());
           Dead();
       }

return false;
}

SetRotationToXY(x, y);
SetXYZ(x, y, 0);

   if (GetDungeon())
   {
       // 던젼용 이벤트 속성 변화
       int iLastEventAttr = m_iEventAttr;
       m_iEventAttr = new_tree->GetEventAttribute(x, y);

       if (m_iEventAttr != iLastEventAttr)
       {
           if (GetParty())
           {
               quest::CQuestManager::instance().AttrOut(GetParty()->GetLeaderPID(), this, iLastEventAttr);
               quest::CQuestManager::instance().AttrIn(GetParty()->GetLeaderPID(), this, m_iEventAttr);
           }
           else
           {
               quest::CQuestManager::instance().AttrOut(GetPlayerID(), this, iLastEventAttr);
               quest::CQuestManager::instance().AttrIn(GetPlayerID(), this, m_iEventAttr);
           }
       }
   }

   if (GetSectree() != new_tree)
   {
       if (!IsNPC())
       {
           SECTREEID id = new_tree->GetID();
           SECTREEID old_id = GetSectree()->GetID();

           sys_log(0, "SECTREE DIFFER: %s %dx%d was %dx%d",
                   GetName(),
                   id.coord.x,
                   id.coord.y,
                   old_id.coord.x,
                   old_id.coord.y);
       }

new_tree->InsertEntity(this);
}

return true;
}

void CHARACTER::Stop()
{
if (!IsState(m_stateIdle))
MonsterLog("[IDLE] 정지");

GotoState(m_stateIdle);

m_posDest.x = m_posStart.x = GetX();
m_posDest.y = m_posStart.y = GetY();
}

bool CHARACTER::Goto(long x, long y)
{
   // TODO 거리체크 필요
   // 같은 위치면 이동할 필요 없음 (자동 성공)
   if (GetX() == x && GetY() == y)
       return false;

   if (m_posDest.x == x && m_posDest.y == y)
   {
       if (!IsState(m_stateMove))
       {
           m_dwStateDuration = 4;
           GotoState(m_stateMove);
       }
       return false;
   }

m_posDest.x = x;
m_posDest.y = y;

CalculateMoveDuration();

m_dwStateDuration = 4;

   if (!IsState(m_stateMove))
   {
       MonsterLog("[MOVE] %s", GetVictim() ? "대상추적" : "그냥이동");

       if (GetVictim())
       {
           //MonsterChat(MONSTER_CHAT_CHASE);
           MonsterChat(MONSTER_CHAT_ATTACK);
       }
   }

GotoState(m_stateMove);

return true;
}

DWORD CHARACTER::GetMotionMode() const
{
DWORD dwMode = MOTION_MODE_GENERAL;

if (IsPolymorphed())
return dwMode;

   LPITEM pkItem;
   if ((pkItem = GetWear(WEAR_WEAPON)))
   {
       switch (pkItem->GetProto()->bSubType)
       {
           case WEAPON_SWORD:
               dwMode = MOTION_MODE_ONEHAND_SWORD;
               break;

           case WEAPON_TWO_HANDED:
               dwMode = MOTION_MODE_TWOHAND_SWORD;
               break;

           case WEAPON_DAGGER:
               dwMode = MOTION_MODE_DUALHAND_SWORD;
               break;

           case WEAPON_BOW:
               dwMode = MOTION_MODE_BOW;
               break;

           case WEAPON_BELL:
               dwMode = MOTION_MODE_BELL;
               break;

           case WEAPON_FAN:
               dwMode = MOTION_MODE_FAN;
               break;

           case WEAPON_CLAW:
               dwMode = MOTION_MODE_CLAW;
               break;
       }
   }

return dwMode;
}

float CHARACTER::GetMoveMotionSpeed() const
{
DWORD dwMode = GetMotionMode();

const CMotion * pkMotion = NULL;

   if (!GetMountVnum())
       pkMotion = CMotionManager::instance().GetMotion(GetRaceNum(), MAKE_MOTION_KEY(dwMode, (IsWalking() && IsPC()) ? MOTION_WALK : MOTION_RUN));
   else
   {
       pkMotion = CMotionManager::instance().GetMotion(GetMountVnum(), MAKE_MOTION_KEY(MOTION_MODE_GENERAL, (IsWalking() && IsPC()) ? MOTION_WALK : MOTION_RUN));

       if (!pkMotion)
           pkMotion = CMotionManager::instance().GetMotion(GetRaceNum(), MAKE_MOTION_KEY(MOTION_MODE_HORSE, (IsWalking() && IsPC()) ? MOTION_WALK : MOTION_RUN));
   }

   if (pkMotion)
       return -pkMotion->GetAccumVector().y / pkMotion->GetDuration();
   else
   {
       //sys_err("cannot find motion (name %s race %d mode %d)", GetName(), GetRaceNum(), dwMode);
       return 300.0f;
   }
}

float CHARACTER::GetMoveSpeed() const
{
return GetMoveMotionSpeed() * 10000 / CalculateDuration(GetLimitPoint(POINT_MOV_SPEED), 10000);
}

void CHARACTER::CalculateMoveDuration()
{
m_posStart.x = GetX();
m_posStart.y = GetY();

float fDist = DISTANCE_SQRT(m_posStart.x - m_posDest.x, m_posStart.y - m_posDest.y);

float motionSpeed = GetMoveMotionSpeed();

m_dwMoveDuration = CalculateDuration(GetLimitPoint(POINT_MOV_SPEED),
(int) ((fDist / motionSpeed) * 1000.0f));

   if (IsNPC())
       sys_log(1, "Maxmi - Char.cpp",
               GetName(), fDist, GetLimitPoint(POINT_MOV_SPEED), m_dwMoveDuration, motionSpeed,
               m_posStart.x, m_posStart.y, m_posDest.x, m_posDest.y);

m_dwMoveStartTime = get_dword_time();
}

// x y 위치로 이동 한다. (이동할 수 있는 가 없는 가를 확인 하고 Sync 메소드로 실제 이동 한다)
// 서버는 char의 x, y 값을 바로 바꾸지만,
// 클라에서는 이전 위치에서 바꾼 x, y까지 interpolation한다.
// 걷거나 뛰는 것은 char의 m_bNowWalking에 달려있다.
// Warp를 의도한 것이라면 Show를 사용할 것.
bool CHARACTER::Move(long x, long y)
{
   // 같은 위치면 이동할 필요 없음 (자동 성공)
   if (GetX() == x && GetY() == y)
       return true;

   if (test_server)
       if (m_bDetailLog)
           sys_log(0, "%s position %u %u", GetName(), x, y);

OnMove();
return Sync(x, y);
}

void CHARACTER::SendMovePacket(BYTE bFunc, BYTE bArg, DWORD x, DWORD y, DWORD dwDuration, DWORD dwTime, int iRot)
{
TPacketGCMove pack;

   if (bFunc == FUNC_WAIT)
   {
       x = m_posDest.x;
       y = m_posDest.y;
       dwDuration = m_dwMoveDuration;
   }

EncodeMovePacket(pack, GetVID(), bFunc, bArg, x, y, dwDuration, dwTime, iRot == -1 ? (int) GetRotation() / 5 : iRot);
PacketView(&pack, sizeof(TPacketGCMove), this);
}

int CHARACTER::GetRealPoint(BYTE type) const
{
return m_points.points[type];
}

void CHARACTER::SetRealPoint(BYTE type, int val)
{
m_points.points[type] = val;
}

int CHARACTER::GetPolymorphPoint(BYTE type) const
{
   if (IsPolymorphed() && !IsPolyMaintainStat())
   {
       DWORD dwMobVnum = GetPolymorphVnum();
       const CMob * pMob = CMobManager::instance().Get(dwMobVnum);
       int iPower = GetPolymorphPower();

       if (pMob)
       {
           switch (type)
           {
               case POINT_ST:
                   if (GetJob() == JOB_SHAMAN || GetJob() == JOB_SURA && GetSkillGroup() == 2)
                       return pMob->m_table.bStr * iPower / 100 + GetPoint(POINT_IQ);
                   return pMob->m_table.bStr * iPower / 100 + GetPoint(POINT_ST);

case POINT_HT:
return pMob->m_table.bCon * iPower / 100 + GetPoint(POINT_HT);

case POINT_IQ:
return pMob->m_table.bInt * iPower / 100 + GetPoint(POINT_IQ);

               case POINT_DX:
                   return pMob->m_table.bDex * iPower / 100 + GetPoint(POINT_DX);
           }
       }
   }

return GetPoint(type);
}

int CHARACTER::GetPoint(BYTE type) const
{
   if (type >= POINT_MAX_NUM)
   {
       sys_err("Point type overflow (type %u)", type);
       return 0;
   }

int val = m_pointsInstant.points[type];
int max_val = INT_MAX;

   switch (type)
   {
       case POINT_STEAL_HP:
       case POINT_STEAL_SP:
           max_val = 50;
           break;
   }

if (val > max_val)
sys_err("POINT_ERROR: %s type %d val %d (max: %d)", GetName(), val, max_val);

return (val);
}

int CHARACTER::GetLimitPoint(BYTE type) const
{
   if (type >= POINT_MAX_NUM)
   {
       sys_err("Point type overflow (type %u)", type);
       return 0;
   }

   int val = m_pointsInstant.points[type];
   int max_val = INT_MAX;
   int limit = INT_MAX;
   int min_limit = -INT_MAX;

   switch (type)
   {
       case POINT_ATT_SPEED:
           min_limit = 0;

           if (IsPC())
               limit = 170;
           else
               limit = 250;
           break;

case POINT_MOV_SPEED:
min_limit = 0;

           if (IsPC())
               limit = 200;
           else
               limit = 250;
           break;

       case POINT_STEAL_HP:
       case POINT_STEAL_SP:
           limit = 50;
           max_val = 50;
           break;

       case POINT_MALL_ATTBONUS:
       case POINT_MALL_DEFBONUS:
           limit = 20;
           max_val = 50;
           break;
   }

if (val > max_val)
sys_err("POINT_ERROR: %s type %d val %d (max: %d)", GetName(), val, max_val);

if (val > limit)
val = limit;

if (val < min_limit)
val = min_limit;

return (val);
}

void CHARACTER::SetPoint(BYTE type, int val)
{
   if (type >= POINT_MAX_NUM)
   {
       sys_err("Point type overflow (type %u)", type);
       return;
   }

m_pointsInstant.points[type] = val;

   // 아직 이동이 다 안끝났다면 이동 시간 계산을 다시 해야 한다.
   if (type == POINT_MOV_SPEED && get_dword_time() < m_dwMoveStartTime + m_dwMoveDuration)
   {
       CalculateMoveDuration();
   }
}

INT CHARACTER::GetAllowedGold() const
{
   if (GetLevel() <= 10)
       return 100000;
   else if (GetLevel() <= 20)
       return 500000;
   else
       return 50000000;
}

void CHARACTER::CheckMaximumPoints()
{
if (GetMaxHP() < GetHP())
PointChange(POINT_HP, GetMaxHP() - GetHP());

if (GetMaxSP() < GetSP())
PointChange(POINT_SP, GetMaxSP() - GetSP());
}

void CHARACTER::PointChange(BYTE type, int amount, bool bAmount, bool bBroadcast)
{
int val = 0;

//sys_log(0, "PointChange %d %d | %d -> %d cHP %d mHP %d", type, amount, GetPoint(type), GetPoint(type)+amount, GetHP(), GetMaxHP());

   switch (type)
   {
       case POINT_NONE:
           return;

       case POINT_LEVEL:
           if ((GetLevel() + amount) > gPlayerMaxLevel)
               return;

SetLevel(GetLevel() + amount);
val = GetLevel();

sys_log(0, "LEVELUP: %s %d NEXT EXP %d", GetName(), GetLevel(), GetNextExp());

PointChange(POINT_NEXT_EXP, GetNextExp(), false);

           if (amount)
           {
               quest::CQuestManager::instance().LevelUp(GetPlayerID());

LogManager::instance().LevelLog(this, val, GetRealPoint(POINT_PLAYTIME) + (get_dword_time() - m_dwPlayStartTime) / 60000);

               if (GetGuild())
               {
                   GetGuild()->LevelChange(GetPlayerID(), GetLevel());
               }

               if (GetParty())
               {
                   GetParty()->RequestSetMemberLevel(GetPlayerID(), GetLevel());
               }
           }
           break;

       case POINT_NEXT_EXP:
           val = GetNextExp();
           bAmount = false;
           break;

       case POINT_EXP:
           {
               DWORD exp = GetExp();
               DWORD next_exp = GetNextExp();

               if (LC_IsNewCIBN())
               {
                   if (IsOverTime(OT_NONE))
                   {
                       dev_log(LOG_DEB0, "<EXP_LOG> %s = NONE", GetName());
                   }
                   else if (IsOverTime(OT_3HOUR))
                   {
                       amount = (amount / 2);
                       dev_log(LOG_DEB0, "<EXP_LOG> %s = 3HOUR", GetName());
                   }
                   else if (IsOverTime(OT_5HOUR))
                   {
                       amount = 0;
                       dev_log(LOG_DEB0, "<EXP_LOG> %s = 5HOUR", GetName());
                   }
               }

               if (amount < 0 && (int)exp < -amount)
               {
                   sys_log(1, "%s AMOUNT < 0 %d, CUR EXP: %d", GetName(), -amount, exp);
                   amount = -static_cast<int>(exp);

                   SetExp(exp + amount);
                   val = GetExp();
               }
               else
               {
                   if (gPlayerMaxLevel <= GetLevel())
                       return;

if (test_server)
ChatPacket(CHAT_TYPE_INFO, "You have gained %d exp.", amount);

                   DWORD iExpBalance = 0;
                   if (exp + amount >= next_exp)
                   {
                       iExpBalance = (exp + amount) - next_exp;
                       amount = next_exp - exp;

                       SetExp(0);
                       exp = next_exp;
                   }
                   else
                   {
                       SetExp(exp + amount);
                       exp = GetExp();
                   }

                   DWORD q = DWORD(next_exp / 4.0f);
                   int iLevStep = GetRealPoint(POINT_LEVEL_STEP);
                   if (iLevStep >= 4)
                   {
                       sys_err("%s LEVEL_STEP bigger than 4! (%d)", GetName(), iLevStep);
                       iLevStep = 4;
                   }

                   if (exp >= next_exp && iLevStep < 4)
                   {
                       for (int i = 0; i < 4 - iLevStep; ++i)
                           PointChange(POINT_LEVEL_STEP, 1, false, true);
                   }
                   else if (exp >= q * 3 && iLevStep < 3)
                   {
                       for (int i = 0; i < 3 - iLevStep; ++i)
                           PointChange(POINT_LEVEL_STEP, 1, false, true);
                   }
                   else if (exp >= q * 2 && iLevStep < 2)
                   {
                       for (int i = 0; i < 2 - iLevStep; ++i)
                           PointChange(POINT_LEVEL_STEP, 1, false, true);
                   }
                   else if (exp >= q && iLevStep < 1)
                       PointChange(POINT_LEVEL_STEP, 1);

                   if (iExpBalance)
                   {
                       PointChange(POINT_EXP, iExpBalance);
                   }

                   val = GetExp();
               }
           }
           break;

       case POINT_LEVEL_STEP:
           if (amount > 0)
           {
               val = GetPoint(POINT_LEVEL_STEP) + amount;

               switch (val)
               {
                   case 1:
                   case 2:
                   case 3:
                       if (GetLevel() < 91) PointChange(POINT_STAT, 1);
                       break;

                   case 4:
                       {
                           int iHP = number(JobInitialPoints[GetJob()].hp_per_lv_begin, JobInitialPoints[GetJob()].hp_per_lv_end);
                           int iSP = number(JobInitialPoints[GetJob()].sp_per_lv_begin, JobInitialPoints[GetJob()].sp_per_lv_end);

                           m_points.iRandomHP += iHP;
                           m_points.iRandomSP += iSP;
                           if (GetSkillGroup())
                           {
                               if (GetLevel() >= 5)
                                   PointChange(POINT_SKILL, 1);

                               if (GetLevel() >= 9)
                                   PointChange(POINT_SUB_SKILL, 1);
                           }

                           PointChange(POINT_MAX_HP, iHP);
                           PointChange(POINT_MAX_SP, iSP);
                           PointChange(POINT_LEVEL, 1, false, true);

                           val = 0;
                       }
                       break;
               }

               if (GetLevel() <= 10)
                   AutoGiveItem(27001, 2);
               else if (GetLevel() <= 30)
                   AutoGiveItem(27002, 2);
               else
               {
//                   AutoGiveItem(27002, 2);
//                   AutoGiveItem(27003, 2);
               }

               PointChange(POINT_HP, GetMaxHP() - GetHP());
               PointChange(POINT_SP, GetMaxSP() - GetSP());
               PointChange(POINT_STAMINA, GetMaxStamina() - GetStamina());

SetPoint(POINT_LEVEL_STEP, val);
SetRealPoint(POINT_LEVEL_STEP, val);

               Save();
           }
           else
               val = GetPoint(POINT_LEVEL_STEP);

break;

       case POINT_HP:
           {
               if (IsDead() || IsStun())
                   return;

int prev_hp = GetHP();

               amount = MIN(GetMaxHP() - GetHP(), amount);
               SetHP(GetHP() + amount);
               val = GetHP();

BroadcastTargetPacket();

               if (GetParty() && IsPC() && val != prev_hp)
                   GetParty()->SendPartyInfoOneToAll(this);
           }
           break;

       case POINT_SP:
           {
               if (IsDead() || IsStun())
                   return;

               amount = MIN(GetMaxSP() - GetSP(), amount);
               SetSP(GetSP() + amount);
               val = GetSP();
           }
           break;

       case POINT_STAMINA:
           {
               if (IsDead() || IsStun())
                   return;

               int prev_val = GetStamina();
               amount = MIN(GetMaxStamina() - GetStamina(), amount);
               SetStamina(GetStamina() + amount);
               val = GetStamina();

               if (val == 0)
               {
                   SetNowWalking(true);
               }
               else if (prev_val == 0)
               {
                   ResetWalking();
               }

               if (amount < 0 && val != 0)
                   return;
           }
           break;

       case POINT_MAX_HP:
           {
               SetPoint(type, GetPoint(type) + amount);
               int hp = GetRealPoint(POINT_MAX_HP);
               int add_hp = MIN(3500, hp * GetPoint(POINT_MAX_HP_PCT) / 100);
               add_hp += GetPoint(POINT_MAX_HP);
               add_hp += GetPoint(POINT_PARTY_TANKER_BONUS);

               SetMaxHP(hp + add_hp);
               val = GetMaxHP();
           }
           break;

       case POINT_MAX_SP:
           {
               SetPoint(type, GetPoint(type) + amount);
               int sp = GetRealPoint(POINT_MAX_SP);
               int add_sp = MIN(800, sp * GetPoint(POINT_MAX_SP_PCT) / 100);
               add_sp += GetPoint(POINT_MAX_SP);
               add_sp += GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);

               SetMaxSP(sp + add_sp);
               val = GetMaxSP();
           }
           break;

       case POINT_MAX_HP_PCT:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);

PointChange(POINT_MAX_HP, 0);
break;

       case POINT_MAX_SP_PCT:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);

PointChange(POINT_MAX_SP, 0);
break;

       case POINT_MAX_STAMINA:
           SetMaxStamina(GetMaxStamina() + amount);
           val = GetMaxStamina();
           break;

       case POINT_GOLD:
           {
               const int64_t nTotalMoney = static_cast<int64_t>(GetGold()) + static_cast<int64_t>(amount);

               if (GOLD_MAX <= nTotalMoney)
               {
                   sys_err("[OVERFLOW_GOLD] OriGold %d AddedGold %d id %u Name %s ", GetGold(), amount, GetPlayerID(), GetName());
                   LogManager::instance().CharLog(this, GetGold() + amount, "OVERFLOW_GOLD", "");
                   return;
               }

               // 청소년보호
               if (LC_IsNewCIBN() && amount > 0)
               {
                   if (IsOverTime(OT_NONE))
                   {
                       dev_log(LOG_DEB0, "<GOLD_LOG> %s = NONE", GetName());
                   }
                   else if (IsOverTime(OT_3HOUR))
                   {
                       amount = (amount / 2);
                       dev_log(LOG_DEB0, "<GOLD_LOG> %s = 3HOUR", GetName());
                   }
                   else if (IsOverTime(OT_5HOUR))
                   {
                       amount = 0;
                       dev_log(LOG_DEB0, "<GOLD_LOG> %s = 5HOUR", GetName());
                   }
               }

               SetGold(GetGold() + amount);
               val = GetGold();
           }
           break;

       case POINT_SKILL:
       case POINT_STAT:
       case POINT_SUB_SKILL:
       case POINT_STAT_RESET_COUNT:
       case POINT_HORSE_SKILL:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);

SetRealPoint(type, val);
break;

       case POINT_DEF_GRADE:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);

PointChange(POINT_CLIENT_DEF_GRADE, amount);
break;

       case POINT_CLIENT_DEF_GRADE:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;

       case POINT_ST:
       case POINT_HT:
       case POINT_DX:
       case POINT_IQ:
       case POINT_HP_REGEN:
       case POINT_SP_REGEN:
       case POINT_ATT_SPEED:
       case POINT_ATT_GRADE:
       case POINT_MOV_SPEED:
       case POINT_CASTING_SPEED:
       case POINT_MAGIC_ATT_GRADE:
       case POINT_MAGIC_DEF_GRADE:
       case POINT_BOW_DISTANCE:
       case POINT_HP_RECOVERY:
       case POINT_SP_RECOVERY:
       case POINT_ATTBONUS_HUMAN:
       case POINT_ATTBONUS_ANIMAL:
       case POINT_ATTBONUS_ORC:
       case POINT_ATTBONUS_MILGYO:
       case POINT_ATTBONUS_UNDEAD:
       case POINT_ATTBONUS_DEVIL:
       case POINT_ATTBONUS_MONSTER:
       case POINT_ATTBONUS_SURA:
       case POINT_ATTBONUS_ASSASSIN:
       case POINT_ATTBONUS_WARRIOR:
       case POINT_ATTBONUS_SHAMAN:
       case POINT_ATTBONUS_WOLFMAN:
       case POINT_POISON_PCT:
       case POINT_BLEEDING_PCT:
       case POINT_STUN_PCT:
       case POINT_SLOW_PCT:
       case POINT_BLOCK:
       case POINT_DODGE:
       case POINT_CRITICAL_PCT:
       case POINT_RESIST_CRITICAL:
       case POINT_PENETRATE_PCT:
       case POINT_RESIST_PENETRATE:
       case POINT_CURSE_PCT:
       case POINT_STEAL_HP:
       case POINT_STEAL_SP:
       case POINT_MANA_BURN_PCT:
       case POINT_DAMAGE_SP_RECOVER:
       case POINT_RESIST_NORMAL_DAMAGE:
       case POINT_RESIST_SWORD:
       case POINT_RESIST_TWOHAND:
       case POINT_RESIST_DAGGER:
       case POINT_RESIST_BELL:
       case POINT_RESIST_FAN:
       case POINT_RESIST_BOW:
       case POINT_RESIST_CLAW:
       case POINT_RESIST_FIRE:
       case POINT_RESIST_ELEC:
       case POINT_RESIST_MAGIC:
       case POINT_RESIST_WIND:
       case POINT_RESIST_ICE:
       case POINT_RESIST_EARTH:
       case POINT_RESIST_DARK:
       case POINT_REFLECT_MELEE:
       case POINT_REFLECT_CURSE:
       case POINT_POISON_REDUCE:
       case POINT_BLEEDING_REDUCE:
       case POINT_KILL_SP_RECOVER:
       case POINT_KILL_HP_RECOVERY:
       case POINT_HIT_HP_RECOVERY:
       case POINT_HIT_SP_RECOVERY:
       case POINT_MANASHIELD:
       case POINT_ATT_BONUS:
       case POINT_DEF_BONUS:
       case POINT_SKILL_DAMAGE_BONUS:
       case POINT_NORMAL_HIT_DAMAGE_BONUS:
       case POINT_SKILL_DEFEND_BONUS:
       case POINT_NORMAL_HIT_DEFEND_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;

       case POINT_PARTY_ATTACKER_BONUS:
       case POINT_PARTY_TANKER_BONUS:
       case POINT_PARTY_BUFFER_BONUS:
       case POINT_PARTY_SKILL_MASTER_BONUS:
       case POINT_PARTY_HASTE_BONUS:
       case POINT_PARTY_DEFENDER_BONUS:
       case POINT_RESIST_WARRIOR:
       case POINT_RESIST_ASSASSIN:
       case POINT_RESIST_SURA:
       case POINT_RESIST_SHAMAN:
       case POINT_RESIST_WOLFMAN:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;

       case POINT_MALL_ATTBONUS:
       case POINT_MALL_DEFBONUS:
       case POINT_MALL_EXPBONUS:
       case POINT_MALL_ITEMBONUS:
       case POINT_MALL_GOLDBONUS:
       case POINT_MELEE_MAGIC_ATT_BONUS_PER:
           if (GetPoint(type) + amount > 500)
           {
               sys_err("MALL_BONUS exceeded over 500!! point type: %d name: %s amount %d", type, GetName(), amount);
               amount = 500 - GetPoint(type);
           }

           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;

       case POINT_PC_BANG_EXP_BONUS :
       case POINT_PC_BANG_DROP_BONUS :
       case POINT_RAMADAN_CANDY_BONUS_EXP:
           SetPoint(type, amount);
           val = GetPoint(type);
           break;

       case POINT_EXP_DOUBLE_BONUS:
       case POINT_GOLD_DOUBLE_BONUS:
       case POINT_ITEM_DROP_BONUS:
       case POINT_POTION_BONUS:
           if (GetPoint(type) + amount > 100)
           {
               sys_err("BONUS exceeded over 100!! point type: %d name: %s amount %d", type, GetName(), amount);
               amount = 100 - GetPoint(type);
           }

           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;

       case POINT_IMMUNE_STUN:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           if (val)
           {
               SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_STUN);
           }
           else
           {
               REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_STUN);
           }
           break;

       case POINT_IMMUNE_SLOW:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           if (val)
           {
               SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_SLOW);
           }
           else
           {
               REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_SLOW);
           }
           break;

       case POINT_IMMUNE_FALL:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           if (val)
           {
               SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_FALL);
           }
           else
           {
               REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_FALL);
           }
           break;

       case POINT_ATT_GRADE_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           PointChange(POINT_ATT_GRADE, amount);
           val = GetPoint(type);
           break;

       case POINT_DEF_GRADE_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           PointChange(POINT_DEF_GRADE, amount);
           val = GetPoint(type);
           break;

       case POINT_MAGIC_ATT_GRADE_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           PointChange(POINT_MAGIC_ATT_GRADE, amount);
           val = GetPoint(type);
           break;

       case POINT_MAGIC_DEF_GRADE_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           PointChange(POINT_MAGIC_DEF_GRADE, amount);
           val = GetPoint(type);
           break;

       case POINT_VOICE:
       case POINT_EMPIRE_POINT:
           val = GetRealPoint(type);
           break;

       case POINT_POLYMORPH:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           SetPolymorph(val);
           break;

       case POINT_MOUNT:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           MountVnum(val);
           break;

       case POINT_ENERGY:
       case POINT_COSTUME_ATTR_BONUS:
           {
               int old_val = GetPoint(type);
               SetPoint(type, old_val + amount);
               val = GetPoint(type);
               BuffOnAttr_ValueChange(type, old_val, val);
           }
           break;

       default:
           sys_err("CHARACTER::PointChange: %s: unknown point change type %d", GetName(), type);
           return;
   }

   switch (type)
   {
       case POINT_LEVEL:
       case POINT_ST:
       case POINT_DX:
       case POINT_IQ:
       case POINT_HT:
           ComputeBattlePoints();
           break;

       case POINT_MAX_HP:
       case POINT_MAX_SP:
       case POINT_MAX_STAMINA:
           break;
   }

if (type == POINT_HP && amount == 0)
return;

   if (GetDesc())
   {
       struct packet_point_change pack;
       pack.header = HEADER_GC_CHARACTER_POINT_CHANGE;
       pack.dwVID = m_vid;
       pack.type = type;
       pack.value = val;

       if (bAmount)
           pack.amount = amount;
       else
           pack.amount = 0;

       if (!bBroadcast)
           GetDesc()->Packet(&pack, sizeof(struct packet_point_change));
       else
           PacketAround(&pack, sizeof(pack));
   }
}

#ifdef NEW_PET_SYSTEM
void CHARACTER::SendPetLevelUpEffect(int vid, int type, int value, int amount) {
struct packet_point_change pack;

   pack.header = HEADER_GC_CHARACTER_POINT_CHANGE;
   pack.dwVID = vid;
   pack.type = type;
   pack.value = value;
   pack.amount = amount;
   PacketAround(&pack, sizeof(pack));
}
#endif

void CHARACTER::ApplyPoint(BYTE bApplyType, int iVal)
{
   switch (bApplyType)
   {
       case APPLY_NONE:
           break;

       case APPLY_CON:
           PointChange(POINT_HT, iVal);
           PointChange(POINT_MAX_HP, (iVal * JobInitialPoints[GetJob()].hp_per_ht));
           PointChange(POINT_MAX_STAMINA, (iVal * JobInitialPoints[GetJob()].stamina_per_con));
           break;

       case APPLY_INT:
           PointChange(POINT_IQ, iVal);
           PointChange(POINT_MAX_SP, (iVal * JobInitialPoints[GetJob()].sp_per_iq));
           break;

       case APPLY_SKILL:
           {
               BYTE bSkillVnum = (BYTE) (((DWORD)iVal) >> 24);
               int iAdd = iVal & 0x00800000;
               int iChange = iVal & 0x007fffff;

               sys_log(1, "APPLY_SKILL skill %d add? %d change %d", bSkillVnum, iAdd ? 1 : 0, iChange);
               if (0 == iAdd)
                   iChange = -iChange;

               boost::unordered_map<BYTE, int>::iterator iter = m_SkillDamageBonus.find(bSkillVnum);
               if (iter == m_SkillDamageBonus.end())
                   m_SkillDamageBonus.insert(std::make_pair(bSkillVnum, iChange));
               else
                   iter->second += iChange;
           }
           break;

       case APPLY_STR:
       case APPLY_DEX:
       case APPLY_MAX_HP:
       case APPLY_MAX_SP:
       case APPLY_MAX_HP_PCT:
       case APPLY_MAX_SP_PCT:
       case APPLY_ATT_SPEED:
       case APPLY_MOV_SPEED:
       case APPLY_CAST_SPEED:
       case APPLY_HP_REGEN:
       case APPLY_SP_REGEN:
       case APPLY_POISON_PCT:
       case APPLY_BLEEDING_PCT:
       case APPLY_STUN_PCT:
       case APPLY_SLOW_PCT:
       case APPLY_CRITICAL_PCT:
       case APPLY_PENETRATE_PCT:
       case APPLY_ATTBONUS_HUMAN:
       case APPLY_ATTBONUS_ANIMAL:
       case APPLY_ATTBONUS_ORC:
       case APPLY_ATTBONUS_MILGYO:
       case APPLY_ATTBONUS_UNDEAD:
       case APPLY_ATTBONUS_DEVIL:
       case APPLY_ATTBONUS_WARRIOR:
       case APPLY_ATTBONUS_ASSASSIN:
       case APPLY_ATTBONUS_SURA:
       case APPLY_ATTBONUS_SHAMAN:
       case APPLY_ATTBONUS_MONSTER:
       case APPLY_STEAL_HP:
       case APPLY_STEAL_SP:
       case APPLY_MANA_BURN_PCT:
       case APPLY_DAMAGE_SP_RECOVER:
       case APPLY_BLOCK:
       case APPLY_DODGE:
       case APPLY_RESIST_SWORD:
       case APPLY_RESIST_TWOHAND:
       case APPLY_RESIST_DAGGER:
       case APPLY_RESIST_BELL:
       case APPLY_RESIST_FAN:
       case APPLY_RESIST_BOW:
       case APPLY_RESIST_FIRE:
       case APPLY_RESIST_ELEC:
       case APPLY_RESIST_MAGIC:
       case APPLY_RESIST_WIND:
       case APPLY_RESIST_ICE:
       case APPLY_RESIST_EARTH:
       case APPLY_RESIST_DARK:
       case APPLY_REFLECT_MELEE:
       case APPLY_REFLECT_CURSE:
       case APPLY_ANTI_CRITICAL_PCT:
       case APPLY_ANTI_PENETRATE_PCT:
       case APPLY_POISON_REDUCE:
       case APPLY_BLEEDING_REDUCE:
       case APPLY_KILL_SP_RECOVER:
       case APPLY_EXP_DOUBLE_BONUS:
       case APPLY_GOLD_DOUBLE_BONUS:
       case APPLY_ITEM_DROP_BONUS:
       case APPLY_POTION_BONUS:
       case APPLY_KILL_HP_RECOVER:
       case APPLY_IMMUNE_STUN:
       case APPLY_IMMUNE_SLOW:
       case APPLY_IMMUNE_FALL:
       case APPLY_BOW_DISTANCE:
       case APPLY_ATT_GRADE_BONUS:
       case APPLY_DEF_GRADE_BONUS:
       case APPLY_MAGIC_ATT_GRADE:
       case APPLY_MAGIC_DEF_GRADE:
       case APPLY_CURSE_PCT:
       case APPLY_MAX_STAMINA:
       case APPLY_MALL_ATTBONUS:
       case APPLY_MALL_DEFBONUS:
       case APPLY_MALL_EXPBONUS:
       case APPLY_MALL_ITEMBONUS:
       case APPLY_MALL_GOLDBONUS:
       case APPLY_SKILL_DAMAGE_BONUS:
       case APPLY_NORMAL_HIT_DAMAGE_BONUS:
       case APPLY_SKILL_DEFEND_BONUS:
       case APPLY_NORMAL_HIT_DEFEND_BONUS:
       case APPLY_PC_BANG_EXP_BONUS:
       case APPLY_PC_BANG_DROP_BONUS:
       case APPLY_RESIST_WARRIOR:
       case APPLY_RESIST_ASSASSIN:
       case APPLY_RESIST_SURA:
       case APPLY_RESIST_SHAMAN:
       case APPLY_ENERGY:
       case APPLY_DEF_GRADE:
       case APPLY_COSTUME_ATTR_BONUS:
       case APPLY_MAGIC_ATTBONUS_PER:
       case APPLY_MELEE_MAGIC_ATTBONUS_PER:
       case APPLY_ATTBONUS_WOLFMAN:
       case APPLY_RESIST_WOLFMAN:
       case APPLY_RESIST_CLAW:
           PointChange(aApplyInfo[bApplyType].bPointType, iVal);
           break;

       default:
           sys_err("Unknown apply type %d name %s", bApplyType, GetName());
           break;
   }
}

void CHARACTER::MotionPacketEncode(BYTE motion, LPCHARACTER victim, struct packet_motion * packet)
{
   packet->header   = HEADER_GC_MOTION;
   packet->vid       = m_vid;
   packet->motion   = motion;

   if (victim)
       packet->victim_vid = victim->GetVID();
   else
       packet->victim_vid = 0;
}

void CHARACTER::Motion(BYTE motion, LPCHARACTER victim)
{
   struct packet_motion pack_motion;
   MotionPacketEncode(motion, victim, &pack_motion);
   PacketAround(&pack_motion, sizeof(struct packet_motion));
}

EVENTFUNC(save_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "save_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER ch = info->ch;

   if (ch == NULL) { // <Factor>
       return 0;
   }
   sys_log(1, "SAVE_EVENT: %s", ch->GetName());
   ch->Save();
   ch->FlushDelayedSaveItem();
   return (save_event_second_cycle);
}

void CHARACTER::StartSaveEvent()
{
if (m_pkSaveEvent)
return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;
m_pkSaveEvent = event_create(save_event, info, save_event_second_cycle);
}

void CHARACTER::MonsterLog(const char* format, ...)
{
if (!test_server)
return;

if (IsPC())
return;

char chatbuf[CHAT_MAX_LEN + 1];
int len = snprintf(chatbuf, sizeof(chatbuf), "%u)", (DWORD)GetVID());

if (len < 0 || len >= (int) sizeof(chatbuf))
len = sizeof(chatbuf) - 1;

va_list args;

va_start(args, format);

int len2 = vsnprintf(chatbuf + len, sizeof(chatbuf) - len, format, args);

   if (len2 < 0 || len2 >= (int) sizeof(chatbuf) - len)
       len += (sizeof(chatbuf) - len) - 1;
   else
       len += len2;

// \0 문자 포함
++len;

va_end(args);

TPacketGCChat pack_chat;

   pack_chat.header = HEADER_GC_CHAT;
   pack_chat.size       = sizeof(TPacketGCChat) + len;
   pack_chat.type = CHAT_TYPE_TALKING;
   pack_chat.id = (DWORD)GetVID();
   pack_chat.bEmpire   = 0;

   TEMP_BUFFER buf;
   buf.write(&pack_chat, sizeof(TPacketGCChat));
   buf.write(chatbuf, len);

CHARACTER_MANAGER::instance().PacketMonsterLog(this, buf.read_peek(), buf.size());
}

void CHARACTER::ChatPacket(BYTE type, const char * format, ...)
{
LPDESC d = GetDesc();

if (!d || !format)
return;

char chatbuf[CHAT_MAX_LEN + 1];
va_list args;

   va_start(args, format);
   int len = vsnprintf(chatbuf, sizeof(chatbuf), format, args);
   va_end(args);

struct packet_chat pack_chat;

   pack_chat.header = HEADER_GC_CHAT;
   pack_chat.size = sizeof(struct packet_chat) + len;
   pack_chat.type = type;
   pack_chat.id = 0;
   pack_chat.bEmpire = d->GetEmpire();

   TEMP_BUFFER buf;
   buf.write(&pack_chat, sizeof(struct packet_chat));
   buf.write(chatbuf, len);

d->Packet(buf.read_peek(), buf.size());

if (type == CHAT_TYPE_COMMAND && test_server)
sys_log(0, "SEND_COMMAND %s %s", GetName(), chatbuf);
}

// MINING
void CHARACTER::mining_take()
{
m_pkMiningEvent = NULL;
}

void CHARACTER::mining_cancel()
{
   if (m_pkMiningEvent)
   {
       sys_log(0, "XXX MINING CANCEL");
       event_cancel(&m_pkMiningEvent);
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("채광을 중단하였습니다."));
   }
}

void CHARACTER::mining(LPCHARACTER chLoad)
{
   if (m_pkMiningEvent)
   {
       mining_cancel();
       return;
   }

if (!chLoad)
return;

if (mining::GetRawOreFromLoad(chLoad->GetRaceNum()) == 0)
return;

LPITEM pick = GetWear(WEAR_WEAPON);

   if (!pick || pick->GetType() != ITEM_PICK)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("곡괭이를 장착하세요."));
       return;
   }

int count = number(5, 15); // 동작 횟수, 한 동작당 2초

   // 채광 동작을 보여줌
   TPacketGCDigMotion p;
   p.header = HEADER_GC_DIG_MOTION;
   p.vid = GetVID();
   p.target_vid = chLoad->GetVID();
   p.count = count;

PacketAround(&p, sizeof(p));

m_pkMiningEvent = mining::CreateMiningEvent(this, chLoad, count);
}
// END_OF_MINING

void CHARACTER::fishing()
{
   if (m_pkFishingEvent)
   {
       fishing_take();
       return;
   }

   // 못감 속성에서 낚시를 시도한다?
   {
       LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());

int x = GetX();
int y = GetY();

LPSECTREE tree = pkSectreeMap->Find(x, y);
DWORD dwAttr = tree->GetAttribute(x, y);

       if (IS_SET(dwAttr, ATTR_BLOCK))
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시를 할 수 있는 곳이 아닙니다"));
           return;
       }
   }

LPITEM rod = GetWear(WEAR_WEAPON);

   // 낚시대 장착
   if (!rod || rod->GetType() != ITEM_ROD)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시대를 장착 하세요."));
       return;
   }

   if (0 == rod->GetSocket(2))
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("미끼를 끼고 던져 주세요."));
       return;
   }

float fx, fy;
GetDeltaByDegree(GetRotation(), 400.0f, &fx, &fy);

m_pkFishingEvent = fishing::CreateFishingEvent(this);
}

void CHARACTER::fishing_take()
{
   LPITEM rod = GetWear(WEAR_WEAPON);
   if (rod && rod->GetType() == ITEM_ROD)
   {
       using fishing::fishing_event_info;
       if (m_pkFishingEvent)
       {
           struct fishing_event_info* info = dynamic_cast<struct fishing_event_info*>(m_pkFishingEvent->info);

           if (info)
               fishing::Take(info, this);
       }
   }
   else
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시대가 아닌 물건으로 낚시를 할 수 없습니다!"));
   }

event_cancel(&m_pkFishingEvent);
}

bool CHARACTER::StartStateMachine(int iNextPulse)
{
   if (CHARACTER_MANAGER::instance().AddToStateList(this))
   {
       m_dwNextStatePulse = thecore_heart->pulse + iNextPulse;
       return true;
   }

return false;
}

void CHARACTER::StopStateMachine()
{
CHARACTER_MANAGER::instance().RemoveFromStateList(this);
}

void CHARACTER::UpdateStateMachine(DWORD dwPulse)
{
if (dwPulse < m_dwNextStatePulse)
return;

if (IsDead())
return;

Update();
m_dwNextStatePulse = dwPulse + m_dwStateDuration;
}

void CHARACTER::SetNextStatePulse(int iNextPulse)
{
CHARACTER_MANAGER::instance().AddToStateList(this);
m_dwNextStatePulse = iNextPulse;

if (iNextPulse < 10)
MonsterLog("다음상태로어서가자");
}

// 캐릭터 인스턴스 업데이트 함수.
void CHARACTER::UpdateCharacter(DWORD dwPulse)
{
CFSM::Update();
}

void CHARACTER::SetShop(LPSHOP pkShop)
{
   if ((m_pkShop = pkShop))
       SET_BIT(m_pointsInstant.instant_flag, INSTANT_FLAG_SHOP);
   else
   {
       REMOVE_BIT(m_pointsInstant.instant_flag, INSTANT_FLAG_SHOP);
       SetShopOwner(NULL);
   }
}

void CHARACTER::SetOfflineShop(LPOFFLINESHOP pkOfflineShop)
{
   if ((m_pkOfflineShop = pkOfflineShop))
       SET_BIT(m_pointsInstant.instant_flag, INSTANT_FLAG_OFFLINE_SHOP);
   else
   {
       REMOVE_BIT(m_pointsInstant.instant_flag, INSTANT_FLAG_OFFLINE_SHOP);
       SetOfflineShopOwner(NULL);
   }
}

void CHARACTER::OpenMyOfflineShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount, BYTE bTime)
{
quest::PC * pPC = quest::CQuestManager::Instance().GetPC(GetPlayerID());

if (pPC->IsRunning())
return;

if (bItemCount == 0)
return;

if (GetShop() || GetOfflineShop())
return;

   // Brazil is not use for this option.
   if (!LC_IsBrazil())
   {
       DWORD nTotalMoney = 0;
       for (BYTE n = 0; n < bItemCount; ++n)
           nTotalMoney += (pTable + n)->price;

       if (GOLD_MAX - 1 <= nTotalMoney)
       {
           sys_err("[OVERFLOW_GOLD] Overflow (GOLD_MAX) id %u name %s", GetPlayerID(), GetName());
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("20억 냥을 초과하여 상점을 열수가 없습니다"));
           return;
       }
   }

   // Check if player has current items in database.
   {
       std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT COUNT(*) FROM %soffline_shop_item WHERE owner_id = %u and status = 1", get_table_postfix(), GetPlayerID()));
       MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);

       BYTE bResult = 0;
       str_to_number(bResult, row[0]);

       if (bResult)
       {
           ChatPacket(CHAT_TYPE_INFO, "Inainte sa deschizi un magazin, retrage itemele din vechiul magazin.");
           COfflineShopManager::instance().Giveback2(this);
           return;
       }
   }
   // End of check if player has current items in database

   // Check player is open offline shop or not
   {
       std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT COUNT(*) FROM %soffline_shop_npc WHERE owner_id = %u", get_table_postfix(), GetPlayerID()));
       MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);

       BYTE bResult = 0;
       str_to_number(bResult, row[0]);

       if (bResult)
       {
           ChatPacket(CHAT_TYPE_INFO, "Ai deja un magazin privat deschis. Nu poti deschide altul!");
           return;
       }
   }
   // End Of check player is open offline shop or not

   // Check map allows for Offline Shop
   if (g_bOfflineShopMapAllowLimit)
   {
       if (!offlineshop_map_allow_find(GetMapIndex()))
       {
           ChatPacket(CHAT_TYPE_INFO, "Nu poti deschide un magazin privat in acest loc!");
           return;
       }
   }
   // End Of Check map allows for offline shop

   // Need Item For Offline Shop
   if (g_bNeedItem)
   {
       BYTE bCount = quest::CQuestManager::instance().GetCurrentCharacterPtr()->CountSpecifyItem(g_iItemVnum);
       if (bCount < g_bItemCount)
       {
           LPITEM item = ITEM_MANAGER::instance().CreateItem(g_iItemVnum);
           ChatPacket(CHAT_TYPE_INFO, "Nu poti deschide magazinul. Ai nevoie de x%d %s", g_bItemCount, item->GetName());
           return;
       }
   }
   // End Of Need Item For Offline Shop

   // Need Money For Offline Shop
   if (g_bNeedMoney)
   {
       if (GetGold() < static_cast<int>(g_dwNeedMoney))
       {
           ChatPacket(CHAT_TYPE_INFO, "Yang insuficienti![Necesar %u]", g_dwNeedMoney);
           return;
       }
   }
   // End Of Need Money For Offline Shop

   if (!check_name(c_pszSign))
   {
       ChatPacket(CHAT_TYPE_INFO, "Nu poti folosi aceste charactere in titlul magazinului!");
       return;
   }

m_stOfflineShopSign = c_pszSign;

   if (CBanwordManager::instance().CheckString(m_stOfflineShopSign.c_str(), m_stOfflineShopSign.length()))
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ºn¼O¾i³ª Aº¾i°¡ Æ÷COμE ≫oA¡ AI¸§A¸·I ≫oA¡A≫ ¿ ¼o ¾ø½A´I´U."));
       return;
   }

   LPCHARACTER npc = CHARACTER_MANAGER::instance().SpawnMob(30000, GetMapIndex(), GetX(), GetY(), GetZ(), false, -1, false, true, GetPlayerID());

   if (!npc)
   {
       ChatPacket(CHAT_TYPE_INFO, "Magazinul nu a fost creeat. Te rog incearca din nou.");
       return;
   }

   std::map<DWORD, DWORD> itemkind;
   std::set<TItemPos> cont;

   for (BYTE i = 0; i < bItemCount; ++i)
   {
       if (cont.find((pTable + i)->pos) != cont.end())
       {
           sys_err("MY_OFFLINE_SHOP: duplicate shop item detected! (name: %s)", GetName());
           return;
       }

// ANTI_GIVE, ANTI_MYSHOP check
LPITEM pkItem = GetItem((pTable + i)->pos);

       if (pkItem)
       {
           const TItemTable * item_table = pkItem->GetProto();

           if (item_table && (IS_SET(item_table->dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP)))
           {
               ChatPacket(CHAT_TYPE_INFO, "Acest item nu poate fi vandut!");
               return;
           }

           if (pkItem->IsEquipped() == true)
           {
               ChatPacket(CHAT_TYPE_INFO, "Nu poti vinde itemele echipate de tine!");
               return;
           }

           if (true == pkItem->isLocked())
           {
               ChatPacket(CHAT_TYPE_INFO, "You can not sell locked items!");
               return;
           }

itemkind[pkItem->GetVnum()] = (pTable + i)->price / pkItem->GetCount();

char szColumns[QUERY_MAX_LEN], szValues[QUERY_MAX_LEN];

int iLen = snprintf(szColumns, sizeof(szColumns), "id,owner_id,pos,count,price,vnum");
int iUpdateLen = snprintf(szValues, sizeof(szValues), "%u,%u,%d,%u,%u,%u", pkItem->GetID(), GetPlayerID(), (pTable + i)->display_pos, pkItem->GetCount(), (pTable + i)->price, pkItem->GetVnum());

iLen += snprintf(szColumns + iLen, sizeof(szColumns) - iLen, ",socket0,socket1,socket2");
iUpdateLen += snprintf(szValues + iUpdateLen, sizeof(szValues) - iUpdateLen, ",%ld,%ld,%ld", pkItem->GetSocket(0), pkItem->GetSocket(1), pkItem->GetSocket(2));

           iLen += snprintf(szColumns + iLen, sizeof(szColumns) - iLen, ",attrtype0,attrvalue0,attrtype1,attrvalue1,attrtype2,attrvalue2,attrtype3,attrvalue3,attrtype4,attrvalue4");
           iUpdateLen += snprintf(szValues + iUpdateLen, sizeof(szValues) - iUpdateLen, ",%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
               pkItem->GetAttributeType(0), pkItem->GetAttributeValue(0),
               pkItem->GetAttributeType(1), pkItem->GetAttributeValue(1),
               pkItem->GetAttributeType(2), pkItem->GetAttributeValue(2),
               pkItem->GetAttributeType(3), pkItem->GetAttributeValue(3),
               pkItem->GetAttributeType(4), pkItem->GetAttributeValue(4));

           char szInsertQuery[QUERY_MAX_LEN];
           snprintf(szInsertQuery, sizeof(szInsertQuery), "INSERT INTO %soffline_shop_item (%s) VALUES (%s)", get_table_postfix(), szColumns, szValues);
           std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery(szInsertQuery));
           pkItem->RemoveFromCharacter();
       }

cont.insert((pTable + i)->pos);
}

   // Time Mechanism
   int iTime = 0;
   switch (bTime)
   {
       case 1:
           iTime = 4 * 60 * 60;
           break;
       case 2:
           iTime = 8 * 60 * 60;
           break;
       case 3:
           iTime = 12 * 60 * 60;
           break;
   }

   // If bTime is not equal to unlimited time, start the time!
   if (bTime != 4)
   {
       npc->SetOfflineShopTimer(iTime);
       npc->StartOfflineShopUpdateEvent();
   }

   // Insert
   char szQuery2[512];
   snprintf(szQuery2, sizeof(szQuery2), "INSERT INTO %soffline_shop_npc(owner_id, sign, name, time, x, y, z, mapIndex, channel) VALUES(%u, '%s', '%s', %d, %ld, %ld, %ld, %ld, %d)", get_table_postfix(), GetPlayerID(), c_pszSign, GetName(), iTime, GetX(), GetY(), GetZ(), GetMapIndex(), g_bChannel);
   DBManager::Instance().DirectQuery(szQuery2);

   // Create Offline Shop
   LPOFFLINESHOP pkOfflineShop = COfflineShopManager::instance().CreateOfflineShop(npc, GetPlayerID());

   if (!pkOfflineShop)
   {
       ChatPacket(CHAT_TYPE_INFO, "Magazinul nu a fost deschisc. Incearca din nou.");
       return;
   }

   npc->SetOfflineShop(pkOfflineShop);
   npc->SetOfflineShopChannel(g_bChannel);
   // End Of Create Offline Shop

   // Set Name
   char szName[CHARACTER_NAME_MAX_LEN + 1];
   snprintf(szName, sizeof(szName), "Magazin(%s)", GetName());
   npc->SetName(szName);
   // End Of Set Name

   SetOfflineShopVID(npc->GetVID());
   npc->Show(GetMapIndex(), GetX(), GetY(), GetZ(), true);

   // Send Offline Shop Sign to Everyone
   TPacketGCShopSign p;
   p.bHeader = HEADER_GC_OFFLINE_SHOP_SIGN;
   p.dwVID = npc->GetVID();
   strlcpy(p.szSign, c_pszSign, sizeof(p.szSign));

   PacketAround(&p, sizeof(TPacketGCShopSign));
   // End Of Send Offline Shop Sign to Everyone

   if (bTime != 4)
       ChatPacket(CHAT_TYPE_INFO, "<Magazin Privat> Magazinul a fost deschis cu succes.El este conficurat pe timpul %d din consola", bTime);
   else
       ChatPacket(CHAT_TYPE_INFO, "<Offline Shop> Your offline shop's time is configured as unlimited!");

   if (g_bNeedItem)
   {
       LPITEM item = FindSpecifyItem(g_iItemVnum);
       if (!item)
       {
           ChatPacket(CHAT_TYPE_INFO, "Ceva s-a intamplat, contacteaza un GM!");
           return;
       }

       if (item->IsStackable())
           if (item->GetCount() == g_bItemCount)
               ITEM_MANAGER::instance().RemoveItem(item);
           else
               item->SetCount(item->GetCount() - g_bItemCount);
       else
           ITEM_MANAGER::instance().RemoveItem(item);
   }

if (g_bNeedMoney)
PointChange(POINT_GOLD, -g_dwNeedMoney, false);
}

EVENTFUNC(offline_shop_update_event)
{
char_event_info* pInfo = dynamic_cast<char_event_info*>(event->info);

   if (pInfo == NULL)
   {
       sys_err("offline_shop_update_event> <Factor> Null pointer");
       return 0;
   }

LPCHARACTER npc = pInfo->ch;

   if (npc == NULL)
       return 0;

   int remain_time = npc->GetOfflineShopTimer() - processing_time / passes_per_sec;
   if (remain_time <= 0)
   {
       sys_log(0, "OFFLINE SHOP EXPIRED : expired %s", npc->GetName());
       LPCHARACTER pChar = CHARACTER_MANAGER::instance().Find(npc->GetOfflineShopRealOwner());
       if (pChar)
       {
           pChar->ChatPacket(CHAT_TYPE_INFO, "Timpul magazinului privat s-a terminat.Itemele ti-au fost redistribuite.");
           COfflineShopManager::instance().Giveback(pChar);
       }
       COfflineShopManager::instance().DestroyOfflineShop(NULL, npc->GetVID());
       DBManager::instance().DirectQuery("DELETE FROM %soffline_shop_npc WHERE owner_id = %u", get_table_postfix(), npc->GetOfflineShopRealOwner());
       M2_DESTROY_CHARACTER(npc);
       return 0;
   }

   // If the variable is reach to maximum, start to save it
   if (npc->GetOfflineShopSaveTime() >= g_bOfflineShopSaveTime)
   {
       DBManager::instance().DirectQuery("UPDATE %soffline_shop_npc SET time = %d WHERE owner_id = %u", get_table_postfix(), npc->GetOfflineShopTimer(), npc->GetOfflineShopRealOwner());
       npc->SetOfflineShopTimer(1);
   }

   npc->SetOfflineShopTimer(remain_time);
   npc->SetOfflineShopSaveTime(npc->GetOfflineShopSaveTime() + 1);
   return PASSES_PER_SEC(MIN(60, remain_time));
}

void CHARACTER::StartOfflineShopUpdateEvent()
{
if (m_pkOfflineShopUpdateEvent)
return;

if (IsPC() || IsMonster())
return;

   char_event_info * pInfo = AllocEventInfo<char_event_info>();
   pInfo->ch = this;
   m_pkOfflineShopUpdateEvent = event_create(offline_shop_update_event, pInfo, PASSES_PER_SEC(60));
}

void CHARACTER::StopOfflineShopUpdateEvent()
{
   m_pointsInstant.bSaveTime = 0;
   m_pointsInstant.leftTime = 0;
   event_cancel(&m_pkOfflineShopUpdateEvent);
}

void CHARACTER::SetExchange(CExchange * pkExchange)
{
m_pkExchange = pkExchange;
}

void CHARACTER::SetPart(BYTE bPartPos, WORD wVal)
{
assert(bPartPos < PART_MAX_NUM);
m_pointsInstant.parts[bPartPos] = wVal;
}

WORD CHARACTER::GetPart(BYTE bPartPos) const
{
assert(bPartPos < PART_MAX_NUM);
return m_pointsInstant.parts[bPartPos];
}

WORD CHARACTER::GetOriginalPart(BYTE bPartPos) const
{
   switch (bPartPos)
   {
       case PART_MAIN:
           if (!IsPC())
               return GetPart(PART_MAIN);
           else
               return m_pointsInstant.bBasePart;
       case PART_HAIR:
           return GetPart(PART_HAIR);
       case PART_ACCE:
           return GetPart(PART_ACCE);
#ifdef __WEAPON_COSTUME_SYSTEM__
       case PART_WEAPON:
           return GetPart(PART_WEAPON);
#endif
       default:
           return 0;
   }
}

BYTE CHARACTER::GetCharType() const
{
return m_bCharType;
}

bool CHARACTER::SetSyncOwner(LPCHARACTER ch, bool bRemoveFromList)
{
   // TRENT_MONSTER
   if (IS_SET(m_pointsInstant.dwAIFlag, AIFLAG_NOMOVE))
       return false;
   // END_OF_TRENT_MONSTER

   if (ch == this)
   {
       sys_err("SetSyncOwner owner == this (%p)", this);
       return false;
   }

   if (!ch)
   {
       if (bRemoveFromList && m_pkChrSyncOwner)
       {
           m_pkChrSyncOwner->m_kLst_pkChrSyncOwned.remove(this);
       }

if (m_pkChrSyncOwner)
sys_log(1, "SyncRelease %s %p from %s", GetName(), this, m_pkChrSyncOwner->GetName());

       // 리스트에서 제거하지 않더라도 포인터는 NULL로 셋팅되어야 한다.
       m_pkChrSyncOwner = NULL;
   }
   else
   {
       if (!IsSyncOwner(ch))
           return false;

       // 거리가 200 이상이면 SyncOwner가 될 수 없다.
       if (DISTANCE_APPROX(GetX() - ch->GetX(), GetY() - ch->GetY()) > 250)
       {
           sys_log(1, "SetSyncOwner distance over than 250 %s %s", GetName(), ch->GetName());

           // SyncOwner일 경우 Owner로 표시한다.
           if (m_pkChrSyncOwner == ch)
               return true;

return false;
}

       if (m_pkChrSyncOwner != ch)
       {
           if (m_pkChrSyncOwner)
           {
               sys_log(1, "SyncRelease %s %p from %s", GetName(), this, m_pkChrSyncOwner->GetName());
               m_pkChrSyncOwner->m_kLst_pkChrSyncOwned.remove(this);
           }

m_pkChrSyncOwner = ch;
m_pkChrSyncOwner->m_kLst_pkChrSyncOwned.push_back(this);

           // SyncOwner가 바뀌면 LastSyncTime을 초기화한다.
           static const timeval zero_tv = {0, 0};
           SetLastSyncTime(zero_tv);

sys_log(1, "SetSyncOwner set %s %p to %s", GetName(), this, ch->GetName());
}

m_fSyncTime = get_float_time();
}

   // TODO: Sync Owner가 같더라도 계속 패킷을 보내고 있으므로,
   // 동기화 된 시간이 3초 이상 지났을 때 풀어주는 패킷을
   // 보내는 방식으로 하면 패킷을 줄일 수 있다.
   TPacketGCOwnership pack;

   pack.bHeader   = HEADER_GC_OWNERSHIP;
   pack.dwOwnerVID   = ch ? ch->GetVID() : 0;
   pack.dwVictimVID   = GetVID();

PacketAround(&pack, sizeof(TPacketGCOwnership));
return true;
}

struct FuncClearSync
{
   void operator () (LPCHARACTER ch)
   {
       assert(ch != NULL);
       ch->SetSyncOwner(NULL, false);   // false 플래그로 해야 for_each 가 제대로 돈다.
   }
};

void CHARACTER::ClearSync()
{
SetSyncOwner(NULL);

   // 아래 for_each에서 나를 m_pkChrSyncOwner로 가진 자들의 포인터를 NULL로 한다.
   std::for_each(m_kLst_pkChrSyncOwned.begin(), m_kLst_pkChrSyncOwned.end(), FuncClearSync());
   m_kLst_pkChrSyncOwned.clear();
}

bool CHARACTER::IsSyncOwner(LPCHARACTER ch) const
{
if (m_pkChrSyncOwner == ch)
return true;

   // 마지막으로 동기화 된 시간이 3초 이상 지났다면 소유권이 아무에게도
   // 없다. 따라서 아무나 SyncOwner이므로 true 리턴
   if (get_float_time() - m_fSyncTime >= 3.0f)
       return true;

return false;
}

void CHARACTER::SetParty(LPPARTY pkParty)
{
if (pkParty == m_pkParty)
return;

if (pkParty && m_pkParty)
sys_err("%s is trying to reassigning party (current %p, new party %p)", GetName(), get_pointer(m_pkParty), get_pointer(pkParty));

sys_log(1, "PARTY set to %p", get_pointer(pkParty));

   //if (m_pkDungeon && IsPC())
   //SetDungeon(NULL);
   m_pkParty = pkParty;

   if (IsPC())
   {
       if (m_pkParty)
           SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_PARTY);
       else
           REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_PARTY);

UpdatePacket();
}
}

// PARTY_JOIN_BUG_FIX
/// 파티 가입 event 정보
EVENTINFO(TPartyJoinEventInfo)
{
DWORD dwGuestPID; ///< 파티에 참여할 캐릭터의 PID
DWORD dwLeaderPID; ///< 파티 리더의 PID

   TPartyJoinEventInfo()
   : dwGuestPID( 0 )
   , dwLeaderPID( 0 )
   {
   }
} ;

EVENTFUNC(party_request_event)
{
TPartyJoinEventInfo * info = dynamic_cast<TPartyJoinEventInfo *>( event->info );

   if ( info == NULL )
   {
       sys_err( "party_request_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(info->dwGuestPID);

   if (ch)
   {
       sys_log(0, "PartyRequestEvent %s", ch->GetName());
       ch->ChatPacket(CHAT_TYPE_COMMAND, "PartyRequestDenied");
       ch->SetPartyRequestEvent(NULL);
   }

return 0;
}

bool CHARACTER::RequestToParty(LPCHARACTER leader)
{
if (leader->GetParty())
leader = leader->GetParty()->GetLeaderCharacter();

   if (!leader)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("파티장이 접속 상태가 아니라서 요청을 할 수 없습니다."));
       return false;
   }

if (m_pkPartyRequestEvent)
return false;

if (!IsPC() || !leader->IsPC())
return false;

if (leader->IsBlockMode(BLOCK_PARTY_REQUEST))
return false;

PartyJoinErrCode errcode = IsPartyJoinableCondition(leader, this);

   switch (errcode)
   {
       case PERR_NONE:
           break;

       case PERR_SERVER:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다."));
           return false;

       case PERR_DIFFEMPIRE:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 다른 제국과 파티를 이룰 수 없습니다."));
           return false;

       case PERR_DUNGEON:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던전 안에서는 파티 초대를 할 수 없습니다."));
           return false;

       case PERR_OBSERVER:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 관전 모드에선 파티 초대를 할 수 없습니다."));
           return false;

       case PERR_LVBOUNDARY:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> -30 ~ +30 레벨 이내의 상대방만 초대할 수 있습니다."));
           return false;

       case PERR_LOWLEVEL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최고 레벨 보다 30레벨이 낮아 초대할 수 없습니다."));
           return false;

       case PERR_HILEVEL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최저 레벨 보다 30레벨이 높아 초대할 수 없습니다."));
           return false;

case PERR_ALREADYJOIN:
return false;

       case PERR_PARTYISFULL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 더 이상 파티원을 초대할 수 없습니다."));
           return false;

       default:
           sys_err("Do not process party join error(%d)", errcode);
           return false;
   }

TPartyJoinEventInfo* info = AllocEventInfo<TPartyJoinEventInfo>();

info->dwGuestPID = GetPlayerID();
info->dwLeaderPID = leader->GetPlayerID();

SetPartyRequestEvent(event_create(party_request_event, info, PASSES_PER_SEC(10)));

   leader->ChatPacket(CHAT_TYPE_COMMAND, "PartyRequest %u", (DWORD) GetVID());
   ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s 님에게 파티가입 신청을 했습니다."), leader->GetName());
   return true;
}

void CHARACTER::DenyToParty(LPCHARACTER member)
{
sys_log(1, "DenyToParty %s member %s %p", GetName(), member->GetName(), get_pointer(member->m_pkPartyRequestEvent));

if (!member->m_pkPartyRequestEvent)
return;

TPartyJoinEventInfo * info = dynamic_cast<TPartyJoinEventInfo *>(member->m_pkPartyRequestEvent->info);

   if (!info)
   {
       sys_err( "CHARACTER::DenyToParty> <Factor> Null pointer" );
       return;
   }

if (info->dwGuestPID != member->GetPlayerID())
return;

if (info->dwLeaderPID != GetPlayerID())
return;

event_cancel(&member->m_pkPartyRequestEvent);

member->ChatPacket(CHAT_TYPE_COMMAND, "PartyRequestDenied");
}

void CHARACTER::AcceptToParty(LPCHARACTER member)
{
sys_log(1, "AcceptToParty %s member %s %p", GetName(), member->GetName(), get_pointer(member->m_pkPartyRequestEvent));

if (!member->m_pkPartyRequestEvent)
return;

TPartyJoinEventInfo * info = dynamic_cast<TPartyJoinEventInfo *>(member->m_pkPartyRequestEvent->info);

   if (!info)
   {
       sys_err( "CHARACTER::AcceptToParty> <Factor> Null pointer" );
       return;
   }

if (info->dwGuestPID != member->GetPlayerID())
return;

if (info->dwLeaderPID != GetPlayerID())
return;

event_cancel(&member->m_pkPartyRequestEvent);

   if (!GetParty())
       member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 파티에 속해있지 않습니다."));
   else
   {
       if (GetPlayerID() != GetParty()->GetLeaderPID())
           return;

       PartyJoinErrCode errcode = IsPartyJoinableCondition(this, member);
       switch (errcode)
       {
           case PERR_NONE:        member->PartyJoin(this); return;
           case PERR_SERVER:       member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다.")); break;
           case PERR_DUNGEON:       member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던전 안에서는 파티 초대를 할 수 없습니다.")); break;
           case PERR_OBSERVER:    member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 관전 모드에선 파티 초대를 할 수 없습니다.")); break;
           case PERR_LVBOUNDARY:   member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> -30 ~ +30 레벨 이내의 상대방만 초대할 수 있습니다.")); break;
           case PERR_LOWLEVEL:    member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최고 레벨 보다 30레벨이 낮아 초대할 수 없습니다.")); break;
           case PERR_HILEVEL:        member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최저 레벨 보다 30레벨이 높아 초대할 수 없습니다.")); break;
           case PERR_ALREADYJOIN:    break;
           case PERR_PARTYISFULL: {
                                   ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 더 이상 파티원을 초대할 수 없습니다."));
                                   member->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티의 인원제한이 초과하여 파티에 참가할 수 없습니다."));
                                   break;
                               }
           default: sys_err("Do not process party join error(%d)", errcode);
       }
   }

member->ChatPacket(CHAT_TYPE_COMMAND, "PartyRequestDenied");
}

/**
* 파티 초대 event callback 함수.
* event 가 발동하면 초대 거절로 처리한다.
*/
EVENTFUNC(party_invite_event)
{
TPartyJoinEventInfo * pInfo = dynamic_cast<TPartyJoinEventInfo *>( event->info );

   if ( pInfo == NULL )
   {
       sys_err( "party_invite_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER pchInviter = CHARACTER_MANAGER::instance().FindByPID(pInfo->dwLeaderPID);

   if (pchInviter)
   {
       sys_log(1, "PartyInviteEvent %s", pchInviter->GetName());
       pchInviter->PartyInviteDeny(pInfo->dwGuestPID);
   }

return 0;
}

void CHARACTER::PartyInvite(LPCHARACTER pchInvitee)
{
   if (GetParty() && GetParty()->GetLeaderPID() != GetPlayerID())
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티원을 초대할 수 있는 권한이 없습니다."));
       return;
   }
   else if (pchInvitee->IsBlockMode(BLOCK_PARTY_INVITE))
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> %s 님이 파티 거부 상태입니다."), pchInvitee->GetName());
       return;
   }

PartyJoinErrCode errcode = IsPartyJoinableCondition(this, pchInvitee);

   switch (errcode)
   {
       case PERR_NONE:
           break;

       case PERR_SERVER:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다."));
           return;

       case PERR_DIFFEMPIRE:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 다른 제국과 파티를 이룰 수 없습니다."));
           return;

       case PERR_DUNGEON:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던전 안에서는 파티 초대를 할 수 없습니다."));
           return;

       case PERR_OBSERVER:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 관전 모드에선 파티 초대를 할 수 없습니다."));
           return;

       case PERR_LVBOUNDARY:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> -30 ~ +30 레벨 이내의 상대방만 초대할 수 있습니다."));
           return;

       case PERR_LOWLEVEL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최고 레벨 보다 30레벨이 낮아 초대할 수 없습니다."));
           return;

       case PERR_HILEVEL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최저 레벨 보다 30레벨이 높아 초대할 수 없습니다."));
           return;

       case PERR_ALREADYJOIN:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 이미 %s님은 파티에 속해 있습니다."), pchInvitee->GetName());
           return;

       case PERR_PARTYISFULL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 더 이상 파티원을 초대할 수 없습니다."));
           return;

       default:
           sys_err("Do not process party join error(%d)", errcode);
           return;
   }

if (m_PartyInviteEventMap.end() != m_PartyInviteEventMap.find(pchInvitee->GetPlayerID()))
return;

   //
   // EventMap 에 이벤트 추가
   //
   TPartyJoinEventInfo* info = AllocEventInfo<TPartyJoinEventInfo>();

info->dwGuestPID = pchInvitee->GetPlayerID();
info->dwLeaderPID = GetPlayerID();

m_PartyInviteEventMap.insert(EventMap::value_type(pchInvitee->GetPlayerID(), event_create(party_invite_event, info, PASSES_PER_SEC(10))));

   //
   // 초대 받는 character 에게 초대 패킷 전송
   //

   TPacketGCPartyInvite p;
   p.header = HEADER_GC_PARTY_INVITE;
   p.leader_vid = GetVID();
   pchInvitee->GetDesc()->Packet(&p, sizeof(p));
}

void CHARACTER::PartyInviteAccept(LPCHARACTER pchInvitee)
{
EventMap::iterator itFind = m_PartyInviteEventMap.find(pchInvitee->GetPlayerID());

   if (itFind == m_PartyInviteEventMap.end())
   {
       sys_log(1, "PartyInviteAccept from not invited character(%s)", pchInvitee->GetName());
       return;
   }

event_cancel(&itFind->second);
m_PartyInviteEventMap.erase(itFind);

   if (GetParty() && GetParty()->GetLeaderPID() != GetPlayerID())
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티원을 초대할 수 있는 권한이 없습니다."));
       return;
   }

PartyJoinErrCode errcode = IsPartyJoinableMutableCondition(this, pchInvitee);

   switch (errcode)
   {
       case PERR_NONE:
           break;

       case PERR_SERVER:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다."));
           return;

       case PERR_DUNGEON:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던전 안에서는 파티 초대에 응할 수 없습니다."));
           return;

       case PERR_OBSERVER:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 관전 모드에선 파티 초대를 할 수 없습니다."));
           return;

       case PERR_LVBOUNDARY:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> -30 ~ +30 레벨 이내의 상대방만 초대할 수 있습니다."));
           return;

       case PERR_LOWLEVEL:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최고 레벨 보다 30레벨이 낮아 초대할 수 없습니다."));
           return;

       case PERR_HILEVEL:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티내 최저 레벨 보다 30레벨이 높아 초대할 수 없습니다."));
           return;

       case PERR_ALREADYJOIN:
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티 초대에 응할 수 없습니다."));
           return;

       case PERR_PARTYISFULL:
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 더 이상 파티원을 초대할 수 없습니다."));
           pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티의 인원제한이 초과하여 파티에 참가할 수 없습니다."));
           return;

       default:
           sys_err("ignore party join error(%d)", errcode);
           return;
   }

   //
   // 파티 가입 처리
   //

   if (GetParty())
       pchInvitee->PartyJoin(this);
   else
   {
       LPPARTY pParty = CPartyManager::instance().CreateParty(this);

       pParty->Join(pchInvitee->GetPlayerID());
       pParty->Link(pchInvitee);
       pParty->SendPartyInfoAllToOne(this);
   }
}

void CHARACTER::PartyInviteDeny(DWORD dwPID)
{
EventMap::iterator itFind = m_PartyInviteEventMap.find(dwPID);

   if (itFind == m_PartyInviteEventMap.end())
   {
       sys_log(1, "PartyInviteDeny to not exist event(inviter PID: %d, invitee PID: %d)", GetPlayerID(), dwPID);
       return;
   }

event_cancel(&itFind->second);
m_PartyInviteEventMap.erase(itFind);

   LPCHARACTER pchInvitee = CHARACTER_MANAGER::instance().FindByPID(dwPID);
   if (pchInvitee)
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> %s님이 파티 초대를 거절하셨습니다."), pchInvitee->GetName());
}

void CHARACTER::PartyJoin(LPCHARACTER pLeader)
{
pLeader->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> %s님이 파티에 참가하셨습니다."), GetName());
ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> %s님의 파티에 참가하셨습니다."), pLeader->GetName());

pLeader->GetParty()->Join(GetPlayerID());
pLeader->GetParty()->Link(this);
}

CHARACTER::PartyJoinErrCode CHARACTER::IsPartyJoinableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest)
{
if (pchLeader->GetEmpire() != pchGuest->GetEmpire())
return PERR_DIFFEMPIRE;

return IsPartyJoinableMutableCondition(pchLeader, pchGuest);
}

static bool __party_can_join_by_level(LPCHARACTER leader, LPCHARACTER quest)
{
int level_limit = 30;

   if (LC_IsCanada())
       level_limit = 15;
   else if (LC_IsBrazil() == true)
   {
       level_limit = 10;
   }
   else
       level_limit = 30;

return (abs(leader->GetLevel() - quest->GetLevel()) <= level_limit);
}

CHARACTER::PartyJoinErrCode CHARACTER::IsPartyJoinableMutableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest)
{
   if (!CPartyManager::instance().IsEnablePCParty())
       return PERR_SERVER;
   else if (pchLeader->GetDungeon())
       return PERR_DUNGEON;
   else if (pchGuest->IsObserverMode())
       return PERR_OBSERVER;
   else if (false == __party_can_join_by_level(pchLeader, pchGuest))
       return PERR_LVBOUNDARY;
   else if (pchGuest->GetParty())
       return PERR_ALREADYJOIN;
   else if (pchLeader->GetParty())
    {
      if (pchLeader->GetParty()->GetMemberCount() == PARTY_MAX_MEMBER)
           return PERR_PARTYISFULL;
   }

return PERR_NONE;
}
// END_OF_PARTY_JOIN_BUG_FIX

void CHARACTER::SetDungeon(LPDUNGEON pkDungeon)
{
if (pkDungeon && m_pkDungeon)
sys_err("%s is trying to reassigning dungeon (current %p, new party %p)", GetName(), get_pointer(m_pkDungeon), get_pointer(pkDungeon));

   if (m_pkDungeon == pkDungeon) {
       return;
   }

   if (m_pkDungeon)
   {
       if (IsPC())
       {
           if (GetParty())
               m_pkDungeon->DecPartyMember(GetParty(), this);
           else
               m_pkDungeon->DecMember(this);
       }
       else if (IsMonster() || IsStone())
       {
           m_pkDungeon->DecMonster();
       }
   }

m_pkDungeon = pkDungeon;

   if (pkDungeon)
   {
       sys_log(0, "%s DUNGEON set to %p, PARTY is %p", GetName(), get_pointer(pkDungeon), get_pointer(m_pkParty));

       if (IsPC())
       {
           if (GetParty())
               m_pkDungeon->IncPartyMember(GetParty(), this);
           else
               m_pkDungeon->IncMember(this);
       }
       else if (IsMonster() || IsStone())
       {
           m_pkDungeon->IncMonster();
       }
   }
}

void CHARACTER::SetWarMap(CWarMap * pWarMap)
{
if (m_pWarMap)
m_pWarMap->DecMember(this);

m_pWarMap = pWarMap;

if (m_pWarMap)
m_pWarMap->IncMember(this);
}

void CHARACTER::SetWeddingMap(marriage::WeddingMap* pMap)
{
if (m_pWeddingMap)
m_pWeddingMap->DecMember(this);

m_pWeddingMap = pMap;

if (m_pWeddingMap)
m_pWeddingMap->IncMember(this);
}

void CHARACTER::SetRegen(LPREGEN pkRegen)
{
   m_pkRegen = pkRegen;
   if (pkRegen != NULL) {
       regen_id_ = pkRegen->id;
   }
   m_fRegenAngle = GetRotation();
   m_posRegen = GetXYZ();
}

bool CHARACTER::OnIdle()
{
return false;
}

void CHARACTER::OnMove(bool bIsAttack)
{
m_dwLastMoveTime = get_dword_time();

   if (bIsAttack)
   {
       m_dwLastAttackTime = m_dwLastMoveTime;

       if (IsAffectFlag(AFF_EUNHYUNG))
       {
           RemoveAffect(SKILL_EUNHYUNG);
           SetAffectedEunhyung();
       }
       else
       {
           ClearAffectedEunhyung();
       }

       /*if (IsAffectFlag(AFF_JEONSIN))
       RemoveAffect(SKILL_JEONSINBANGEO);*/
   }

/*if (IsAffectFlag(AFF_GUNGON))
RemoveAffect(SKILL_GUNGON);*/

   // MINING
   mining_cancel();
   // END_OF_MINING
}

void CHARACTER::OnClick(LPCHARACTER pkChrCauser)
{
   if (!pkChrCauser)
   {
       sys_err("OnClick %s by NULL", GetName());
       return;
   }

DWORD vid = GetVID();
sys_log(0, "OnClick %s[vnum %d ServerUniqueID %d, pid %d] by %s", GetName(), GetRaceNum(), vid, GetPlayerID(), pkChrCauser->GetName());

   // 상점을 연상태로 퀘스트를 진행할 수 없다.
   {
       // 단, 자신은 자신의 상점을 클릭할 수 있다.
       if (pkChrCauser->GetMyShop() && pkChrCauser != this)
       {
           sys_err("OnClick Fail (%s->%s) - pc has shop", pkChrCauser->GetName(), GetName());
           return;
       }
   }

   // 교환중일때 퀘스트를 진행할 수 없다.
   {
       if (pkChrCauser->GetExchange())
       {
           sys_err("OnClick Fail (%s->%s) - pc is exchanging", pkChrCauser->GetName(), GetName());
           return;
       }
   }

   if (IsPC())
   {
       // 타겟으로 설정된 경우는 PC에 의한 클릭도 퀘스트로 처리하도록 합니다.
       if (!CTargetManager::instance().GetTargetInfo(pkChrCauser->GetPlayerID(), TARGET_TYPE_VID, GetVID()))
       {
           // 2005.03.17.myevan.타겟이 아닌 경우는 개인 상점 처리 기능을 작동시킨다.
           if (GetMyShop())
           {
               if (pkChrCauser->IsDead() == true) return;

               //PREVENT_TRADE_WINDOW
               if (pkChrCauser == this) // 자기는 가능
               {
                   if ((GetExchange() || IsOpenSafebox() || GetShopOwner()) || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen())
                   {
                       pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중(창고,교환,상점)에는 개인상점을 사용할 수 없습니다."));
                       return;
                   }
               }
               else // 다른 사람이 클릭했을때
               {
                   // 클릭한 사람이 교환/창고/개인상점/상점이용중이라면 불가
                   if ((pkChrCauser->GetExchange() || pkChrCauser->IsOpenSafebox() || pkChrCauser->GetMyShop() || pkChrCauser->GetShopOwner()) || pkChrCauser->IsCubeOpen() || pkChrCauser->GetOfflineShopOwner() || pkChrCauser->IsAcceOpen())
                   {
                       pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중(창고,교환,상점)에는 개인상점을 사용할 수 없습니다."));
                       return;
                   }

                   // 클릭한 대상이 교환/창고/상점이용중이라면 불가
                   //if ((GetExchange() || IsOpenSafebox() || GetShopOwner()))
                   if ((GetExchange() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen()))
                   {
                       pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 다른 거래를 하고 있는 중입니다."));
                       return;
                   }
               }
               //END_PREVENT_TRADE_WINDOW

               if (pkChrCauser->GetShop())
               {
                   pkChrCauser->GetShop()->RemoveGuest(pkChrCauser);
                   pkChrCauser->SetShop(NULL);
               }

               GetMyShop()->AddGuest(pkChrCauser, GetVID(), false);
               pkChrCauser->SetShopOwner(this);
               return;
           }

if (test_server)
sys_err("%s.OnClickFailure(%s) - target is PC", pkChrCauser->GetName(), GetName());

           return;
       }
   }

   // Offline Shop
   if (IsOfflineShopNPC())
   {
       pkChrCauser->SetOfflineShopOwner(this);
       GetOfflineShop()->AddGuest(pkChrCauser, this);
       return;
   }

   // 청소년은 퀘스트 못함
   if (LC_IsNewCIBN())
   {
       if (pkChrCauser->IsOverTime(OT_3HOUR))
       {
           sys_log(0, "Teen OverTime : name = %s, hour = %d)", pkChrCauser->GetName(), 3);
           return;
       }
       else if (pkChrCauser->IsOverTime(OT_5HOUR))
       {
           sys_log(0, "Teen OverTime : name = %s, hour = %d)", pkChrCauser->GetName(), 5);
           return;
       }
   }

pkChrCauser->SetQuestNPCID(GetVID());

   if (quest::CQuestManager::instance().Click(pkChrCauser->GetPlayerID(), this))
   {
       return;
   }

   // NPC 전용 기능 수행 : 상점 열기 등
   if (!IsPC())
   {
       if (!m_triggerOnClick.pFunc)
       {
           // NPC 트리거 시스템 로그 보기
           //sys_err("%s.OnClickFailure(%s) : triggerOnClick.pFunc is EMPTY(pid=%d)",
           //           pkChrCauser->GetName(),
           //           GetName(),
           //           pkChrCauser->GetPlayerID());
           return;
       }

m_triggerOnClick.pFunc(this, pkChrCauser);
}

}

BYTE CHARACTER::GetGMLevel() const
{
   if (test_server)
       return GM_IMPLEMENTOR;
   return m_pointsInstant.gm_level;
}

void CHARACTER::SetGMLevel()
{
   if (GetDesc())
   {
   m_pointsInstant.gm_level = gm_get_level(GetName(), GetDesc()->GetHostName(), GetDesc()->GetAccountTable().login);
   }
   else
   {
   m_pointsInstant.gm_level = GM_PLAYER;
   }
}

BOOL CHARACTER::IsGM() const
{
   if (m_pointsInstant.gm_level != GM_PLAYER)
       return true;
   if (test_server)
       return true;
   return false;
}

void CHARACTER::SetStone(LPCHARACTER pkChrStone)
{
m_pkChrStone = pkChrStone;

   if (m_pkChrStone)
   {
       if (pkChrStone->m_set_pkChrSpawnedBy.find(this) == pkChrStone->m_set_pkChrSpawnedBy.end())
           pkChrStone->m_set_pkChrSpawnedBy.insert(this);
   }
}

struct FuncDeadSpawnedByStone
{
   void operator () (LPCHARACTER ch)
   {
       ch->Dead(NULL);
       ch->SetStone(NULL);
   }
};

void CHARACTER::ClearStone()
{
   if (!m_set_pkChrSpawnedBy.empty())
   {
       // 내가 스폰시킨 몬스터들을 모두 죽인다.
       FuncDeadSpawnedByStone f;
       std::for_each(m_set_pkChrSpawnedBy.begin(), m_set_pkChrSpawnedBy.end(), f);
       m_set_pkChrSpawnedBy.clear();
   }

if (!m_pkChrStone)
return;

m_pkChrStone->m_set_pkChrSpawnedBy.erase(this);
m_pkChrStone = NULL;
}

void CHARACTER::ClearTarget()
{
   if (m_pkChrTarget)
   {
       m_pkChrTarget->m_set_pkChrTargetedBy.erase(this);
       m_pkChrTarget = NULL;
   }

   TPacketGCTarget p;
   p.header = HEADER_GC_TARGET;
   p.dwVID = 0;
   p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
   p.iMinHP = 0;
   p.iMaxHP = 0;
#endif
   CHARACTER_SET::iterator it = m_set_pkChrTargetedBy.begin();
   while (it != m_set_pkChrTargetedBy.end())
   {
       LPCHARACTER pkChr = *(it++);
       pkChr->m_pkChrTarget = NULL;

       if (!pkChr->GetDesc())
       {
           sys_err("%s %p does not have desc", pkChr->GetName(), get_pointer(pkChr));
           abort();
       }

       pkChr->GetDesc()->Packet(&p, sizeof(TPacketGCTarget));
   }

   m_set_pkChrTargetedBy.clear();
}

void CHARACTER::SetTarget(LPCHARACTER pkChrTarget)
{
   if (m_pkChrTarget == pkChrTarget)
       return;

   if (IS_CASTLE_MAP(GetMapIndex()) && !IsGM())
       return;

   if (m_pkChrTarget)
       m_pkChrTarget->m_set_pkChrTargetedBy.erase(this);

   m_pkChrTarget = pkChrTarget;

   TPacketGCTarget p;
   p.header = HEADER_GC_TARGET;
   if (m_pkChrTarget)
   {
       m_pkChrTarget->m_set_pkChrTargetedBy.insert(this);
       p.dwVID   = m_pkChrTarget->GetVID();
#ifdef __VIEW_TARGET_PLAYER_HP__
       if ((m_pkChrTarget->GetMaxHP() <= 0))
       {
           p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
           p.iMinHP = 0;
           p.iMaxHP = 0;
#endif
       }
       else if (m_pkChrTarget->IsPC() && !m_pkChrTarget->IsPolymorphed())
       {
           p.bHPPercent = MINMAX(0, (m_pkChrTarget->GetHP() * 100) / m_pkChrTarget->GetMaxHP(), 100);
#ifdef __VIEW_TARGET_DECIMAL_HP__
           p.iMinHP = m_pkChrTarget->GetHP();
           p.iMaxHP = m_pkChrTarget->GetMaxHP();
#endif
#else
       if ((m_pkChrTarget->IsPC() && !m_pkChrTarget->IsPolymorphed()) || (m_pkChrTarget->GetMaxHP() <= 0))
       {
           p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
           p.iMinHP = 0;
           p.iMaxHP = 0;
#endif
#endif
       }
       else
       {
           if (m_pkChrTarget->GetRaceNum() == 20101 || m_pkChrTarget->GetRaceNum() == 20102 || m_pkChrTarget->GetRaceNum() == 20103 || m_pkChrTarget->GetRaceNum() == 20104 || m_pkChrTarget->GetRaceNum() == 20105 || m_pkChrTarget->GetRaceNum() == 20106 || m_pkChrTarget->GetRaceNum() == 20107 || m_pkChrTarget->GetRaceNum() == 20108 || m_pkChrTarget->GetRaceNum() == 20109)
           {
               LPCHARACTER owner = m_pkChrTarget->GetVictim();
               if (owner)
               {
                   int iHorseHealth = owner->GetHorseHealth();
                   int iHorseMaxHealth = owner->GetHorseMaxHealth();
                   if (iHorseMaxHealth)
                   {
                       p.bHPPercent = MINMAX(0, iHorseHealth * 100 / iHorseMaxHealth, 100);
#ifdef __VIEW_TARGET_DECIMAL_HP__
                       p.iMinHP = 100;
                       p.iMaxHP = 100;
#endif
                   }
                   else
                   {
                       p.bHPPercent = 100;
#ifdef __VIEW_TARGET_DECIMAL_HP__
                       p.iMinHP = 100;
                       p.iMaxHP = 100;
#endif
                   }
               }
               else
               {
                   p.bHPPercent = 100;
#ifdef __VIEW_TARGET_DECIMAL_HP__
                   p.iMinHP = 100;
                   p.iMaxHP = 100;
#endif
               }
           }
           else
           {
               if (m_pkChrTarget->GetMaxHP() <= 0)
               {
                   p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
                   p.iMinHP = 0;
                   p.iMaxHP = 0;
#endif
               }
               else
               {
                   p.bHPPercent = MINMAX(0, (m_pkChrTarget->GetHP() * 100) / m_pkChrTarget->GetMaxHP(), 100);
#ifdef __VIEW_TARGET_DECIMAL_HP__
                   p.iMinHP = m_pkChrTarget->GetHP();
                   p.iMaxHP = m_pkChrTarget->GetMaxHP();
#endif
               }
           }
       }
   }
   else
   {
       p.dwVID = 0;
       p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
       p.iMinHP = 0;
       p.iMaxHP = 0;
#endif
   }

   GetDesc()->Packet(&p, sizeof(TPacketGCTarget));
}

void CHARACTER::BroadcastTargetPacket()
{
   if (m_set_pkChrTargetedBy.empty())
       return;

   TPacketGCTarget p;
   p.header = HEADER_GC_TARGET;
   p.dwVID = GetVID();
   if (GetMaxHP() <= 0)
   {
       p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
       p.iMinHP = 0;
       p.iMaxHP = 0;
#endif
   }
   else
   {
#ifdef __VIEW_TARGET_PLAYER_HP__
       p.bHPPercent = MINMAX(0, (GetHP() * 100) / GetMaxHP(), 100);
#ifdef __VIEW_TARGET_DECIMAL_HP__
       p.iMinHP = GetHP();
       p.iMaxHP = GetMaxHP();
#endif
#else
       if (IsPC())
       {
           p.bHPPercent = 0;
#ifdef __VIEW_TARGET_DECIMAL_HP__
           p.iMinHP = 0;
           p.iMaxHP = 0;
#endif
       }
       else
       {
           p.bHPPercent = MINMAX(0, (GetHP() * 100) / GetMaxHP(), 100);
#ifdef __VIEW_TARGET_DECIMAL_HP__
           p.iMinHP = GetHP();
           p.iMaxHP = GetMaxHP();
#endif
       }
#endif
   }

   CHARACTER_SET::iterator it = m_set_pkChrTargetedBy.begin();
   while (it != m_set_pkChrTargetedBy.end())
   {
       LPCHARACTER pkChr = *it++;
       if (!pkChr->GetDesc())
       {
           sys_err("%s %p does not have desc", pkChr->GetName(), get_pointer(pkChr));
           abort();
       }

       pkChr->GetDesc()->Packet(&p, sizeof(TPacketGCTarget));
   }
}

void CHARACTER::CheckTarget()
{
if (!m_pkChrTarget)
return;

if (DISTANCE_APPROX(GetX() - m_pkChrTarget->GetX(), GetY() - m_pkChrTarget->GetY()) >= 4800)
SetTarget(NULL);
}

void CHARACTER::SetWarpLocation(long lMapIndex, long x, long y)
{
   m_posWarp.x = x * 100;
   m_posWarp.y = y * 100;
   m_lWarpMapIndex = lMapIndex;
}

void CHARACTER::SaveExitLocation()
{
m_posExit = GetXYZ();
m_lExitMapIndex = GetMapIndex();
}

void CHARACTER::ExitToSavedLocation()
{
sys_log (0, "ExitToSavedLocation");
WarpSet(m_posWarp.x, m_posWarp.y, m_lWarpMapIndex);

m_posExit.x = m_posExit.y = m_posExit.z = 0;
m_lExitMapIndex = 0;
}

// fixme
// 지금까진 privateMapIndex 가 현재 맵 인덱스와 같은지 체크 하는 것을 외부에서 하고,
// 다르면 warpset을 불렀는데
// 이를 warpset 안으로 넣자.
bool CHARACTER::WarpSet(long x, long y, long lPrivateMapIndex)
{
if (!IsPC())
return false;

   long lAddr;
   long lMapIndex;
   WORD wPort;

   if (!CMapLocation::instance().Get(x, y, lMapIndex, lAddr, wPort))
   {
       sys_err("cannot find map location index %d x %d y %d name %s", lMapIndex, x, y, GetName());
       return false;
   }

   //Send Supplementary Data Block if new map requires security packages in loading this map
   {
       long lCurAddr;
       long lCurMapIndex = 0;
       WORD wCurPort;

CMapLocation::instance().Get(GetX(), GetY(), lCurMapIndex, lCurAddr, wCurPort);

       //do not send SDB files if char is in the same map
       if( lCurMapIndex != lMapIndex )
       {
           const TMapRegion * rMapRgn = SECTREE_MANAGER::instance().GetMapRegion(lMapIndex);
           {
               DESC_MANAGER::instance().SendClientPackageSDBToLoadMap( GetDesc(), rMapRgn->strMapName.c_str() );
           }
       }
   }

   if (lPrivateMapIndex >= 10000)
   {
       if (lPrivateMapIndex / 10000 != lMapIndex)
       {
           sys_err("Invalid map inedx %d, must be child of %d", lPrivateMapIndex, lMapIndex);
           return false;
       }

lMapIndex = lPrivateMapIndex;
}

Stop();
Save();

   if (GetSectree())
   {
       GetSectree()->RemoveEntity(this);
       ViewCleanup();

EncodeRemovePacket(this);
}

   m_lWarpMapIndex = lMapIndex;
   m_posWarp.x = x;
   m_posWarp.y = y;

sys_log(0, "WarpSet %s %d %d current map %d target map %d", GetName(), x, y, GetMapIndex(), lMapIndex);

TPacketGCWarp p;

   p.bHeader   = HEADER_GC_WARP;
   p.lX   = x;
   p.lY   = y;
   p.lAddr   = lAddr;
   p.wPort   = wPort;

GetDesc()->Packet(&p, sizeof(TPacketGCWarp));

   //if (!LC_IsNewCIBN())
   {
       char buf[256];
       snprintf(buf, sizeof(buf), "%s MapIdx %ld DestMapIdx%ld DestX%ld DestY%ld Empire%d", GetName(), GetMapIndex(), lPrivateMapIndex, x, y, GetEmpire());
       LogManager::instance().CharLog(this, 0, "WARP", buf);
   }

return true;
}

void CHARACTER::WarpEnd()
{
if (test_server)
sys_log(0, "WarpEnd %s", GetName());

if (m_posWarp.x == 0 && m_posWarp.y == 0)
return;

int index = m_lWarpMapIndex;

if (index > 10000)
index /= 10000;

if (!map_allow_find(index))
GoHome();

sys_log(0, "WarpEnd %s %d %u %u", GetName(), m_lWarpMapIndex, m_posWarp.x, m_posWarp.y);

Show(m_lWarpMapIndex, m_posWarp.x, m_posWarp.y, 0);
Stop();

m_lWarpMapIndex = 0;
m_posWarp.x = m_posWarp.y = m_posWarp.z = 0;

   {
       // P2P Login
       TPacketGGLogin p;

       p.bHeader = HEADER_GG_LOGIN;
       strlcpy(p.szName, GetName(), sizeof(p.szName));
       p.dwPID = GetPlayerID();
       p.bEmpire = GetEmpire();
       p.lMapIndex = SECTREE_MANAGER::instance().GetMapIndex(GetX(), GetY());
       p.bChannel = g_bChannel;

P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGLogin));
}
}

bool CHARACTER::Return()
{
if (!IsNPC())
return false;

   int x, y;
   /*
   float fDist = DISTANCE_SQRT(m_pkMobData->m_posLastAttacked.x - GetX(), m_pkMobData->m_posLastAttacked.y - GetY());
   float fx, fy;
   GetDeltaByDegree(GetRotation(), fDist, &fx, &fy);
   x = GetX() + (int) fx;
   y = GetY() + (int) fy;
   */
   SetVictim(NULL);

x = m_pkMobInst->m_posLastAttacked.x;
y = m_pkMobInst->m_posLastAttacked.y;

SetRotationToXY(x, y);

if (!Goto(x, y))
return false;

SendMovePacket(FUNC_WAIT, 0, 0, 0, 0);

if (test_server)
sys_log(0, "%s %p 포기하고 돌아가자! %d %d", GetName(), this, x, y);

if (GetParty())
GetParty()->SendMessage(this, PM_RETURN, x, y);

return true;
}

bool CHARACTER::Follow(LPCHARACTER pkChr, float fMinDistance)
{
   if (IsPC())
   {
       sys_err("CHARACTER::Follow : PC cannot use this method", GetName());
       return false;
   }

   // TRENT_MONSTER
   if (IS_SET(m_pointsInstant.dwAIFlag, AIFLAG_NOMOVE))
   {
       if (pkChr->IsPC()) // 쫓아가는 상대가 PC일 때
       {
           // If i'm in a party. I must obey party leader's AI.
           if (!GetParty() || !GetParty()->GetLeader() || GetParty()->GetLeader() == this)
           {
               if (get_dword_time() - m_pkMobInst->m_dwLastAttackedTime >= 15000) // 마지막으로 공격받은지 15초가 지났고
               {
                   // 마지막 맞은 곳으로 부터 50미터 이상 차이나면 포기하고 돌아간다.
                   if (m_pkMobData->m_table.wAttackRange < DISTANCE_APPROX(pkChr->GetX() - GetX(), pkChr->GetY() - GetY()))
                       if (Return())
                           return true;
               }
           }
       }
       return false;
   }
   // END_OF_TRENT_MONSTER

long x = pkChr->GetX();
long y = pkChr->GetY();

   if (pkChr->IsPC()) // 쫓아가는 상대가 PC일 때
   {
       // If i'm in a party. I must obey party leader's AI.
       if (!GetParty() || !GetParty()->GetLeader() || GetParty()->GetLeader() == this)
       {
           if (get_dword_time() - m_pkMobInst->m_dwLastAttackedTime >= 15000) // 마지막으로 공격받은지 15초가 지났고
           {
               // 마지막 맞은 곳으로 부터 50미터 이상 차이나면 포기하고 돌아간다.
               if (5000 < DISTANCE_APPROX(m_pkMobInst->m_posLastAttacked.x - GetX(), m_pkMobInst->m_posLastAttacked.y - GetY()))
                   if (Return())
                       return true;
           }
       }
   }

   if (IsGuardNPC())
   {
       if (5000 < DISTANCE_APPROX(m_pkMobInst->m_posLastAttacked.x - GetX(), m_pkMobInst->m_posLastAttacked.y - GetY()))
           if (Return())
               return true;
   }
#ifdef NEW_PET_SYSTEM
   if (pkChr->IsState(pkChr->m_stateMove) &&
       GetMobBattleType() != BATTLE_TYPE_RANGE &&
       GetMobBattleType() != BATTLE_TYPE_MAGIC &&
       false == IsPet() && false == IsNewPet())
#else

#ifdef ENABLE_MOUNT_SYSTEM
   if (pkChr->IsState(pkChr->m_stateMove) &&
       GetMobBattleType() != BATTLE_TYPE_RANGE &&
       GetMobBattleType() != BATTLE_TYPE_MAGIC &&
       false == IsPet() && false == IsMountSystem())
#else
   if (pkChr->IsState(pkChr->m_stateMove) &&
       GetMobBattleType() != BATTLE_TYPE_RANGE &&
       GetMobBattleType() != BATTLE_TYPE_MAGIC &&
       false == IsPet())
#endif

   if (pkChr->IsState(pkChr->m_stateMove) &&
       GetMobBattleType() != BATTLE_TYPE_RANGE &&
       GetMobBattleType() != BATTLE_TYPE_MAGIC &&
       false == IsPet())
   {
       // 대상이 이동중이면 예측 이동을 한다
       // 나와 상대방의 속도차와 거리로부터 만날 시간을 예상한 후
       // 상대방이 그 시간까지 직선으로 이동한다고 가정하여 거기로 이동한다.
       float rot = pkChr->GetRotation();
       float rot_delta = GetDegreeDelta(rot, GetDegreeFromPositionXY(GetX(), GetY(), pkChr->GetX(), pkChr->GetY()));

float yourSpeed = pkChr->GetMoveSpeed();
float mySpeed = GetMoveSpeed();

float fDist = DISTANCE_SQRT(x - GetX(), y - GetY());
float fFollowSpeed = mySpeed - yourSpeed * cos(rot_delta * M_PI / 180);

       if (fFollowSpeed >= 0.1f)
       {
           float fMeetTime = fDist / fFollowSpeed;
           float fYourMoveEstimateX, fYourMoveEstimateY;

           if( fMeetTime * yourSpeed <= 100000.0f )
           {
               GetDeltaByDegree(pkChr->GetRotation(), fMeetTime * yourSpeed, &fYourMoveEstimateX, &fYourMoveEstimateY);

x += (long) fYourMoveEstimateX;
y += (long) fYourMoveEstimateY;

               float fDistNew = sqrt(((double)x - GetX())*(x-GetX())+((double)y - GetY())*(y-GetY()));
               if (fDist < fDistNew)
               {
                   x = (long)(GetX() + (x - GetX()) * fDist / fDistNew);
                   y = (long)(GetY() + (y - GetY()) * fDist / fDistNew);
               }
           }
       }
   }

// 가려는 위치를 바라봐야 한다.
SetRotationToXY(x, y);

float fDist = DISTANCE_SQRT(x - GetX(), y - GetY());

if (fDist <= fMinDistance)
return false;

float fx, fy;

   if (IsChangeAttackPosition(pkChr) && GetMobRank() < MOB_RANK_BOSS)
   {
       // 상대방 주변 랜덤한 곳으로 이동
       SetChangeAttackPositionTime();

       int retry = 16;
       int dx, dy;
       int rot = (int) GetDegreeFromPositionXY(x, y, GetX(), GetY());

       while (--retry)
       {
           if (fDist < 500.0f)
               GetDeltaByDegree((rot + number(-90, 90) + number(-90, 90)) % 360, fMinDistance, &fx, &fy);
           else
               GetDeltaByDegree(number(0, 359), fMinDistance, &fx, &fy);

dx = x + (int) fx;
dy = y + (int) fy;

LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), dx, dy);

if (NULL == tree)
break;

           if (0 == (tree->GetAttribute(dx, dy) & (ATTR_BLOCK | ATTR_OBJECT)))
               break;
       }

       //sys_log(0, "근처 어딘가로 이동 %s retry %d", GetName(), retry);
       if (!Goto(dx, dy))
           return false;
   }
   else
   {
       // 직선 따라가기
       float fDistToGo = fDist - fMinDistance;
       GetDeltaByDegree(GetRotation(), fDistToGo, &fx, &fy);

       //sys_log(0, "직선으로 이동 %s", GetName());
       if (!Goto(GetX() + (int) fx, GetY() + (int) fy))
           return false;
   }

   SendMovePacket(FUNC_WAIT, 0, 0, 0, 0);
   //MonsterLog("쫓아가기; %s", pkChr->GetName());
   return true;
}

float CHARACTER::GetDistanceFromSafeboxOpen() const
{
return DISTANCE_APPROX(GetX() - m_posSafeboxOpen.x, GetY() - m_posSafeboxOpen.y);
}

void CHARACTER::SetSafeboxOpenPosition()
{
m_posSafeboxOpen = GetXYZ();
}

CSafebox * CHARACTER::GetSafebox() const
{
return m_pkSafebox;
}

void CHARACTER::ReqSafeboxLoad(const char* pszPassword)
{
   if (!*pszPassword || strlen(pszPassword) > SAFEBOX_PASSWORD_MAX_LEN)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 잘못된 암호를 입력하셨습니다."));
       return;
   }
   else if (m_pkSafebox)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 창고가 이미 열려있습니다."));
       return;
   }

int iPulse = thecore_pulse();

   if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(10))
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 창고를 닫은지 10초 안에는 열 수 없습니다."));
       return;
   }
   else if (GetDistanceFromSafeboxOpen() > 1000)
   {
       ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 거리가 멀어서 창고를 열 수 없습니다."));
       return;
   }
   else if (m_bOpeningSafebox)
   {
       sys_log(0, "Overlapped safebox load request from %s", GetName());
       return;
   }

SetSafeboxLoadTime();
m_bOpeningSafebox = true;

   TSafeboxLoadPacket p;
   p.dwID = GetDesc()->GetAccountTable().id;
   strlcpy(p.szLogin, GetDesc()->GetAccountTable().login, sizeof(p.szLogin));
   strlcpy(p.szPassword, pszPassword, sizeof(p.szPassword));

db_clientdesc->DBPacket(HEADER_GD_SAFEBOX_LOAD, GetDesc()->GetHandle(), &p, sizeof(p));
}

void CHARACTER::LoadSafebox(int iSize, DWORD dwGold, int iItemCount, TPlayerItem * pItems)
{
bool bLoaded = false;

   //PREVENT_TRADE_WINDOW
   SetOpenSafebox(true);
   //END_PREVENT_TRADE_WINDOW

if (m_pkSafebox)
bLoaded = true;

   if (!m_pkSafebox)
       m_pkSafebox = M2_NEW CSafebox(this, iSize, dwGold);
   else
       m_pkSafebox->ChangeSize(iSize);

m_iSafeboxSize = iSize;

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_SAFEBOX_SIZE;
p.bSize = iSize;

GetDesc()->Packet(&p, sizeof(TPacketCGSafeboxSize));

   if (!bLoaded)
   {
       for (int i = 0; i < iItemCount; ++i, ++pItems)
       {
           if (!m_pkSafebox->IsValidPosition(pItems->pos))
               continue;

LPITEM item = ITEM_MANAGER::instance().CreateItem(pItems->vnum, pItems->count, pItems->id);

           if (!item)
           {
               sys_err("cannot create item vnum %d id %u (name: %s)", pItems->vnum, pItems->id, GetName());
               continue;
           }

           item->SetSkipSave(true);
           item->SetSockets(pItems->alSockets);
           item->SetAttributes(pItems->aAttr);

           if (!m_pkSafebox->Add(pItems->pos, item))
           {
               M2_DESTROY_ITEM(item);
           }
           else
               item->SetSkipSave(false);
       }
   }
}

void CHARACTER::ChangeSafeboxSize(BYTE bSize)
{
//if (!m_pkSafebox)
//return;

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_SAFEBOX_SIZE;
p.bSize = bSize;

GetDesc()->Packet(&p, sizeof(TPacketCGSafeboxSize));

if (m_pkSafebox)
m_pkSafebox->ChangeSize(bSize);

m_iSafeboxSize = bSize;
}

void CHARACTER::CloseSafebox()
{
if (!m_pkSafebox)
return;

   //PREVENT_TRADE_WINDOW
   SetOpenSafebox(false);
   //END_PREVENT_TRADE_WINDOW

m_pkSafebox->Save();

M2_DELETE(m_pkSafebox);
m_pkSafebox = NULL;

ChatPacket(CHAT_TYPE_COMMAND, "CloseSafebox");

SetSafeboxLoadTime();
m_bOpeningSafebox = false;

Save();
}

CSafebox * CHARACTER::GetMall() const
{
return m_pkMall;
}

void CHARACTER::LoadMall(int iItemCount, TPlayerItem * pItems)
{
bool bLoaded = false;

if (m_pkMall)
bLoaded = true;

   if (!m_pkMall)
       m_pkMall = M2_NEW CSafebox(this, 3 * SAFEBOX_PAGE_SIZE, 0);
   else
       m_pkMall->ChangeSize(3 * SAFEBOX_PAGE_SIZE);

m_pkMall->SetWindowMode(MALL);

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_MALL_OPEN;
p.bSize = 3 * SAFEBOX_PAGE_SIZE;

GetDesc()->Packet(&p, sizeof(TPacketCGSafeboxSize));

   if (!bLoaded)
   {
       for (int i = 0; i < iItemCount; ++i, ++pItems)
       {
           if (!m_pkMall->IsValidPosition(pItems->pos))
               continue;

LPITEM item = ITEM_MANAGER::instance().CreateItem(pItems->vnum, pItems->count, pItems->id);

           if (!item)
           {
               sys_err("cannot create item vnum %d id %u (name: %s)", pItems->vnum, pItems->id, GetName());
               continue;
           }

           item->SetSkipSave(true);
           item->SetSockets(pItems->alSockets);
           item->SetAttributes(pItems->aAttr);

           if (!m_pkMall->Add(pItems->pos, item))
               M2_DESTROY_ITEM(item);
           else
               item->SetSkipSave(false);
       }
   }
}

void CHARACTER::CloseMall()
{
if (!m_pkMall)
return;

m_pkMall->Save();

M2_DELETE(m_pkMall);
m_pkMall = NULL;

ChatPacket(CHAT_TYPE_COMMAND, "CloseMall");
}

bool CHARACTER::BuildUpdatePartyPacket(TPacketGCPartyUpdate & out)
{
if (!GetParty())
return false;

memset(&out, 0, sizeof(out));

   out.header       = HEADER_GC_PARTY_UPDATE;
   out.pid       = GetPlayerID();
   out.percent_hp   = MINMAX(0, GetHP() * 100 / GetMaxHP(), 100);
   out.role       = GetParty()->GetRole(GetPlayerID());

sys_log(1, "PARTY %s role is %d", GetName(), out.role);

LPCHARACTER l = GetParty()->GetLeaderCharacter();

   if (l && DISTANCE_APPROX(GetX() - l->GetX(), GetY() - l->GetY()) < PARTY_DEFAULT_RANGE)
   {
       if (g_iUseLocale)
           out.affects[0] = GetParty()->GetPartyBonusExpPercent();
       else
           out.affects[0] = GetParty()->GetExpBonusPercent();
       out.affects[1] = GetPoint(POINT_PARTY_ATTACKER_BONUS);
       out.affects[2] = GetPoint(POINT_PARTY_TANKER_BONUS);
       out.affects[3] = GetPoint(POINT_PARTY_BUFFER_BONUS);
       out.affects[4] = GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);
       out.affects[5] = GetPoint(POINT_PARTY_HASTE_BONUS);
       out.affects[6] = GetPoint(POINT_PARTY_DEFENDER_BONUS);
   }

return true;
}

int CHARACTER::GetLeadershipSkillLevel() const
{
return GetSkillLevel(SKILL_LEADERSHIP);
}

void CHARACTER::QuerySafeboxSize()
{
   if (m_iSafeboxSize == -1)
   {
       DBManager::instance().ReturnQuery(QID_SAFEBOX_SIZE,
               GetPlayerID(),
               NULL,
               "SELECT size FROM safebox%s WHERE account_id = %u",
               get_table_postfix(),
               GetDesc()->GetAccountTable().id);
   }
}

void CHARACTER::SetSafeboxSize(int iSize)
{
   sys_log(1, "SetSafeboxSize: %s %d", GetName(), iSize);
   m_iSafeboxSize = iSize;
   DBManager::instance().Query("UPDATE safebox%s SET size = %d WHERE account_id = %u", get_table_postfix(), iSize / SAFEBOX_PAGE_SIZE, GetDesc()->GetAccountTable().id);
}

int CHARACTER::GetSafeboxSize() const
{
return m_iSafeboxSize;
}

void CHARACTER::SetNowWalking(bool bWalkFlag)
{
   //if (m_bNowWalking != bWalkFlag || IsNPC())
   if (m_bNowWalking != bWalkFlag)
   {
       if (bWalkFlag)
       {
           m_bNowWalking = true;
           m_dwWalkStartTime = get_dword_time();
       }
       else
       {
           m_bNowWalking = false;
       }

       //if (m_bNowWalking)
       {
           TPacketGCWalkMode p;
           p.vid = GetVID();
           p.header = HEADER_GC_WALK_MODE;
           p.mode = m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;

PacketView(&p, sizeof(p));
}

       if (IsNPC())
       {
           if (m_bNowWalking)
               MonsterLog("걷는다");
           else
               MonsterLog("뛴다");
       }

//sys_log(0, "%s is now %s", GetName(), m_bNowWalking?"walking.":"running.");
}
}

void CHARACTER::StartStaminaConsume()
{
   if (m_bStaminaConsume)
       return;
   PointChange(POINT_STAMINA, 0);
   m_bStaminaConsume = true;
   //ChatPacket(CHAT_TYPE_COMMAND, "StartStaminaConsume %d %d", STAMINA_PER_STEP * passes_per_sec, GetStamina());
   if (IsStaminaHalfConsume())
       ChatPacket(CHAT_TYPE_COMMAND, "StartStaminaConsume %d %d", STAMINA_PER_STEP * passes_per_sec / 2, GetStamina());
   else
       ChatPacket(CHAT_TYPE_COMMAND, "StartStaminaConsume %d %d", STAMINA_PER_STEP * passes_per_sec, GetStamina());
}

void CHARACTER::StopStaminaConsume()
{
   if (!m_bStaminaConsume)
       return;
   PointChange(POINT_STAMINA, 0);
   m_bStaminaConsume = false;
   ChatPacket(CHAT_TYPE_COMMAND, "StopStaminaConsume %d", GetStamina());
}

bool CHARACTER::IsStaminaConsume() const
{
return m_bStaminaConsume;
}

bool CHARACTER::IsStaminaHalfConsume() const
{
return IsEquipUniqueItem(UNIQUE_ITEM_HALF_STAMINA);
}

void CHARACTER::ResetStopTime()
{
m_dwStopTime = get_dword_time();
}

DWORD CHARACTER::GetStopTime() const
{
return m_dwStopTime;
}

void CHARACTER::ResetPoint(int iLv)
{
BYTE bJob = GetJob();

PointChange(POINT_LEVEL, iLv - GetLevel());

SetRealPoint(POINT_ST, JobInitialPoints[bJob].st);
SetPoint(POINT_ST, GetRealPoint(POINT_ST));

SetRealPoint(POINT_HT, JobInitialPoints[bJob].ht);
SetPoint(POINT_HT, GetRealPoint(POINT_HT));

SetRealPoint(POINT_DX, JobInitialPoints[bJob].dx);
SetPoint(POINT_DX, GetRealPoint(POINT_DX));

SetRealPoint(POINT_IQ, JobInitialPoints[bJob].iq);
SetPoint(POINT_IQ, GetRealPoint(POINT_IQ));

SetRandomHP((iLv - 1) * number(JobInitialPoints[GetJob()].hp_per_lv_begin, JobInitialPoints[GetJob()].hp_per_lv_end));
SetRandomSP((iLv - 1) * number(JobInitialPoints[GetJob()].sp_per_lv_begin, JobInitialPoints[GetJob()].sp_per_lv_end));

   //PointChange(POINT_STAT, ((MINMAX(1, iLv, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));
   // Maxmi Stat?
   if(iLv <= 105)
       PointChange(POINT_STAT, ((MINMAX(1, iLv, 105) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));
   else
       PointChange(POINT_STAT, 315 - GetPoint(POINT_STAT));

   ComputePoints();

   // 회복
   PointChange(POINT_HP, GetMaxHP() - GetHP());
   PointChange(POINT_SP, GetMaxSP() - GetSP());

PointsPacket();

LogManager::instance().CharLog(this, 0, "RESET_POINT", "");
}

bool CHARACTER::IsChangeAttackPosition(LPCHARACTER target) const
{
if (!IsNPC())
return true;

DWORD dwChangeTime = AI_CHANGE_ATTACK_POISITION_TIME_NEAR;

   if (DISTANCE_APPROX(GetX() - target->GetX(), GetY() - target->GetY()) >
       AI_CHANGE_ATTACK_POISITION_DISTANCE + GetMobAttackRange())
       dwChangeTime = AI_CHANGE_ATTACK_POISITION_TIME_FAR;

return get_dword_time() - m_dwLastChangeAttackPositionTime > dwChangeTime;
}

void CHARACTER::GiveRandomSkillBook()
{
   LPITEM item = AutoGiveItem(50300);
   if (NULL != item)
   {
       BYTE bJob = 0;
       if (!number(0, 1))
           bJob = GetJob() + 1;

       DWORD dwSkillVnum = 0;
       do
       {
           if (number(1, 3) == 2)
           {
               dwSkillVnum = number(170, 175);
           }
           else
           {
               dwSkillVnum = number(1, 111);
           }
           const CSkillProto* pkSk = CSkillManager::instance().Get(dwSkillVnum);

if (NULL == pkSk)
continue;

if (bJob && bJob != pkSk->dwType)
continue;

break;
} while (true);

item->SetSocket(0, dwSkillVnum);
}
}

void CHARACTER::ReviveInvisible(int iDur)
{
AddAffect(AFFECT_REVIVE_INVISIBLE, POINT_NONE, 0, AFF_REVIVE_INVISIBLE, iDur, 0, true);
}

#ifdef __MOUNT_SYSTEM__
void CHARACTER::Mount(int mount_vnum, bool isWearCell, long iTime, BYTE iApplyType, long iApplyValue)
{
   Dismount();
   const CMob* pkMob = CMobManager::instance().Get(mount_vnum);
   if (pkMob == NULL)
   {
       if (UnEquipMountUniqueItem())
           Dismount();

       return;
   }
   else
   {
       if (isWearCell)
           AddAffect(AFFECT_MOUNT, POINT_MOUNT, mount_vnum, AFF_NONE, 60 * 60 * 24 * 365, 0, true);
       else
       {
           AddAffect(AFFECT_MOUNT, POINT_MOUNT, mount_vnum, AFF_NONE, iTime, 0, true);
           AddAffect(AFFECT_MOUNT_BONUS, aApplyInfo[iApplyType].bPointType, iApplyValue, AFF_NONE, iTime, 0, false);
       }
   }
}

void CHARACTER::Dismount()
{
   RemoveAffect(AFFECT_MOUNT);
   RemoveAffect(AFFECT_MOUNT_BONUS);
   MountVnum(0);
   PointChange(POINT_ST, 0);
   PointChange(POINT_DX, 0);
   PointChange(POINT_HT, 0);
   PointChange(POINT_IQ, 0);
   if (IsHorseRiding())
       StopRiding();

   if (GetHorse())
       HorseSummon(false);
}

void CHARACTER::CheckMount()
{
   LPITEM item = GetWear(WEAR_COSTUME_MOUNT);
   if (item)
   {
       if (!item->IsMountItem())
           return;
       else
           Mount(item->GetValue(4));
   }
   else
       return;
}

bool CHARACTER::IsRidingMount()
{
   LPITEM item = GetWear(WEAR_COSTUME_MOUNT);
   if (!item)
       return false;

   if (item->IsMountItem())
       return true;

   return false;
}
#endif

void CHARACTER::ToggleMonsterLog()
{
m_bMonsterLog = !m_bMonsterLog;

   if (m_bMonsterLog)
   {
       CHARACTER_MANAGER::instance().RegisterForMonsterLog(this);
   }
   else
   {
       CHARACTER_MANAGER::instance().UnregisterForMonsterLog(this);
   }
}

void CHARACTER::SetGuild(CGuild* pGuild)
{
   if (m_pGuild != pGuild)
   {
       m_pGuild = pGuild;
       UpdatePacket();
   }
}

void CHARACTER::SendGreetMessage()
{
typeof(DBManager::instance().GetGreetMessage()) v = DBManager::instance().GetGreetMessage();

   for (itertype(v) it = v.begin(); it != v.end(); ++it)
   {
       ChatPacket(CHAT_TYPE_NOTICE, it->c_str());
   }
}

void CHARACTER::BeginStateEmpty()
{
MonsterLog("!");
}

void CHARACTER::EffectPacket(int enumEffectType)
{
TPacketGCSpecialEffect p;

   p.header = HEADER_GC_SEPCIAL_EFFECT;
   p.type = enumEffectType;
   p.vid = GetVID();

PacketAround(&p, sizeof(TPacketGCSpecialEffect));
}

void CHARACTER::SpecificEffectPacket(const char filename[MAX_EFFECT_FILE_NAME])
{
TPacketGCSpecificEffect p;

   p.header = HEADER_GC_SPECIFIC_EFFECT;
   p.vid = GetVID();
   memcpy (p.effect_file, filename, MAX_EFFECT_FILE_NAME);

PacketAround(&p, sizeof(TPacketGCSpecificEffect));
}

void CHARACTER::MonsterChat(BYTE bMonsterChatType)
{
if (IsPC())
return;

char sbuf[256+1];

   if (IsMonster())
   {
       if (number(0, 60))
           return;

       snprintf(sbuf, sizeof(sbuf),
               "(locale.monster_chat[%i] and locale.monster_chat[%i][%d] or '')",
               GetRaceNum(), GetRaceNum(), bMonsterChatType*3 + number(1, 3));
   }
   else
   {
       if (bMonsterChatType != MONSTER_CHAT_WAIT)
           return;

       if (IsGuardNPC())
       {
           if (number(0, 6))
               return;
       }
       else
       {
           if (number(0, 30))
               return;
       }

snprintf(sbuf, sizeof(sbuf), "(locale.monster_chat[%i] and locale.monster_chat[%i][number(1, table.getn(locale.monster_chat[%i]))] or '')", GetRaceNum(), GetRaceNum(), GetRaceNum());
}

std::string text = quest::ScriptToString(sbuf);

if (text.empty())
return;

struct packet_chat pack_chat;

   pack_chat.header = HEADER_GC_CHAT;
   pack_chat.size   = sizeof(struct packet_chat) + text.size() + 1;
   pack_chat.type = CHAT_TYPE_TALKING;
   pack_chat.id = GetVID();
   pack_chat.bEmpire   = 0;

   TEMP_BUFFER buf;
   buf.write(&pack_chat, sizeof(struct packet_chat));
   buf.write(text.c_str(), text.size() + 1);

PacketAround(buf.read_peek(), buf.size());
}

void CHARACTER::SetQuestNPCID(DWORD vid)
{
m_dwQuestNPCVID = vid;
}

LPCHARACTER CHARACTER::GetQuestNPC() const
{
return CHARACTER_MANAGER::instance().Find(m_dwQuestNPCVID);
}

void CHARACTER::SetQuestItemPtr(LPITEM item)
{
m_pQuestItem = item;
}

void CHARACTER::ClearQuestItemPtr()
{
m_pQuestItem = NULL;
}

LPITEM CHARACTER::GetQuestItemPtr() const
{
return m_pQuestItem;
}

LPDUNGEON CHARACTER::GetDungeonForce() const
{
if (m_lWarpMapIndex > 10000)
return CDungeonManager::instance().FindByMapIndex(m_lWarpMapIndex);

return m_pkDungeon;
}

void CHARACTER::SetBlockMode(BYTE bFlag)
{
m_pointsInstant.bBlockMode = bFlag;

ChatPacket(CHAT_TYPE_COMMAND, "setblockmode %d", m_pointsInstant.bBlockMode);

   SetQuestFlag("game_option.block_exchange", bFlag & BLOCK_EXCHANGE ? 1 : 0);
   SetQuestFlag("game_option.block_party_invite", bFlag & BLOCK_PARTY_INVITE ? 1 : 0);
   SetQuestFlag("game_option.block_guild_invite", bFlag & BLOCK_GUILD_INVITE ? 1 : 0);
   SetQuestFlag("game_option.block_whisper", bFlag & BLOCK_WHISPER ? 1 : 0);
   SetQuestFlag("game_option.block_messenger_invite", bFlag & BLOCK_MESSENGER_INVITE ? 1 : 0);
   SetQuestFlag("game_option.block_party_request", bFlag & BLOCK_PARTY_REQUEST ? 1 : 0);
}

void CHARACTER::SetBlockModeForce(BYTE bFlag)
{
m_pointsInstant.bBlockMode = bFlag;
ChatPacket(CHAT_TYPE_COMMAND, "setblockmode %d", m_pointsInstant.bBlockMode);
}

bool CHARACTER::IsGuardNPC() const
{
return IsNPC() && (GetRaceNum() == 11000 || GetRaceNum() == 11002 || GetRaceNum() == 11004);
}

int CHARACTER::GetPolymorphPower() const
{
   if (test_server)
   {
       int value = quest::CQuestManager::instance().GetEventFlag("poly");
       if (value)
           return value;
   }
   return aiPolymorphPowerByLevel[MINMAX(0, GetSkillLevel(SKILL_POLYMORPH), 40)];
}

void CHARACTER::SetPolymorph(DWORD dwRaceNum, bool bMaintainStat)
{
   if (dwRaceNum < JOB_MAX_NUM)
   {
       dwRaceNum = 0;
       bMaintainStat = false;
   }

if (m_dwPolymorphRace == dwRaceNum)
return;

m_bPolyMaintainStat = bMaintainStat;
m_dwPolymorphRace = dwRaceNum;

sys_log(0, "POLYMORPH: %s race %u ", GetName(), dwRaceNum);

if (dwRaceNum != 0)
StopRiding();

SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);
m_afAffectFlag.Set(AFF_SPAWN);

ViewReencode();

REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

   if (!bMaintainStat)
   {
       PointChange(POINT_ST, 0);
       PointChange(POINT_DX, 0);
       PointChange(POINT_IQ, 0);
       PointChange(POINT_HT, 0);
   }

   // 폴리모프 상태에서 죽는 경우, 폴리모프가 풀리게 되는데
   // 폴리 모프 전후로 valid combo interval이 다르기 때문에
   // Combo 핵 또는 Hacker로 인식하는 경우가 있다.
   // 따라서 폴리모프를 풀거나 폴리모프 하게 되면,
   // valid combo interval을 reset한다.
   SetValidComboInterval(0);
   SetComboSequence(0);

ComputeBattlePoints();
}

int CHARACTER::GetQuestFlag(const std::string& flag) const
{
   quest::CQuestManager& q = quest::CQuestManager::instance();
   quest::PC* pPC = q.GetPC(GetPlayerID());
   return pPC->GetFlag(flag);
}

void CHARACTER::SetQuestFlag(const std::string& flag, int value)
{
   quest::CQuestManager& q = quest::CQuestManager::instance();
   quest::PC* pPC = q.GetPC(GetPlayerID());
   pPC->SetFlag(flag, value);
}

void CHARACTER::DetermineDropMetinStone()
{
   const int METIN_STONE_NUM = 14;
   static DWORD c_adwMetin[METIN_STONE_NUM] =
   {
       28030,
       28031,
       28032,
       28033,
       28034,
       28035,
       28036,
       28037,
       28038,
       28039,
       28040,
       28041,
       28042,
       28043,
   };
   DWORD stone_num = GetRaceNum();
   int idx = std::lower_bound(aStoneDrop, aStoneDrop+STONE_INFO_MAX_NUM, stone_num) - aStoneDrop;
   if (idx >= STONE_INFO_MAX_NUM || aStoneDrop[idx].dwMobVnum != stone_num)
   {
       m_dwDropMetinStone = 0;
   }
   else
   {
       const SStoneDropInfo & info = aStoneDrop[idx];
       m_bDropMetinStonePct = info.iDropPct;
       {
           m_dwDropMetinStone = c_adwMetin[number(0, METIN_STONE_NUM - 1)];
           int iGradePct = number(1, 100);
           for (int iStoneLevel = 0; iStoneLevel < STONE_LEVEL_MAX_NUM; iStoneLevel ++)
           {
               int iLevelGradePortion = info.iLevelPct[iStoneLevel];
               if (iGradePct <= iLevelGradePortion)
               {
                   break;
               }
               else
               {
                   iGradePct -= iLevelGradePortion;
                   m_dwDropMetinStone += 100; // 돌 +a -> +(a+1)이 될때마다 100씩 증가
               }
           }
       }
   }
}

void CHARACTER::SendEquipment(LPCHARACTER ch)
{
TPacketViewEquip p;
p.header = HEADER_GC_VIEW_EQUIP;
p.vid = GetVID();
int pos[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 20, 21, 22, 23 };
for (int i = 0; i < 16; i++)
{
LPITEM item = GetWear(pos);
if (item)
{
p.equips.vnum = item->GetVnum();
p.equips.count = item->GetCount();

thecore_memcpy(p.equips.alSockets, item->GetSockets(), sizeof(p.equips.alSockets));
thecore_memcpy(p.equips.aAttr, item->GetAttributes(), sizeof(p.equips.aAttr));
}
else
{
p.equips.vnum = 0;
}
}
ch->GetDesc()->Packet(&p, sizeof(p));
}

bool CHARACTER::CanSummon(int iLeaderShip)
{
return (iLeaderShip >= 20 || iLeaderShip >= 12 && m_dwLastDeadTime + 180 > get_dword_time());
}

void CHARACTER::MountVnum(DWORD vnum)
{
if (m_dwMountVnum == vnum)
return;

m_dwMountVnum = vnum;
m_dwMountTime = get_dword_time();

if (m_bIsObserver)
return;

   //NOTE : Mount한다고 해서 Client Side의 객체를 삭제하진 않는다.
   //그리고 서버Side에서 탔을때 위치 이동은 하지 않는다. 왜냐하면 Client Side에서 Coliision Adjust를 할수 있는데
   //객체를 소멸시켰다가 서버위치로 이동시키면 이때 collision check를 하지는 않으므로 배경에 끼거나 뚫고 나가는 문제가 존재한다.
   m_posDest.x = m_posStart.x = GetX();
   m_posDest.y = m_posStart.y = GetY();
   //EncodeRemovePacket(this);
   EncodeInsertPacket(this);

ENTITY_MAP::iterator it = m_map_view.begin();

   while (it != m_map_view.end())
   {
       LPENTITY entity = (it++)->first;

       //Mount한다고 해서 Client Side의 객체를 삭제하진 않는다.
       //EncodeRemovePacket(entity);
       //if (!m_bIsObserver)
       EncodeInsertPacket(entity);

       //if (!entity->IsObserverMode())
       //   entity->EncodeInsertPacket(this);
   }

SetValidComboInterval(0);
SetComboSequence(0);

ComputePoints();
}

namespace {
   class FuncCheckWarp
   {
       public:
           FuncCheckWarp(LPCHARACTER pkWarp)
           {
               m_lTargetY = 0;
               m_lTargetX = 0;

m_lX = pkWarp->GetX();
m_lY = pkWarp->GetY();

m_bInvalid = false;
m_bEmpire = pkWarp->GetEmpire();

char szTmp[64];

               if (3 != sscanf(pkWarp->GetName(), " %s %ld %ld ", szTmp, &m_lTargetX, &m_lTargetY))
               {
                   if (number(1, 100) < 5)
                       //sys_err("Warp NPC name wrong : vnum(%d) name(%s)", pkWarp->GetRaceNum(), pkWarp->GetName());

m_bInvalid = true;

return;
}

m_lTargetX *= 100;
m_lTargetY *= 100;

m_bUseWarp = true;

               if (pkWarp->IsGoto())
               {
                   LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(pkWarp->GetMapIndex());
                   m_lTargetX += pkSectreeMap->m_setting.iBaseX;
                   m_lTargetY += pkSectreeMap->m_setting.iBaseY;
                   m_bUseWarp = false;
               }
           }

           bool Valid()
           {
               return !m_bInvalid;
           }

           void operator () (LPENTITY ent)
           {
               if (!Valid())
                   return;

if (!ent->IsType(ENTITY_CHARACTER))
return;

LPCHARACTER pkChr = (LPCHARACTER) ent;

if (!pkChr->IsPC())
return;

int iDist = DISTANCE_APPROX(pkChr->GetX() - m_lX, pkChr->GetY() - m_lY);

if (iDist > 300)
return;

if (m_bEmpire && pkChr->GetEmpire() && m_bEmpire != pkChr->GetEmpire())
return;

if (pkChr->IsHack())
return;

               if (!pkChr->CanHandleItem(false, true))
                   return;

               if (m_bUseWarp)
                   pkChr->WarpSet(m_lTargetX, m_lTargetY);
               else
               {
                   pkChr->Show(pkChr->GetMapIndex(), m_lTargetX, m_lTargetY);
                   pkChr->Stop();
               }
           }

bool m_bInvalid;
bool m_bUseWarp;

           long m_lX;
           long m_lY;
           long m_lTargetX;
           long m_lTargetY;

BYTE m_bEmpire;
};
}

EVENTFUNC(warp_npc_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "warp_npc_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER ch = info->ch;

   if (ch == NULL) { // <Factor>
       return 0;
   }

   if (!ch->GetSectree())
   {
       ch->m_pkWarpNPCEvent = NULL;
       return 0;
   }

   FuncCheckWarp f(ch);
   if (f.Valid())
       ch->GetSectree()->ForEachAround(f);

return passes_per_sec / 2;
}

void CHARACTER::StartWarpNPCEvent()
{
if (m_pkWarpNPCEvent)
return;

if (!IsWarp() && !IsGoto())
return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkWarpNPCEvent = event_create(warp_npc_event, info, passes_per_sec / 2);
}

void CHARACTER::SyncPacket()
{
TEMP_BUFFER buf;

TPacketCGSyncPositionElement elem;

   elem.dwVID = GetVID();
   elem.lX = GetX();
   elem.lY = GetY();

TPacketGCSyncPosition pack;

pack.bHeader = HEADER_GC_SYNC_POSITION;
pack.wSize = sizeof(TPacketGCSyncPosition) + sizeof(elem);

buf.write(&pack, sizeof(pack));
buf.write(&elem, sizeof(elem));

PacketAround(buf.read_peek(), buf.size());
}

LPCHARACTER CHARACTER::GetMarryPartner() const
{
return m_pkChrMarried;
}

void CHARACTER::SetMarryPartner(LPCHARACTER ch)
{
m_pkChrMarried = ch;
}

int CHARACTER::GetMarriageBonus(DWORD dwItemVnum, bool bSum)
{
if (IsNPC())
return 0;

marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());

if (!pMarriage)
return 0;

return pMarriage->GetBonus(dwItemVnum, bSum, this);
}

void CHARACTER::ConfirmWithMsg(const char* szMsg, int iTimeout, DWORD dwRequestPID)
{
if (!IsPC())
return;

TPacketGCQuestConfirm p;

   p.header = HEADER_GC_QUEST_CONFIRM;
   p.requestPID = dwRequestPID;
   p.timeout = iTimeout;
   strlcpy(p.msg, szMsg, sizeof(p.msg));

GetDesc()->Packet(&p, sizeof(p));
}

int CHARACTER::GetPremiumRemainSeconds(BYTE bType) const
{
if (bType >= PREMIUM_MAX_NUM)
return 0;

return m_aiPremiumTimes[bType] - get_global_time();
}

bool CHARACTER::WarpToPID(DWORD dwPID)
{
   LPCHARACTER victim;
   if ((victim = (CHARACTER_MANAGER::instance().FindByPID(dwPID))))
   {
       int mapIdx = victim->GetMapIndex();
       if (IS_SUMMONABLE_ZONE(mapIdx))
       {
           if (CAN_ENTER_ZONE(this, mapIdx))
           {
               WarpSet(victim->GetX(), victim->GetY());
           }
           else
           {
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 있는 곳으로 워프할 수 없습니다."));
               return false;
           }
       }
       else
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 있는 곳으로 워프할 수 없습니다."));
           return false;
       }
   }
   else
   {
       // 다른 서버에 로그인된 사람이 있음 -> 메시지 보내 좌표를 받아오자
       // 1. A.pid, B.pid 를 뿌림
       // 2. B.pid를 가진 서버가 뿌린서버에게 A.pid, 좌표 를 보냄
       // 3. 워프
       CCI * pcci = P2P_MANAGER::instance().FindByPID(dwPID);

       if (!pcci)
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 온라인 상태가 아닙니다."));
           return false;
       }

       if (pcci->bChannel != g_bChannel)
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 %d 채널에 있습니다. (현재 채널 %d)"), pcci->bChannel, g_bChannel);
           return false;
       }
       else if (false == IS_SUMMONABLE_ZONE(pcci->lMapIndex))
       {
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 있는 곳으로 워프할 수 없습니다."));
           return false;
       }
       else
       {
           if (!CAN_ENTER_ZONE(this, pcci->lMapIndex))
           {
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 있는 곳으로 워프할 수 없습니다."));
               return false;
           }

           TPacketGGFindPosition p;
           p.header = HEADER_GG_FIND_POSITION;
           p.dwFromPID = GetPlayerID();
           p.dwTargetPID = dwPID;
           pcci->pkDesc->Packet(&p, sizeof(TPacketGGFindPosition));

           if (test_server)
               ChatPacket(CHAT_TYPE_PARTY, "sent find position packet for teleport");
       }
   }
   return true;
}

// ADD_REFINE_BUILDING
CGuild* CHARACTER::GetRefineGuild() const
{
LPCHARACTER chRefineNPC = CHARACTER_MANAGER::instance().Find(m_dwRefineNPCVID);

return (chRefineNPC ? chRefineNPC->GetGuild() : NULL);
}

bool CHARACTER::IsRefineThroughGuild() const
{
return GetRefineGuild() != NULL;
}

int CHARACTER::ComputeRefineFee(int iCost, int iMultiply) const
{
   CGuild* pGuild = GetRefineGuild();
   if (pGuild)
   {
       if (pGuild == GetGuild())
           return iCost * iMultiply * 9 / 10;

       // 다른 제국 사람이 시도하는 경우 추가로 3배 더
       LPCHARACTER chRefineNPC = CHARACTER_MANAGER::instance().Find(m_dwRefineNPCVID);
       if (chRefineNPC && chRefineNPC->GetEmpire() != GetEmpire())
           return iCost * iMultiply * 3;

       return iCost * iMultiply;
   }
   else
       return iCost;
}

void CHARACTER::PayRefineFee(int iTotalMoney)
{
int iFee = iTotalMoney / 10;
CGuild* pGuild = GetRefineGuild();

int iRemain = iTotalMoney;

   if (pGuild)
   {
       // 자기 길드이면 iTotalMoney에 이미 10%가 제외되어있다
       if (pGuild != GetGuild())
       {
           pGuild->RequestDepositMoney(this, iFee);
           iRemain -= iFee;
       }
   }

PointChange(POINT_GOLD, -iRemain);
}
// END_OF_ADD_REFINE_BUILDING

//Hack 방지를 위한 체크.
bool CHARACTER::IsHack(bool bSendMsg, bool bCheckShopOwner, int limittime)
{
const int iPulse = thecore_pulse();

if (test_server)
bSendMsg = true;

   //창고 연후 체크
   if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(limittime))
   {
       if (bSendMsg)
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 다른곳으로 이동할수 없습니다."), limittime);

       if (test_server)
           ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(limittime));
       return true;
   }

   //거래관련 창 체크
   if (bCheckShopOwner)
   {
       if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen())
       {
           if (bSendMsg)
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 다른곳으로 이동,종료 할수 없습니다"));

           return true;
       }
   }
   else
   {
       if (GetExchange() || GetMyShop() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen())
       {
           if (bSendMsg)
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 다른곳으로 이동,종료 할수 없습니다"));

           return true;
       }
   }

   //PREVENT_PORTAL_AFTER_EXCHANGE
   //교환 후 시간체크
   if (iPulse - GetExchangeTime() < PASSES_PER_SEC(limittime))
   {
       if (bSendMsg)
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에는 다른지역으로 이동 할 수 없습니다."), limittime );
       return true;
   }
   //END_PREVENT_PORTAL_AFTER_EXCHANGE

   //PREVENT_ITEM_COPY
   if (iPulse - GetMyShopTime() < PASSES_PER_SEC(limittime))
   {
       if (bSendMsg)
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에는 다른지역으로 이동 할 수 없습니다."), limittime);
       return true;
   }

   if (iPulse - GetRefineTime() < PASSES_PER_SEC(limittime))
   {
       if (bSendMsg)
           ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 개량후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), limittime);
       return true;
   }
   //END_PREVENT_ITEM_COPY

return false;
}

BOOL CHARACTER::IsMonarch() const
{
   //MONARCH_LIMIT
   if (CMonarch::instance().IsMonarch(GetPlayerID(), GetEmpire()))
       return true;

return false;

//END_MONARCH_LIMIT
}
void CHARACTER::Say(const std::string & s)
{
struct ::packet_script packet_script;

   packet_script.header = HEADER_GC_SCRIPT;
   packet_script.skin = 1;
   packet_script.src_size = s.size();
   packet_script.size = packet_script.src_size + sizeof(struct packet_script);

   TEMP_BUFFER buf;

buf.write(&packet_script, sizeof(struct packet_script));
buf.write(&s[0], s.size());

   if (IsPC())
   {
       GetDesc()->Packet(buf.read_peek(), buf.size());
   }
}

//
// Monarch
//
void CHARACTER::InitMC()
{
   for (int n = 0; n < MI_MAX; ++n)
   {
       m_dwMonarchCooltime[n] = thecore_pulse();
   }

   m_dwMonarchCooltimelimit[MI_HEAL] = PASSES_PER_SEC(MC_HEAL);
   m_dwMonarchCooltimelimit[MI_WARP] = PASSES_PER_SEC(MC_WARP);
   m_dwMonarchCooltimelimit[MI_TRANSFER] = PASSES_PER_SEC(MC_TRANSFER);
   m_dwMonarchCooltimelimit[MI_TAX] = PASSES_PER_SEC(MC_TAX);
   m_dwMonarchCooltimelimit[MI_SUMMON] = PASSES_PER_SEC(MC_SUMMON);

   m_dwMonarchCooltime[MI_HEAL] -= PASSES_PER_SEC(GetMCL(MI_HEAL));
   m_dwMonarchCooltime[MI_WARP] -= PASSES_PER_SEC(GetMCL(MI_WARP));
   m_dwMonarchCooltime[MI_TRANSFER] -= PASSES_PER_SEC(GetMCL(MI_TRANSFER));
   m_dwMonarchCooltime[MI_TAX] -= PASSES_PER_SEC(GetMCL(MI_TAX));
   m_dwMonarchCooltime[MI_SUMMON] -= PASSES_PER_SEC(GetMCL(MI_SUMMON));
}

DWORD CHARACTER::GetMC(enum MONARCH_INDEX e) const
{
return m_dwMonarchCooltime[e];
}

void CHARACTER::SetMC(enum MONARCH_INDEX e)
{
m_dwMonarchCooltime[e] = thecore_pulse();
}

bool CHARACTER::IsMCOK(enum MONARCH_INDEX e) const
{
int iPulse = thecore_pulse();

   if ((iPulse - GetMC(e)) < GetMCL(e))
   {
       if (test_server)
           sys_log(0, " Pulse %d cooltime %d, limit %d", iPulse, GetMC(e), GetMCL(e));

       return false;
   }

   if (test_server)
       sys_log(0, " Pulse %d cooltime %d, limit %d", iPulse, GetMC(e), GetMCL(e));

return true;
}

DWORD CHARACTER::GetMCL(enum MONARCH_INDEX e) const
{
return m_dwMonarchCooltimelimit[e];
}

DWORD CHARACTER::GetMCLTime(enum MONARCH_INDEX e) const
{
int iPulse = thecore_pulse();

if (test_server)
sys_log(0, " Pulse %d cooltime %d, limit %d", iPulse, GetMC(e), GetMCL(e));

return (GetMCL(e)) / passes_per_sec - (iPulse - GetMC(e)) / passes_per_sec;
}

bool CHARACTER::IsSiegeNPC() const
{
return IsNPC() && (GetRaceNum() == 11000 || GetRaceNum() == 11002 || GetRaceNum() == 11004);
}

//------------------------------------------------
void CHARACTER::UpdateDepositPulse()
{
m_deposit_pulse = thecore_pulse() + PASSES_PER_SEC(60*5); // 5분
}

bool CHARACTER::CanDeposit() const
{
return (m_deposit_pulse == 0 || (m_deposit_pulse < thecore_pulse()));
}
//------------------------------------------------

ESex GET_SEX(LPCHARACTER ch)
{
   switch (ch->GetRaceNum())
   {
       case MAIN_RACE_WARRIOR_M:
       case MAIN_RACE_SURA_M:
       case MAIN_RACE_ASSASSIN_M:
       case MAIN_RACE_SHAMAN_M:
       case MAIN_RACE_WOLFMAN_M:
           return SEX_MALE;

       case MAIN_RACE_ASSASSIN_W:
       case MAIN_RACE_SHAMAN_W:
       case MAIN_RACE_WARRIOR_W:
       case MAIN_RACE_SURA_W:
           return SEX_FEMALE;
   }

/* default sex = male */
return SEX_MALE;
}

int CHARACTER::GetHPPct() const
{
return (GetHP() * 100) / GetMaxHP();
}

bool CHARACTER::IsBerserk() const
{
   if (m_pkMobInst != NULL)
       return m_pkMobInst->m_IsBerserk;
   else
       return false;
}

void CHARACTER::SetBerserk(bool mode)
{
if (m_pkMobInst != NULL)
m_pkMobInst->m_IsBerserk = mode;
}

bool CHARACTER::IsGodSpeed() const
{
   if (m_pkMobInst != NULL)
   {
       return m_pkMobInst->m_IsGodSpeed;
   }
   else
   {
       return false;
   }
}

void CHARACTER::SetGodSpeed(bool mode)
{
   if (m_pkMobInst != NULL)
   {
       m_pkMobInst->m_IsGodSpeed = mode;

       if (mode == true)
       {
           SetPoint(POINT_ATT_SPEED, 250);
       }
       else
       {
           SetPoint(POINT_ATT_SPEED, m_pkMobData->m_table.sAttackSpeed);
       }
   }
}

bool CHARACTER::IsDeathBlow() const
{
   if (number(1, 100) <= m_pkMobData->m_table.bDeathBlowPoint)
   {
       return true;
   }
   else
   {
       return false;
   }
}

struct FFindReviver
{
   FFindReviver()
   {
       pChar = NULL;
       HasReviver = false;
   }

   void operator() (LPCHARACTER ch)
   {
       if (ch->IsMonster() != true)
       {
           return;
       }

       if (ch->IsReviver() == true && pChar != ch && ch->IsDead() != true)
       {
           if (number(1, 100) <= ch->GetMobTable().bRevivePoint)
           {
               HasReviver = true;
               pChar = ch;
           }
       }
   }

LPCHARACTER pChar;
bool HasReviver;
};

bool CHARACTER::HasReviverInParty() const
{
LPPARTY party = GetParty();

   if (party != NULL)
   {
       if (party->GetMemberCount() == 1) return false;

       FFindReviver f;
       party->ForEachMemberPtr(f);
       return f.HasReviver;
   }

return false;
}

bool CHARACTER::IsRevive() const
{
   if (m_pkMobInst != NULL)
   {
       return m_pkMobInst->m_IsRevive;
   }

return false;
}

void CHARACTER::SetRevive(bool mode)
{
   if (m_pkMobInst != NULL)
   {
       m_pkMobInst->m_IsRevive = mode;
   }
}

#define IS_SPEED_HACK_PLAYER(ch) (ch->m_speed_hack_count > SPEEDHACK_LIMIT_COUNT * 3)

EVENTFUNC(check_speedhack_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "check_speedhack_event> <Factor> Null pointer" );
       return 0;
   }

LPCHARACTER ch = info->ch;

if (NULL == ch || ch->IsNPC())
return 0;

   if (IS_SPEED_HACK_PLAYER(ch))
   {
       // write hack log
       LogManager::instance().SpeedHackLog(ch->GetPlayerID(), ch->GetX(), ch->GetY(), ch->m_speed_hack_count);

       if (false == LC_IsEurope())
       {
           // close connection
           LPDESC desc = ch->GetDesc();

           if (desc)
           {
               DESC_MANAGER::instance().DestroyDesc(desc);
               return 0;
           }
       }
   }

ch->m_speed_hack_count = 0;

ch->ResetComboHackCount();
return PASSES_PER_SEC(60);
}

void CHARACTER::StartCheckSpeedHackEvent()
{
if (m_pkCheckSpeedHackEvent)
return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkCheckSpeedHackEvent = event_create(check_speedhack_event, info, PASSES_PER_SEC(60)); // 1분
}

void CHARACTER::GoHome()
{
WarpSet(EMPIRE_START_X(GetEmpire()), EMPIRE_START_Y(GetEmpire()));
}

void CHARACTER::SendGuildName(CGuild* pGuild)
{
if (NULL == pGuild) return;

DESC *desc = GetDesc();

if (NULL == desc) return;
if (m_known_guild.find(pGuild->GetID()) != m_known_guild.end()) return;

m_known_guild.insert(pGuild->GetID());

TPacketGCGuildName pack;
memset(&pack, 0x00, sizeof(pack));

   pack.header       = HEADER_GC_GUILD;
   pack.subheader   = GUILD_SUBHEADER_GC_GUILD_NAME;
   pack.size       = sizeof(TPacketGCGuildName);
   pack.guildID   = pGuild->GetID();
   memcpy(pack.guildName, pGuild->GetName(), GUILD_NAME_MAX_LEN);

desc->Packet(&pack, sizeof(pack));
}

void CHARACTER::SendGuildName(DWORD dwGuildID)
{
SendGuildName(CGuildManager::instance().FindGuild(dwGuildID));
}

EVENTFUNC(destroy_when_idle_event)
{
   char_event_info* info = dynamic_cast<char_event_info*>( event->info );
   if ( info == NULL )
   {
       sys_err( "destroy_when_idle_event> <Factor> Null pointer" );
       return 0;
   }

   LPCHARACTER ch = info->ch;
   if (ch == NULL) { // <Factor>
       return 0;
   }

   if (ch->GetVictim())
   {
       return PASSES_PER_SEC(300);
   }

sys_log(1, "DESTROY_WHEN_IDLE: %s", ch->GetName());

   ch->m_pkDestroyWhenIdleEvent = NULL;
   M2_DESTROY_CHARACTER(ch);
   return 0;
}

void CHARACTER::StartDestroyWhenIdleEvent()
{
if (m_pkDestroyWhenIdleEvent)
return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkDestroyWhenIdleEvent = event_create(destroy_when_idle_event, info, PASSES_PER_SEC(300));
}

void CHARACTER::SetComboSequence(BYTE seq)
{
m_bComboSequence = seq;
}

BYTE CHARACTER::GetComboSequence() const
{
return m_bComboSequence;
}

void CHARACTER::SetLastComboTime(DWORD time)
{
m_dwLastComboTime = time;
}

DWORD CHARACTER::GetLastComboTime() const
{
return m_dwLastComboTime;
}

void CHARACTER::SetValidComboInterval(int interval)
{
m_iValidComboInterval = interval;
}

int CHARACTER::GetValidComboInterval() const
{
return m_iValidComboInterval;
}

BYTE CHARACTER::GetComboIndex() const
{
return m_bComboIndex;
}

void CHARACTER::IncreaseComboHackCount(int k)
{
   m_iComboHackCount += k;
   if (m_iComboHackCount >= 10)
   {
       if (GetJob() == JOB_WOLFMAN && m_iComboHackCount <= 20)
       {
           return;
       }

       if (GetDesc())
       {
           if (GetDesc()->DelayedDisconnect(number(2, 7)))
           {
               sys_log(0, "COMBO_HACK_DISCONNECT: %s count: %d", GetName(), m_iComboHackCount);
               LogManager::instance().HackLog("Combo", this);
           }
       }
   }
}

void CHARACTER::ResetComboHackCount()
{
m_iComboHackCount = 0;
}

void CHARACTER::SkipComboAttackByTime(int interval)
{
m_dwSkipComboAttackByTime = get_dword_time() + interval;
}

DWORD CHARACTER::GetSkipComboAttackByTime() const
{
return m_dwSkipComboAttackByTime;
}

void CHARACTER::ResetChatCounter()
{
m_bChatCounter = 0;
}

BYTE CHARACTER::IncreaseChatCounter()
{
return ++m_bChatCounter;
}

BYTE CHARACTER::GetChatCounter() const
{
return m_bChatCounter;
}

// 말이나 다른것을 타고 있나?
bool CHARACTER::IsRiding() const
{
return IsHorseRiding() || GetMountVnum();
}

bool CHARACTER::CanWarp() const
{
const int iPulse = thecore_pulse();
const int limit_time = PASSES_PER_SEC(g_nPortalLimitTime);

if ((iPulse - GetSafeboxLoadTime()) < limit_time)
return false;

if ((iPulse - GetExchangeTime()) < limit_time)
return false;

if ((iPulse - GetMyShopTime()) < limit_time)
return false;

if ((iPulse - GetRefineTime()) < limit_time)
return false;

if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen())
return false;

return true;
}

DWORD CHARACTER::GetNextExp() const
{
   if (PLAYER_EXP_TABLE_MAX < GetLevel())
       return 2500000000;
   else
       return exp_table[GetLevel()];
}

#ifdef NEW_PET_SYSTEM
DWORD CHARACTER::PetGetNextExp() const
{
   if (IsNewPet()) {
       if (PLAYER_EXP_TABLE_MAX < GetLevel())
           return 2500000000;
       else
           return exppet_table[GetLevel()];
   }
}
#endif

int CHARACTER::GetSkillPowerByLevel(int level, bool bMob) const
{
return CTableBySkill::instance().GetSkillPowerByLevelFromType(GetJob(), GetSkillGroup(), MINMAX(0, level, SKILL_MAX_LEVEL), bMob);
}

void CHARACTER::ban(char* reason2, unsigned int myid2)
{
DWORD myself = GetAID();
char * query = (char*) malloc(sizeof(*query));
snprintf(query, 1024, "UPDATE account.account SET status='BLOCK' WHERE id='%u'", myself);
SQLMsg * msg = DBManager::instance().DirectQuery(query);
if(!msg) {
sys_err("cmd_ban: MySQL Query failed!");
}
free(query);

char * query2 = (char*) malloc(sizeof(*query2));
snprintf(query2, 1024, "INSERT INTO account.ban_list (account, reason, source, date, action) VALUES('%u', '%s', '%u', NOW(), 'ban')", myself, reason2, myid2);
//const char * query2 = "INSERT INTO account.ban_list (account, reason, source) VALUES('%d', '%d', '%s')", GetAID(), myid2, reason2;
SQLMsg * msg2 = DBManager::instance().DirectQuery(query2);
if(!msg2) {
sys_err("cmd_ban: MySQL Query2 failed!");
}
free(query2);
M2_DELETE(query);
M2_DELETE(query2);
M2_DELETE(msg);
M2_DELETE(msg2);
char * resulttxt = (char*) malloc(sizeof(*query2));
snprintf(resulttxt, 1024, "%s %s", LC_TEXT("You were banned! Reason:"), reason2);
ChatPacket(CHAT_TYPE_INFO, resulttxt);
GetDesc()->DelayedDisconnect(3);
M2_DELETE(resulttxt);
}

void CHARACTER::unban(char* name)
{
char * query = (char*) malloc(sizeof(*query));
snprintf(query, 1024, "UPDATE account.account INNER JOIN player.player ON player.account_id=account.id SET status='OK' WHERE player.name='%s'", name);
//snprintf(query, 1024, "UPDATE account.account SET status='OK' WHERE id='%u'", GetAID());
SQLMsg * msg = DBManager::instance().DirectQuery(query);
if(!msg) {
sys_err("cmd_unban: MySQL Query failed!");
}
free(query);

char * query2 = (char*) malloc(sizeof(*query));
snprintf(query2, 1024, "INSERT INTO account.ban_list (account, reason, source, date, action) VALUES(0, '%s', '%u', NOW(), 'unban')", name, GetPlayerID());
//snprintf(query, 1024, "UPDATE account.account SET status='OK' WHERE id='%u'", GetAID());
SQLMsg * msg2 = DBManager::instance().DirectQuery(query2);
if(!msg2) {
sys_err("cmd_unban: MySQL Query failed!");
}
free(query2);
M2_DELETE(query2);
M2_DELETE(msg2);
M2_DELETE(query);
M2_DELETE(msg);
}

void CHARACTER::SetOfflineShopSign(const char * c_szSign)
{
   char szSign[SHOP_SIGN_MAX_LEN + 1];
   strlcpy(szSign, c_szSign, sizeof(szSign));
   m_stOfflineShopSign = szSign;
}

void CHARACTER::DestroyOfflineShop()
{
   DBManager::instance().DirectQuery("DELETE FROM %soffline_shop_npc WHERE owner_id = %u", get_table_postfix(), GetOfflineShopRealOwner());
   LPOFFLINESHOP pkOfflineShop = GetOfflineShop();
   if (pkOfflineShop)
       pkOfflineShop->RemoveAllGuest();
   M2_DESTROY_CHARACTER(this);
}

Zor · November 29, 2017

Ok, search in char.cpp

void CHARACTER::EncodeInsertPacket(LPENTITY entity)

In the fuction change this:

#ifdef NEW_PET_SYSTEM
    if (IsPet() || IsNewPet())
#else

#ifdef ENABLE_MOUNT_SYSTEM
    if (IsPet() || IsMountSystem())
#else
    if (IsPet())
#endif

To:

#ifdef NEW_PET_SYSTEM
    if (IsPet() || IsNewPet())
#else
	if (IsPet())
#endif

#ifdef ENABLE_MOUNT_SYSTEM
    if (IsPet() || IsMountSystem() || IsNewPet())
#else
    if (IsPet())
#endif

Diamondz · November 29, 2017

On 11/29/2017 at 5:12 PM, Zor said:

Ok, search in char.cpp

void CHARACTER::EncodeInsertPacket(LPENTITY entity)

In the fuction change this:


#ifdef NEW_PET_SYSTEM
    if (IsPet() || IsNewPet())
#else

#ifdef ENABLE_MOUNT_SYSTEM
    if (IsPet() || IsMountSystem())
#else
    if (IsPet())
#endif

To:


#ifdef NEW_PET_SYSTEM
    if (IsPet() || IsNewPet())
#else
	if (IsPet())
#endif

#ifdef ENABLE_MOUNT_SYSTEM
    if (IsPet() || IsMountSystem() || IsNewPet())
#else
    if (IsPet())
#endif

now i have this..

Spoiler

In file included from char.cpp:22:
shop_manager.h:40:7: warning: no newline at end of file
In file included from char.cpp:74:
offlineshop_config.h:19:7: warning: no newline at end of file
char.cpp:7955:2: warning: no newline at end of file
char.cpp:5969:1: error: unterminated #else
char.cpp: In member function 'bool CHARACTER::Follow(CHARACTER*, float)':
char.cpp:5973: error: expected statement at end of input
char.cpp:5944: warning: unused variable 'x'
char.cpp:5945: warning: unused variable 'y'
char.cpp:5973: error: expected `}' at end of input
gmake: *** [OBJDIR/char.o] Error 1

Zor · November 30, 2017

Same mistake, problems with the "else", learn to look for them and correct them, it is not difficult.

Diamondz · November 30, 2017

Acum 13 ore, Zor a spus:

Same mistake, problems with the "else", learn to look for them and correct them, it is not difficult.

idk bro , you have skype?

#Dumb

Diamondz · December 1, 2017

#Dumb

Sign In

Help fastt

Recommended Posts

Diamondz 1

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Zor 1

Link to comment

Share on other sites

Diamondz 1

Link to comment

Share on other sites

Zor 1

Link to comment

Share on other sites

Diamondz 1

Link to comment

Share on other sites

Zor 1

Link to comment

Share on other sites

Diamondz 1

Link to comment

Share on other sites

Diamondz 1

Link to comment

Share on other sites

Please sign in to comment

Announcements

Similar Content

Activity

Recently Browsing

Important Information