frogen1145

March 25, 2019

2 minuty temu, WeedHex napisał:

You don't even have a clue what you do.

Ctrl+V without thinking.

Ehh will you help me or not ?? That's why I'm here mate for short explanation how to fix the problem.

Thanks

March 25, 2019

1 godzinę temu, WeedHex napisał:

Please show your game.py it's a problem of bad position of codes.

I solved this problem now. But is there any chance that you can help with source code ?? as below:

Cytat

char.cpp:7230: warning: this decimal constant is unsigned only in ISO C90
char.cpp: In member function 'int CHARACTER::GetPolymorphPoint(BYTE) const':
char.cpp:2880: warning: suggest parentheses around && within ||
char.cpp: In member function 'void CHARACTER::PointChange(BYTE, int, bool, bool)':
char.cpp:3088: warning: comparison between signed and unsigned integer expressions
char.cpp: In member function 'void CHARACTER::SetTarget(CHARACTER*)':
char.cpp:5103: warning: suggest parentheses around && within ||
char.cpp: In member function 'bool CHARACTER::CanSummon(int)':
char.cpp:6284: warning: suggest parentheses around && within ||
char.cpp: In member function 'int CHARACTER::GetBiologState(const std::string&) const':
char.cpp:6290: error: 'pPC' was not declared in this scope
char.cpp:6289: warning: unused variable 'q'
../../../Extern/include/cryptopp/cryptlib.h: In member function 'bool CryptoPP::NameValuePairs::GetValue(const char*, T&) const [with T = std::string]':
../../../Extern/include/cryptopp/cryptlib.h:277: instantiated from here
../../../Extern/include/cryptopp/cryptlib.h:264: warning: dereferencing type-punned pointer will break strict-aliasing rules
../../../Extern/include/cryptopp/cryptlib.h: In member function 'bool CryptoPP::NameValuePairs::GetValue(const char*, T&) const [with T = int]':
../../../Extern/include/cryptopp/cryptlib.h:283: instantiated from here
../../../Extern/include/cryptopp/cryptlib.h:264: warning: dereferencing type-punned pointer will break strict-aliasing rules
gmake: *** [Makefile:133: OBJDIR/char.o] Error 1
gmake: *** Waiting for unfinished jobs....

My char.cpp :

Cytat

#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"

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

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_bNoOpenedShop = true;

   m_bOpeningSafebox = false;

   m_fSyncTime = get_float_time()-3;
   m_dwPlayerID = 0;
   m_dwKillerPID = 0;

   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;

   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_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_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

   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

   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;
   }

   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_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();

   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();

   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;
   }

   // ÁřÇŕÁßŔÎ Äů˝şĆ®°ˇ ŔÖŔ¸¸é »óÁˇŔ» ż Ľö ľř´Ů.
   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();
   if (IsPet())
   {
       pack.bMovingSpeed   = 150;
   }
   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.bPKMode = m_bPKMode;
       addPacket.dwMountVnum = GetMountVnum();
       addPacket.bEmpire = m_bEmpire;

       if (IsPC() == true && (LC_IsEurope() == true || LC_IsCanada() == true || LC_IsSingapore() == true))
       {
           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));
   }

   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.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;
   pack.bPKMode   = m_bPKMode;

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

   pack.dwMountVnum   = GetMountVnum();

   pack2 = pack;
   pack2.dwGuildID = 0;
   pack2.sAlignment = 0;

   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);
   }
   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);
   }

   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 (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));
}

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;

       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]);

   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
}

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
}

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;
           // lev + con
           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));

       //
       // ±âş» ATK = 2lev + 2str, Á÷ľ÷żˇ ¸¶´Ů 2strŔş ąŮ˛đ Ľö ŔÖŔ˝
       //
       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;

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

       // ¸»Ŕ» Ĺ¸°í ŔÖ°í, ˝şĹČŔ¸·Î ŔÎÇŃ °ř°Ý·ÂŔĚ ST*2 ş¸´Ů ł·Ŕ¸¸é ST*2·Î ÇŃ´Ů.
       // ˝şĹČŔ» Ŕß¸ř ÂďŔş »ç¶÷ °ř°Ý·ÂŔĚ ´ő ł·Áö ľĘ°Ô ÇĎ±â Ŕ§ÇŘĽ´Ů.
       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;
           }
       }

       //
       // ATK Setting
       //
       iAtk += GetPoint(POINT_ATT_GRADE_BONUS);

       PointChange(POINT_ATT_GRADE, iAtk);

       // DEF = LEV + CON + ARMOR
       int iShowDef = GetLevel() + GetPoint(POINT_HT); // For Ymir(Ăµ¸¶)
       int iDef = GetLevel() + (int) (GetPoint(POINT_HT) / 1.25); // For Other
       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);

       // INTERNATIONAL_VERSION
       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));
       }
       // END_OF_INTERNATIONAL_VERSION

       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
   {
       // 2lev + str * 2
       int iAtt = GetLevel() * 2 + GetPoint(POINT_ST) * 2;
       // lev + con
       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));

   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();
   }

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

   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))
           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)
       {
           // Áßµ¶ŔÎ °ćżě ŔÚµżČ¸şą ±ÝÁö
           // ĆÄąýĽúŔÎ °ćżě ŔÚµżČ¸şą ±ÝÁö
           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;
       }
   }
   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, "%s: GOTO: distance %f, spd %u, duration %u, motion speed %f pos %d %d -> %d %d",
               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;   // ą«Á¶°Ç 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());
                   }
               }

               // exp°ˇ 0 ŔĚÇĎ·Î °ˇÁö ľĘµµ·Ď ÇŃ´Ů
               if (amount < 0 && exp < -amount)
               {
                   sys_log(1, "%s AMOUNT < 0 %d, CUR EXP: %d", GetName(), -amount, exp);
                   amount = -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);

                   // iLevStepŔĚ 4 ŔĚ»óŔĚ¸é ·ąş§ŔĚ żĂ¶úľîľß ÇĎąÇ·Î ż©±âżˇ żĂ Ľö ľř´Â °ŞŔĚ´Ů.
                   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() < 100) PointChange(POINT_STAT, 1);
                       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)
               {
                   // Stamina°ˇ ľřŔ¸´Ď °ČŔÚ!
                   SetNowWalking(true);
               }
               else if (prev_val == 0)
               {
                   // ľř´ř ˝şĹ×ąĚłŞ°ˇ »ý°ĺŔ¸´Ď ŔĚŔü ¸đµĺ şą±Í
                   ResetWalking();
               }

               if (amount < 0 && val != 0) // °¨ĽŇ´Â ş¸ł»ÁöľĘ´Â´Ů.
                   return;
           }
           break;

       case POINT_MAX_HP:
           {
               SetPoint(type, GetPoint(type) + amount);

               //SetMaxHP(GetMaxHP() + 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);

               //SetMaxSP(GetMaxSP() + 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:   // 42 ŔÎ°Łżˇ°Ô °ÇÔ
       case POINT_ATTBONUS_ANIMAL:   // 43 µżą°żˇ°Ô µĄąĚÁö % Áő°ˇ
       case POINT_ATTBONUS_ORC:       // 44 żő±Íżˇ°Ô µĄąĚÁö % Áő°ˇ
       case POINT_ATTBONUS_MILGYO:   // 45 ąĐ±łżˇ°Ô µĄąĚÁö % Áő°ˇ
       case POINT_ATTBONUS_UNDEAD:   // 46 ˝ĂĂĽżˇ°Ô µĄąĚÁö % Áő°ˇ
       case POINT_ATTBONUS_DEVIL:   // 47 ¸¶±Í(ľÇ¸¶)żˇ°Ô µĄąĚÁö % Áő°ˇ

       case POINT_ATTBONUS_MONSTER:
       case POINT_ATTBONUS_SURA:
       case POINT_ATTBONUS_ASSASSIN:
       case POINT_ATTBONUS_WARRIOR:
       case POINT_ATTBONUS_SHAMAN:

       case POINT_POISON_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:       // 48 »ý¸í·Â ČíĽö
       case POINT_STEAL_SP:       // 49 Á¤˝Ĺ·Â ČíĽö

       case POINT_MANA_BURN_PCT:   // 50 ¸¶łŞ ąř
       case POINT_DAMAGE_SP_RECOVER:   // 51 °ř°Ý´çÇŇ ˝Ă Á¤˝Ĺ·Â Č¸şą Č®·ü
       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_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:   // 67 °ř°Ý ąÝ»ç
       case POINT_REFLECT_CURSE:   // 68 ŔúÁÖ ąÝ»ç
       case POINT_POISON_REDUCE:   // 69 µ¶µĄąĚÁö °¨ĽŇ
       case POINT_KILL_SP_RECOVER:   // 70 Ŕű ĽŇ¸ę˝Ă MP Č¸şą
       case POINT_KILL_HP_RECOVERY:   // 75
       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:

           // DEPEND_BONUS_ATTRIBUTES
       case POINT_SKILL_DEFEND_BONUS:
       case POINT_NORMAL_HIT_DEFEND_BONUS:
           SetPoint(type, GetPoint(type) + amount);
           val = GetPoint(type);
           break;
           // END_OF_DEPEND_BONUS_ATTRIBUTES

       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 :

           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 > 100)
           {
               sys_err("MALL_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;

           // PC_BANG_ITEM_ADD
       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;
           // END_PC_BANG_ITEM_ADD

       case POINT_EXP_DOUBLE_BONUS:   // 71
       case POINT_GOLD_DOUBLE_BONUS:   // 72
       case POINT_ITEM_DROP_BONUS:   // 73
       case POINT_POTION_BONUS:   // 74
           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:       // 76
           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:       // 77
           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:   // 78
           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:
           //sys_err("CHARACTER::PointChange: %s: point cannot be changed. use SetPoint instead (type: %d)", GetName(), type);
           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));
   }
}

void CHARACTER::ApplyPoint(BYTE bApplyType, int iVal)
{
   switch (bApplyType)
   {
       case APPLY_NONE:           // 0
           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:
           // SKILL_DAMAGE_BONUS
           {
               // ĂÖ»óŔ§ şńĆ® ±âÁŘŔ¸·Î 8şńĆ® vnum, 9şńĆ® add, 15şńĆ® change
               // 00000000 00000000 00000000 00000000
               // ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
               // vnum ^ add change
               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;
           }
           // END_OF_SKILL_DAMAGE_BONUS
           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_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:   // 59
       case APPLY_ATTBONUS_ASSASSIN:   // 60
       case APPLY_ATTBONUS_SURA:   // 61
       case APPLY_ATTBONUS_SHAMAN:   // 62
       case APPLY_ATTBONUS_MONSTER:   // 63
       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_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:

           // DEPEND_BONUS_ATTRIBUTES
       case APPLY_SKILL_DEFEND_BONUS:
       case APPLY_NORMAL_HIT_DEFEND_BONUS:
           // END_OF_DEPEND_BONUS_ATTRIBUTES

       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:                   // 82 ±â·Â
       case APPLY_DEF_GRADE:               // 83 ąćľî·Â. DEF_GRADE_BONUS´Â Ĺ¬¶óżˇĽ µÎąč·Î ş¸ż©Áö´Â ŔÇµµµČ ąö±×(...)°ˇ ŔÖ´Ů.
       case APPLY_COSTUME_ATTR_BONUS:       // 84 ÄÚ˝şĆ¬ ľĆŔĚĹŰżˇ şŮŔş ĽÓĽşÄˇ ş¸łĘ˝ş
       case APPLY_MAGIC_ATTBONUS_PER:       // 85 ¸¶ąý °ř°Ý·Â +x%
       case APPLY_MELEE_MAGIC_ATTBONUS_PER:           // 86 ¸¶ąý + ąĐ¸® °ř°Ý·Â +x%
           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::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()) // PC°ˇ ľĆ´Ń °ćżě ÇöŔç ĆÄĆ®¸¦ ±×´ë·Î ¸®ĹĎ
               return GetPart(PART_MAIN);
           else
               return m_pointsInstant.bBasePart;

       case PART_HAIR:
           return GetPart(PART_HAIR);

       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_REVIVE_INVISIBLE))
           RemoveAffect(AFFECT_REVIVE_INVISIBLE);

       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())
                   {
                       pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´Ů¸Ą °Ĺ·ˇÁß(Ă˘°í,±łČŻ,»óÁˇ)żˇ´Â °łŔÎ»óÁˇŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
                       return;
                   }
               }
               else // ´Ů¸Ą »ç¶÷ŔĚ Ĺ¬¸ŻÇßŔ»¶§
               {
                   // Ĺ¬¸ŻÇŃ »ç¶÷ŔĚ ±łČŻ/Ă˘°í/°łŔÎ»óÁˇ/»óÁˇŔĚżëÁßŔĚ¶ó¸é şŇ°ˇ
                   if ((pkChrCauser->GetExchange() || pkChrCauser->IsOpenSafebox() || pkChrCauser->GetMyShop() || pkChrCauser->GetShopOwner()) || pkChrCauser->IsCubeOpen() )
                   {
                       pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´Ů¸Ą °Ĺ·ˇÁß(Ă˘°í,±łČŻ,»óÁˇ)żˇ´Â °łŔÎ»óÁˇŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
                       return;
                   }

                   // Ĺ¬¸ŻÇŃ ´ë»óŔĚ ±łČŻ/Ă˘°í/»óÁˇŔĚżëÁßŔĚ¶ó¸é şŇ°ˇ
                   //if ((GetExchange() || IsOpenSafebox() || GetShopOwner()))
                   if ((GetExchange() || IsOpenSafebox() || IsCubeOpen()))
                   {
                       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;
       }
   }

   // Ă»ĽŇłâŔş Äů˝şĆ® ¸řÇÔ
   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;

   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;

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

   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();

       if (m_pkChrTarget->IsPC() && !m_pkChrTarget->IsPolymorphed() || m_pkChrTarget->GetMaxHP() <= 0)
           p.bHPPercent = 0;
       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);
                   else
                       p.bHPPercent = 100;
               }
               else
                   p.bHPPercent = 100;
           }
           else
               p.bHPPercent = MINMAX(0, (m_pkChrTarget->GetHP() * 100) / m_pkChrTarget->GetMaxHP(), 100);
       }
   }
   else
   {
       p.dwVID = 0;
       p.bHPPercent = 0;
   }

   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 (IsPC())
       p.bHPPercent = 0;
   else
       p.bHPPercent = MINMAX(0, (GetHP() * 100) / GetMaxHP(), 100);

   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))
   {
       // ŔĚ °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľřŔ¸ąÇ·Î żöÇÁÇĎ±â Ŕü ÁÂÇĄ·Î µÇµą¸®ŔÚ.
       sys_err("location %d %d not allowed to login this server", m_posWarp.x, m_posWarp.y);
       GetDesc()->SetPhase(PHASE_CLOSE);
       return;
   }

   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;
   }

   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, 99) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));
   PointChange(POINT_STAT, ((MINMAX(1, iLv, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - 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
       {
           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);
}

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();
   for (int i = 0; i<WEAR_MAX_NUM; i++)
   {
       LPITEM item = GetWear(i);
       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());
}
#ifdef ENABLE_BIOLOG_SYSTEM
int CHARACTER::GetBiologState(const std::string& state) const
{
   quest::CQuestManager& q = quest::CQuestManager::instance();
   return pPC->GetFlag(state);
}

void CHARACTER::SetBiologState(const std::string& state, int szValue)
{
   quest::CQuestManager& q = quest::CQuestManager::instance();
   quest::PC* pPC = q.GetPC(GetPlayerID());
   pPC->SetFlag(state, szValue);
}
#endif

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())
       {
           if (bSendMsg)
               ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Ĺ·ˇĂ˘,Ă˘°í µîŔ» ż¬ »óĹÂżˇĽ´Â ´Ů¸Ą°÷Ŕ¸·Î ŔĚµż,Áľ·á ÇŇĽö ľř˝Ŕ´Ď´Ů"));

           return true;
       }
   }
   else
   {
       if (GetExchange() || GetMyShop() || IsOpenSafebox() || IsCubeOpen())
       {
           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:
           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)

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 (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())
       return false;

   return true;
}

DWORD CHARACTER::GetNextExp() const
{
   if (PLAYER_EXP_TABLE_MAX < GetLevel())
       return 2500000000;
   else
       return exp_table[GetLevel()];
}

int   CHARACTER::GetSkillPowerByLevel(int level, bool bMob) const
{
   return CTableBySkill::instance().GetSkillPowerByLevelFromType(GetJob(), GetSkillGroup(), MINMAX(0, level, SKILL_MAX_LEVEL), bMob);
}

March 25, 2019

Hi guys,

is there anyone who can help me out with this error ? please my sysser below

Cytat

0325 15:39:14284 :: Traceback (most recent call last):

0325 15:39:14284 :: File "networkModule.py", line 247, in SetGamePhase

0325 15:39:14284 :: File "game.py", line 127, in __init__

0325 15:39:14284 :: File "game.py", line 1858, in __ServerCommand_Build

0325 15:39:14285 :: AttributeError
0325 15:39:14285 :: :
0325 15:39:14285 :: 'GameWindow' object has no attribute 'serverCommander'
0325 15:39:14285 ::

Much appreciate for your help !

July 20, 2016

this is a presentation of server? .. LOL

July 8, 2016

Hello today I added new costume to the server but I can't see them in the game, anyone got any idea how I can fix this? Also I added new lines in the warrior_m.msm using one model GR2 but different textures and number. I added everything to the client also to the databases.

Some ideas? thank you

this is my msm:

Spoiler

   Group ShapeData154
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40190
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin22.dds"
       TargetSkin           "warrior_assasin22.dds"
   }
   Group ShapeData155
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40191
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin33.dds"
       TargetSkin           "warrior_assasin33.dds"
   }
   Group ShapeData156
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40192
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin44.dds"
       TargetSkin           "warrior_assasin44.dds"
   }
   Group ShapeData157
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40193
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin55.dds"
       TargetSkin           "warrior_assasin55.dds"
   }

and screenshot from the game: ( and the is a bottle because I didn't add an icon yet )

Spoiler

July 8, 2016

Hello today I added new costume, but I can't see then in the game. I add new linies in warrior_m.msm item_proto client and server , but I can't see it in the game.

I'm using only one model gr2 but few colours this is my msm:

Spoiler

   Group ShapeData154
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40190
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin22.dds"
       TargetSkin           "warrior_assasin22.dds"
   }
   Group ShapeData155
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40191
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin33.dds"
       TargetSkin           "warrior_assasin33.dds"
   }
   Group ShapeData156
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40192
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin44.dds"
       TargetSkin           "warrior_assasin44.dds"
   }
   Group ShapeData157
   {

       SpecialPath           "d:/ymir Work/pc/warrior/"

       ShapeIndex           40193
       Model               "warrior_assasin1.GR2"
       SourceSkin           "warrior_assasin55.dds"
       TargetSkin           "warrior_assasin55.dds"
   }

Any one know how to fix it ? thank you.

July 5, 2016

4 minutes ago, Thorer said:

uiquest.py

Here i think

   def OnUpdate(self):
       if self.skin == self.SKIN_CINEMA:
           event.UpdateEventSet(self.descIndex, 50, -(wndMgr.GetScreenHeight() - 44))

       # AUTO_RESIZE_BOARD
       elif self.skin == 3:
           if self.board:
               event.UpdateEventSet(self.descIndex, self.board.GetGlobalPosition()[0]+20+self.sx, -self.board.GetGlobalPosition()[1]-20-self.sy)
               event.SetEventSetWidth(self.descIndex, self.board.GetWidth()-40)
       elif self.skin:
           if self.board:
               event.UpdateEventSet(self.descIndex, self.board.GetGlobalPosition()[0]+20, -self.board.GetGlobalPosition()[1]-20)
               event.SetEventSetWidth(self.descIndex, self.board.GetWidth()-40)

Okey and how do I need to edit it ? please

EDIT: OK THANK YOU I CHANGED THE VALUE AND IT'S WORKING NOW

July 5, 2016

2 minutes ago, Thorer said:

I mean, fix this.

Ohhh okey , It's fixed now.

July 5, 2016

22 minutes ago, Thorer said:

Fix image.

Image was fixed many times .. and always text align auto to the left side :/ .

July 5, 2016

#REF

July 4, 2016

check the py file , where you got the Channels switch .. in root or uiscript

July 4, 2016

Hello ,

Today I added new weapon to my server, but I can't see it in game.. The weapon is Granny 2.6 and my Granny is 2.9. so the question is: ' how can I update the weapon model from 2.6 to 2.9 ' ?

Thank you

June 28, 2016

Hello could any one help me to align a quest text on board? I trying for 3 days now I don't know how to do it. ( I want to have it in the box not out of the box )

Spoiler

Please help me with it

thank you

June 26, 2016

Hello, how I can change the quest text position ?? to be in the box not out of the box ? SS below thank you :

Spoiler

June 25, 2016

29 minutes ago, arves100 said:

nop they're differen. but you can try MeldMerge to check easy the packet ^^

Where can I find the MeldMerge? and how to do it please

29 minutes ago, arves100 said:

nop they're differen. but you can try MeldMerge to check easy the packet ^^

I used this MeldMerge but I dont' know how to use and how to check it if it's got same packet.h :/

Spoiler

June 25, 2016

13 minutes ago, arves100 said:

Check if packets are the same (packet.h)

There is a lot of lines to check ? or need to find only one .. and can I cpy whole packet from client to packet game?

thanks

June 25, 2016

29 minutes ago, arves100 said:

You have to use mainline_sg for server and novaline for client

Okey so I was trying to Compile Binrary from the Novaline and Boom :

Spoiler

Error   273   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   900   1   UserInterface
Error   275   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   919   1   UserInterface
Error   280   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1294   1   UserInterface
Error   281   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1340   1   UserInterface
Error   282   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1393   1   UserInterface
Error   283   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1456   1   UserInterface
Error   284   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1531   1   UserInterface
Error   285   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1616   1   UserInterface
Error   286   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1673   1   UserInterface
Error   287   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1713   1   UserInterface
Error   288   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1976   1   UserInterface
Error   289   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   2017   1   UserInterface
Error   329   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonShop.cpp   330   1   UserInterface
Error   330   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonShop.cpp   348   1   UserInterface
Error   331   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonShop.cpp   360   1   UserInterface
Error   332   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonShop.cpp   387   1   UserInterface
Error   333   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonShop.cpp   396   1   UserInterface
Error   452   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   953   1   UserInterface
Error   453   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   1222   1   UserInterface
Error   454   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   1254   1   UserInterface
Error   455   error C2665: 'PyTuple_GetInteger' : none of the 3 overloads could convert all the argument types   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   1303   1   UserInterface
Error   404   error C2664: 'int lzo1x_decompress_safe(const unsigned char *,lzo_uint,unsigned char *,lzo_uint *,void *)' : cannot convert argument 1 from 'const char *' to 'const unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\MarkImage.cpp   190   1   UserInterface
Error   405   error C2664: 'int lzo1x_999_compress(const unsigned char *,lzo_uint,unsigned char *,lzo_uint *,void *)' : cannot convert argument 1 from 'const char *' to 'const unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\MarkImage.cpp   305   1   UserInterface
Error   268   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   770   1   UserInterface
Error   269   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   774   1   UserInterface
Error   270   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   812   1   UserInterface
Error   271   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   842   1   UserInterface
Error   272   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   873   1   UserInterface
Error   274   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   912   1   UserInterface
Error   276   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   958   1   UserInterface
Error   277   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   991   1   UserInterface
Error   278   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1021   1   UserInterface
Error   279   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   1083   1   UserInterface
Error   290   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   2130   1   UserInterface
Error   291   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonPlayerModule.cpp   2152   1   UserInterface
Error   444   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   678   1   UserInterface
Error   445   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   706   1   UserInterface
Error   446   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   712   1   UserInterface
Error   447   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   736   1   UserInterface
Error   448   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   765   1   UserInterface
Error   449   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   821   1   UserInterface
Error   450   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   825   1   UserInterface
Error   451   error C2664: 'bool PyTuple_GetByte(PyObject *,int,unsigned char *)' : cannot convert argument 3 from 'char *' to 'unsigned char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonNetworkStreamModule.cpp   871   1   UserInterface
Error   199   error C2664: 'bool CPythonGraphic::SaveJPEG(const char *,LPBYTE,UINT,UINT)' : cannot convert argument 2 from 'char *' to 'LPBYTE'   C:\project\xxxxl\xxx2\Client\eterPythonLib\PythonGraphic.cpp   294   1   eterPythonLib
Error   184   error C2660: 'GrannyUpdateModelMatrix' : function does not take 4 arguments   C:\project\xxxxl\xxx2\Client\eterGrnLib\ModelInstanceUpdate.cpp   50   1   eterGrnLib
Error   179   error C2660: 'GrannyNewMeshDeformer' : function does not take 3 arguments   C:\project\xxxxl\xxx2\Client\eterGrnLib\Mesh.cpp   139   1   eterGrnLib
Error   175   error C2660: 'GrannyFindMatchingMember' : function does not take 3 arguments   C:\project\xxxxl\xxx2\Client\eterGrnLib\Material.cpp   250   1   eterGrnLib
Error   176   error C2660: 'GrannyConvertSingleObject' : function does not take 4 arguments   C:\project\xxxxl\xxx2\Client\eterGrnLib\Material.cpp   253   1   eterGrnLib
Error   178   error C2440: 'return' : cannot convert from 'const granny_int32x *' to 'int *'   C:\project\xxxxl\xxx2\Client\eterGrnLib\Mesh.cpp   105   1   eterGrnLib
Error   182   error C2440: 'return' : cannot convert from 'const granny_int32x *' to 'int *'   C:\project\xxxxl\xxx2\Client\eterGrnLib\ModelInstanceModel.cpp   80   1   eterGrnLib
Error   177   error C2440: 'initializing' : cannot convert from 'const granny_int32x *' to 'int *'   C:\project\xxxxl\xxx2\Client\eterGrnLib\Mesh.cpp   59   1   eterGrnLib
Error   217   error C2440: 'initializing' : cannot convert from 'CAffectFlagContainer::Element' to 'char &'   C:\project\xxxxl\xxx2\Client\UserInterface\AffectFlagContainer.cpp   68   1   UserInterface
Error   358   error C2440: 'initializing' : cannot convert from 'byte *' to 'char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonApplicationLogo.cpp   122   1   UserInterface
Error   360   error C2440: 'initializing' : cannot convert from 'byte *' to 'char *'   C:\project\xxxxl\xxx2\Client\UserInterface\PythonApplicationLogo.cpp   166   1   UserInterface
Error   518   error C2440: '=' : cannot convert from 'void (__cdecl *)(granny_log_message_type,granny_log_message_origin,const char *,void *)' to 'granny_log_function (__cdecl *)'   C:\project\xxxxl\xxx2\Client\UserInterface\UserInterface.cpp   719   1   UserInterface
Error   398   error C2065: 'ILvoid' : undeclared identifier   C:\project\xxxxl\xxx2\Client\UserInterface\GuildMarkUploader.cpp   100   1   UserInterface
Error   399   error C2059: syntax error : ')'   C:\project\xxxxl\xxx2\Client\UserInterface\GuildMarkUploader.cpp   100   1   UserInterface

Any IDEA?

June 25, 2016

Hello I compiled Binrary code 40k with source game 40k and there is eRRoR load the game . :/

if anyone know how to fix it will be great thank you

Client SYSSER:

Spoiler

0625 13:04:25716 :: Unknown packet header: 100, last: 32 17
0625 13:04:25731 :: Unknown packet header: 100, last: 32 17
0625 13:04:25749 :: Unknown packet header: 100, last: 32 17
0625 13:04:25764 :: Unknown packet header: 100, last: 32 17
0625 13:04:25781 :: Unknown packet header: 100, last: 32 17
0625 13:04:25797 :: Unknown packet header: 100, last: 32 17
0625 13:04:25814 :: Unknown packet header: 100, last: 32 17
0625 13:04:25830 :: Unknown packet header: 100, last: 32 17
0625 13:04:25847 :: Unknown packet header: 100, last: 32 17
0625 13:04:25864 :: Unknown packet header: 100, last: 32 17
0625 13:04:25881 :: Unknown packet header: 100, last: 32 17
0625 13:04:25896 :: Unknown packet header: 100, last: 32 17
0625 13:04:25913 :: Unknown packet header: 100, last: 32 17
0625 13:04:25930 :: Unknown packet header: 100, last: 32 17
0625 13:04:25947 :: Unknown packet header: 100, last: 32 17
0625 13:04:25963 :: Unknown packet header: 100, last: 32 17
0625 13:04:25979 :: Unknown packet header: 100, last: 32 17
0625 13:04:25996 :: Unknown packet header: 100, last: 32 17
0625 13:04:26013 :: Unknown packet header: 100, last: 32 17
0625 13:04:26029 :: Unknown packet header: 100, last: 32 17
0625 13:04:26046 :: Unknown packet header: 100, last: 32 17
0625 13:04:26062 :: Unknown packet header: 100, last: 32 17
0625 13:04:26078 :: Unknown packet header: 100, last: 32 17
0625 13:04:26094 :: Unknown packet header: 100, last: 32 17
0625 13:04:26113 :: Unknown packet header: 100, last: 32 17
0625 13:04:26128 :: Unknown packet header: 100, last: 32 17
0625 13:04:26144 :: Unknown packet header: 100, last: 32 17
0625 13:04:26160 :: Unknown packet header: 100, last: 32 17
0625 13:04:26178 :: Unknown packet header: 100, last: 32 17
0625 13:04:26194 :: Unknown packet header: 100, last: 32 17
0625 13:04:26210 :: Unknown packet header: 100, last: 32 17
0625 13:04:26227 :: Unknown packet header: 100, last: 32 17
0625 13:04:26243 :: Unknown packet header: 100, last: 32 17
0625 13:04:26259 :: Unknown packet header: 100, last: 32 17
0625 13:04:26277 :: Unknown packet header: 100, last: 32 17
0625 13:04:26293 :: Unknown packet header: 100, last: 32 17
0625 13:04:26310 :: Unknown packet header: 100, last: 32 17
0625 13:04:26326 :: Unknown packet header: 100, last: 32 17
0625 13:04:26343 :: Unknown packet header: 100, last: 32 17
0625 13:04:26358 :: Unknown packet header: 100, last: 32 17
0625 13:04:26376 :: Unknown packet header: 100, last: 32 17
0625 13:04:26391 :: Unknown packet header: 100, last: 32 17
0625 13:04:26408 :: Unknown packet header: 100, last: 32 17
0625 13:04:26424 :: Unknown packet header: 100, last: 32 17
0625 13:04:26441 :: Unknown packet header: 100, last: 32 17
0625 13:04:26457 :: Unknown packet header: 100, last: 32 17
0625 13:04:26474 :: Unknown packet header: 100, last: 32 17
0625 13:04:26492 :: Unknown packet header: 100, last: 32 17
0625 13:04:26507 :: Unknown packet header: 100, last: 32 17
0625 13:04:26523 :: Unknown packet header: 100, last: 32 17
0625 13:04:26540 :: Unknown packet header: 100, last: 32 17
0625 13:04:26556 :: Unknown packet header: 100, last: 32 17
0625 13:04:26574 :: Unknown packet header: 100, last: 32 17
0625 13:04:26589 :: Unknown packet header: 100, last: 32 17
0625 13:04:26606 :: Unknown packet header: 100, last: 32 17
0625 13:04:26622 :: Unknown packet header: 100, last: 32 17
0625 13:04:26639 :: Unknown packet header: 100, last: 32 17
0625 13:04:26655 :: Unknown packet header: 100, last: 32 17
0625 13:04:26673 :: Unknown packet header: 100, last: 32 17
0625 13:04:26689 :: Unknown packet header: 100, last: 32 17
0625 13:04:26706 :: Unknown packet header: 100, last: 32 17
0625 13:04:26722 :: Unknown packet header: 100, last: 32 17
0625 13:04:26739 :: Unknown packet header: 100, last: 32 17
0625 13:04:26754 :: Unknown packet header: 100, last: 32 17
0625 13:04:26772 :: Unknown packet header: 100, last: 32 17
0625 13:04:26788 :: Unknown packet header: 100, last: 32 17
0625 13:04:26805 :: Unknown packet header: 100, last: 32 17
0625 13:04:26821 :: Unknown packet header: 100, last: 32 17
0625 13:04:26837 :: Unknown packet header: 100, last: 32 17
0625 13:04:26854 :: Unknown packet header: 100, last: 32 17
0625 13:04:26871 :: Unknown packet header: 100, last: 32 17
0625 13:04:26887 :: Unknown packet header: 100, last: 32 17
0625 13:04:26903 :: Unknown packet header: 100, last: 32 17
0625 13:04:26919 :: Unknown packet header: 100, last: 32 17
0625 13:04:26937 :: Unknown packet header: 100, last: 32 17
0625 13:04:26953 :: Unknown packet header: 100, last: 32 17
0625 13:04:26970 :: Unknown packet header: 100, last: 32 17
0625 13:04:26985 :: Unknown packet header: 100, last: 32 17
0625 13:04:27002 :: Unknown packet header: 100, last: 32 17
0625 13:04:27018 :: Unknown packet header: 100, last: 32 17
0625 13:04:27036 :: Unknown packet header: 100, last: 32 17
0625 13:04:27052 :: Unknown packet header: 100, last: 32 17
0625 13:04:27069 :: Unknown packet header: 100, last: 32 17
0625 13:04:27084 :: Unknown packet header: 100, last: 32 17
0625 13:04:27102 :: Unknown packet header: 100, last: 32 17
0625 13:04:27118 :: Unknown packet header: 100, last: 32 17
0625 13:04:27135 :: Unknown packet header: 100, last: 32 17
0625 13:04:27150 :: Unknown packet header: 100, last: 32 17
0625 13:04:27167 :: Unknown packet header: 100, last: 32 17
0625 13:04:27184 :: Unknown packet header: 100, last: 32 17
0625 13:04:27201 :: Unknown packet header: 100, last: 32 17
0625 13:04:27217 :: Unknown packet header: 100, last: 32 17
0625 13:04:27234 :: Unknown packet header: 100, last: 32 17
0625 13:04:27249 :: Unknown packet header: 100, last: 32 17
0625 13:04:27267 :: Unknown packet header: 100, last: 32 17
0625 13:04:27282 :: Unknown packet header: 100, last: 32 17
0625 13:04:27299 :: Unknown packet header: 100, last: 32 17
0625 13:04:27316 :: Unknown packet header: 100, last: 32 17
0625 13:04:27333 :: Unknown packet header: 100, last: 32 17
0625 13:04:27348 :: Unknown packet header: 100, last: 32 17
0625 13:04:27365 :: Unknown packet header: 100, last: 32 17
0625 13:04:27382 :: Unknown packet header: 100, last: 32 17
0625 13:04:27398 :: Unknown packet header: 100, last: 32 17
0625 13:04:27414 :: Unknown packet header: 100, last: 32 17
0625 13:04:27431 :: Unknown packet header: 100, last: 32 17
0625 13:04:27448 :: Unknown packet header: 100, last: 32 17
0625 13:04:27464 :: Unknown packet header: 100, last: 32 17
0625 13:04:27480 :: Unknown packet header: 100, last: 32 17
0625 13:04:27497 :: Unknown packet header: 100, last: 32 17
0625 13:04:27513 :: Unknown packet header: 100, last: 32 17
0625 13:04:27530 :: Unknown packet header: 100, last: 32 17
0625 13:04:27546 :: Unknown packet header: 100, last: 32 17
0625 13:04:27564 :: Unknown packet header: 100, last: 32 17
0625 13:04:27580 :: Unknown packet header: 100, last: 32 17
0625 13:04:27597 :: Unknown packet header: 100, last: 32 17
0625 13:04:27612 :: Unknown packet header: 100, last: 32 17
0625 13:04:27630 :: Unknown packet header: 100, last: 32 17
0625 13:04:27645 :: Unknown packet header: 100, last: 32 17
0625 13:04:27662 :: Unknown packet header: 100, last: 32 17
0625 13:04:27678 :: Unknown packet header: 100, last: 32 17
0625 13:04:27695 :: Unknown packet header: 100, last: 32 17
0625 13:04:27711 :: Unknown packet header: 100, last: 32 17
0625 13:04:27728 :: Unknown packet header: 100, last: 32 17
0625 13:04:27745 :: Unknown packet header: 100, last: 32 17
0625 13:04:27761 :: Unknown packet header: 100, last: 32 17
0625 13:04:27777 :: Unknown packet header: 100, last: 32 17
0625 13:04:27795 :: Unknown packet header: 100, last: 32 17
0625 13:04:27810 :: Unknown packet header: 100, last: 32 17
0625 13:04:27827 :: Unknown packet header: 100, last: 32 17
0625 13:04:27843 :: Unknown packet header: 100, last: 32 17
0625 13:04:27860 :: Unknown packet header: 100, last: 32 17
0625 13:04:27877 :: Unknown packet header: 100, last: 32 17
0625 13:04:27894 :: Unknown packet header: 100, last: 32 17
0625 13:04:27909 :: Unknown packet header: 100, last: 32 17
0625 13:04:27926 :: Unknown packet header: 100, last: 32 17
0625 13:04:27942 :: Unknown packet header: 100, last: 32 17
0625 13:04:27959 :: Unknown packet header: 100, last: 32 17
0625 13:04:27975 :: Unknown packet header: 100, last: 32 17
0625 13:04:27992 :: Unknown packet header: 100, last: 32 17
0625 13:04:28008 :: Unknown packet header: 100, last: 32 17
0625 13:04:28025 :: Unknown packet header: 100, last: 32 17
0625 13:04:28041 :: Unknown packet header: 100, last: 32 17
0625 13:04:28058 :: Unknown packet header: 100, last: 32 17
0625 13:04:28074 :: Unknown packet header: 100, last: 32 17
0625 13:04:28091 :: Unknown packet header: 100, last: 32 17
0625 13:04:28107 :: Unknown packet header: 100, last: 32 17
0625 13:04:28124 :: Unknown packet header: 100, last: 32 17
0625 13:04:28140 :: Unknown packet header: 100, last: 32 17
0625 13:04:28157 :: Unknown packet header: 100, last: 32 17
0625 13:04:28173 :: Unknown packet header: 100, last: 32 17
0625 13:04:28190 :: Unknown packet header: 100, last: 32 17
0625 13:04:28206 :: Unknown packet header: 100, last: 32 17
0625 13:04:28223 :: Unknown packet header: 100, last: 32 17
0625 13:04:28239 :: Unknown packet header: 100, last: 32 17
0625 13:04:28256 :: Unknown packet header: 100, last: 32 17
0625 13:04:28273 :: Unknown packet header: 100, last: 32 17
0625 13:04:28290 :: Unknown packet header: 100, last: 32 17
0625 13:04:28306 :: Unknown packet header: 100, last: 32 17
0625 13:04:28323 :: Unknown packet header: 100, last: 32 17
0625 13:04:28339 :: Unknown packet header: 100, last: 32 17
0625 13:04:28356 :: Unknown packet header: 100, last: 32 17
0625 13:04:28372 :: Unknown packet header: 100, last: 32 17
0625 13:04:28389 :: Unknown packet header: 100, last: 32 17
0625 13:04:28404 :: Unknown packet header: 100, last: 32 17
0625 13:04:28421 :: Unknown packet header: 100, last: 32 17
0625 13:04:28438 :: Unknown packet header: 100, last: 32 17
0625 13:04:28455 :: Unknown packet header: 100, last: 32 17
0625 13:04:28470 :: Unknown packet header: 100, last: 32 17
0625 13:04:28487 :: Unknown packet header: 100, last: 32 17
0625 13:04:28503 :: Unknown packet header: 100, last: 32 17
0625 13:04:28521 :: Unknown packet header: 100, last: 32 17
0625 13:04:28537 :: Unknown packet header: 100, last: 32 17
0625 13:04:28553 :: Unknown packet header: 100, last: 32 17
0625 13:04:28569 :: Unknown packet header: 100, last: 32 17
0625 13:04:28586 :: Unknown packet header: 100, last: 32 17
0625 13:04:28603 :: Unknown packet header: 100, last: 32 17
0625 13:04:28619 :: Unknown packet header: 100, last: 32 17
0625 13:04:28635 :: Unknown packet header: 100, last: 32 17
0625 13:04:28653 :: Unknown packet header: 100, last: 32 17
0625 13:04:28669 :: Unknown packet header: 100, last: 32 17
0625 13:04:28686 :: Unknown packet header: 100, last: 32 17
0625 13:04:28701 :: Unknown packet header: 100, last: 32 17
0625 13:04:28718 :: Unknown packet header: 100, last: 32 17
0625 13:04:28734 :: Unknown packet header: 100, last: 32 17
0625 13:04:28752 :: Unknown packet header: 100, last: 32 17
0625 13:04:28767 :: Unknown packet header: 100, last: 32 17
0625 13:04:28785 :: Unknown packet header: 100, last: 32 17
0625 13:04:28801 :: Unknown packet header: 100, last: 32 17
0625 13:04:28817 :: Unknown packet header: 100, last: 32 17
0625 13:04:28834 :: Unknown packet header: 100, last: 32 17
0625 13:04:28851 :: Unknown packet header: 100, last: 32 17
0625 13:04:28866 :: Unknown packet header: 100, last: 32 17
0625 13:04:28883 :: Unknown packet header: 100, last: 32 17
0625 13:04:28899 :: Unknown packet header: 100, last: 32 17
0625 13:04:28916 :: Unknown packet header: 100, last: 32 17
0625 13:04:28932 :: Unknown packet header: 100, last: 32 17
0625 13:04:28949 :: Unknown packet header: 100, last: 32 17
0625 13:04:28965 :: Unknown packet header: 100, last: 32 17
0625 13:04:28982 :: Unknown packet header: 100, last: 32 17
0625 13:04:28998 :: Unknown packet header: 100, last: 32 17
0625 13:04:29016 :: Unknown packet header: 100, last: 32 17
0625 13:04:29031 :: Unknown packet header: 100, last: 32 17
0625 13:04:29048 :: Unknown packet header: 100, last: 32 17
0625 13:04:29064 :: Unknown packet header: 100, last: 32 17
0625 13:04:29081 :: Unknown packet header: 100, last: 32 17
0625 13:04:29097 :: Unknown packet header: 100, last: 32 17
0625 13:04:29114 :: Unknown packet header: 100, last: 32 17
0625 13:04:29131 :: Unknown packet header: 100, last: 32 17
0625 13:04:29147 :: Unknown packet header: 100, last: 32 17
0625 13:04:29164 :: Unknown packet header: 100, last: 32 17
0625 13:04:29181 :: Unknown packet header: 100, last: 32 17
0625 13:04:29197 :: Unknown packet header: 100, last: 32 17
0625 13:04:29214 :: Unknown packet header: 100, last: 32 17
0625 13:04:29229 :: Unknown packet header: 100, last: 32 17
0625 13:04:29247 :: Unknown packet header: 100, last: 32 17
0625 13:04:29263 :: Unknown packet header: 100, last: 32 17
0625 13:04:29280 :: Unknown packet header: 100, last: 32 17
0625 13:04:29295 :: Unknown packet header: 100, last: 32 17
0625 13:04:29313 :: Unknown packet header: 100, last: 32 17
0625 13:04:29328 :: Unknown packet header: 100, last: 32 17
0625 13:04:29346 :: Unknown packet header: 100, last: 32 17
0625 13:04:29361 :: Unknown packet header: 100, last: 32 17
0625 13:04:29378 :: Unknown packet header: 100, last: 32 17
0625 13:04:29395 :: Unknown packet header: 100, last: 32 17
0625 13:04:29411 :: Unknown packet header: 100, last: 32 17
0625 13:04:29428 :: Unknown packet header: 100, last: 32 17
0625 13:04:29444 :: Unknown packet header: 100, last: 32 17
0625 13:04:29461 :: Unknown packet header: 100, last: 32 17
0625 13:04:29478 :: Unknown packet header: 100, last: 32 17
0625 13:04:29494 :: Unknown packet header: 100, last: 32 17
0625 13:04:29511 :: Unknown packet header: 100, last: 32 17
0625 13:04:29527 :: Unknown packet header: 100, last: 32 17
0625 13:04:29544 :: Unknown packet header: 100, last: 32 17
0625 13:04:29560 :: Unknown packet header: 100, last: 32 17
0625 13:04:29577 :: Unknown packet header: 100, last: 32 17
0625 13:04:29593 :: Unknown packet header: 100, last: 32 17
0625 13:04:29609 :: Unknown packet header: 100, last: 32 17
0625 13:04:29625 :: Unknown packet header: 100, last: 32 17
0625 13:04:29642 :: Unknown packet header: 100, last: 32 17
0625 13:04:29659 :: Unknown packet header: 100, last: 32 17
0625 13:04:29675 :: Unknown packet header: 100, last: 32 17
0625 13:04:29692 :: Unknown packet header: 100, last: 32 17
0625 13:04:29708 :: Unknown packet header: 100, last: 32 17
0625 13:04:29724 :: Unknown packet header: 100, last: 32 17
0625 13:04:29741 :: Unknown packet header: 100, last: 32 17
0625 13:04:29757 :: Unknown packet header: 100, last: 32 17
0625 13:04:29775 :: Unknown packet header: 100, last: 32 17
0625 13:04:29790 :: Unknown packet header: 100, last: 32 17
0625 13:04:29807 :: Unknown packet header: 100, last: 32 17
0625 13:04:29824 :: Unknown packet header: 100, last: 32 17
0625 13:04:29840 :: Unknown packet header: 100, last: 32 17
0625 13:04:29856 :: Unknown packet header: 100, last: 32 17
0625 13:04:29873 :: Unknown packet header: 100, last: 32 17
0625 13:04:29889 :: Unknown packet header: 100, last: 32 17
0625 13:04:29906 :: Unknown packet header: 100, last: 32 17
0625 13:04:29922 :: Unknown packet header: 100, last: 32 17
0625 13:04:29940 :: Unknown packet header: 100, last: 32 17
0625 13:04:29956 :: Unknown packet header: 100, last: 32 17
0625 13:04:29973 :: Unknown packet header: 100, last: 32 17
0625 13:04:29989 :: Unknown packet header: 100, last: 32 17
0625 13:04:30005 :: Unknown packet header: 100, last: 32 17
0625 13:04:30022 :: Unknown packet header: 100, last: 32 17
0625 13:04:30038 :: Unknown packet header: 100, last: 32 17
0625 13:04:30054 :: Unknown packet header: 100, last: 32 17
0625 13:04:30072 :: Unknown packet header: 100, last: 32 17
0625 13:04:30088 :: Unknown packet header: 100, last: 32 17
0625 13:04:30105 :: Unknown packet header: 100, last: 32 17
0625 13:04:30120 :: Unknown packet header: 100, last: 32 17
0625 13:04:30138 :: Unknown packet header: 100, last: 32 17
0625 13:04:30154 :: Unknown packet header: 100, last: 32 17
0625 13:04:30171 :: Unknown packet header: 100, last: 32 17
0625 13:04:30187 :: Unknown packet header: 100, last: 32 17
0625 13:04:30204 :: Unknown packet header: 100, last: 32 17
0625 13:04:30220 :: Unknown packet header: 100, last: 32 17
0625 13:04:30237 :: Unknown packet header: 100, last: 32 17
0625 13:04:30253 :: Unknown packet header: 100, last: 32 17
0625 13:04:30269 :: Unknown packet header: 100, last: 32 17
0625 13:04:30285 :: Unknown packet header: 100, last: 32 17
0625 13:04:30303 :: Unknown packet header: 100, last: 32 17
0625 13:04:30319 :: Unknown packet header: 100, last: 32 17
0625 13:04:30336 :: Unknown packet header: 100, last: 32 17
0625 13:04:30352 :: Unknown packet header: 100, last: 32 17
0625 13:04:30368 :: Unknown packet header: 100, last: 32 17
0625 13:04:30384 :: Unknown packet header: 100, last: 32 17
0625 13:04:30401 :: Unknown packet header: 100, last: 32 17
0625 13:04:30417 :: Unknown packet header: 100, last: 32 17
0625 13:04:30436 :: Unknown packet header: 100, last: 32 17
0625 13:04:30450 :: Unknown packet header: 100, last: 32 17
0625 13:04:30468 :: Unknown packet header: 100, last: 32 17
0625 13:04:30484 :: Unknown packet header: 100, last: 32 17
0625 13:04:30501 :: Unknown packet header: 100, last: 32 17
0625 13:04:30517 :: Unknown packet header: 100, last: 32 17
0625 13:04:30534 :: Unknown packet header: 100, last: 32 17
0625 13:04:30550 :: Unknown packet header: 100, last: 32 17
0625 13:04:30566 :: Unknown packet header: 100, last: 32 17
0625 13:04:30582 :: Unknown packet header: 100, last: 32 17
0625 13:04:30599 :: Unknown packet header: 100, last: 32 17
0625 13:04:30615 :: Unknown packet header: 100, last: 32 17
0625 13:04:30632 :: Unknown packet header: 100, last: 32 17
0625 13:04:30648 :: Unknown packet header: 100, last: 32 17
0625 13:04:30666 :: Unknown packet header: 100, last: 32 17
0625 13:04:30682 :: Unknown packet header: 100, last: 32 17
0625 13:04:30699 :: Unknown packet header: 100, last: 32 17
0625 13:04:30715 :: Unknown packet header: 100, last: 32 17
0625 13:04:30731 :: Unknown packet header: 100, last: 32 17
0625 13:04:30748 :: Unknown packet header: 100, last: 32 17
0625 13:04:30764 :: Unknown packet header: 100, last: 32 17
0625 13:04:30781 :: Unknown packet header: 100, last: 32 17
0625 13:04:30798 :: Unknown packet header: 100, last: 32 17
0625 13:04:30814 :: Unknown packet header: 100, last: 32 17
0625 13:04:30831 :: Unknown packet header: 100, last: 32 17
0625 13:04:30846 :: Unknown packet header: 100, last: 32 17
0625 13:04:30864 :: Unknown packet header: 100, last: 32 17
0625 13:04:30880 :: Unknown packet header: 100, last: 32 17
0625 13:04:30896 :: Unknown packet header: 100, last: 32 17
0625 13:04:30913 :: Unknown packet header: 100, last: 32 17
0625 13:04:30930 :: Unknown packet header: 100, last: 32 17
0625 13:04:30946 :: Unknown packet header: 100, last: 32 17
0625 13:04:30963 :: Unknown packet header: 100, last: 32 17
0625 13:04:30979 :: Unknown packet header: 100, last: 32 17
0625 13:04:30996 :: Unknown packet header: 100, last: 32 17
0625 13:04:31011 :: Unknown packet header: 100, last: 32 17
0625 13:04:31029 :: Unknown packet header: 100, last: 32 17
0625 13:04:31044 :: Unknown packet header: 100, last: 32 17
0625 13:04:31061 :: Unknown packet header: 100, last: 32 17
0625 13:04:31077 :: Unknown packet header: 100, last: 32 17
0625 13:04:31094 :: Unknown packet header: 100, last: 32 17
0625 13:04:31111 :: Unknown packet header: 100, last: 32 17
0625 13:04:31127 :: Unknown packet header: 100, last: 32 17
0625 13:04:31143 :: Unknown packet header: 100, last: 32 17
0625 13:04:31160 :: Unknown packet header: 100, last: 32 17
0625 13:04:31176 :: Unknown packet header: 100, last: 32 17
0625 13:04:31194 :: Unknown packet header: 100, last: 32 17
0625 13:04:31210 :: Unknown packet header: 100, last: 32 17
0625 13:04:31227 :: Unknown packet header: 100, last: 32 17
0625 13:04:31242 :: Unknown packet header: 100, last: 32 17
0625 13:04:31259 :: Unknown packet header: 100, last: 32 17
0625 13:04:31276 :: Unknown packet header: 100, last: 32 17
0625 13:04:31293 :: Unknown packet header: 100, last: 32 17
0625 13:04:31308 :: Unknown packet header: 100, last: 32 17
0625 13:04:31325 :: Unknown packet header: 100, last: 32 17
0625 13:04:31341 :: Unknown packet header: 100, last: 32 17
0625 13:04:31359 :: Unknown packet header: 100, last: 32 17
0625 13:04:31375 :: Unknown packet header: 100, last: 32 17
0625 13:04:31392 :: Unknown packet header: 100, last: 32 17
0625 13:04:31407 :: Unknown packet header: 100, last: 32 17
0625 13:04:31424 :: Unknown packet header: 100, last: 32 17
0625 13:04:31441 :: Unknown packet header: 100, last: 32 17
0625 13:04:31458 :: Unknown packet header: 100, last: 32 17
0625 13:04:31473 :: Unknown packet header: 100, last: 32 17
0625 13:04:31491 :: Unknown packet header: 100, last: 32 17
0625 13:04:31506 :: Unknown packet header: 100, last: 32 17
0625 13:04:31524 :: Unknown packet header: 100, last: 32 17
0625 13:04:31539 :: Unknown packet header: 100, last: 32 17
0625 13:04:31556 :: Unknown packet header: 100, last: 32 17
0625 13:04:31573 :: Unknown packet header: 100, last: 32 17
0625 13:04:31589 :: Unknown packet header: 100, last: 32 17
0625 13:04:31606 :: Unknown packet header: 100, last: 32 17
0625 13:04:31622 :: Unknown packet header: 100, last: 32 17
0625 13:04:31639 :: Unknown packet header: 100, last: 32 17
0625 13:04:31655 :: Unknown packet header: 100, last: 32 17
0625 13:04:31671 :: Unknown packet header: 100, last: 32 17
0625 13:04:31689 :: Unknown packet header: 100, last: 32 17
0625 13:04:31705 :: Unknown packet header: 100, last: 32 17
0625 13:04:31722 :: Unknown packet header: 100, last: 32 17
0625 13:04:31737 :: Unknown packet header: 100, last: 32 17
0625 13:04:31754 :: Unknown packet header: 100, last: 32 17
0625 13:04:31770 :: Unknown packet header: 100, last: 32 17
0625 13:04:31787 :: Unknown packet header: 100, last: 32 17
0625 13:04:31803 :: Unknown packet header: 100, last: 32 17
0625 13:04:31820 :: Unknown packet header: 100, last: 32 17
0625 13:04:31836 :: Unknown packet header: 100, last: 32 17
0625 13:04:31853 :: Unknown packet header: 100, last: 32 17
0625 13:04:31870 :: Unknown packet header: 100, last: 32 17
0625 13:04:31886 :: Unknown packet header: 100, last: 32 17
0625 13:04:31902 :: Unknown packet header: 100, last: 32 17
0625 13:04:31919 :: Unknown packet header: 100, last: 32 17
0625 13:04:31935 :: Unknown packet header: 100, last: 32 17
0625 13:04:31952 :: Unknown packet header: 100, last: 32 17
0625 13:04:31969 :: Unknown packet header: 100, last: 32 17
0625 13:04:31985 :: Unknown packet header: 100, last: 32 17
0625 13:04:32001 :: Unknown packet header: 100, last: 32 17
0625 13:04:32019 :: Unknown packet header: 100, last: 32 17
0625 13:04:32034 :: Unknown packet header: 100, last: 32 17
0625 13:04:32051 :: Unknown packet header: 100, last: 32 17
0625 13:04:32067 :: Unknown packet header: 100, last: 32 17
0625 13:04:32085 :: Unknown packet header: 100, last: 32 17
0625 13:04:32101 :: Unknown packet header: 100, last: 32 17
0625 13:04:32117 :: Unknown packet header: 100, last: 32 17
0625 13:04:32133 :: Unknown packet header: 100, last: 32 17
0625 13:04:32150 :: Unknown packet header: 100, last: 32 17
0625 13:04:32167 :: Unknown packet header: 100, last: 32 17
0625 13:04:32184 :: Unknown packet header: 100, last: 32 17
0625 13:04:32200 :: Unknown packet header: 100, last: 32 17
0625 13:04:32217 :: Unknown packet header: 100, last: 32 17
0625 13:04:32232 :: Unknown packet header: 100, last: 32 17
0625 13:04:32249 :: Unknown packet header: 100, last: 32 17
0625 13:04:32265 :: Unknown packet header: 100, last: 32 17
0625 13:04:32282 :: Unknown packet header: 100, last: 32 17
0625 13:04:32299 :: Unknown packet header: 100, last: 32 17
0625 13:04:32316 :: Unknown packet header: 100, last: 32 17
0625 13:04:32338 :: Unknown packet header: 100, last: 32 17
0625 13:04:32351 :: Unknown packet header: 100, last: 32 17
0625 13:04:32366 :: Unknown packet header: 100, last: 32 17
0625 13:04:32381 :: Unknown packet header: 100, last: 32 17
0625 13:04:32397 :: Unknown packet header: 100, last: 32 17
0625 13:04:32417 :: Unknown packet header: 100, last: 32 17
0625 13:04:32431 :: Unknown packet header: 100, last: 32 17
0625 13:04:32448 :: Unknown packet header: 100, last: 32 17
0625 13:04:32463 :: Unknown packet header: 100, last: 32 17
0625 13:04:32481 :: Unknown packet header: 100, last: 32 17
0625 13:04:32497 :: Unknown packet header: 100, last: 32 17
0625 13:04:32514 :: Unknown packet header: 100, last: 32 17
0625 13:04:32529 :: Unknown packet header: 100, last: 32 17
0625 13:04:32546 :: Unknown packet header: 100, last: 32 17
0625 13:04:32563 :: Unknown packet header: 100, last: 32 17
0625 13:04:32580 :: Unknown packet header: 100, last: 32 17
0625 13:04:32595 :: Unknown packet header: 100, last: 32 17
0625 13:04:32612 :: Unknown packet header: 100, last: 32 17
0625 13:04:32628 :: Unknown packet header: 100, last: 32 17
0625 13:04:32646 :: Unknown packet header: 100, last: 32 17
0625 13:04:32662 :: Unknown packet header: 100, last: 32 17
0625 13:04:32678 :: Unknown packet header: 100, last: 32 17
0625 13:04:32694 :: Unknown packet header: 100, last: 32 17
0625 13:04:32711 :: Unknown packet header: 100, last: 32 17
0625 13:04:32727 :: Unknown packet header: 100, last: 32 17
0625 13:04:32745 :: Unknown packet header: 100, last: 32 17
0625 13:04:32760 :: Unknown packet header: 100, last: 32 17
0625 13:04:32777 :: Unknown packet header: 100, last: 32 17
0625 13:04:32794 :: Unknown packet header: 100, last: 32 17
0625 13:04:32811 :: Unknown packet header: 100, last: 32 17
0625 13:04:32826 :: Unknown packet header: 100, last: 32 17
0625 13:04:32843 :: Unknown packet header: 100, last: 32 17
0625 13:04:32859 :: Unknown packet header: 100, last: 32 17
0625 13:04:32877 :: Unknown packet header: 100, last: 32 17
0625 13:04:32892 :: Unknown packet header: 100, last: 32 17
0625 13:04:32910 :: Unknown packet header: 100, last: 32 17
0625 13:04:32926 :: Unknown packet header: 100, last: 32 17
0625 13:04:32943 :: Unknown packet header: 100, last: 32 17
0625 13:04:32958 :: Unknown packet header: 100, last: 32 17
0625 13:04:32976 :: Unknown packet header: 100, last: 32 17
0625 13:04:32992 :: Unknown packet header: 100, last: 32 17
0625 13:04:33008 :: Unknown packet header: 100, last: 32 17
0625 13:04:33024 :: Unknown packet header: 100, last: 32 17
0625 13:04:33042 :: Unknown packet header: 100, last: 32 17
0625 13:04:33057 :: Unknown packet header: 100, last: 32 17
0625 13:04:33074 :: Unknown packet header: 100, last: 32 17
0625 13:04:33091 :: Unknown packet header: 100, last: 32 17
0625 13:04:33108 :: Unknown packet header: 100, last: 32 17
0625 13:04:33124 :: Unknown packet header: 100, last: 32 17
0625 13:04:33141 :: Unknown packet header: 100, last: 32 17
0625 13:04:33157 :: Unknown packet header: 100, last: 32 17
0625 13:04:33173 :: Unknown packet header: 100, last: 32 17
0625 13:04:33189 :: Unknown packet header: 100, last: 32 17
0625 13:04:33207 :: Unknown packet header: 100, last: 32 17
0625 13:04:33222 :: Unknown packet header: 100, last: 32 17
0625 13:04:33240 :: Unknown packet header: 100, last: 32 17

June 24, 2016

On 23/06/2016 at 9:30 PM, arves100 said:

Yup it's 40k

Okey so I compiled game from novaline and it's compiled without error, but the problem is now that I can't compile the db from novaline :/ . and server won't start

June 24, 2016

Game compiled properly but how to compile db ?? because the server won't start with my db which is from Mainline_SG .. anyone know how ??

June 23, 2016

1 hour ago, arves100 said:

Try to use game from novaline, all packets are ok

What version is it ? 40k? because I need for client 40k .. :/

June 23, 2016

Hello ,

I compiled binrary code without error and when the game is loading it's stock on EMPTY gauge ..

GAME source Mainline_sg

BINRARY source Mainline_sg

someone know how to change the packet.h to make this work ? thank you

SYSERR:

Spoiler

0623 19:14:19704 :: Phase Select does not handle this header (header: 18, last: 17, 18)
0623 19:14:19753 :: Phase Select does not handle this header (header: 20, last: 17, 20)

June 23, 2016

3 minutes ago, ErNabbone said:

Ok, this time the error is
db.cpp: At global scope:
db.cpp:142: error: redefinition of 'void DBManager::ReturnQuery(int, DWORD, void*, const char*, ...)'
db.cpp:112: error: 'void DBManager::ReturnQuery(int, DWORD, void*, const char*, ...)' previously defined here
db.cpp:162: error: redefinition of 'SQLMsg* DBManager::PopResult()'
db.cpp:132: error: 'SQLMsg* DBManager::PopResult()' previously defined here

so I was wrong supposing that the 2nd function name is "DBManager::ReturnQuery":

But there is also another similiar error here:
db.cpp:162: error: redefinition of 'SQLMsg* DBManager::PopResult()'
db.cpp:132: error: 'SQLMsg* DBManager::PopResult()' previously defined here

Don't you have a previous backup?

Thank you for your help it's compile now , the ERROR was in the db.cpp and, there was a space between VOID .

But thank you for your help

# TOPIC RESOLVED CAN BE CLOSED

June 23, 2016

9 minutes ago, ErNabbone said:

As you can see, this time the error is in exchange.cpp;
you used "victim" without declare it:
"exchange.cpp: In constructor 'CExchange::CExchange(CHARACTER*)':
exchange.cpp:121: error: 'victim' was not declared in this scope"

[€dit]: "victim" used in line 121

Okey , I upload no edited files from Mainline_sg + I only change in db.cpp this what you wrote above , and this is my BUILD ERROR LOG again. I don't know where I'm doing error in this :/

Spoiler

In file included from char.cpp:4:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char.cpp:25:
shop_manager.h:40:7: warning: no newline at end of file
In file included from char.cpp:62:
PetSystem.h:163:31: warning: no newline at end of file
char.cpp:7217: warning: this decimal constant is unsigned only in ISO C90
char.cpp:7225:2: warning: no newline at end of file
In file included from char_battle.cpp:27:
shop_manager.h:40:7: warning: no newline at end of file
In file included from char_horse.cpp:14:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char_item.cpp:44:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char_item.cpp:47:
belt_inventory_helper.h:108:42: warning: no newline at end of file
In file included from char_state.cpp:25:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from PetSystem.cpp:8:
PetSystem.h:163:31: warning: no newline at end of file
In file included from PetSystem.cpp:9:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
PetSystem.cpp:637:2: warning: no newline at end of file
In file included from cmd_general.cpp:36:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
constants.cpp:291: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:292: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:293: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:294: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:295: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:296: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:297: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:298: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:299: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:300: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:301: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:302: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:303: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:304: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:305: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:306: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:307: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:308: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:309: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:310: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:311: warning: this decimal constant is unsigned only in ISO C90
char.cpp: In member function 'void CHARACTER::PointChange(BYTE, int, bool, bool)':
char.cpp:3088: warning: comparison between signed and unsigned integer expressions
In file included from char_item.cpp:47:
belt_inventory_helper.h: In static member function 'static BYTE CBeltInventoryHelper::GetBeltGradeByRefineLevel(int)':
belt_inventory_helper.h:28: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::IsEmptyItemGrid(TItemPos, BYTE, int) const':
char_item.cpp:640: warning: comparison is always false due to limited range of data type
char_item.cpp:666: warning: comparison is always false due to limited range of data type
char_item.cpp: In member function 'bool CHARACTER::UseItemEx(CItem*, TItemPos)':
char_item.cpp:2387: warning: format '%d' expects type 'int', but argument 6 has type 'long int'
char_item.cpp:2391: warning: format '%d' expects type 'int', but argument 6 has type 'long int'
char_item.cpp:2403: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:2407: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:2434: warning: format '%d' expects type 'int', but argument 6 has type 'long int'
char_item.cpp:2442: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:5087: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::UseItem(TItemPos, TItemPos)':
char_item.cpp:5159: warning: unused variable 'wDestCell'
char_item.cpp:5160: warning: unused variable 'bDestInven'
char_item.cpp: In member function 'bool CHARACTER::EquipItem(CItem*, int)':
char_item.cpp:6160: warning: array subscript has type 'char'
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_AddBuffsFromItem(CItem*)':
char_item.cpp:6224: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(CItem*)':
char_item.cpp:6236: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::CanEquipNow(CItem*, const TItemPos&, const TItemPos&)':
char_item.cpp:7422: warning: unused variable 'itemType'
char_item.cpp:7423: warning: unused variable 'itemSubType'
In file included from desc_manager.cpp:15:
ClientPackageCryptInfo.h:117:41: warning: no newline at end of file
char_state.cpp: In member function 'virtual void CHARACTER::StateMove()':
char_state.cpp:901: warning: unused variable 'rider'
PetSystem.cpp: In member function 'virtual bool CPetActor::_UpdateFollowAI()':
PetSystem.cpp:246: warning: unused variable 'bDoMoveAlone'
PetSystem.cpp: In member function 'CPetActor* CPetSystem::Summon(DWORD, CItem*, const char*, bool, DWORD)':
PetSystem.cpp:552: warning: unused variable 'petVID'
db.cpp: In member function 'void DBManager::Query(const char*, ...)':
db.cpp:93: warning: comparison between signed and unsigned integer expressions
db.cpp: At global scope:
db.cpp:142: error: redefinition of 'void DBManager::ReturnQuery(int, DWORD, void*, const char*, ...)'
db.cpp:112: error: 'void DBManager::ReturnQuery(int, DWORD, void*, const char*, ...)' previously defined here
db.cpp:162: error: redefinition of 'SQLMsg* DBManager::PopResult()'
db.cpp:132: error: 'SQLMsg* DBManager::PopResult()' previously defined here
gmake: *** [OBJDIR/db.o] Error 1
gmake: *** Waiting for unfinished jobs....
In file included from config.cpp:22:
check_server.h: In static member function 'static bool CheckServer::CheckIp(const char*)':
check_server.h:24: warning: comparison between signed and unsigned integer expressions
config.cpp: In function 'void config_init(const std::string&)':
config.cpp:435: warning: NULL used in arithmetic
config.cpp:459: warning: NULL used in arithmetic
config.cpp:483: warning: NULL used in arithmetic
config.cpp:505: warning: unused variable 'line'
desc_client.cpp: In member function 'void CLIENT_DESC::UpdateChannelStatus(DWORD, bool)':
desc_client.cpp:299: warning: comparison between signed and unsigned integer expressions
cmd_gm.cpp: In function 'void do_set_stat(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:3935: warning: NULL used in arithmetic
cube.cpp: In function 'bool Cube_make(CHARACTER*)':
cube.cpp:544: warning: comparison between signed and unsigned integer expressions
cube.cpp: In function 'void Cube_MakeCubeInformationText()':
cube.cpp:716: warning: unused variable 'npcVNUM'
cube.cpp: In function 'bool Cube_InformationInitialize()':
cube.cpp:783: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::IsEmptyItemGrid(TItemPos, BYTE, int) const':
char_item.cpp:679: warning: control reaches end of non-void function
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_ValueChange(BYTE, BYTE, BYTE)':
char_item.cpp:6271: warning: 'pBuff' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_use_item(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:4357: warning: 'cell' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_set_stat(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:3977: warning: 'n' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_mob_ld(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:855: warning: 'x' may be used uninitialized in this function
cmd_gm.cpp:855: warning: 'y' may be used uninitialized in this function

June 23, 2016

14 minutes ago, ErNabbone said:
So, you forgot the function names:
{

	    char szQuery[4096];

	    va_list args;
va_start(args, c_pszFormat); vsnprintf(szQuery, sizeof(szQuery), c_pszFormat, args); va_end(args);

m_sql.AsyncQuery(szQuery); } Should be "void DBManager::Query(const char * c_pszFormat, ...)"

But I don't know which function is this:

(should be "void DBManager::ReturnQuery(int iType, DWORD dwIdent, void * pvData, const char * c_pszFormat, ...)" but I'm not sure)
{

	    char szQuery[4096];

	    va_list args;
   va_start(args, c_pszFormat);
   vsnprintf(szQuery, sizeof(szQuery), c_pszFormat, args);
   va_end(args);

   return m_sql_direct.DirectQuery(szQuery);
}

If it's like I do suppose, you should replace 95's from "{" to "void DBManager::Query(const char * c_pszFormat, ...) {" and the 116's even from "{" to "void DBManager::ReturnQuery(int iType, DWORD dwIdent, void * pvData, const char * c_pszFormat, ...) {".

Ehhh. :/ same problem with the compile game :/ but even more :/

Spoiler

In file included from char.cpp:4:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char.cpp:25:
shop_manager.h:40:7: warning: no newline at end of file
In file included from char.cpp:62:
PetSystem.h:163:31: warning: no newline at end of file
char.cpp:7207: warning: this decimal constant is unsigned only in ISO C90
char.cpp:7215:2: warning: no newline at end of file
In file included from char_battle.cpp:27:
shop_manager.h:40:7: warning: no newline at end of file
In file included from char_horse.cpp:14:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char_item.cpp:44:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from char_item.cpp:47:
belt_inventory_helper.h:108:42: warning: no newline at end of file
In file included from PetSystem.cpp:8:
PetSystem.h:163:31: warning: no newline at end of file
In file included from PetSystem.cpp:9:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
PetSystem.cpp:637:2: warning: no newline at end of file
In file included from char_state.cpp:25:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
In file included from cmd_general.cpp:36:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
constants.cpp:291: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:292: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:293: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:294: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:295: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:296: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:297: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:298: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:299: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:300: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:301: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:302: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:303: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:304: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:305: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:306: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:307: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:308: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:309: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:310: warning: this decimal constant is unsigned only in ISO C90
constants.cpp:311: warning: this decimal constant is unsigned only in ISO C90
char.cpp: In member function 'void CHARACTER::PointChange(BYTE, int, bool, bool)':
char.cpp:3088: warning: comparison between signed and unsigned integer expressions
In file included from char_item.cpp:47:
belt_inventory_helper.h: In static member function 'static BYTE CBeltInventoryHelper::GetBeltGradeByRefineLevel(int)':
belt_inventory_helper.h:28: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::IsEmptyItemGrid(TItemPos, BYTE, int) const':
char_item.cpp:640: warning: comparison is always false due to limited range of data type
char_item.cpp:666: warning: comparison is always false due to limited range of data type
char_item.cpp: In member function 'bool CHARACTER::UseItemEx(CItem*, TItemPos)':
char_item.cpp:2387: warning: format '%ld' expects type 'long int', but argument 4 has type 'DWORD'
char_item.cpp:2387: warning: format '%ld' expects type 'long int', but argument 5 has type 'int'
char_item.cpp:2391: warning: format '%ld' expects type 'long int', but argument 4 has type 'DWORD'
char_item.cpp:2391: warning: format '%ld' expects type 'long int', but argument 5 has type 'int'
char_item.cpp:2403: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:2407: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:2434: warning: format '%d' expects type 'int', but argument 6 has type 'long int'
char_item.cpp:2442: warning: format '%d' expects type 'int', but argument 5 has type 'long int'
char_item.cpp:5087: warning: comparison between signed and unsigned integer expressions
In file included from desc_manager.cpp:15:
ClientPackageCryptInfo.h:117:41: warning: no newline at end of file
PetSystem.cpp: In member function 'virtual bool CPetActor::_UpdateFollowAI()':
PetSystem.cpp:246: warning: unused variable 'bDoMoveAlone'
PetSystem.cpp: In member function 'CPetActor* CPetSystem::Summon(DWORD, CItem*, const char*, bool, DWORD)':
PetSystem.cpp:552: warning: unused variable 'petVID'
cube.cpp: In function 'bool Cube_make(CHARACTER*)':
cube.cpp:544: warning: comparison between signed and unsigned integer expressions
cube.cpp: In function 'void Cube_MakeCubeInformationText()':
cube.cpp:716: warning: unused variable 'npcVNUM'
cube.cpp: In function 'bool Cube_InformationInitialize()':
cube.cpp:783: warning: comparison between signed and unsigned integer expressions
cmd_gm.cpp: In function 'void do_set_stat(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:3935: warning: NULL used in arithmetic
desc_client.cpp: In member function 'void CLIENT_DESC::UpdateChannelStatus(DWORD, bool)':
desc_client.cpp:299: warning: comparison between signed and unsigned integer expressions
char_state.cpp: In member function 'virtual void CHARACTER::StateMove()':
char_state.cpp:901: warning: unused variable 'rider'
In file included from config.cpp:22:
check_server.h: In static member function 'static bool CheckServer::CheckIp(const char*)':
check_server.h:24: warning: comparison between signed and unsigned integer expressions
config.cpp: In function 'void config_init(const std::string&)':
config.cpp:435: warning: NULL used in arithmetic
config.cpp:459: warning: NULL used in arithmetic
config.cpp:483: warning: NULL used in arithmetic
config.cpp:505: warning: unused variable 'line'
char_item.cpp: In member function 'bool CHARACTER::UseItem(TItemPos, TItemPos)':
char_item.cpp:5159: warning: unused variable 'wDestCell'
char_item.cpp:5160: warning: unused variable 'bDestInven'
char_item.cpp: In member function 'bool CHARACTER::EquipItem(CItem*, int)':
char_item.cpp:6160: warning: array subscript has type 'char'
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_AddBuffsFromItem(CItem*)':
char_item.cpp:6224: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(CItem*)':
char_item.cpp:6236: warning: comparison between signed and unsigned integer expressions
char_item.cpp: In member function 'bool CHARACTER::CanEquipNow(CItem*, const TItemPos&, const TItemPos&)':
char_item.cpp:7422: warning: unused variable 'itemType'
char_item.cpp:7423: warning: unused variable 'itemSubType'
char_item.cpp: In member function 'bool CHARACTER::IsEmptyItemGrid(TItemPos, BYTE, int) const':
char_item.cpp:679: warning: control reaches end of non-void function
char_item.cpp: In member function 'void CHARACTER::BuffOnAttr_ValueChange(BYTE, BYTE, BYTE)':
char_item.cpp:6271: warning: 'pBuff' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_use_item(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:4357: warning: 'cell' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_set_stat(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:3977: warning: 'n' may be used uninitialized in this function
cmd_gm.cpp: In function 'void do_mob_ld(CHARACTER*, const char*, int, int)':
cmd_gm.cpp:855: warning: 'x' may be used uninitialized in this function
cmd_gm.cpp:855: warning: 'y' may be used uninitialized in this function
In file included from input_db.cpp:13:
shop_manager.h:40:7: warning: no newline at end of file
input_db.cpp:2722:2: warning: no newline at end of file
In file included from input_main.cpp:16:
shop_manager.h:40:7: warning: no newline at end of file
exchange.cpp: In constructor 'CExchange::CExchange(CHARACTER*)':
exchange.cpp:121: error: 'victim' was not declared in this scope
gmake: *** [OBJDIR/exchange.o] Error 1
gmake: *** Waiting for unfinished jobs....
In file included from item.cpp:22:
belt_inventory_helper.h:108:42: warning: no newline at end of file
In file included from item.cpp:23:
../../common/VnumHelper.h:59:32: warning: no newline at end of file
item.cpp:2084:2: warning: no newline at end of file
input_main.cpp: In member function 'void CInputMain::Exchange(CHARACTER*, const char*)':
input_main.cpp:1163: warning: comparison is always false due to limited range of data type
input_main.cpp: In member function 'int CInputMain::MyShop(CHARACTER*, const char*, size_t)':
input_main.cpp:2937: warning: comparison is always false due to limited range of data type
In file included from item.cpp:22:
belt_inventory_helper.h: In static member function 'static BYTE CBeltInventoryHelper::GetBeltGradeByRefineLevel(int)':
belt_inventory_helper.h:28: warning: comparison between signed and unsigned integer expressions
item.h: In constructor 'CItem::CItem(DWORD)':
item.h:286: warning: 'CItem::m_pkRealTimeExpireEvent' will be initialized after
item.h:283: warning: 'LPEVENT CItem::m_pkExpireEvent'
item.cpp:25: warning: when initialized here
item.cpp: In function 'const bool CanPutIntoRing(CItem*, CItem*)':
item.cpp:1725: warning: unused variable 'vnum'
item.cpp: In member function 'bool CItem::CanPutInto(CItem*)':
item.cpp:1758: warning: comparison between signed and unsigned integer expressions
item.cpp: In member function 'int CItem::GiveMoreTime_Per(float)':
item.cpp:2014: warning: comparison between signed and unsigned integer expressions
item.cpp:2016: warning: comparison between signed and unsigned integer expressions
item.cpp: In member function 'int CItem::GiveMoreTime_Fix(DWORD)':
item.cpp:2038: warning: comparison between signed and unsigned integer expressions
item.cpp: In member function 'int CItem::GetDuration()':
item.cpp:2069: warning: array subscript has type 'char'
input_auth.cpp: In member function 'int CInputAuth::auth_OpenID(const char*, const char*, char*)':
input_auth.cpp:467: warning: unused variable 'last'

Sign In

Forums

Store

Third Party - Providers Directory

Feature Plan

Release Notes

Docs

Events

Posts posted by frogen1145

Important Information