teser

From teser, 5 Years ago, written in Plain Text.

Embed

Download Paste or View Raw
Hits: 555

#include "stdafx.h"

#include "../../common/VnumHelper.h"

#include "char.h"

#include "config.h"

#include "utils.h"

#include "crc32.h"

#include "char_manager.h"

#include "desc_client.h"

#include "desc_manager.h"

#include "buffer_manager.h"

#include "item_manager.h"

#include "motion.h"

#include "vector.h"

#include "packet.h"

#include "cmd.h"

#include "fishing.h"

#include "exchange.h"

#include "battle.h"

#include "affect.h"

#include "shop.h"

#include "shop_manager.h"

#include "safebox.h"

#include "regen.h"

#include "pvp.h"

#include "party.h"

#include "start_position.h"

#include "questmanager.h"

#include "log.h"

#include "p2p.h"

#include "guild.h"

#include "guild_manager.h"

#include "dungeon.h"

#include "messenger_manager.h"

#include "unique_item.h"

#include "priv_manager.h"

#include "war_map.h"

#include "xmas_event.h"

#include "banword.h"

#include "target.h"

#include "wedding.h"

#include "mob_manager.h"

#include "mining.h"

#include "monarch.h"

#include "castle.h"

#include "arena.h"

#include "dev_log.h"

#include "horsename_manager.h"

#include "pcbang.h"

#include "gm.h"

#include "map_location.h"

#include "BlueDragon_Binder.h"

#include "HackShield.h"

#include "skill_power.h"

#include "XTrapManager.h"

#include "buff_on_attributes.h"

#include "PetSystem.h"

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

#ifdef OFFLINE_SHOP

m_pkRefreshShopEvent = NULL;

bprivShop = 0;

bprivShopOwner = 0;

bprivShop = 0;

bprivShopOwner = 0;

dw_ShopTime = 0;

m_mapshops.clear();

m_pkEditShopEvent = NULL;

m_bShopEditMode = false;

m_dwShopEditModeTick = 0;

#endif

#ifdef GIFT_SYSTEM

m_pkGiftRefresh = NULL;

m_dwLastGiftPage = 0;

m_mapGiftGrid.clear();

#endif

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;

m_petSystem = 0;

m_bIsPet = false;

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

}

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

m_petSystem = 0;

}

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

#ifdef OFFLINE_SHOP

event_cancel(&m_pkRefreshShopEvent);

m_pkRefreshShopEvent = NULL;

bprivShop = 0;

bprivShopOwner = 0;

bprivShop = 0;

bprivShopOwner = 0;

dw_ShopTime = 0;

m_mapshops.clear();

event_cancel(&m_pkEditShopEvent);

m_pkEditShopEvent = NULL;

m_bShopEditMode = false;

m_dwShopEditModeTick = 0;

#endif

#ifdef GIFT_SYSTEM

m_pkGiftRefresh = NULL;

m_dwLastGiftPage = 0;

m_mapGiftGrid.clear();

#endif

}

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

{

CloseMyShop();

return;

}

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

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

#ifdef OFFLINE_SHOP

if (IsPrivShop())

{

M2_DESTROY_CHARACTER(this);

return;

}

#endif

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:

#if defined(SHOP_HIDE_NAME) && defined(OFFLINE_SHOP)

if (IsPC() || GetRaceNum() != 30000 && !IsPrivShop())

#endif

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[i] = m_quickslot[i];

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 (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[i] = 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;

#ifdef ANTY_DAMAGE_HACK

ClearLastTimeDmg();

#endif

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

}

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

}

m_petSystem = M2_NEW CPetSystem(this);

}

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

int curMaxHP = GetMaxHP();

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

float fRatio = (float)GetMaxHP() / (float)curMaxHP;

PointChange(POINT_HP, GetHP() * fRatio - GetHP());

val = GetMaxHP();

}

break;

case POINT_MAX_SP:

{

SetPoint(type, GetPoint(type) + amount);

int curMaxSP = GetMaxSP();

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

float fRatio = (float)GetMaxSP() / (float)curMaxSP;

PointChange(POINT_SP, GetSP() * fRatio - GetSP());

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;

std::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_HP_PCT:

{

if(GetMaxHP() == 0) break;

PointChange(aApplyInfo[bApplyType].bPointType, iVal);

}

break;

case APPLY_MAX_SP:

case APPLY_MAX_SP_PCT:

{

if(GetMaxSP() == 0) break;

PointChange(aApplyInfo[bApplyType].bPointType, iVal);

}

break;

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

// pt

if (m_pkDungeon && IsPC())

SetDungeon(NULL);

// pt

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;

}

}

#ifdef OFFLINE_SHOP

if (IsPC() || IsNPC() && GetRaceNum() == 30000)

{

if (!CTargetManager::instance().GetTargetInfo(pkChrCauser->GetPlayerID(), TARGET_TYPE_VID, GetVID()) || GetRaceNum() == 30000)

#else

if (IsPC())

{

if (!CTargetManager::instance().GetTargetInfo(pkChrCauser->GetPlayerID(), TARGET_TYPE_VID, GetVID()))

#endif

{

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

}

#ifdef OFFLINE_SHOP

if (GetMyShop()->IsLocked()){

pkChrCauser->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_LOCKED"));

return;

}

#endif

GetMyShop()->AddGuest(pkChrCauser, GetVID(), false);

pkChrCauser->SetShopOwner(this);

return;

}

if (test_server)

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

return;

}

}

pkChrCauser->SetQuestNPCID(GetVID());

if (quest::CQuestManager::instance().Click(pkChrCauser->GetPlayerID(), this))

{

return;

}

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, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));

if(iLv <= 90)

PointChange(POINT_STAT, ((MINMAX(1, iLv, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));

else

PointChange(POINT_STAT, 270 - 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());

if (NULL == pPC)

return 0;

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

if (NULL == pPC)

return;

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[i].vnum = item->GetVnum();

p.equips[i].count = item->GetCount();

thecore_memcpy(p.equips[i].alSockets, item->GetSockets(), sizeof(p.equips[i].alSockets));

thecore_memcpy(p.equips[i].aAttr, item->GetAttributes(), sizeof(p.equips[i].aAttr));

}

else

{

p.equips[i].vnum = 0;

}

}

ch->GetDesc()->Packet(&p, sizeof(p));

}

bool CHARACTER::CanSummon(int iLeaderShip)

{

return (iLeaderShip >= 20 || iLeaderShip >= 12 && m_dwLastDeadTime + 180 > get_dword_time());

}

void CHARACTER::MountVnum(DWORD vnum)

{

if (m_dwMountVnum == vnum)

return;

m_dwMountVnum = vnum;

m_dwMountTime = get_dword_time();

if (m_bIsObserver)

return;

//NOTE : MountÇŃ´Ů°í ÇŘĽ Client SideŔÇ °´ĂĽ¸¦ »čÁ¦ÇĎÁř ľĘ´Â´Ů.

//±×¸®°í ĽąöSideżˇĽ ĹŔŔ»¶§ Ŕ§Äˇ ŔĚµżŔş ÇĎÁö ľĘ´Â´Ů. żÖłÄÇĎ¸é Client SideżˇĽ Coliision Adjust¸¦ ÇŇĽö ŔÖ´ÂµĄ

//°´ĂĽ¸¦ ĽŇ¸ę˝ĂÄ×´Ů°ˇ ĽąöŔ§Äˇ·Î ŔĚµż˝ĂĹ°¸é ŔĚ¶§ collision check¸¦ ÇĎÁö´Â ľĘŔ¸ąÇ·Î ąč°ćżˇ ł˘°ĹłŞ ¶Ő°í łŞ°ˇ´Â ą®Á¦°ˇ Á¸ŔçÇŃ´Ů.

m_posDest.x = m_posStart.x = GetX();

m_posDest.y = m_posStart.y = GetY();

//EncodeRemovePacket(this);

EncodeInsertPacket(this);

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

while (it != m_map_view.end())

{

LPENTITY entity = (it++)->first;

//MountÇŃ´Ů°í ÇŘĽ Client SideŔÇ °´ĂĽ¸¦ »čÁ¦ÇĎÁř ľĘ´Â´Ů.

//EncodeRemovePacket(entity);

//if (!m_bIsObserver)

EncodeInsertPacket(entity);

//if (!entity->IsObserverMode())

// entity->EncodeInsertPacket(this);

}

SetValidComboInterval(0);

SetComboSequence(0);

ComputePoints();

}

namespace {

class FuncCheckWarp

{

public:

FuncCheckWarp(LPCHARACTER pkWarp)

{

m_lTargetY = 0;

m_lTargetX = 0;

m_lX = pkWarp->GetX();

m_lY = pkWarp->GetY();

m_bInvalid = false;

m_bEmpire = pkWarp->GetEmpire();

char szTmp[64];

if (3 != sscanf(pkWarp->GetName(), " %s %ld %ld ", szTmp, &m_lTargetX, &m_lTargetY))

{

if (number(1, 100) < 5)

sys_err("Warp NPC name wrong : vnum(%d) name(%s)", pkWarp->GetRaceNum(), pkWarp->GetName());

m_bInvalid = true;

return;

}

m_lTargetX *= 100;

m_lTargetY *= 100;

m_bUseWarp = true;

if (pkWarp->IsGoto())

{

LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(pkWarp->GetMapIndex());

m_lTargetX += pkSectreeMap->m_setting.iBaseX;

m_lTargetY += pkSectreeMap->m_setting.iBaseY;

m_bUseWarp = false;

}

}

bool Valid()

{

return !m_bInvalid;

}

void operator () (LPENTITY ent)

{

if (!Valid())

return;

if (!ent->IsType(ENTITY_CHARACTER))

return;

LPCHARACTER pkChr = (LPCHARACTER) ent;

if (!pkChr->IsPC())

return;

int iDist = DISTANCE_APPROX(pkChr->GetX() - m_lX, pkChr->GetY() - m_lY);

if (iDist > 300)

return;

if (m_bEmpire && pkChr->GetEmpire() && m_bEmpire != pkChr->GetEmpire())

return;

if (pkChr->IsHack())

return;

if (!pkChr->CanHandleItem(false, true))

return;

if (m_bUseWarp)

pkChr->WarpSet(m_lTargetX, m_lTargetY);

else

{

pkChr->Show(pkChr->GetMapIndex(), m_lTargetX, m_lTargetY);

pkChr->Stop();

}

}

bool m_bInvalid;

bool m_bUseWarp;

long m_lX;

long m_lY;

long m_lTargetX;

long m_lTargetY;

BYTE m_bEmpire;

};

}

EVENTFUNC(warp_npc_event)

{

char_event_info* info = dynamic_cast<char_event_info*>( event->info );

if ( info == NULL )

{

sys_err( "warp_npc_event> <Factor> Null pointer" );

return 0;

}

LPCHARACTER ch = info->ch;

if (ch == NULL) { // <Factor>

return 0;

}

if (!ch->GetSectree())

{

ch->m_pkWarpNPCEvent = NULL;

return 0;

}

FuncCheckWarp f(ch);

if (f.Valid())

ch->GetSectree()->ForEachAround(f);

return passes_per_sec / 2;

}

void CHARACTER::StartWarpNPCEvent()

{

if (m_pkWarpNPCEvent)

return;

if (!IsWarp() && !IsGoto())

return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkWarpNPCEvent = event_create(warp_npc_event, info, passes_per_sec / 2);

}

void CHARACTER::SyncPacket()

{

TEMP_BUFFER buf;

TPacketCGSyncPositionElement elem;

elem.dwVID = GetVID();

elem.lX = GetX();

elem.lY = GetY();

TPacketGCSyncPosition pack;

pack.bHeader = HEADER_GC_SYNC_POSITION;

pack.wSize = sizeof(TPacketGCSyncPosition) + sizeof(elem);

buf.write(&pack, sizeof(pack));

buf.write(&elem, sizeof(elem));

PacketAround(buf.read_peek(), buf.size());

}

LPCHARACTER CHARACTER::GetMarryPartner() const

{

return m_pkChrMarried;

}

void CHARACTER::SetMarryPartner(LPCHARACTER ch)

{

m_pkChrMarried = ch;

}

int CHARACTER::GetMarriageBonus(DWORD dwItemVnum, bool bSum)

{

if (IsNPC())

return 0;

marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());

if (!pMarriage)

return 0;

return pMarriage->GetBonus(dwItemVnum, bSum, this);

}

void CHARACTER::ConfirmWithMsg(const char* szMsg, int iTimeout, DWORD dwRequestPID)

{

if (!IsPC())

return;

TPacketGCQuestConfirm p;

p.header = HEADER_GC_QUEST_CONFIRM;

p.requestPID = dwRequestPID;

p.timeout = iTimeout;

strlcpy(p.msg, szMsg, sizeof(p.msg));

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

}

int CHARACTER::GetPremiumRemainSeconds(BYTE bType) const

{

if (bType >= PREMIUM_MAX_NUM)

return 0;

return m_aiPremiumTimes[bType] - get_global_time();

}

bool CHARACTER::WarpToPID(DWORD dwPID)

{

LPCHARACTER victim;

if ((victim = (CHARACTER_MANAGER::instance().FindByPID(dwPID))))

{

if (victim->GetMapIndex() >= 10000)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("player_in_dungeon"));

return false;

}

if (victim->GetMapIndex() == 202 && GetLevel() < 75)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("lvl_to_low"));

return false;

}

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

}

void ShopFix(int channel)

{

}

#ifdef __CHANNEL_CHANGE_SYSTEM__

bool CHARACTER::ChannelChange(int channel)

{

if (!IsPC() || channel == g_bChannel)

return false;

long lAddr;

WORD wPort;

long x = GetX();

long y = GetY();

long lMapIndex = GetMapIndex();

if (GetLevel() < chChange_nLevel)

{

ChatPacket(CHAT_TYPE_INFO, "You need to be at least Lv. %d for change CH In-Game.", chChange_nLevel);

return false;

}

if (GetGold() < chChange_nYang)

{

ChatPacket(CHAT_TYPE_INFO, "You need to pay %d Yang for change CH In-Game.", chChange_nYang);

return false;

}

if (chChange_map_allow_find(lMapIndex))

{

ChatPacket(CHAT_TYPE_INFO, "You can't change the CH from this map!");

return false;

}

char szQuery[512];

snprintf(szQuery, sizeof(szQuery), "SELECT port, host FROM %smap_list WHERE channel = %d AND map_index = %ld", get_table_postfix(), channel, lMapIndex);

SQLMsg *msg = DBManager::instance().DirectQuery(szQuery);

MYSQL_RES *res = msg->Get()->pSQLResult;

if (!res)

{

ChatPacket(1, "Cannot find map %d on channel %d", lMapIndex, channel);

return false;

}

int rows;

if ((rows = mysql_num_rows(res)) <= 0)

{

ChatPacket(1, "Cannot find map %d on channel %d", lMapIndex, channel);

return false;

}

for (int i = 0; i < rows; ++i)

{

MYSQL_ROW row = mysql_fetch_row(res);

int cur = 0;

str_to_number(wPort, row[cur++]);

str_to_number(lAddr, row[cur++]);

}

if (chChange_port_allow_find(wPort))

{

ChatPacket(CHAT_TYPE_INFO, "You can't go to the CH choosed!");

return false;

}

if (g_iUserLimit > 0)

{

int iTotal;

int * paiEmpireUserCount;

int iLocal;

DESC_MANAGER::instance().GetUserCount(iTotal, &paiEmpireUserCount, iLocal);

if (g_iUserLimit <= iTotal)

{

ChatPacket(1, "Channel %d is FULL", channel);

return false;

}

}

#ifdef FULL_YANG

long long yang = GetGold()-chChange_nYang;

SetGold(yang);

#else

PointChange(POINT_GOLD, -chChange_nYang, false);

#endif

//ChatPacket(CHAT_TYPE_COMMAND, "channel %d", channel);

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 port %d", GetName(), x, y, GetMapIndex(), lMapIndex, wPort);

TPacketGCWarp p;

p.bHeader = HEADER_GC_WARP;

p.lX = x;

p.lY = y;

p.lAddr = lAddr;

p.wPort = wPort;

GetDesc()->Packet(&p, sizeof(TPacketGCWarp));

return true;

}

#endif

void CHARACTER::CostumeFix()

{

//if (IsPC())

//{

// if (GetQuestFlag("kostium.zmiana") == 1)

// {

// SetPart(PART_MAIN, WEAR_BODY);

// UpdatePacket();

// ChatPacket(CHAT_TYPE_INFO, "Updatuje na PART_BODY");

// }

// else

// {

// //SetPart(PART_MAIN, GetVnum());

// UpdatePacket();

// ChatPacket(CHAT_TYPE_INFO, "Updatuje na item->GetVnum()");

// }

//}

if (IsPC())

{

UpdatePacket() ;

ComputePoints() ;

}

}

void CHARACTER::ChannelSwitch(int newChannel) {

int ChannelPorts[5][3] = { {13000, 13001, 13002}, {16000, 16001, 16002}, {18000, 18001, 18002}, {20000, 20001, 20002}, {22000, 22001, 22002} }; //, {3005, 3055, 3105}, };

long lAddr, lMapIndex;

WORD wPort;

long x = GetX();

long y = GetY();

if (!CMapLocation::Instance().Get(x, y, lMapIndex, lAddr, wPort)) {

sys_err("Can not find map location index[%ld] x[%ld] y[%ld] name[%s]", lMapIndex, x, y, GetName());

return;

}

if (lMapIndex >= 10000 || (int)wPort == 13099 || GetDungeon())

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("CANNOT_CHANGE_CHANNEL"));

return;

}

int newPort = 0;

switch((int) wPort)

{

case 13000:

case 16000:

case 18000:

case 20000:

case 22000:

newPort = ChannelPorts[newChannel-1][0];

break;

case 13001:

case 16001:

case 18001:

case 20001:

case 22001:

newPort = ChannelPorts[newChannel-1][1];

break;

case 13002:

case 16002:

case 18002:

case 20002:

case 22002:

newPort = ChannelPorts[newChannel-1][2];

break;

default:

break;

}

if (newPort == 0)

return;

if (!CanWarp())

return;

ForgetMyAttacker();

Stop();

Save();

if (GetSectree()) {

GetSectree()->RemoveEntity(this);

ViewCleanup();

EncodeRemovePacket(this); }

TPacketGCWarp p;

p.bHeader = HEADER_GC_WARP;

p.lX    = x;

p.lY    = y;

p.lAddr = lAddr;

p.wPort = newPort;

GetDesc()->Packet(&p, sizeof(TPacketGCWarp));

}

#ifdef ANTY_DAMAGE_HACK

void CHARACTER::SetLastTimeDmg(std::string name, int value)

{

itertype(m_map_DmgTime) it = m_map_DmgTime.find(name);

if (it != m_map_DmgTime.end())

it->second = value;

else

m_map_DmgTime.insert(make_pair(name, value));

}

int CHARACTER::GetLastTimeDmg(std::string name)

{

itertype(m_map_DmgTime) it = m_map_DmgTime.find(name);

if (it != m_map_DmgTime.end())

return it->second;

else

return 0;

}

void CHARACTER::ClearLastTimeDmg()

{

m_map_DmgTime.clear();

}

#endif

#ifdef GIFT_SYSTEM

#include <boost/algorithm/string.hpp>

EVENTFUNC(gift_refresh_event)

{

char_event_info* info = dynamic_cast<char_event_info*>(event->info);

if (info == NULL)

{

sys_err("gift_refresh_event> <Factor> Null pointer");

return 0;

}

LPCHARACTER ch = info->ch;

if (NULL == ch || ch->IsNPC())

return 0;

ch->RefreshGift();

return PASSES_PER_SEC(5 * 60);

}

void CHARACTER::StartRefreshGift()

{

if (m_pkGiftRefresh)

return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkGiftRefresh = event_create(gift_refresh_event, info, PASSES_PER_SEC(1)); // 1o?

}

void SendGift(LPCHARACTER ch, TGiftItem item)

{

char szSockets[1024] = { '\0' };

int szSocketsLen=0;

for (int soc = 0; soc < ITEM_SOCKET_MAX_NUM; soc++)

szSocketsLen += snprintf(szSockets+szSocketsLen, sizeof(szSockets)-szSocketsLen, "%ld%s", item.alSockets[soc], (soc<ITEM_SOCKET_MAX_NUM - 1 ? "|" : ""));

char szAttrs[1024] = { '\0' };

int szAttrsLen = 0;

for (int attr = 0; attr < ITEM_ATTRIBUTE_MAX_NUM; attr++)

szAttrsLen += snprintf(szAttrs+szAttrsLen, sizeof(szAttrs)-szAttrsLen, "%u,%d%s", item.aAttr[attr].bType, item.aAttr[attr].sValue, (attr<ITEM_ATTRIBUTE_MAX_NUM - 1 ? "|" : ""));

char szCMD[1024] = {0};

int szLength = 0;

#ifdef FULL_YANG

szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, "gift_item %d#%d#%lld#%d#%d#%s#%s#%s#%s",item.id, item.vnum, item.count, item.pos, item.dwDateAdd, item.szFrom, item.szReason, szSockets, szAttrs);

#else

szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, "gift_item %d#%d#%d#%d#%d#%s#%s#%s#%s",item.id, item.vnum, item.count, item.pos, item.dwDateAdd, item.szFrom, item.szReason, szSockets, szAttrs);

#endif

#ifdef ENABLE_TRANSMUTE_SYSTEM

szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, "#%d", item.look);

#endif

ch->ChatPacket(CHAT_TYPE_COMMAND, szCMD);

memset(&szSockets, 0, sizeof(szSockets));

memset(&szAttrs, 0, sizeof(szAttrs));

memset(&szCMD, 0, sizeof(szCMD));

}

void CHARACTER::LoadGiftPage(int page)

{

page = MINMAX(1, page, m_mapGiftGrid.size());

ChatPacket(CHAT_TYPE_COMMAND, "gift_clear");

GIFT_MAP::iterator it = m_mapGiftGrid.find(page);

if (it == m_mapGiftGrid.end())

return;

m_dwLastGiftPage = page;

for (int i = 0; i < it->second.size(); i++)

SendGift(this, it->second[i]);

ChatPacket(CHAT_TYPE_COMMAND, "gift_load");

}

static CGrid* grid;

void CHARACTER::AddGiftGrid(int page)

{

if (m_mapGiftGrid.find(page) == m_mapGiftGrid.end())

{

std::vector<TGiftItem> vec;

m_mapGiftGrid.insert(std::make_pair(page, vec));

}

}

int CHARACTER::AddGiftGridItem(int page, int size)

{

AddGiftGrid(page);

int iPos = grid->FindBlank(1, size);

if (iPos < 0)

return -1;

if (!grid->IsEmpty(iPos, 1, size))

return -1;

grid->Put(iPos, 1, size);

return iPos;

}

void CHARACTER::RefreshGift()

{

char szSockets[1024] = { '\0' };

char *tempSockets = szSockets;

for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)

{

tempSockets += sprintf(tempSockets, "socket%d", i);

if (i<ITEM_SOCKET_MAX_NUM - 1)

tempSockets += sprintf(tempSockets, ",");

}

char szAttrs[1024] = { '\0' };

char *tempAttrs = szAttrs;

for (int i = 0; i < ITEM_ATTRIBUTE_MAX_NUM; i++)

{

if (i < 7)

tempAttrs += sprintf(tempAttrs, "attrtype%d,attrvalue%d", i, i);

else

tempAttrs += sprintf(tempAttrs, "applytype%d,applyvalue%d", i - 7, i - 7);

if (i<ITEM_ATTRIBUTE_MAX_NUM - 1)

tempAttrs += sprintf(tempAttrs, ",");

}

std::auto_ptr<SQLMsg>pkMsg(DBManager::instance().DirectQuery(

"SELECT id,vnum,count,"

#ifdef ENABLE_TRANSMUTE_SYSTEM

"look,"

#endif

"UNIX_TIMESTAMP(date_add),REPLACE(reason,' ','_'),REPLACE(`from`,' ','_'),%s,%s FROM player_gift where owner_id = %d and status = 'WAIT' ORDER BY date_add ",

szSockets, szAttrs, GetPlayerID())

);

SQLResult * pRes = pkMsg->Get();

m_mapGiftGrid.clear();

grid = M2_NEW CGrid(15, 8);

grid->Clear();

int page = 1;

if (pRes->uiNumRows>0)

{

AddGiftGrid(page);

MYSQL_ROW row;

while ((row = mysql_fetch_row(pRes->pSQLResult)) != NULL)

{

int col = 0;

TGiftItem item;

memset(&item, 0, sizeof(item));

str_to_number(item.id, row[col++]);

str_to_number(item.vnum, row[col++]);

str_to_number(item.count, row[col++]);

#ifdef ENABLE_TRANSMUTE_SYSTEM

str_to_number(item.look, row[col++]);

#endif

str_to_number(item.dwDateAdd, row[col++]);

strlcpy(item.szReason, row[col++], sizeof(item.szReason) - 1);

strlcpy(item.szFrom, row[col++], sizeof(item.szFrom) - 1);

for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)

str_to_number(item.alSockets[i], row[col++]);

for (int i = 0; i < ITEM_ATTRIBUTE_MAX_NUM; i++)

{

str_to_number(item.aAttr[i].bType, row[col++]);

str_to_number(item.aAttr[i].sValue, row[col++]);

}

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(item.vnum);

if (!item_table)

continue;

int iPos = AddGiftGridItem(page, item_table->bSize);

if (iPos < 0)

{

page++;

grid->Clear();

iPos = AddGiftGridItem(page, item_table->bSize);

if (iPos < 0)

{

sys_err("iPos <0");

break;

}

}

item.pos = iPos;

m_mapGiftGrid[page].push_back(item);

}

M2_DELETE(grid);

if (GetGiftPages()>0)

ChatPacket(CHAT_TYPE_COMMAND, "gift_info %d", GetGiftPages());

}

}

#endif

#ifdef OFFLINE_SHOP

extern std::map<DWORD, DWORD> g_ShopIndexCount;

extern std::map<int, TShopCost> g_ShopCosts;

int get_offline_shops_count()

{

int cnt=0;

CharacterVectorInteractor i;

if (CHARACTER_MANAGER::instance().GetCharactersByRaceNum(30000, i))

{

CharacterVectorInteractor::iterator it = i.begin();

while (it != i.end()) {

LPCHARACTER pc = *it++;

if (pc && pc->IsPrivShop())

++cnt;

}

}

return cnt;

}

void CHARACTER::OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount, DWORD id)

{

if (g_ShopCosts.find(id) == g_ShopCosts.end())

{

sys_log(0, "Shop days error %s %d", c_pszSign, id);

return;

}

int days = g_ShopCosts[id].days;

long long price = g_ShopCosts[id].price;

if (price > 0 && GetGold() < price)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_NEED_MONEY"), price);

return;

}

if (days == 0 && GetPart(PART_MAIN) > 2)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_987f5b44210444d9f99365cb415a9ee9"));

return;

}

if (GetMyShop())

{

CloseMyShop();

return;

}

int gShopMax = quest::CQuestManager::Instance().GetEventFlag("shop_max");

if (m_mapshops.size() >= (gShopMax ? gShopMax : 2))

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_MAX_ERR"));

return;

}

if (g_ShopIndexCount.count(GetMapIndex())>0)

{

int shop_max = g_ShopIndexCount[GetMapIndex()];

#ifdef SHOP_ONLY_ALLOWED_INDEX

bool block = (shop_max > 0 ? (get_offline_shops_count() >= shop_max): false);

#else

bool block = (get_offline_shops_count() >= shop_max);

#endif

if (block)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_MAP_MAX"));

return;

}

}

#ifdef SHOP_ONLY_ALLOWED_INDEX

else

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_CANNOT_OPEN_HERE"));

return;

}

#endif

if (GetMyShop())

{

CloseMyShop();

return;

}

#ifndef FULL_YANG

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

#else

long long nTotalMoney = GetGold();

for (int n = 0; n < bItemCount; ++n)

nTotalMoney += (pTable + n)->price;

#endif

if (GOLD_MAX <= nTotalMoney)

{

sys_err("[OVERFLOW_GOLD] Overflow (GOLD_MAX) id %u name %s", GetPlayerID(), GetName());

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_a63bef352db11de2b934bce71d8e11d6"));

return;

}

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

if (pPC->IsRunning())

return;

std::vector<TShopItemTable *> map_shop;

for (BYTE i = 0; i < bItemCount; ++i)

{

// 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("HASH_7499a9fd04587f7f3d6af3c9d46b9d00"));

return;

}

if (pkItem->IsEquipped())

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_31cc6cc69598ac44fdbd43e57bad25ff"));

return;

}

if (pkItem->isLocked())

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_484fd2e80b394d521341cd089734e63e"));

return;

}

if (pkItem->GetOwner() != this)

{

return;

}

#ifdef SOULBIND_SYSTEM

if (pkItem->IsSoulBind())

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_3225c935119ae0ac342911794a5ba0b7"));

return;

}

#endif

}

if (days != 0)

map_shop.push_back(pTable++);

}

if (days != 0 && map_shop.size() == 0)

return;

m_stShopSign = c_pszSign;

if (m_stShopSign.length()>30)

m_stShopSign.resize(30);

#ifdef STRING_PROTECTION

if (CBanwordManager::instance().CheckString(m_stShopSign.c_str(), m_stShopSign.length()) != "")

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_b4a17db4bfe12e1bf505e59a4a47e50b"));

return;

}

#else

if (CBanwordManager::instance().CheckString(m_stShopSign.c_str(), m_stShopSign.length()))

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("HASH_b4a17db4bfe12e1bf505e59a4a47e50b"));

return;

}

#endif

if (m_pkExchange)

m_pkExchange->Cancel();

if (price > 0)

#ifdef FULL_YANG_OWN

ChangeGold(-price);

#else

PointChange(POINT_GOLD, -price);

#endif

if (days != 0)

{

CShopManager::instance().CreateOfflineShop(this, m_stShopSign.c_str(), map_shop, id);

m_stShopSign.clear();

return;

}

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));

PacketAround(&p, sizeof(TPacketGCShopSign));

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

if (!m_pkMyShop)

{

sys_err("Cannot open normal shop %s %s", GetName(), m_stShopSign.c_str());

return;

}

if (IsPolymorphed() == true)

{

RemoveAffect(AFFECT_POLYMORPH);

}

if (GetHorse())

{

HorseSummon(false, true);

}

else if (GetMountVnum())

{

RemoveAffect(AFFECT_MOUNT);

RemoveAffect(AFFECT_MOUNT_BONUS);

}

SetPolymorph(30000, true);

}

void CHARACTER::SetShopSign(const char * name)

{

m_stShopSign = name;

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));

PacketAround(&p, sizeof(TPacketGCShopSign));

}

TPrivShop CHARACTER::GetPrivShopTable(DWORD id)

{

TPrivShop shop;

memset(&shop, 0, sizeof(TPrivShop));

PSHOP_MAP::iterator it = m_mapshops.find(id);

if (it != m_mapshops.end())

return it->second;

return shop;

}

void CHARACTER::UpdatePrivShopTable(DWORD id, TPrivShop shop)

{

if (m_mapshops.find(id) != m_mapshops.end())

m_mapshops[id] = shop;

SendShops();

}

void CHARACTER::RemovePrivShopTable(DWORD id)

{

if (m_mapshops.find(id) != m_mapshops.end())

m_mapshops.erase(m_mapshops.find(id));

SendShops();

}

void CHARACTER::UpdateShopItems()

{

LPSHOP npcshop = GetMyShop();

LPCHARACTER owner = CHARACTER_MANAGER::instance().FindByPID(GetPrivShopOwner());

if (!npcshop || !IsPrivShop())

return;

npcshop->ClearItems();

std::vector<TShopItemTable *> map_shop;

char szSockets[1024] = { '\0' };

char *tempSockets = szSockets;

for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)

{

tempSockets += sprintf(tempSockets, "socket%d", i);

if (i<ITEM_SOCKET_MAX_NUM - 1)

tempSockets += sprintf(tempSockets, ",");

}

char szAttrs[1024] = { '\0' };

char *tempAttrs = szAttrs;

for (int i = 0; i < ITEM_ATTRIBUTE_MAX_NUM; i++)

{

if (i < 7)

tempAttrs += sprintf(tempAttrs, "attrtype%d,attrvalue%d", i, i);

else

tempAttrs += sprintf(tempAttrs, "applytype%d,applyvalue%d", i - 7, i - 7);

if (i<ITEM_ATTRIBUTE_MAX_NUM - 1)

tempAttrs += sprintf(tempAttrs, ",");

}

std::auto_ptr<SQLMsg>Msg(DBManager::instance().DirectQuery(

"SELECT id,vnum,count,"

#ifdef ENABLE_TRANSMUTE_SYSTEM

"look,"

#endif

"display_pos,price,%s,%s from player_shop_items where shop_id='%d'", szSockets, szAttrs, GetPrivShop()));

memset(&szAttrs, 0, sizeof(szAttrs));

memset(&szSockets, 0, sizeof(szSockets));

DWORD attr, soc;

long val;

SQLResult * Res = Msg->Get();

if (Res->uiNumRows > 0)

{

MYSQL_ROW row;

while ((row = mysql_fetch_row(Res->pSQLResult)) != NULL)

{

int col = 0;

TShopItemTable *shop = new TShopItemTable;

memset(shop, 0, sizeof(TShopItemTable));

DWORD id;

shop->pos.window_type = INVENTORY;

str_to_number(id, row[col++]);

str_to_number(shop->vnum, row[col++]);

str_to_number(shop->count, row[col++]);

#ifdef ENABLE_TRANSMUTE_SYSTEM

str_to_number(shop->look, row[col++]);

#endif

str_to_number(shop->display_pos, row[col++]);

//col++;

str_to_number(shop->price, row[col++]);

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(shop->vnum);

if (!item_table)

{

sys_err("Shop: no item table by item vnum #%d", shop->vnum);

continue;

}

for (int i = 0; i < INVENTORY_MAX_NUM; ++i)

{

if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetRealID() == id)

GetInventoryItem(i)->RemoveFromCharacter();

}

LPITEM item = ITEM_MANAGER::instance().CreateItem(shop->vnum, shop->count, id, false, -1, true);

if (-1 == (shop->pos.cell = GetEmptyInventory(item_table->bSize)))

{

sys_err("no empty position in npc inventory");

return;

}

if (item)

{

item->ClearAttribute();

item->SetRealID(id);

#ifdef ENABLE_TRANSMUTE_SYSTEM

item->SetLook(shop->look);

#endif

for (int s = 0; s<ITEM_SOCKET_MAX_NUM; s++)

{

str_to_number(soc, row[col++]);

item->SetSocket(s, soc, false);

}

for (int at = 0; at<ITEM_ATTRIBUTE_MAX_NUM; at++)

{

str_to_number(attr, row[col++]);

str_to_number(val, row[col++]);

item->SetForceAttribute(at, attr, val);

}

item->AddToCharacter(this, shop->pos);

}

else

{

sys_err("%d is not item", shop->vnum);

continue;

}

map_shop.push_back(shop);

}

}

if (map_shop.size() == 0 || map_shop.size() > SHOP_HOST_ITEM_MAX_NUM)

{

DeleteMyShop();

return;

}

npcshop->SetPrivShopItems(map_shop);

for (int i = 0; i < SHOP_HOST_ITEM_MAX_NUM; i++)

npcshop->BroadcastUpdateItem(i);

if (owner)

{

owner->LoadPrivShops();

owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_EDIT_SUCCESS"));

}

}

void CHARACTER::LoadPrivShops()

{

m_mapshops.clear();

std::auto_ptr<SQLMsg>pkMsg(DBManager::instance().DirectQuery("SELECT id,shop_vid,replace(replace(name,' ','\\\\'),'#','_'),gold,item_count,(select count(id) from player_shop_items where shop_id=player_shop.id),DATEDIFF(date_close,now()) AS days,UNIX_TIMESTAMP(date_close) from player_shop WHERE player_id=%d", GetPlayerID()));

SQLResult * pRes = pkMsg->Get();

if (pRes->uiNumRows>0)

{

MYSQL_ROW row;

while ((row = mysql_fetch_row(pRes->pSQLResult)) != NULL)

{

int col = 0;

TPrivShop shop;

memset(&shop, 0, sizeof(TPrivShop));

str_to_number(shop.shop_id, row[col++]);

str_to_number(shop.shop_vid, row[col++]);

strlcpy(shop.szSign, row[col++], sizeof(shop.szSign));

if(strlen(shop.szSign) == 0)

strlcpy(shop.szSign, LC_TEXT("SHOP_NONAME"), sizeof(shop.szSign));

str_to_number(shop.gold, row[col++]);

str_to_number(shop.item_count, row[col++]);

str_to_number(shop.rest_count, row[col++]);

str_to_number(shop.days, row[col++]);

str_to_number(shop.date_close, row[col++]);

m_mapshops.insert(std::make_pair(shop.shop_id, shop));

}

}

SendShops();

}

void CHARACTER::SendShops(bool isGm)

{

ChatPacket(CHAT_TYPE_COMMAND, "shop_clear");

PSHOP_MAP::iterator it = m_mapshops.begin();

while (it != m_mapshops.end())

{

ChatPacket(CHAT_TYPE_COMMAND, "shop_add %d %d %s %lld %d %d %d %d", it->second.shop_id, it->second.shop_vid, it->second.szSign, it->second.gold, it->second.item_count, it->second.rest_count, it->second.days, it->second.date_close);

it++;

}

}

void CHARACTER::SendShopCost()

{

extern std::map<int, TShopCost> g_ShopCosts;

ChatPacket(CHAT_TYPE_COMMAND, "shop_cost_clear");

std::map<int, TShopCost>::iterator it = g_ShopCosts.begin();

while (it != g_ShopCosts.end())

{

ChatPacket(CHAT_TYPE_COMMAND, "shop_cost %d %d %d %d", it->first, it->second.days, it->second.time, it->second.price);

it++;

}

}

void CHARACTER::OpenShop(DWORD id, const char *name, bool onboot)

{

if (GetMyShop())

{

CloseMyShop();

return;

}

if (IsPC())

return;

char szSockets[1024] = { '\0' };

char *tempSockets = szSockets;

for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)

{

tempSockets += sprintf(tempSockets, "socket%d", i);

if (i<ITEM_SOCKET_MAX_NUM - 1)

tempSockets += sprintf(tempSockets, ",");

}

char szAttrs[1024] = { '\0' };

char *tempAttrs = szAttrs;

for (int i = 0; i < ITEM_ATTRIBUTE_MAX_NUM; i++)

{

if (i < 7)

tempAttrs += sprintf(tempAttrs, "attrtype%d,attrvalue%d", i, i);

else

tempAttrs += sprintf(tempAttrs, "applytype%d,applyvalue%d", i - 7, i - 7);

if (i<ITEM_ATTRIBUTE_MAX_NUM - 1)

tempAttrs += sprintf(tempAttrs, ",");

}

std::auto_ptr<SQLMsg>pkMsg(DBManager::instance().DirectQuery(

"SELECT id,vnum,count,"

#ifdef ENABLE_TRANSMUTE_SYSTEM

"look,"

#endif

"display_pos,price,%s,%s from player_shop_items where shop_id='%d'", szSockets, szAttrs, id));

memset(&szSockets, 0, sizeof(szSockets));

memset(&szAttrs, 0, sizeof(szAttrs));

SQLResult * pRes = pkMsg->Get();

BYTE bItemCount = pRes->uiNumRows;

TShopItemTable * m_pShopTable = new TShopItemTable[bItemCount];

memset(&m_pShopTable[0], 0, sizeof(TShopItemTable) * bItemCount);

std::vector<TShopItemTable *> map_shop;

if (bItemCount>0)

{

bItemCount = 0;

MYSQL_ROW row;

int c = 0;

while ((row = mysql_fetch_row(pRes->pSQLResult)) != NULL)

{

int col = 0;

TShopItemTable *shop = new TShopItemTable;

memset(shop, 0, sizeof(TShopItemTable));

DWORD id;

shop->pos.window_type = INVENTORY;

str_to_number(id, row[col++]);

str_to_number(shop->vnum, row[col++]);

str_to_number(shop->count, row[col++]);

#ifdef ENABLE_TRANSMUTE_SYSTEM

str_to_number(shop->look, row[col++]);

#endif

str_to_number(shop->display_pos, row[col++]);

//col++;

str_to_number(shop->price, row[col++]);

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(shop->vnum);

if (!item_table)

{

sys_err("Shop: no item table by item vnum #%d", shop->vnum);

continue;

}

if (-1 == (shop->pos.cell = GetEmptyInventory(item_table->bSize)))

{

sys_err("no empty position in npc inventory");

return;

}

LPITEM item = ITEM_MANAGER::instance().CreateItem(shop->vnum, shop->count, 0, false, -1, true);

if (item)

{

item->ClearAttribute();

item->SetSkipSave(true);

item->SetRealID(id);

#ifdef ENABLE_TRANSMUTE_SYSTEM

item->SetLook(shop->look);

#endif

for (int s = 0; s<ITEM_SOCKET_MAX_NUM; s++)

{

DWORD soc;

str_to_number(soc, row[col++]);

item->SetSocket(s, soc, false);

}

for (int at = 0; at<ITEM_ATTRIBUTE_MAX_NUM; at++)

{

DWORD attr;

long val;

str_to_number(attr, row[col++]);

str_to_number(val, row[col++]);

item->SetForceAttribute(at, attr, val);

}

item->AddToCharacter(this, shop->pos);

}

else

{

sys_err("%d is not item", shop->vnum);

continue;

}

map_shop.push_back(shop);

++bItemCount;

}

}

if (bItemCount == 0 && !onboot || bItemCount > SHOP_HOST_ITEM_MAX_NUM)

return;

m_stShopSign = name;

if (m_stShopSign.length()>30)

m_stShopSign.resize(30);

if (m_stShopSign.length() == 0 && !onboot)

return;

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));

PacketAround(&p, sizeof(TPacketGCShopSign));

m_pkMyShop = CShopManager::instance().CreateNPCShop(this, map_shop);

}

void CHARACTER::DeleteMyShop()

{

if (GetMyShop())

{

LPCHARACTER owner = CHARACTER_MANAGER::instance().FindByPID(GetPrivShopOwner());

if(get_global_time() - GetShopEditModeTick() < 20)

{

if (owner)

{

owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT( "SHOP_SUCCESS_TOO_FAST"));

}else{

TPacketShopClose packet;

packet.shop_id = GetPrivShop();

packet.pid = GetPrivShopOwner();

packet.error = true;

packet.reload = false;

db_clientdesc->DBPacket(HEADER_GD_SHOP_CLOSE, 0, &packet, sizeof(packet));

}

return;

}

std::auto_ptr<SQLMsg>pkMsg(DBManager::instance().DirectQuery("SELECT gold FROM player_shop where id='%d'", GetPrivShop()));

SQLResult * pRes = pkMsg->Get();

if (pRes->uiNumRows>0)

{

MYSQL_ROW row;

while ((row = mysql_fetch_row(pRes->pSQLResult)) != NULL)

{

long long gold;

str_to_number(gold, row[0]);

if (gold>0)

{

DBManager::instance().DirectQuery("INSERT INTO player_gift SET \

owner_id=%d,vnum=1,count='%s',reason=\"%s\",`from`=replace(\"%s\",' ','_'),status='WAIT',date_add=NOW()",

GetPrivShopOwner(), row[0], LC_TEXT("SHOP_REASON"), GetName());

}

}

GetMyShop()->GetItems();

if (owner)

{

#ifdef GIFT_SYSTEM

owner->RefreshGift();

#endif

owner->RemovePrivShopTable(GetPrivShop());

owner->SendShops();

owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("SHOP_SUCCESS_CLOSE"));

}

else {

TPacketShopClose packet;

packet.shop_id = GetPrivShop();

packet.pid = GetPrivShopOwner();

packet.error = false;

packet.reload = false;

db_clientdesc->DBPacket(HEADER_GD_SHOP_CLOSE, 0, &packet, sizeof(packet));

}

std::unique_ptr<SQLMsg> (DBManager::instance().DirectQuery("delete from player_shop where id='%d'", GetPrivShop()));

CloseMyShop();

}

return;

}

M2_DESTROY_CHARACTER(this);

}

EVENTFUNC(RefreshShopEvent)

{

char_event_info* info = dynamic_cast<char_event_info*>(event->info);

if (info == NULL)

{

sys_err("ishop_refresh_event> <Factor> Null pointer");

return 0;

}

LPCHARACTER ch = info->ch;

if (NULL == ch)

return 0;

ch->SendShops();

ch->SendShopCost();

if (ch->GetGiftPages()>0)

ch->ChatPacket(CHAT_TYPE_COMMAND, "gift_info %d", ch->GetGiftPages());

return PASSES_PER_SEC(10);

}

void CHARACTER::StartRefreshShopEvent()

{

if (m_pkRefreshShopEvent)

return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkRefreshShopEvent = event_create(RefreshShopEvent, info, PASSES_PER_SEC(1)); // 1o?

}

EVENTFUNC(ShopEditModeEvent)

{

char_event_info* info = dynamic_cast<char_event_info*>(event->info);

if (info == NULL)

{

sys_err("ShopEditModeEvent> <Factor> Null pointer");

return 0;

}

LPCHARACTER ch = info->ch;

if (NULL == ch)

return 0;

if(!ch->GetMyShop() || !ch->IsPrivShop())

return 0;

if(ch->GetShopEditMode() && get_global_time() - ch->GetShopEditModeTick() > 5)

ch->SetShopEditMode(false);

return PASSES_PER_SEC(6);

}

void CHARACTER::SetShopEditMode(bool val)

{

m_bShopEditMode = val;

GetMyShop()->SetLocked(val);

if(val)

GetMyShop()->RemoveGuests(this);

else

UpdateShopItems();

std::unique_ptr<SQLMsg> (DBManager::instance().DirectQuery("UPDATE player_shop SET edit_mode=%d WHERE id=%d", val, GetPrivShop()));

}

void CHARACTER::SetShopEditModeTick()

{

m_dwShopEditModeTick = get_global_time();

}

void CHARACTER::StartShopEditModeEvent()

{

if (m_pkEditShopEvent)

return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkEditShopEvent = event_create(ShopEditModeEvent, info, PASSES_PER_SEC(1)); // 1o?

}

#endif

Author

Title

Language

Your paste - Paste your paste here

#include &quot;stdafx.h&quot;
#include &quot;../../common/VnumHelper.h&quot;

#include &quot;char.h&quot;

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

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&amp; ch, int map_index);

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

// &lt;Factor&gt; 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&amp; DynamicCharacterPtr::operator=(LPCHARACTER character) {
	if (character == NULL) {
		Reset();
		return *this;
	}
	if (character-&gt;IsPC()) {
		is_pc = true;
		id = character-&gt;GetPlayerID();
	} else {
		is_pc = false;
		id = character-&gt;GetVID();
	}
	return *this;
}

CHARACTER::CHARACTER()
{
	m_stateIdle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateIdle, &amp;CHARACTER::EndStateEmpty);
	m_stateMove.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateMove, &amp;CHARACTER::EndStateEmpty);
	m_stateBattle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateBattle, &amp;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);

#ifdef OFFLINE_SHOP
	m_pkRefreshShopEvent = NULL;
	bprivShop = 0;
	bprivShopOwner = 0;
	bprivShop = 0;
	bprivShopOwner = 0;
	dw_ShopTime = 0;
	m_mapshops.clear();
	m_pkEditShopEvent = NULL;
	m_bShopEditMode = false;
	m_dwShopEditModeTick = 0;
#endif
#ifdef GIFT_SYSTEM
	m_pkGiftRefresh = NULL;
	m_dwLastGiftPage = 0;
	m_mapGiftGrid.clear();
#endif
	m_pkDestroyWhenIdleEvent = NULL;

m_pkChrSyncOwner = NULL;

memset(&amp;m_points, 0, sizeof(m_points));
	memset(&amp;m_pointsInstant, 0, sizeof(m_pointsInstant));
	memset(&amp;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(&quot;arena_potion_limit_count&quot;);
	// 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 = &quot;&quot;;

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;

m_petSystem = 0;
	m_bIsPet = false;

m_fAttMul = 1.0f;
	m_fDamMul = 1.0f;

m_pointsInstant.iDragonSoulActiveDeck = -1;

memset(&amp;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), &quot;%s%p%d&quot;, 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-&gt;IsValidRegen(m_pkRegen, regen_id_)) {
				--m_pkRegen-&gt;count;
			}
		} else {
			// Is this really safe?
			--m_pkRegen-&gt;count;
		}
		m_pkRegen = NULL;
	}

if (m_pkDungeon)
	{
		SetDungeon(NULL);
	}

if (m_petSystem)
	{
		m_petSystem-&gt;Destroy();
		delete m_petSystem;

m_petSystem = 0;
	}

HorseSummon(false);

if (GetRider())
		GetRider()-&gt;ClearHorseInfo();

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

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

if (m_pkExchange)
		m_pkExchange-&gt;Cancel();

SetVictim(NULL);

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

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

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

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

if (!IsPC())
				party-&gt;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(&amp;m_pkWarpNPCEvent);
	event_cancel(&amp;m_pkRecoveryEvent);
	event_cancel(&amp;m_pkDeadEvent);
	event_cancel(&amp;m_pkSaveEvent);
	event_cancel(&amp;m_pkTimedEvent);
	event_cancel(&amp;m_pkStunEvent);
	event_cancel(&amp;m_pkFishingEvent);
	event_cancel(&amp;m_pkPoisonEvent);
	event_cancel(&amp;m_pkFireEvent);
	event_cancel(&amp;m_pkPartyRequestEvent);
	//DELAYED_WARP
	event_cancel(&amp;m_pkWarpEvent);
	event_cancel(&amp;m_pkCheckSpeedHackEvent);
	//END_DELAYED_WARP

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

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

StopHackShieldCheckCycle();

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

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

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

event_cancel(&amp;m_pkDestroyWhenIdleEvent);

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

CEntity::Destroy();

if (GetSectree())
		GetSectree()-&gt;RemoveEntity(this);

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

#ifdef OFFLINE_SHOP
	event_cancel(&amp;m_pkRefreshShopEvent);
	m_pkRefreshShopEvent = NULL;
	bprivShop = 0;
	bprivShopOwner = 0;
	bprivShop = 0;
	bprivShopOwner = 0;
	dw_ShopTime = 0;
	m_mapshops.clear();
	event_cancel(&amp;m_pkEditShopEvent);
	m_pkEditShopEvent = NULL;
	m_bShopEditMode = false;
	m_dwShopEditModeTick = 0;
#endif
#ifdef GIFT_SYSTEM
	m_pkGiftRefresh = NULL;
	m_dwLastGiftPage = 0;
	m_mapGiftGrid.clear();
#endif
}

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

void CHARACTER::OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount)
{
	if (GetMyShop())
	{
		CloseMyShop();
		return;
	}

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

if (pPC-&gt;IsRunning())
		return;

if (bItemCount == 0)
		return;

int64_t nTotalMoney = 0;

for (int n = 0; n &lt; bItemCount; ++n)
	{
		nTotalMoney += static_cast&lt;int64_t&gt;((pTable+n)-&gt;price);
	}

nTotalMoney += static_cast&lt;int64_t&gt;(GetGold());

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(&quot;şńĽÓľîłŞ Ŕşľî°ˇ Ć÷ÇÔµČ »óÁˇ ŔĚ¸§Ŕ¸·Î »óÁˇŔ» ż Ľö ľř˝Ŕ´Ď´Ů.&quot;));	
			return;
		}
	}

// MYSHOP_PRICE_LIST
	std::map&lt;DWORD, DWORD&gt; itemkind;  // ľĆŔĚĹŰ Áľ·ůş° °ˇ°Ý, first: vnum, second: ´ÜŔĎ Ľö·® °ˇ°Ý
	// END_OF_MYSHOP_PRICE_LIST

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

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

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

if (item_table &amp;&amp; (IS_SET(item_table-&gt;dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP)))
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ŔŻ·áČ ľĆŔĚĹŰŔş °łŔÎ»óÁˇżˇĽ ĆÇ¸ĹÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
				return;
			}

if (pkItem-&gt;IsEquipped() == true)
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ŔĺşńÁßŔÎ ľĆŔĚĹŰŔş °łŔÎ»óÁˇżˇĽ ĆÇ¸ĹÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
				return;
			}

if (true == pkItem-&gt;isLocked())
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»çżëÁßŔÎ ľĆŔĚĹŰŔş °łŔÎ»óÁˇżˇĽ ĆÇ¸ĹÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
				return;
			}

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

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

// MYSHOP_PRICE_LIST
	// ş¸µű¸® °łĽö¸¦ °¨ĽŇ˝ĂĹ˛´Ů. 
	if (CountSpecifyItem(71049)) { // şń´Ü ş¸µű¸®´Â ľřľÖÁö ľĘ°í °ˇ°ÝÁ¤ş¸¸¦ ŔúŔĺÇŃ´Ů.

//
		// ľĆŔĚĹŰ °ˇ°ÝÁ¤ş¸¸¦ ŔúŔĺÇĎ±â Ŕ§ÇŘ ľĆŔĚĹŰ °ˇ°ÝÁ¤ş¸ ĆĐĹ¶Ŕ» ¸¸µéľî DB Äł˝Ăżˇ ş¸ł˝´Ů.
		//
		TPacketMyshopPricelistHeader header;
		TItemPriceInfo info;
		
		header.dwOwnerID = GetPlayerID();
		header.byCount = itemkind.size();

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

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

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

db_clientdesc-&gt;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-&gt;Cancel();

TPacketGCShopSign p;

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

PacketAround(&amp;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(&amp;p, sizeof(p));

#ifdef OFFLINE_SHOP
		if (IsPrivShop())
		{
			M2_DESTROY_CHARACTER(this);
			return;
		}
#endif
		SetPolymorph(GetJob(), true);
	}
}
void EncodeMovePacket(TPacketGCMove &amp; 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++)-&gt;first;

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

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

// Entityżˇ ł»°ˇ łŞĹ¸łµ´Ů°í ĆĐĹ¶Ŕ» ş¸ł˝´Ů.
void CHARACTER::EncodeInsertPacket(LPENTITY entity)
{

LPDESC d;

if (!(d = entity-&gt;GetDesc()))
		return;

// ±ćµĺŔĚ¸§ ąö±× ĽöÁ¤ ÄÚµĺ
	LPCHARACTER ch = (LPCHARACTER) entity;
	ch-&gt;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 &lt;= 0)
		{
			pack.x = m_posDest.x;
			pack.y = m_posDest.y;
		}
	}

d-&gt;Packet(&amp;pack, sizeof(pack));

if (IsPC() == true || m_bCharType == CHAR_TYPE_NPC)
	{
		TPacketGCCharacterAdditionalInfo addPacket;
		memset(&amp;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 &amp;&amp; (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-&gt;GetEmpire() || ch-&gt;GetGMLevel() &gt; 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:
#if defined(SHOP_HIDE_NAME) &amp;&amp; defined(OFFLINE_SHOP)
		if (IsPC() || GetRaceNum() != 30000 &amp;&amp; !IsPrivShop())
#endif
			strlcpy(addPacket.name, GetName(), sizeof(addPacket.name));

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

addPacket.sAlignment = m_iAlignment / 10;
		}

d-&gt;Packet(&amp;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-&gt;Packet(&amp;pack, sizeof(pack));

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

d-&gt;Packet(&amp;p, sizeof(p));
	}

if (entity-&gt;IsType(ENTITY_CHARACTER) &amp;&amp; GetDesc())
	{
		LPCHARACTER ch = (LPCHARACTER) entity;
		if (ch-&gt;IsWalking())
		{
			TPacketGCWalkMode p;
			p.vid = ch-&gt;GetVID();
			p.header = HEADER_GC_WALK_MODE;
			p.mode = ch-&gt;m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;
			GetDesc()-&gt;Packet(&amp;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-&gt;Packet(&amp;p, sizeof(TPacketGCShopSign));
	}

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

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

LPDESC d;

if (!(d = entity-&gt;GetDesc()))
		return;

TPacketGCCharacterDelete pack;

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

d-&gt;Packet(&amp;pack, sizeof(TPacketGCCharacterDelete));

if (entity-&gt;IsType(ENTITY_CHARACTER))
		sys_log(3, &quot;EntityRemove %s(%d) FROM %s&quot;, GetName(), (DWORD) m_vid, ((LPCHARACTER) entity)-&gt;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()-&gt;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-&gt;first;

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

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

if (GetDesc() != NULL)
		{
			GetDesc()-&gt;Packet(&amp;pack, sizeof(pack));
		}
	}
	else
	{
		PacketAround(&amp;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-&gt;first-&gt;IsType(ENTITY_CHARACTER))
			continue;

LPCHARACTER tch = (LPCHARACTER) it-&gt;first;

if (bFindPCOnly &amp;&amp; tch-&gt;IsNPC())
			continue;

if (!strcasecmp(tch-&gt;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(&amp;m_pkDeadEvent);
		event_cancel(&amp;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(&quot;[BATTLE] ˝Îżě´Â »óĹÂ&quot;);

GotoState(m_stateBattle);
				break;

default:
				if (!IsState(m_stateIdle))
					MonsterLog(&quot;[IDLE] ˝¬´Â »óĹÂ&quot;);

GotoState(m_stateIdle);
				break;
		}
	}

m_pointsInstant.position = pos;
}

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

void CHARACTER::CreatePlayerProto(TPlayerTable &amp; tab)
{
	memset(&amp;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()-&gt;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 &gt; 60000)
	{
		if (GetSectree() &amp;&amp; !GetSectree()-&gt;IsAttr(GetX(), GetY(), ATTR_BANPK))
		{
			if (GetRealAlignment() &lt; 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, &quot;SAVE: %s %dx%d&quot;, 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 &lt; QUICKSLOT_MAX_NUM; ++i)
		tab.quickslot[i] = m_quickslot[i];

if (m_stMobile.length() &amp;&amp; !*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(&quot;Character::Save : no descriptor when saving (name: %s)&quot;, GetName());
		return;
	}

TPlayerTable table;
	CreatePlayerProto(table);

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

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

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

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

void CHARACTER::FlushDelayedSaveItem()
{
	// ŔúŔĺ ľČµČ ĽŇÁöÇ°Ŕ» ŔüşÎ ŔúŔĺ˝ĂĹ˛´Ů.
	LPITEM item;

for (int i = 0; i &lt; 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, &quot;DISCONNECT: %s (%s)&quot;, GetName(), c_pszReason ? c_pszReason : &quot;unset&quot; );

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

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

if (GetParty() != NULL)
	{
		GetParty()-&gt;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(&amp;p, sizeof(TPacketGGLogout));
	char buf[51];
	snprintf(buf, sizeof(buf), &quot;%s %d %d %ld %d&quot;, 
		inet_ntoa(GetDesc()-&gt;GetAddr().sin_addr), GetGold(), g_bChannel, GetMapIndex(), GetAlignment());

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

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

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

if (m_pWarMap)
		SetWarMap(NULL);

if (m_pWeddingMap)
	{
		SetWeddingMap(NULL);
	}

if (GetGuild())
		GetGuild()-&gt;LogoutMember(this);

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

if (GetParty())
		GetParty()-&gt;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 (GetDesc())
	{
		GetDesc()-&gt;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, &quot;cannot find sectree by %dx%d mapindex %d&quot;, x, y, lMapIndex);
		return false;
	}

SetMapIndex(lMapIndex);

bool bChangeTree = false;

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

if (bChangeTree)
	{
		if (GetSectree())
			GetSectree()-&gt;RemoveEntity(this);

ViewCleanup();
	}

if (!IsNPC())
	{
		sys_log(0, &quot;SHOW: %s %dx%dx%d&quot;, GetName(), x, y, z);
		if (GetStamina() &lt; GetMaxStamina())
			StartAffectEvent();
	}
	else if (m_pkMobData)
	{
		m_pkMobInst-&gt;m_posLastAttacked.x = x;
		m_pkMobInst-&gt;m_posLastAttacked.y = y;
		m_pkMobInst-&gt;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-&gt;InsertEntity(this);

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

REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);
	
	SetValidComboInterval(0);
	return true;
}

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

typedef std::map&lt;unsigned, BGMInfo&gt; BGMInfoMap;

static BGMInfoMap 	gs_bgmInfoMap;
static bool		gs_bgmVolEnable = false;

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

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, &quot;bgm_info.add_info(%d, '%s', %f)&quot;, mapIndex, name, vol);
}

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

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

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

// SUPPORT_BGM
	if (!bgmInfo.name.empty())
	{
		if (CHARACTER_IsBGMVolumeEnable())
		{
			sys_log(1, &quot;bgm_info.play_bgm_vol(%d, name='%s', vol=%f)&quot;, 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()-&gt;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()-&gt;Packet(&amp;mainChrPacket, sizeof(TPacketGCMainCharacter4_BGM_VOL));
		}
		else
		{
			sys_log(1, &quot;bgm_info.play(%d, '%s')&quot;, 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()-&gt;GetEmpire();
			mainChrPacket.skill_group = GetSkillGroup();
			strlcpy(mainChrPacket.szChrName, GetName(), sizeof(mainChrPacket.szChrName));
			strlcpy(mainChrPacket.szBGMName, bgmInfo.name.c_str(), sizeof(mainChrPacket.szBGMName));
			GetDesc()-&gt;Packet(&amp;mainChrPacket, sizeof(TPacketGCMainCharacter3_BGM));
		}
		//if (m_stMobile.length())
		//		ChatPacket(CHAT_TYPE_COMMAND, &quot;sms&quot;);
	}
	// END_OF_SUPPORT_BGM
	else
	{
		sys_log(0, &quot;bgm_info.play(%d, DEFAULT_BGM_NAME)&quot;, 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()-&gt;GetEmpire();
		pack.skill_group = GetSkillGroup();
		strlcpy(pack.szName, GetName(), sizeof(pack.szName));
		GetDesc()-&gt;Packet(&amp;pack, sizeof(TPacketGCMainCharacter));

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

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 &lt; POINT_MAX_NUM; ++i)
		pack.points[i] = GetPoint(i);

GetDesc()-&gt;Packet(&amp;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(&quot;CHANGE_SEX: %s unknown race %d&quot;, GetName(), src_race);
			return false;
	}

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

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

if (m_pkMobData)
		return m_pkMobData-&gt;m_table.dwVnum;

return m_points.job;
}

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

m_points.job = race;
}

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

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

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

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

if (IsPC())
	{
		if (level &lt; 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()-&gt;GetHostName())
		sys_err(&quot;cannot get desc or hostname&quot;);
	else
		SetGMLevel();

m_bCharType = CHAR_TYPE_PC;

m_dwPlayerID = t-&gt;id;

m_iAlignment = t-&gt;lAlignment;
	m_iRealAlignment = t-&gt;lAlignment;

m_points.voice = t-&gt;voice;

m_points.skill_group = t-&gt;skill_group;

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

m_points.iRandomHP = t-&gt;sRandomHP;
	m_points.iRandomSP = t-&gt;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-&gt;skills, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
	// END_OF_REMOVE_REAL_SKILL_LEVLES

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

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

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

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

SetPoint(POINT_STAT_RESET_COUNT, t-&gt;stat_reset_count);

SetPoint(POINT_LEVEL_STEP, t-&gt;level_step);
	SetRealPoint(POINT_LEVEL_STEP, t-&gt;level_step);

SetRace(t-&gt;job);

SetLevel(t-&gt;level);
	SetExp(t-&gt;exp);
	SetGold(t-&gt;gold);

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

ComputePoints();

SetHP(t-&gt;hp);
	SetSP(t-&gt;sp);
	SetStamina(t-&gt;stamina);

//GMŔĎ¶§ ş¸ČŁ¸đµĺ  
	if (!test_server)
	{
		if (GetGMLevel() &gt; GM_LOW_WIZARD)
		{
			m_afAffectFlag.Set(AFF_YMIR);
			m_bPKMode = PK_MODE_PROTECT;
		}
	}

if (GetLevel() &lt; PK_PROTECT_LEVEL)
		m_bPKMode = PK_MODE_PROTECT;
	#ifdef ANTY_DAMAGE_HACK
ClearLastTimeDmg();
#endif
	m_stMobile = t-&gt;szMobile;

SetHorseData(t-&gt;horse);

if (GetHorseLevel() &gt; 0)
		UpdateHorseDataByLogoff(t-&gt;logoff_interval);

thecore_memcpy(m_aiPremiumTimes, t-&gt;aiPremiumTimes, sizeof(t-&gt;aiPremiumTimes));

m_dwLogOffInterval = t-&gt;logoff_interval;

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

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

if (m_petSystem)
	{
		m_petSystem-&gt;Destroy();
		delete m_petSystem;
	}

m_petSystem = M2_NEW CPetSystem(this);
}

EVENTFUNC(kill_ore_load_event)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;kill_ore_load_even&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;
	if (ch == NULL) { // &lt;Factor&gt;
		return 0;
	}

ch-&gt;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 = &amp;m_pkMobData-&gt;m_table;

m_bCharType = t-&gt;bType;

SetLevel(t-&gt;bLevel);
	SetEmpire(t-&gt;bEmpire);

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

ComputePoints();

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

////////////////////
	m_pointsInstant.dwAIFlag = t-&gt;dwAIFlag;
	SetImmuneFlag(t-&gt;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, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlag, &amp;CHARACTER::EndStateEmpty);
		m_stateMove.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlag, &amp;CHARACTER::EndStateEmpty);
		m_stateBattle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlag, &amp;CHARACTER::EndStateEmpty);
	}

if (warmap::IsWarFlagBase(GetRaceNum()))
	{
		m_stateIdle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlagBase, &amp;CHARACTER::EndStateEmpty);
		m_stateMove.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlagBase, &amp;CHARACTER::EndStateEmpty);
		m_stateBattle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateFlagBase, &amp;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, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateHorse, &amp;CHARACTER::EndStateEmpty);
		m_stateMove.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateMove, &amp;CHARACTER::EndStateEmpty);
		m_stateBattle.Set(this, &amp;CHARACTER::BeginStateEmpty, &amp;CHARACTER::StateHorse, &amp;CHARACTER::EndStateEmpty);
	}

// MINING
	if (mining::IsVeinOfOre (GetRaceNum()))
	{
		char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;ch = this;

m_pkMiningEvent = event_create(kill_ore_load_event, info, PASSES_PER_SEC(number(7 * 60, 15 * 60)));
	}
	// END_OF_MINING
}

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

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

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

DWORD CHARACTER::GetMobDamageMax() const
{
	return m_pkMobData-&gt;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-&gt;m_table.dwDropItemVnum;
}

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

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

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

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

BYTE CHARACTER::GetMobRank() const
{
	if (!m_pkMobData)
		return MOB_RANK_KNIGHT;	// PCŔĎ °ćżě KNIGHT±Ţ

return m_pkMobData-&gt;m_table.bRank;
}

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

return m_pkMobData-&gt;m_table.bSize;
}

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

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

return (m_pkMobData-&gt;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-&gt;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(&quot;invalid job %d&quot;, GetJob());
				iStatAtk = (2 * GetPoint(POINT_ST));
				break;
		}

// ¸»Ŕ» Ĺ¸°í ŔÖ°í, ˝şĹČŔ¸·Î ŔÎÇŃ °ř°Ý·ÂŔĚ ST*2 ş¸´Ů ł·Ŕ¸¸é ST*2·Î ÇŃ´Ů.
		// ˝şĹČŔ» Ŕß¸ř ÂďŔş »ç¶÷ °ř°Ý·ÂŔĚ ´ő ł·Áö ľĘ°Ô ÇĎ±â Ŕ§ÇŘĽ´Ů.
		if (GetMountVnum() &amp;&amp; iStatAtk &lt; 2 * GetPoint(POINT_ST))
			iStatAtk = (2 * GetPoint(POINT_ST));

iAtk += iStatAtk;

// ˝Â¸¶(¸») : °ËĽö¶ó µĄąĚÁö °¨ĽŇ  
		if (GetMountVnum())
		{
			if (GetJob() == JOB_SURA &amp;&amp; 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 &lt; WEAR_MAX_NUM; ++i)
			if ((pkItem = GetWear(i)) &amp;&amp; pkItem-&gt;GetType() == ITEM_ARMOR)
			{
				if (pkItem-&gt;GetSubType() == ARMOR_BODY || pkItem-&gt;GetSubType() == ARMOR_HEAD || pkItem-&gt;GetSubType() == ARMOR_FOOTS || pkItem-&gt;GetSubType() == ARMOR_SHIELD)
				{
					iArmor += pkItem-&gt;GetValue(1);
					iArmor += (2 * pkItem-&gt;GetValue(5));
				}
			}

// ¸» Ĺ¸°í ŔÖŔ» ¶§ ąćľî·ÂŔĚ ¸»ŔÇ ±âÁŘ ąćľî·Âş¸´Ů ł·Ŕ¸¸é ±âÁŘ ąćľî·ÂŔ¸·Î ĽłÁ¤
		if( true == IsHorseRiding() )
		{
			if (iArmor &lt; GetHorseArmor())
				iArmor = GetHorseArmor();

const char* pHorseName = CHorseNameManager::instance().GetHorseName(GetPlayerID());

if (pHorseName != NULL &amp;&amp; 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-&gt;SetPointVar(&quot;k&quot;, 1.0f * GetSkillPower(SKILL_ADD_HP) / 100.0f);

iMaxHP += static_cast&lt;int&gt;(pkSk-&gt;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-&gt;m_table.dwMaxHP;
		iMaxSP = 0;
		iMaxStamina = 0;

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

if (IsPC())
	{
		// ¸» Ĺ¸°í ŔÖŔ» ¶§´Â ±âş» ˝şĹČŔĚ ¸»ŔÇ ±âÁŘ ˝şĹČş¸´Ů ł·Ŕ¸¸é łô°Ô ¸¸µç´Ů.
		// µű¶óĽ ¸»ŔÇ ±âÁŘ ˝şĹČŔĚ ą«»ç ±âÁŘŔĚąÇ·Î, Ľö¶ó/ą«´çŔş ŔüĂĽ ˝şĹČ ÇŐŔĚ
		// ´ëĂ¤ŔűŔ¸·Î ´ő żĂ¶ó°ˇ°Ô µÉ °ÍŔĚ´Ů.
		if (GetMountVnum()) 
		{
			if (GetHorseST() &gt; GetPoint(POINT_ST))
				PointChange(POINT_ST, GetHorseST() - GetPoint(POINT_ST));

if (GetHorseDX() &gt; GetPoint(POINT_DX))
				PointChange(POINT_DX, GetHorseDX() - GetPoint(POINT_DX));

if (GetHorseHT() &gt; GetPoint(POINT_HT))
				PointChange(POINT_HT, GetHorseHT() - GetPoint(POINT_HT));

if (GetHorseIQ() &gt; 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 &lt; WEAR_MAX_NUM; i++) 
	{
		LPITEM pItem = GetWear(i);
		if (pItem)
		{
			pItem-&gt;ModifyPoints(true);
			SET_BIT(m_pointsInstant.dwImmuneFlag, GetWear(i)-&gt;GetImmuneFlag());
		}
	}

// żëČĄĽ® ˝Ă˝şĹŰ
	// ComputePointsżˇĽ´Â ÄÉ¸ŻĹÍŔÇ ¸đµç ĽÓĽş°ŞŔ» ĂĘ±âČÇĎ°í,
	// ľĆŔĚĹŰ, ąöÇÁ µîżˇ °ü·ĂµČ ¸đµç ĽÓĽş°ŞŔ» Ŕç°č»ęÇĎ±â ¶§ą®żˇ,
	// żëČĄĽ® ˝Ă˝şĹŰµµ ActiveDeckżˇ ŔÖ´Â ¸đµç żëČĄĽ®ŔÇ ĽÓĽş°ŞŔ» ´Ů˝Ă Ŕűżë˝ĂÄŃľß ÇŃ´Ů.
	if (DragonSoul_IsDeckActivated())
	{
		for (int i = WEAR_MAX_NUM + DS_SLOT_MAX * DragonSoul_GetActiveDeck(); 
			i &lt; WEAR_MAX_NUM + DS_SLOT_MAX * (DragonSoul_GetActiveDeck() + 1); i++)	
		{
			LPITEM pItem = GetWear(i);
			if (pItem)
			{
				if (DSManager::instance().IsTimeLeftDragonSoul(pItem))
					pItem-&gt;ModifyPoints(true);
			}
		}
	}

if (GetHP() &gt; GetMaxHP())
		PointChange(POINT_HP, GetMaxHP() - GetHP());

if (GetSP() &gt; GetMaxSP())
		PointChange(POINT_SP, GetMaxSP() - GetSP());

ComputeSkillPoints();

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

for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
	{
		it-&gt;second-&gt;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&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;recovery_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (ch == NULL) { // &lt;Factor&gt;
		return 0;
	}

if (!ch-&gt;IsPC())
	{
		//
		// ¸ó˝şĹÍ Č¸şą
		//
		if (ch-&gt;IsAffectFlag(AFF_POISON))
			return PASSES_PER_SEC(MAX(1, ch-&gt;GetMobTable().bRegenCycle));

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

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

regenPct += (val*cnt);

break;
				}
			}

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

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

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

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

return PASSES_PER_SEC(MAX(1, ch-&gt;GetMobTable().bRegenCycle));
	}
	else
	{
		//
		// PC Č¸şą
		//
		ch-&gt;CheckTarget();
		//ch-&gt;UpdateSectree(); // ż©±âĽ ŔĚ°É żÖÇĎÁö?
		ch-&gt;UpdateKillerMode();

if (ch-&gt;IsAffectFlag(AFF_POISON) == true)
		{
			// Áßµ¶ŔÎ °ćżě ŔÚµżČ¸şą ±ÝÁö
			// ĆÄąýĽúŔÎ °ćżě ŔÚµżČ¸şą ±ÝÁö
			return 3;
		}

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

// SP Č¸şą ·çĆľ.
		// żÖ ŔĚ°É·Î ÇŘĽ ÇÔĽö·Î »©łů´Â°ˇ ?!
		ch-&gt;DistributeSP(ch);

if (ch-&gt;GetMaxHP() &lt;= ch-&gt;GetHP())
			return PASSES_PER_SEC(3);

int iPercent = 0;
		int iAmount = 0;
		
		{
			iPercent = aiRecoveryPercents[MIN(9, iSec)];
			iAmount = 15 + (ch-&gt;GetMaxHP() * iPercent) / 100;
		}
		
		iAmount += (iAmount * ch-&gt;GetPoint(POINT_HP_REGEN)) / 100;

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

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

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

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

if (IsNPC() &amp;&amp; GetHP() &gt;= GetMaxHP()) // ¸ó˝şĹÍ´Â ĂĽ·ÂŔĚ ´Ů Â÷ŔÖŔ¸¸é ˝ĂŔŰ ľČÇŃ´Ů.
		return;

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;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, &quot;STANDUP: %s&quot;, GetName());

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

PacketAround(&amp;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, &quot;SITDOWN: %s&quot;, GetName());

pack_position.header	= HEADER_GC_CHARACTER_POSITION;
	pack_position.vid		= GetVID();
	pack_position.position	= POSITION_SITTING_GROUND;
	PacketAround(&amp;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 &lt; 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(&quot;cannot find tree at %d %d (name: %s)&quot;, x, y, GetName());
			GetDesc()-&gt;SetPhase(PHASE_CLOSE);
		}
		else
		{
			sys_err(&quot;no tree: %s %d %d %d&quot;, GetName(), x, y, GetMapIndex());
			Dead();
		}

return false;
	}

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

if (GetDungeon())
	{
		// ´řÁŻżë ŔĚşĄĆ® ĽÓĽş şŻČ
		int iLastEventAttr = m_iEventAttr;
		m_iEventAttr = new_tree-&gt;GetEventAttribute(x, y);

if (m_iEventAttr != iLastEventAttr)
		{
			if (GetParty())
			{
				quest::CQuestManager::instance().AttrOut(GetParty()-&gt;GetLeaderPID(), this, iLastEventAttr);
				quest::CQuestManager::instance().AttrIn(GetParty()-&gt;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-&gt;GetID();
			SECTREEID old_id = GetSectree()-&gt;GetID();

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

new_tree-&gt;InsertEntity(this);
	}

return true;
}

void CHARACTER::Stop()
{
	if (!IsState(m_stateIdle))
		MonsterLog(&quot;[IDLE] Á¤Áö&quot;);

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 &amp;&amp; GetY() == y)
		return false;

if (m_posDest.x == x &amp;&amp; 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(&quot;[MOVE] %s&quot;, GetVictim() ? &quot;´ë»óĂßŔű&quot; : &quot;±×łÉŔĚµż&quot;);

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-&gt;GetProto()-&gt;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() &amp;&amp; IsPC()) ? MOTION_WALK : MOTION_RUN));
	else
	{
		pkMotion = CMotionManager::instance().GetMotion(GetMountVnum(), MAKE_MOTION_KEY(MOTION_MODE_GENERAL, (IsWalking() &amp;&amp; IsPC()) ? MOTION_WALK : MOTION_RUN));

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

if (pkMotion)
		return -pkMotion-&gt;GetAccumVector().y / pkMotion-&gt;GetDuration();
	else
	{
		sys_err(&quot;cannot find motion (name %s race %d mode %d)&quot;, 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, &quot;%s: GOTO: distance %f, spd %u, duration %u, motion speed %f pos %d %d -&gt; %d %d&quot;,
				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 &amp;&amp; GetY() == y)
		return true;

if (test_server)
		if (m_bDetailLog)
			sys_log(0, &quot;%s position %u %u&quot;, 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(&amp;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() &amp;&amp; !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 &amp;&amp; GetSkillGroup() == 2)
						return pMob-&gt;m_table.bStr * iPower / 100 + GetPoint(POINT_IQ);
					return pMob-&gt;m_table.bStr * iPower / 100 + GetPoint(POINT_ST);

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

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

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

return GetPoint(type);
}

int CHARACTER::GetPoint(BYTE type) const
{
	if (type &gt;= POINT_MAX_NUM)
	{
		sys_err(&quot;Point type overflow (type %u)&quot;, 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 &gt; max_val)
		sys_err(&quot;POINT_ERROR: %s type %d val %d (max: %d)&quot;, GetName(), val, max_val);

return (val);
}

int CHARACTER::GetLimitPoint(BYTE type) const
{
	if (type &gt;= POINT_MAX_NUM)
	{
		sys_err(&quot;Point type overflow (type %u)&quot;, 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 &gt; max_val)
		sys_err(&quot;POINT_ERROR: %s type %d val %d (max: %d)&quot;, GetName(), val, max_val);

if (val &gt; limit)
		val = limit;

if (val &lt; min_limit)
		val = min_limit;

return (val);
}

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

m_pointsInstant.points[type] = val;

// ľĆÁ÷ ŔĚµżŔĚ ´Ů ľČłˇłµ´Ů¸é ŔĚµż ˝Ă°Ł °č»ęŔ» ´Ů˝Ă ÇŘľß ÇŃ´Ů.
	if (type == POINT_MOV_SPEED &amp;&amp; get_dword_time() &lt; m_dwMoveStartTime + m_dwMoveDuration)
	{
		CalculateMoveDuration();
	}
}

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

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

if (GetMaxSP() &lt; GetSP())
		PointChange(POINT_SP, GetMaxSP() - GetSP());
}

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

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

switch (type)
	{
		case POINT_NONE:
			return;

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

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

sys_log(0, &quot;LEVELUP: %s %d NEXT EXP %d&quot;, 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()-&gt;LevelChange(GetPlayerID(), GetLevel());
				}

if (GetParty())
				{
					GetParty()-&gt;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, &quot;&lt;EXP_LOG&gt; %s = NONE&quot;, GetName());
					}
					else if (IsOverTime(OT_3HOUR))
					{
						amount = (amount / 2);
						dev_log(LOG_DEB0, &quot;&lt;EXP_LOG&gt; %s = 3HOUR&quot;, GetName());
					}
					else if (IsOverTime(OT_5HOUR))
					{
						amount = 0;
						dev_log(LOG_DEB0, &quot;&lt;EXP_LOG&gt; %s = 5HOUR&quot;, GetName());
					}
				}

// exp°ˇ 0 ŔĚÇĎ·Î °ˇÁö ľĘµµ·Ď ÇŃ´Ů
				if (amount &lt; 0 &amp;&amp; exp &lt; -amount)
				{
					sys_log(1, &quot;%s AMOUNT &lt; 0 %d, CUR EXP: %d&quot;, GetName(), -amount, exp);
					amount = -exp;

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

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

DWORD iExpBalance = 0;

// ·ąş§ ľ÷!
					if (exp + amount &gt;= 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 &gt;= 4)
					{
						sys_err(&quot;%s LEVEL_STEP bigger than 4! (%d)&quot;, GetName(), iLevStep);
						iLevStep = 4;
					}

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

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

val = GetExp();
				}
			}
			break;

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

switch (val)
				{
					case 1:
					case 2:
					case 3:
						//if (GetLevel() &lt; 100) PointChange(POINT_STAT, 1);
						if (GetLevel() &lt; 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() &gt;= 5)
									PointChange(POINT_SKILL, 1);

if (GetLevel() &gt;= 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() &lt;= 10)
					AutoGiveItem(27001, 2);
				else if (GetLevel() &lt;= 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() &amp;&amp; IsPC() &amp;&amp; val != prev_hp)
					GetParty()-&gt;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 &lt; 0 &amp;&amp; val != 0) // °¨ĽŇ´Â ş¸ł»ÁöľĘ´Â´Ů.
					return;
			}
			break;

case POINT_MAX_HP:
			{
                            
				SetPoint(type, GetPoint(type) + amount);
				int curMaxHP = GetMaxHP();
				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);
				float fRatio = (float)GetMaxHP() / (float)curMaxHP;
				PointChange(POINT_HP, GetHP() * fRatio - GetHP());
				val = GetMaxHP();
			}
			break;

case POINT_MAX_SP:
			{
				SetPoint(type, GetPoint(type) + amount);
				int curMaxSP = GetMaxSP();
				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);
				float fRatio = (float)GetMaxSP() / (float)curMaxSP;
				PointChange(POINT_SP, GetSP() * fRatio - GetSP());
				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&lt;int64_t&gt;(GetGold()) + static_cast&lt;int64_t&gt;(amount);

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

// Ă»ĽŇłâş¸ČŁ
				if (LC_IsNewCIBN() &amp;&amp; amount &gt; 0)
				{
					if (IsOverTime(OT_NONE))
					{
						dev_log(LOG_DEB0, &quot;&lt;GOLD_LOG&gt; %s = NONE&quot;, GetName());
					}
					else if (IsOverTime(OT_3HOUR))
					{
						amount = (amount / 2);
						dev_log(LOG_DEB0, &quot;&lt;GOLD_LOG&gt; %s = 3HOUR&quot;, GetName());
					}
					else if (IsOverTime(OT_5HOUR))
					{
						amount = 0;
						dev_log(LOG_DEB0, &quot;&lt;GOLD_LOG&gt; %s = 5HOUR&quot;, 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 &gt; 100)
			{
				sys_err(&quot;MALL_BONUS exceeded over 100!! point type: %d name: %s amount %d&quot;, 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 &gt; 100)
			{
				sys_err(&quot;BONUS exceeded over 100!! point type: %d name: %s amount %d&quot;, 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(&quot;CHARACTER::PointChange: %s: point cannot be changed. use SetPoint instead (type: %d)&quot;, 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(&quot;CHARACTER::PointChange: %s: unknown point change type %d&quot;, 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 &amp;&amp; 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()-&gt;Packet(&amp;pack, sizeof(struct packet_point_change));
		else
			PacketAround(&amp;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) &gt;&gt; 24);
				int iAdd = iVal &amp; 0x00800000;
				int iChange = iVal &amp; 0x007fffff;

sys_log(1, &quot;APPLY_SKILL skill %d add? %d change %d&quot;, bSkillVnum, iAdd ? 1 : 0, iChange);

if (0 == iAdd)
					iChange = -iChange;

std::unordered_map&lt;BYTE, int&gt;::iterator iter = m_SkillDamageBonus.find(bSkillVnum);

if (iter == m_SkillDamageBonus.end())
					m_SkillDamageBonus.insert(std::make_pair(bSkillVnum, iChange));
				else
					iter-&gt;second += iChange;
			}
			// END_OF_SKILL_DAMAGE_BONUS
			break;

case APPLY_STR:
		case APPLY_DEX:
		case APPLY_MAX_HP:
		case APPLY_MAX_HP_PCT:
			{
				if(GetMaxHP() == 0) break;
				PointChange(aApplyInfo[bApplyType].bPointType, iVal);
			}
			break;

case APPLY_MAX_SP:
		case APPLY_MAX_SP_PCT:
			{
				if(GetMaxSP() == 0) break;
				PointChange(aApplyInfo[bApplyType].bPointType, iVal);
			}
			break;
		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(&quot;Unknown apply type %d name %s&quot;, bApplyType, GetName());
			break;
	}
}

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

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

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

EVENTFUNC(save_event)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;save_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER ch = info-&gt;ch;

if (ch == NULL) { // &lt;Factor&gt;
		return 0;
	}	
	sys_log(1, &quot;SAVE_EVENT: %s&quot;, ch-&gt;GetName());
	ch-&gt;Save();
	ch-&gt;FlushDelayedSaveItem();
	return (save_event_second_cycle);
}

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

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;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), &quot;%u)&quot;, (DWORD)GetVID());

if (len &lt; 0 || len &gt;= (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 &lt; 0 || len2 &gt;= (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(&amp;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-&gt;GetEmpire();

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

d-&gt;Packet(buf.read_peek(), buf.size());

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

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

void CHARACTER::mining_cancel()
{
	if (m_pkMiningEvent)
	{
		sys_log(0, &quot;XXX MINING CANCEL&quot;);
		event_cancel(&amp;m_pkMiningEvent);
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;Ă¤±¤Ŕ» Áß´ÜÇĎż´˝Ŕ´Ď´Ů.&quot;));
	}
}

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

if (!chLoad)
		return;

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

LPITEM pick = GetWear(WEAR_WEAPON);

if (!pick || pick-&gt;GetType() != ITEM_PICK)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;°î±ŞŔĚ¸¦ ŔĺÂřÇĎĽĽżä.&quot;));
		return;
	}

int count = number(5, 15); // µżŔŰ Č˝Ľö, ÇŃ µżŔŰ´ç 2ĂĘ

// Ă¤±¤ µżŔŰŔ» ş¸ż©ÁÜ
	TPacketGCDigMotion p;
	p.header = HEADER_GC_DIG_MOTION;
	p.vid = GetVID();
	p.target_vid = chLoad-&gt;GetVID();
	p.count = count;

PacketAround(&amp;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-&gt;Find(x, y);
		DWORD dwAttr = tree-&gt;GetAttribute(x, y);

if (IS_SET(dwAttr, ATTR_BLOCK))
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ł¬˝Ă¸¦ ÇŇ Ľö ŔÖ´Â °÷ŔĚ ľĆ´Ő´Ď´Ů&quot;));
			return;
		}
	}

LPITEM rod = GetWear(WEAR_WEAPON);

// ł¬˝Ă´ë ŔĺÂř
	if (!rod || rod-&gt;GetType() != ITEM_ROD)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ł¬˝Ă´ë¸¦ ŔĺÂř ÇĎĽĽżä.&quot;));
		return;
	}

if (0 == rod-&gt;GetSocket(2))
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ąĚł˘¸¦ ł˘°í ´řÁ® ÁÖĽĽżä.&quot;));
		return;
	}

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

m_pkFishingEvent = fishing::CreateFishingEvent(this);
}

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

if (info)
				fishing::Take(info, this);
		}
	}
	else
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ł¬˝Ă´ë°ˇ ľĆ´Ń ą°°ÇŔ¸·Î ł¬˝Ă¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů!&quot;));
	}

event_cancel(&amp;m_pkFishingEvent);
}

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

return false;
}

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

void CHARACTER::UpdateStateMachine(DWORD dwPulse)
{
	if (dwPulse &lt; 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 &lt; 10)
		MonsterLog(&quot;´ŮŔ˝»óĹÂ·ÎľîĽ°ˇŔÚ&quot;);
}

// Äł¸ŻĹÍ ŔÎ˝şĹĎ˝ş ľ÷µĄŔĚĆ® ÇÔĽö.
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 &lt; PART_MAX_NUM);
	m_pointsInstant.parts[bPartPos] = wVal;
}

WORD CHARACTER::GetPart(BYTE bPartPos) const
{
	assert(bPartPos &lt; 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(&quot;SetSyncOwner owner == this (%p)&quot;, this);
		return false;
	}

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

if (m_pkChrSyncOwner)
			sys_log(1, &quot;SyncRelease %s %p from %s&quot;, GetName(), this, m_pkChrSyncOwner-&gt;GetName());

// ¸®˝şĆ®żˇĽ Á¦°ĹÇĎÁö ľĘ´ő¶óµµ Ć÷ŔÎĹÍ´Â NULL·Î ĽÂĆĂµÇľîľß ÇŃ´Ů.
		m_pkChrSyncOwner = NULL;
	}
	else
	{
		if (!IsSyncOwner(ch))
			return false;

// °Ĺ¸®°ˇ 200 ŔĚ»óŔĚ¸é SyncOwner°ˇ µÉ Ľö ľř´Ů.
		if (DISTANCE_APPROX(GetX() - ch-&gt;GetX(), GetY() - ch-&gt;GetY()) &gt; 250)
		{
			sys_log(1, &quot;SetSyncOwner distance over than 250 %s %s&quot;, GetName(), ch-&gt;GetName());

// SyncOwnerŔĎ °ćżě Owner·Î ÇĄ˝ĂÇŃ´Ů.
			if (m_pkChrSyncOwner == ch)
				return true;

return false;
		}

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

m_pkChrSyncOwner = ch;
			m_pkChrSyncOwner-&gt;m_kLst_pkChrSyncOwned.push_back(this);

// SyncOwner°ˇ ąŮ˛î¸é LastSyncTimeŔ» ĂĘ±âČÇŃ´Ů.
			static const timeval zero_tv = {0, 0};
			SetLastSyncTime(zero_tv);

sys_log(1, &quot;SetSyncOwner set %s %p to %s&quot;, GetName(), this, ch-&gt;GetName());
		}

m_fSyncTime = get_float_time();
	}

// TODO: Sync Owner°ˇ °°´ő¶óµµ °čĽÓ ĆĐĹ¶Ŕ» ş¸ł»°í ŔÖŔ¸ąÇ·Î,
	//       µż±âČ µČ ˝Ă°ŁŔĚ 3ĂĘ ŔĚ»ó ÁöłµŔ» ¶§ Ç®ľîÁÖ´Â ĆĐĹ¶Ŕ»
	//       ş¸ł»´Â ąć˝ÄŔ¸·Î ÇĎ¸é ĆĐĹ¶Ŕ» ÁŮŔĎ Ľö ŔÖ´Ů.
	TPacketGCOwnership pack;

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

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

struct FuncClearSync
{
	void operator () (LPCHARACTER ch)
	{
		assert(ch != NULL);
		ch-&gt;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 &gt;= 3.0f)
		return true;

return false;
}

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

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

sys_log(1, &quot;PARTY set to %p&quot;, get_pointer(pkParty));
// pt
	if (m_pkDungeon &amp;&amp; IsPC())
		SetDungeon(NULL);
// pt
	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;		///&lt; ĆÄĆĽżˇ Âüż©ÇŇ Äł¸ŻĹÍŔÇ PID
	DWORD	dwLeaderPID;		///&lt; ĆÄĆĽ ¸®´őŔÇ PID

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

EVENTFUNC(party_request_event)
{
	TPartyJoinEventInfo * info = dynamic_cast&lt;TPartyJoinEventInfo *&gt;(  event-&gt;info );

if ( info == NULL )
	{
		sys_err( &quot;party_request_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

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

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

return 0;
}

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

if (!leader)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ĆÄĆĽŔĺŔĚ Á˘ĽÓ »óĹÂ°ˇ ľĆ´Ď¶óĽ żäĂ»Ŕ» ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
		return false;
	}

if (m_pkPartyRequestEvent)
		return false;

if (!IsPC() || !leader-&gt;IsPC())
		return false;

if (leader-&gt;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(&quot;&lt;ĆÄĆĽ&gt; Ľąö ą®Á¦·Î ĆÄĆĽ °ü·Ă Ăł¸®¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return false;

case PERR_DIFFEMPIRE:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´Ů¸Ą Á¦±ą°ú ĆÄĆĽ¸¦ ŔĚ·ę Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return false;

case PERR_DUNGEON:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´řŔü ľČżˇĽ´Â ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); 
			return false;

case PERR_OBSERVER:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; °üŔü ¸đµĺżˇĽ± ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); 
			return false;

case PERR_LVBOUNDARY:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; -30 ~ +30 ·ąş§ ŔĚł»ŔÇ »ó´ëąć¸¸ ĂĘ´ëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů.&quot;)); 
			return false;

case PERR_LOWLEVEL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖ°í ·ąş§ ş¸´Ů 30·ąş§ŔĚ ł·ľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return false;

case PERR_HILEVEL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖŔú ·ąş§ ş¸´Ů 30·ąş§ŔĚ łôľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); 
			return false;

case PERR_ALREADYJOIN: 	
			return false;

case PERR_PARTYISFULL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´ő ŔĚ»ó ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); 
			return false;

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

TPartyJoinEventInfo* info = AllocEventInfo&lt;TPartyJoinEventInfo&gt;();

info-&gt;dwGuestPID = GetPlayerID();
	info-&gt;dwLeaderPID = leader-&gt;GetPlayerID();

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

leader-&gt;ChatPacket(CHAT_TYPE_COMMAND, &quot;PartyRequest %u&quot;, (DWORD) GetVID());
	ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;%s ´Ôżˇ°Ô ĆÄĆĽ°ˇŔÔ ˝ĹĂ»Ŕ» Çß˝Ŕ´Ď´Ů.&quot;), leader-&gt;GetName());
	return true;
}

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

if (!member-&gt;m_pkPartyRequestEvent)
		return;

TPartyJoinEventInfo * info = dynamic_cast&lt;TPartyJoinEventInfo *&gt;(member-&gt;m_pkPartyRequestEvent-&gt;info);

if (!info)
	{
		sys_err( &quot;CHARACTER::DenyToParty&gt; &lt;Factor&gt; Null pointer&quot; );
		return;
	}

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

if (info-&gt;dwLeaderPID != GetPlayerID())
		return;

event_cancel(&amp;member-&gt;m_pkPartyRequestEvent);

member-&gt;ChatPacket(CHAT_TYPE_COMMAND, &quot;PartyRequestDenied&quot;);
}

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

if (!member-&gt;m_pkPartyRequestEvent)
		return;

TPartyJoinEventInfo * info = dynamic_cast&lt;TPartyJoinEventInfo *&gt;(member-&gt;m_pkPartyRequestEvent-&gt;info);

if (!info)
	{
		sys_err( &quot;CHARACTER::AcceptToParty&gt; &lt;Factor&gt; Null pointer&quot; );
		return;
	}

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

if (info-&gt;dwLeaderPID != GetPlayerID())
		return;

event_cancel(&amp;member-&gt;m_pkPartyRequestEvent);

if (!GetParty())
		member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ĆÄĆĽżˇ ĽÓÇŘŔÖÁö ľĘ˝Ŕ´Ď´Ů.&quot;));
	else 
	{
		if (GetPlayerID() != GetParty()-&gt;GetLeaderPID())
			return;

PartyJoinErrCode errcode = IsPartyJoinableCondition(this, member);
		switch (errcode) 
		{
			case PERR_NONE: 		member-&gt;PartyJoin(this); return;
			case PERR_SERVER:		member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; Ľąö ą®Á¦·Î ĆÄĆĽ °ü·Ă Ăł¸®¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_DUNGEON:		member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´řŔü ľČżˇĽ´Â ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_OBSERVER: 	member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; °üŔü ¸đµĺżˇĽ± ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_LVBOUNDARY:	member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; -30 ~ +30 ·ąş§ ŔĚł»ŔÇ »ó´ëąć¸¸ ĂĘ´ëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_LOWLEVEL: 	member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖ°í ·ąş§ ş¸´Ů 30·ąş§ŔĚ ł·ľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_HILEVEL: 		member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖŔú ·ąş§ ş¸´Ů 30·ąş§ŔĚ łôľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;)); break;
			case PERR_ALREADYJOIN: 	break;
			case PERR_PARTYISFULL: {
									   ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´ő ŔĚ»ó ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
									   member-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽŔÇ ŔÎżřÁ¦ÇŃŔĚ ĂĘ°úÇĎż© ĆÄĆĽżˇ Âü°ˇÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
									   break;
								   }
			default: sys_err(&quot;Do not process party join error(%d)&quot;, errcode);
		}
	}

member-&gt;ChatPacket(CHAT_TYPE_COMMAND, &quot;PartyRequestDenied&quot;);
}

/**
 * ĆÄĆĽ ĂĘ´ë event callback ÇÔĽö.
 * event °ˇ ąßµżÇĎ¸é ĂĘ´ë °ĹŔý·Î Ăł¸®ÇŃ´Ů.
 */
EVENTFUNC(party_invite_event)
{
	TPartyJoinEventInfo * pInfo = dynamic_cast&lt;TPartyJoinEventInfo *&gt;(  event-&gt;info );

if ( pInfo == NULL )
	{
		sys_err( &quot;party_invite_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

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

if (pchInviter)
	{
		sys_log(1, &quot;PartyInviteEvent %s&quot;, pchInviter-&gt;GetName());
		pchInviter-&gt;PartyInviteDeny(pInfo-&gt;dwGuestPID);
	}

return 0;
}

void CHARACTER::PartyInvite(LPCHARACTER pchInvitee)
{
	if (GetParty() &amp;&amp; GetParty()-&gt;GetLeaderPID() != GetPlayerID())
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ŔÖ´Â ±ÇÇŃŔĚ ľř˝Ŕ´Ď´Ů.&quot;));
		return;
	}
	else if (pchInvitee-&gt;IsBlockMode(BLOCK_PARTY_INVITE))
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; %s ´ÔŔĚ ĆÄĆĽ °ĹşÎ »óĹÂŔÔ´Ď´Ů.&quot;), pchInvitee-&gt;GetName());
		return;
	}

PartyJoinErrCode errcode = IsPartyJoinableCondition(this, pchInvitee);

switch (errcode)
	{
		case PERR_NONE:
			break;

case PERR_SERVER:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; Ľąö ą®Á¦·Î ĆÄĆĽ °ü·Ă Ăł¸®¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_DIFFEMPIRE:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´Ů¸Ą Á¦±ą°ú ĆÄĆĽ¸¦ ŔĚ·ę Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_DUNGEON:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´řŔü ľČżˇĽ´Â ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_OBSERVER:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; °üŔü ¸đµĺżˇĽ± ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_LVBOUNDARY:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; -30 ~ +30 ·ąş§ ŔĚł»ŔÇ »ó´ëąć¸¸ ĂĘ´ëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_LOWLEVEL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖ°í ·ąş§ ş¸´Ů 30·ąş§ŔĚ ł·ľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_HILEVEL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖŔú ·ąş§ ş¸´Ů 30·ąş§ŔĚ łôľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_ALREADYJOIN:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ŔĚąĚ %s´ÔŔş ĆÄĆĽżˇ ĽÓÇŘ ŔÖ˝Ŕ´Ď´Ů.&quot;), pchInvitee-&gt;GetName());
			return;

case PERR_PARTYISFULL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´ő ŔĚ»ó ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

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

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

//
	// EventMap żˇ ŔĚşĄĆ® Ăß°ˇ
	// 
	TPartyJoinEventInfo* info = AllocEventInfo&lt;TPartyJoinEventInfo&gt;();

info-&gt;dwGuestPID = pchInvitee-&gt;GetPlayerID();
	info-&gt;dwLeaderPID = GetPlayerID();

m_PartyInviteEventMap.insert(EventMap::value_type(pchInvitee-&gt;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-&gt;GetDesc()-&gt;Packet(&amp;p, sizeof(p));
}

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

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

event_cancel(&amp;itFind-&gt;second);
	m_PartyInviteEventMap.erase(itFind);

if (GetParty() &amp;&amp; GetParty()-&gt;GetLeaderPID() != GetPlayerID())
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ŔÖ´Â ±ÇÇŃŔĚ ľř˝Ŕ´Ď´Ů.&quot;));
		return;
	}

PartyJoinErrCode errcode = IsPartyJoinableMutableCondition(this, pchInvitee);

switch (errcode)
	{
		case PERR_NONE:
			break;

case PERR_SERVER:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; Ľąö ą®Á¦·Î ĆÄĆĽ °ü·Ă Ăł¸®¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_DUNGEON:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´řŔü ľČżˇĽ´Â ĆÄĆĽ ĂĘ´ëżˇ ŔŔÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_OBSERVER:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; °üŔü ¸đµĺżˇĽ± ĆÄĆĽ ĂĘ´ë¸¦ ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_LVBOUNDARY:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; -30 ~ +30 ·ąş§ ŔĚł»ŔÇ »ó´ëąć¸¸ ĂĘ´ëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_LOWLEVEL:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖ°í ·ąş§ ş¸´Ů 30·ąş§ŔĚ ł·ľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_HILEVEL:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽł» ĂÖŔú ·ąş§ ş¸´Ů 30·ąş§ŔĚ łôľĆ ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_ALREADYJOIN:
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽ ĂĘ´ëżˇ ŔŔÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

case PERR_PARTYISFULL:
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ´ő ŔĚ»ó ĆÄĆĽżřŔ» ĂĘ´ëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			pchInvitee-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; ĆÄĆĽŔÇ ŔÎżřÁ¦ÇŃŔĚ ĂĘ°úÇĎż© ĆÄĆĽżˇ Âü°ˇÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return;

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

//
	// ĆÄĆĽ °ˇŔÔ Ăł¸®
	//

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

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

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

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

event_cancel(&amp;itFind-&gt;second);
	m_PartyInviteEventMap.erase(itFind);

LPCHARACTER pchInvitee = CHARACTER_MANAGER::instance().FindByPID(dwPID);
	if (pchInvitee)
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; %s´ÔŔĚ ĆÄĆĽ ĂĘ´ë¸¦ °ĹŔýÇĎĽĚ˝Ŕ´Ď´Ů.&quot;), pchInvitee-&gt;GetName());
}

void CHARACTER::PartyJoin(LPCHARACTER pLeader)
{
	pLeader-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; %s´ÔŔĚ ĆÄĆĽżˇ Âü°ˇÇĎĽĚ˝Ŕ´Ď´Ů.&quot;), GetName());
	ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;ĆÄĆĽ&gt; %s´ÔŔÇ ĆÄĆĽżˇ Âü°ˇÇĎĽĚ˝Ŕ´Ď´Ů.&quot;), pLeader-&gt;GetName());

pLeader-&gt;GetParty()-&gt;Join(GetPlayerID());
	pLeader-&gt;GetParty()-&gt;Link(this);
}

CHARACTER::PartyJoinErrCode CHARACTER::IsPartyJoinableCondition(const LPCHARACTER pchLeader, const LPCHARACTER pchGuest)
{
	if (pchLeader-&gt;GetEmpire() != pchGuest-&gt;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-&gt;GetLevel() - quest-&gt;GetLevel()) &lt;= level_limit);
}

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

return PERR_NONE;
}
// END_OF_PARTY_JOIN_BUG_FIX

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

if (m_pkDungeon == pkDungeon) {
		return;
	}

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

m_pkDungeon = pkDungeon;

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

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

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

m_pWarMap = pWarMap;

if (m_pWarMap)
		m_pWarMap-&gt;IncMember(this);
}

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

m_pWeddingMap = pMap;

if (m_pWeddingMap)
		m_pWeddingMap-&gt;IncMember(this);
}

void CHARACTER::SetRegen(LPREGEN pkRegen)
{
	m_pkRegen = pkRegen;
	if (pkRegen != NULL) {
		regen_id_ = pkRegen-&gt;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(&quot;OnClick %s by NULL&quot;, GetName());
		return;
	}

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

// »óÁˇŔ» ż¬»óĹÂ·Î Äů˝şĆ®¸¦ ÁřÇŕÇŇ Ľö ľř´Ů.
	{
		// ´Ü, ŔÚ˝ĹŔş ŔÚ˝ĹŔÇ »óÁˇŔ» Ĺ¬¸ŻÇŇ Ľö ŔÖ´Ů.
		if (pkChrCauser-&gt;GetMyShop() &amp;&amp; pkChrCauser != this) 
		{
			sys_err(&quot;OnClick Fail (%s-&gt;%s) - pc has shop&quot;, pkChrCauser-&gt;GetName(), GetName());
			return;
		}
	}

// ±łČŻÁßŔĎ¶§ Äů˝şĆ®¸¦ ÁřÇŕÇŇ Ľö ľř´Ů.
	{
		if (pkChrCauser-&gt;GetExchange())
		{
			sys_err(&quot;OnClick Fail (%s-&gt;%s) - pc is exchanging&quot;, pkChrCauser-&gt;GetName(), GetName());
			return;
		}
	}

#ifdef OFFLINE_SHOP
	if (IsPC() || IsNPC() &amp;&amp; GetRaceNum() == 30000)
	{
		if (!CTargetManager::instance().GetTargetInfo(pkChrCauser-&gt;GetPlayerID(), TARGET_TYPE_VID, GetVID()) || GetRaceNum() == 30000)
#else
	if (IsPC())
	{
		if (!CTargetManager::instance().GetTargetInfo(pkChrCauser-&gt;GetPlayerID(), TARGET_TYPE_VID, GetVID()))
#endif
		{
			// 2005.03.17.myevan.Ĺ¸°ŮŔĚ ľĆ´Ń °ćżě´Â °łŔÎ »óÁˇ Ăł¸® ±â´ÉŔ» ŔŰµż˝ĂĹ˛´Ů.
			if (GetMyShop())
			{
				if (pkChrCauser-&gt;IsDead() == true) return;

//PREVENT_TRADE_WINDOW
				if (pkChrCauser == this) // ŔÚ±â´Â °ˇ´É
				{
					if ((GetExchange() || IsOpenSafebox() || GetShopOwner()) || IsCubeOpen())
					{
						pkChrCauser-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;´Ů¸Ą °Ĺ·ˇÁß(Ă˘°í,±łČŻ,»óÁˇ)żˇ´Â °łŔÎ»óÁˇŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
						return;
					}
				}
				else // ´Ů¸Ą »ç¶÷ŔĚ Ĺ¬¸ŻÇßŔ»¶§
				{
					// Ĺ¬¸ŻÇŃ »ç¶÷ŔĚ ±łČŻ/Ă˘°í/°łŔÎ»óÁˇ/»óÁˇŔĚżëÁßŔĚ¶ó¸é şŇ°ˇ
					if ((pkChrCauser-&gt;GetExchange() || pkChrCauser-&gt;IsOpenSafebox() || pkChrCauser-&gt;GetMyShop() || pkChrCauser-&gt;GetShopOwner()) || pkChrCauser-&gt;IsCubeOpen() )
					{
						pkChrCauser-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;´Ů¸Ą °Ĺ·ˇÁß(Ă˘°í,±łČŻ,»óÁˇ)żˇ´Â °łŔÎ»óÁˇŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
						return;
					}

// Ĺ¬¸ŻÇŃ ´ë»óŔĚ ±łČŻ/Ă˘°í/»óÁˇŔĚżëÁßŔĚ¶ó¸é şŇ°ˇ
					//if ((GetExchange() || IsOpenSafebox() || GetShopOwner()))
					if ((GetExchange() || IsOpenSafebox() || IsCubeOpen()))
					{
						pkChrCauser-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ´Ů¸Ą °Ĺ·ˇ¸¦ ÇĎ°í ŔÖ´Â ÁßŔÔ´Ď´Ů.&quot;));
						return;
					}
				}
				//END_PREVENT_TRADE_WINDOW

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

#ifdef OFFLINE_SHOP
				if (GetMyShop()-&gt;IsLocked()){
					pkChrCauser-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_LOCKED&quot;));
					return;
				}
#endif
				GetMyShop()-&gt;AddGuest(pkChrCauser, GetVID(), false);
				pkChrCauser-&gt;SetShopOwner(this);
				return;
			}

if (test_server)
				sys_err(&quot;%s.OnClickFailure(%s) - target is PC&quot;, pkChrCauser-&gt;GetName(), GetName());

return;
		}
	}

pkChrCauser-&gt;SetQuestNPCID(GetVID());

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

if (!IsPC())
	{
		if (!m_triggerOnClick.pFunc)
		{
			// NPC Ć®¸®°Ĺ ˝Ă˝şĹŰ ·Î±× ş¸±â
			//sys_err(&quot;%s.OnClickFailure(%s) : triggerOnClick.pFunc is EMPTY(pid=%d)&quot;, 
			//			pkChrCauser-&gt;GetName(),
			//			GetName(),
			//			pkChrCauser-&gt;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()-&gt;GetHostName(), GetDesc()-&gt;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-&gt;m_set_pkChrSpawnedBy.find(this) == pkChrStone-&gt;m_set_pkChrSpawnedBy.end())
			pkChrStone-&gt;m_set_pkChrSpawnedBy.insert(this);
	}
}

struct FuncDeadSpawnedByStone
{
	void operator () (LPCHARACTER ch)
	{
		ch-&gt;Dead(NULL);
		ch-&gt;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-&gt;m_set_pkChrSpawnedBy.erase(this);
	m_pkChrStone = NULL;
}

void CHARACTER::ClearTarget()
{
	if (m_pkChrTarget)
	{
		m_pkChrTarget-&gt;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-&gt;m_pkChrTarget = NULL;

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

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

m_set_pkChrTargetedBy.clear();
}

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

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

if (m_pkChrTarget)
		m_pkChrTarget-&gt;m_set_pkChrTargetedBy.erase(this);

m_pkChrTarget = pkChrTarget;

TPacketGCTarget p;

p.header = HEADER_GC_TARGET;

if (m_pkChrTarget)
	{
		m_pkChrTarget-&gt;m_set_pkChrTargetedBy.insert(this);

p.dwVID	= m_pkChrTarget-&gt;GetVID();

if (m_pkChrTarget-&gt;IsPC() &amp;&amp; !m_pkChrTarget-&gt;IsPolymorphed() || m_pkChrTarget-&gt;GetMaxHP() &lt;= 0)
			p.bHPPercent = 0;
		else 
		{
			if (m_pkChrTarget-&gt;GetRaceNum() == 20101 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20102 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20103 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20104 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20105 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20106 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20107 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20108 ||
					m_pkChrTarget-&gt;GetRaceNum() == 20109)
			{
				LPCHARACTER owner = m_pkChrTarget-&gt;GetVictim();

if (owner)
				{
					int iHorseHealth = owner-&gt;GetHorseHealth();
					int iHorseMaxHealth = owner-&gt;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-&gt;GetHP() * 100) / m_pkChrTarget-&gt;GetMaxHP(), 100);
		}
	}
	else
	{
		p.dwVID = 0;
		p.bHPPercent = 0;
	}

GetDesc()-&gt;Packet(&amp;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-&gt;GetDesc())
		{
			sys_err(&quot;%s %p does not have desc&quot;, pkChr-&gt;GetName(), get_pointer(pkChr));
			abort();
		}

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

void CHARACTER::CheckTarget()
{
	if (!m_pkChrTarget)
		return;

if (DISTANCE_APPROX(GetX() - m_pkChrTarget-&gt;GetX(), GetY() - m_pkChrTarget-&gt;GetY()) &gt;= 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, &quot;ExitToSavedLocation&quot;);
	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(&quot;cannot find map location index %d x %d y %d name %s&quot;, 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-&gt;strMapName.c_str() );	
			}
		}
	}

if (lPrivateMapIndex &gt;= 10000)
	{
		if (lPrivateMapIndex / 10000 != lMapIndex)
		{
			sys_err(&quot;Invalid map inedx %d, must be child of %d&quot;, lPrivateMapIndex, lMapIndex);
			return false;
		}

lMapIndex = lPrivateMapIndex;
	}

Stop();
	Save();

if (GetSectree())
	{
		GetSectree()-&gt;RemoveEntity(this);
		ViewCleanup();

EncodeRemovePacket(this);
	}

m_lWarpMapIndex = lMapIndex;
	m_posWarp.x = x;
	m_posWarp.y = y;

sys_log(0, &quot;WarpSet %s %d %d current map %d target map %d&quot;, 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()-&gt;Packet(&amp;p, sizeof(TPacketGCWarp));

//if (!LC_IsNewCIBN())
	{
		char buf[256];
		snprintf(buf, sizeof(buf), &quot;%s MapIdx %ld DestMapIdx%ld DestX%ld DestY%ld Empire%d&quot;, GetName(), GetMapIndex(), lPrivateMapIndex, x, y, GetEmpire());
		LogManager::instance().CharLog(this, 0, &quot;WARP&quot;, buf);
	}

return true;
}

void CHARACTER::WarpEnd()
{
	if (test_server)
		sys_log(0, &quot;WarpEnd %s&quot;, GetName());

if (m_posWarp.x == 0 &amp;&amp; m_posWarp.y == 0)
		return;

int index = m_lWarpMapIndex;

if (index &gt; 10000)
		index /= 10000;

if (!map_allow_find(index))
	{
		// ŔĚ °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľřŔ¸ąÇ·Î żöÇÁÇĎ±â Ŕü ÁÂÇĄ·Î µÇµą¸®ŔÚ.
		sys_err(&quot;location %d %d not allowed to login this server&quot;, m_posWarp.x, m_posWarp.y);
		GetDesc()-&gt;SetPhase(PHASE_CLOSE);
		return;
	}

sys_log(0, &quot;WarpEnd %s %d %u %u&quot;, 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(&amp;p, sizeof(TPacketGGLogin));
	}
}

bool CHARACTER::Return()
{
	if (!IsNPC())
		return false;

int x, y;
	/*
	   float fDist = DISTANCE_SQRT(m_pkMobData-&gt;m_posLastAttacked.x - GetX(), m_pkMobData-&gt;m_posLastAttacked.y - GetY());
	   float fx, fy;
	   GetDeltaByDegree(GetRotation(), fDist, &amp;fx, &amp;fy);
	   x = GetX() + (int) fx;
	   y = GetY() + (int) fy;
	 */
	SetVictim(NULL);

x = m_pkMobInst-&gt;m_posLastAttacked.x;
	y = m_pkMobInst-&gt;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, &quot;%s %p Ć÷±âÇĎ°í µąľĆ°ˇŔÚ! %d %d&quot;, GetName(), this, x, y);

if (GetParty())
		GetParty()-&gt;SendMessage(this, PM_RETURN, x, y);

return true;
}

bool CHARACTER::Follow(LPCHARACTER pkChr, float fMinDistance)
{
	if (IsPC())
	{
		sys_err(&quot;CHARACTER::Follow : PC cannot use this method&quot;, GetName());
		return false;
	}

// TRENT_MONSTER
	if (IS_SET(m_pointsInstant.dwAIFlag, AIFLAG_NOMOVE))
	{
		if (pkChr-&gt;IsPC()) // ÂŃľĆ°ˇ´Â »ó´ë°ˇ PCŔĎ ¶§
		{
			// If i'm in a party. I must obey party leader's AI.
			if (!GetParty() || !GetParty()-&gt;GetLeader() || GetParty()-&gt;GetLeader() == this)
			{
				if (get_dword_time() - m_pkMobInst-&gt;m_dwLastAttackedTime &gt;= 15000) // ¸¶Áö¸·Ŕ¸·Î °ř°ÝąŢŔşÁö 15ĂĘ°ˇ Áöłµ°í
				{
					// ¸¶Áö¸· ¸ÂŔş °÷Ŕ¸·Î şÎĹÍ 50ąĚĹÍ ŔĚ»ó Â÷ŔĚłŞ¸é Ć÷±âÇĎ°í µąľĆ°Ł´Ů.
					if (m_pkMobData-&gt;m_table.wAttackRange &lt; DISTANCE_APPROX(pkChr-&gt;GetX() - GetX(), pkChr-&gt;GetY() - GetY()))
						if (Return())
							return true;
				}
			}
		}
		return false;
	}
	// END_OF_TRENT_MONSTER

long x = pkChr-&gt;GetX();
	long y = pkChr-&gt;GetY();

if (pkChr-&gt;IsPC()) // ÂŃľĆ°ˇ´Â »ó´ë°ˇ PCŔĎ ¶§
	{
		// If i'm in a party. I must obey party leader's AI.
		if (!GetParty() || !GetParty()-&gt;GetLeader() || GetParty()-&gt;GetLeader() == this)
		{
			if (get_dword_time() - m_pkMobInst-&gt;m_dwLastAttackedTime &gt;= 15000) // ¸¶Áö¸·Ŕ¸·Î °ř°ÝąŢŔşÁö 15ĂĘ°ˇ Áöłµ°í
			{
				// ¸¶Áö¸· ¸ÂŔş °÷Ŕ¸·Î şÎĹÍ 50ąĚĹÍ ŔĚ»ó Â÷ŔĚłŞ¸é Ć÷±âÇĎ°í µąľĆ°Ł´Ů.
				if (5000 &lt; DISTANCE_APPROX(m_pkMobInst-&gt;m_posLastAttacked.x - GetX(), m_pkMobInst-&gt;m_posLastAttacked.y - GetY()))
					if (Return())
						return true;
			}
		}
	}

if (IsGuardNPC())
	{
		if (5000 &lt; DISTANCE_APPROX(m_pkMobInst-&gt;m_posLastAttacked.x - GetX(), m_pkMobInst-&gt;m_posLastAttacked.y - GetY()))
			if (Return())
				return true;
	}

if (pkChr-&gt;IsState(pkChr-&gt;m_stateMove) &amp;&amp; 
		GetMobBattleType() != BATTLE_TYPE_RANGE &amp;&amp; 
		GetMobBattleType() != BATTLE_TYPE_MAGIC &amp;&amp;
		false == IsPet())
	{
		// ´ë»óŔĚ ŔĚµżÁßŔĚ¸é żąĂř ŔĚµżŔ» ÇŃ´Ů
		// łŞżÍ »ó´ëąćŔÇ ĽÓµµÂ÷żÍ °Ĺ¸®·ÎşÎĹÍ ¸¸łŻ ˝Ă°ŁŔ» żą»óÇŃ ČÄ
		// »ó´ëąćŔĚ ±× ˝Ă°Ł±îÁö Á÷Ľ±Ŕ¸·Î ŔĚµżÇŃ´Ů°í °ˇÁ¤ÇĎż© °Ĺ±â·Î ŔĚµżÇŃ´Ů.
		float rot = pkChr-&gt;GetRotation();
		float rot_delta = GetDegreeDelta(rot, GetDegreeFromPositionXY(GetX(), GetY(), pkChr-&gt;GetX(), pkChr-&gt;GetY()));

float yourSpeed = pkChr-&gt;GetMoveSpeed();
		float mySpeed = GetMoveSpeed();

float fDist = DISTANCE_SQRT(x - GetX(), y - GetY());
		float fFollowSpeed = mySpeed - yourSpeed * cos(rot_delta * M_PI / 180);

if (fFollowSpeed &gt;= 0.1f)
		{
			float fMeetTime = fDist / fFollowSpeed;
			float fYourMoveEstimateX, fYourMoveEstimateY;

if( fMeetTime * yourSpeed &lt;= 100000.0f )
			{
				GetDeltaByDegree(pkChr-&gt;GetRotation(), fMeetTime * yourSpeed, &amp;fYourMoveEstimateX, &amp;fYourMoveEstimateY);

x += (long) fYourMoveEstimateX;
				y += (long) fYourMoveEstimateY;

float fDistNew = sqrt(((double)x - GetX())*(x-GetX())+((double)y - GetY())*(y-GetY()));
				if (fDist &lt; 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 &lt;= fMinDistance)
		return false;

float fx, fy;

if (IsChangeAttackPosition(pkChr) &amp;&amp; GetMobRank() &lt; MOB_RANK_BOSS)
	{
		// »ó´ëąć ÁÖşŻ ·Ł´ýÇŃ °÷Ŕ¸·Î ŔĚµż
		SetChangeAttackPositionTime();

int retry = 16;
		int dx, dy;
		int rot = (int) GetDegreeFromPositionXY(x, y, GetX(), GetY());

while (--retry)
		{
			if (fDist &lt; 500.0f)
				GetDeltaByDegree((rot + number(-90, 90) + number(-90, 90)) % 360, fMinDistance, &amp;fx, &amp;fy);
			else
				GetDeltaByDegree(number(0, 359), fMinDistance, &amp;fx, &amp;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-&gt;GetAttribute(dx, dy) &amp; (ATTR_BLOCK | ATTR_OBJECT)))
				break;
		}

//sys_log(0, &quot;±ŮĂł ľîµň°ˇ·Î ŔĚµż %s retry %d&quot;, GetName(), retry);
		if (!Goto(dx, dy))
			return false;
	}
	else
	{
		// Á÷Ľ± µű¶ó°ˇ±â
		float fDistToGo = fDist - fMinDistance;
		GetDeltaByDegree(GetRotation(), fDistToGo, &amp;fx, &amp;fy);

//sys_log(0, &quot;Á÷Ľ±Ŕ¸·Î ŔĚµż %s&quot;, GetName());
		if (!Goto(GetX() + (int) fx, GetY() + (int) fy))
			return false;
	}

SendMovePacket(FUNC_WAIT, 0, 0, 0, 0);
	//MonsterLog(&quot;ÂŃľĆ°ˇ±â; %s&quot;, pkChr-&gt;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) &gt; SAFEBOX_PASSWORD_MAX_LEN)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;Ă˘°í&gt; Ŕß¸řµČ ľĎČŁ¸¦ ŔÔ·ÂÇĎĽĚ˝Ŕ´Ď´Ů.&quot;));
		return;
	}
	else if (m_pkSafebox)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;Ă˘°í&gt; Ă˘°í°ˇ ŔĚąĚ ż·ÁŔÖ˝Ŕ´Ď´Ů.&quot;));
		return;
	}

int iPulse = thecore_pulse();

if (iPulse - GetSafeboxLoadTime()  &lt; PASSES_PER_SEC(10))
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;Ă˘°í&gt; Ă˘°í¸¦ ´ÝŔşÁö 10ĂĘ ľČżˇ´Â ż Ľö ľř˝Ŕ´Ď´Ů.&quot;));
		return;
	}
	else if (GetDistanceFromSafeboxOpen() &gt; 1000)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;&lt;Ă˘°í&gt; °Ĺ¸®°ˇ ¸ÖľîĽ Ă˘°í¸¦ ż Ľö ľř˝Ŕ´Ď´Ů.&quot;));
		return;
	}
	else if (m_bOpeningSafebox)
	{
		sys_log(0, &quot;Overlapped safebox load request from %s&quot;, GetName());
		return;
	}

SetSafeboxLoadTime();
	m_bOpeningSafebox = true;

TSafeboxLoadPacket p;
	p.dwID = GetDesc()-&gt;GetAccountTable().id;
	strlcpy(p.szLogin, GetDesc()-&gt;GetAccountTable().login, sizeof(p.szLogin));
	strlcpy(p.szPassword, pszPassword, sizeof(p.szPassword));

db_clientdesc-&gt;DBPacket(HEADER_GD_SAFEBOX_LOAD, GetDesc()-&gt;GetHandle(), &amp;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-&gt;ChangeSize(iSize);

m_iSafeboxSize = iSize;

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_SAFEBOX_SIZE;
	p.bSize = iSize;

GetDesc()-&gt;Packet(&amp;p, sizeof(TPacketCGSafeboxSize));

if (!bLoaded)
	{
		for (int i = 0; i &lt; iItemCount; ++i, ++pItems)
		{
			if (!m_pkSafebox-&gt;IsValidPosition(pItems-&gt;pos))
				continue;

LPITEM item = ITEM_MANAGER::instance().CreateItem(pItems-&gt;vnum, pItems-&gt;count, pItems-&gt;id);

if (!item)
			{
				sys_err(&quot;cannot create item vnum %d id %u (name: %s)&quot;, pItems-&gt;vnum, pItems-&gt;id, GetName());
				continue;
			}

item-&gt;SetSkipSave(true);
			item-&gt;SetSockets(pItems-&gt;alSockets);
			item-&gt;SetAttributes(pItems-&gt;aAttr);

if (!m_pkSafebox-&gt;Add(pItems-&gt;pos, item))
			{
				M2_DESTROY_ITEM(item);
			}
			else
				item-&gt;SetSkipSave(false);
		}
	}
}

void CHARACTER::ChangeSafeboxSize(BYTE bSize)
{
	//if (!m_pkSafebox)
	//return;

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_SAFEBOX_SIZE;
	p.bSize = bSize;

GetDesc()-&gt;Packet(&amp;p, sizeof(TPacketCGSafeboxSize));

if (m_pkSafebox)
		m_pkSafebox-&gt;ChangeSize(bSize);

m_iSafeboxSize = bSize;
}

void CHARACTER::CloseSafebox()
{
	if (!m_pkSafebox)
		return;

//PREVENT_TRADE_WINDOW
	SetOpenSafebox(false);
	//END_PREVENT_TRADE_WINDOW

m_pkSafebox-&gt;Save();

M2_DELETE(m_pkSafebox);
	m_pkSafebox = NULL;

ChatPacket(CHAT_TYPE_COMMAND, &quot;CloseSafebox&quot;);

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-&gt;ChangeSize(3 * SAFEBOX_PAGE_SIZE);

m_pkMall-&gt;SetWindowMode(MALL);

TPacketCGSafeboxSize p;

p.bHeader = HEADER_GC_MALL_OPEN;
	p.bSize = 3 * SAFEBOX_PAGE_SIZE;

GetDesc()-&gt;Packet(&amp;p, sizeof(TPacketCGSafeboxSize));

if (!bLoaded)
	{
		for (int i = 0; i &lt; iItemCount; ++i, ++pItems)
		{
			if (!m_pkMall-&gt;IsValidPosition(pItems-&gt;pos))
				continue;

LPITEM item = ITEM_MANAGER::instance().CreateItem(pItems-&gt;vnum, pItems-&gt;count, pItems-&gt;id);

if (!item)
			{
				sys_err(&quot;cannot create item vnum %d id %u (name: %s)&quot;, pItems-&gt;vnum, pItems-&gt;id, GetName());
				continue;
			}

item-&gt;SetSkipSave(true);
			item-&gt;SetSockets(pItems-&gt;alSockets);
			item-&gt;SetAttributes(pItems-&gt;aAttr);

if (!m_pkMall-&gt;Add(pItems-&gt;pos, item))
				M2_DESTROY_ITEM(item);
			else
				item-&gt;SetSkipSave(false);
		}
	}
}

void CHARACTER::CloseMall()
{
	if (!m_pkMall)
		return;

m_pkMall-&gt;Save();

M2_DELETE(m_pkMall);
	m_pkMall = NULL;

ChatPacket(CHAT_TYPE_COMMAND, &quot;CloseMall&quot;);
}

bool CHARACTER::BuildUpdatePartyPacket(TPacketGCPartyUpdate &amp; out)
{
	if (!GetParty())
		return false;

memset(&amp;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()-&gt;GetRole(GetPlayerID());

sys_log(1, &quot;PARTY %s role is %d&quot;, GetName(), out.role);

LPCHARACTER l = GetParty()-&gt;GetLeaderCharacter();

if (l &amp;&amp; DISTANCE_APPROX(GetX() - l-&gt;GetX(), GetY() - l-&gt;GetY()) &lt; PARTY_DEFAULT_RANGE)
	{
		if (g_iUseLocale)
			out.affects[0] = GetParty()-&gt;GetPartyBonusExpPercent();
		else
			out.affects[0] = GetParty()-&gt;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, 
				&quot;SELECT size FROM safebox%s WHERE account_id = %u&quot;,
				get_table_postfix(),
				GetDesc()-&gt;GetAccountTable().id);
	}
}

void CHARACTER::SetSafeboxSize(int iSize)
{
	sys_log(1, &quot;SetSafeboxSize: %s %d&quot;, GetName(), iSize);
	m_iSafeboxSize = iSize;
	DBManager::instance().Query(&quot;UPDATE safebox%s SET size = %d WHERE account_id = %u&quot;, get_table_postfix(), iSize / SAFEBOX_PAGE_SIZE, GetDesc()-&gt;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(&amp;p, sizeof(p));
		}

if (IsNPC())
		{
			if (m_bNowWalking)
				MonsterLog(&quot;°Č´Â´Ů&quot;);
			else
				MonsterLog(&quot;¶Ú´Ů&quot;);
		}

//sys_log(0, &quot;%s is now %s&quot;, GetName(), m_bNowWalking?&quot;walking.&quot;:&quot;running.&quot;);
	}
}

void CHARACTER::StartStaminaConsume()
{
	if (m_bStaminaConsume)
		return;
	PointChange(POINT_STAMINA, 0);
	m_bStaminaConsume = true;
	//ChatPacket(CHAT_TYPE_COMMAND, &quot;StartStaminaConsume %d %d&quot;, STAMINA_PER_STEP * passes_per_sec, GetStamina());
	if (IsStaminaHalfConsume())
		ChatPacket(CHAT_TYPE_COMMAND, &quot;StartStaminaConsume %d %d&quot;, STAMINA_PER_STEP * passes_per_sec / 2, GetStamina());
	else
		ChatPacket(CHAT_TYPE_COMMAND, &quot;StartStaminaConsume %d %d&quot;, 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, &quot;StopStaminaConsume %d&quot;, GetStamina());
}

bool CHARACTER::IsStaminaConsume() const
{
	return m_bStaminaConsume;
}

bool CHARACTER::IsStaminaHalfConsume() const
{
	return IsEquipUniqueItem(UNIQUE_ITEM_HALF_STAMINA);
}

void CHARACTER::ResetStopTime()
{
	m_dwStopTime = get_dword_time();
}

DWORD CHARACTER::GetStopTime() const
{
	return m_dwStopTime;
}

void CHARACTER::ResetPoint(int iLv)
{
	BYTE bJob = GetJob();

PointChange(POINT_LEVEL, iLv - GetLevel());

SetRealPoint(POINT_ST, JobInitialPoints[bJob].st);
	SetPoint(POINT_ST, GetRealPoint(POINT_ST));

SetRealPoint(POINT_HT, JobInitialPoints[bJob].ht);
	SetPoint(POINT_HT, GetRealPoint(POINT_HT));

SetRealPoint(POINT_DX, JobInitialPoints[bJob].dx);
	SetPoint(POINT_DX, GetRealPoint(POINT_DX));

SetRealPoint(POINT_IQ, JobInitialPoints[bJob].iq);
	SetPoint(POINT_IQ, GetRealPoint(POINT_IQ));

SetRandomHP((iLv - 1) * number(JobInitialPoints[GetJob()].hp_per_lv_begin, JobInitialPoints[GetJob()].hp_per_lv_end));
	SetRandomSP((iLv - 1) * number(JobInitialPoints[GetJob()].sp_per_lv_begin, JobInitialPoints[GetJob()].sp_per_lv_end));

//PointChange(POINT_STAT, ((MINMAX(1, iLv, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));
	
	if(iLv &lt;= 90)
		PointChange(POINT_STAT, ((MINMAX(1, iLv, 90) - 1) * 3) + GetPoint(POINT_LEVEL_STEP) - GetPoint(POINT_STAT));
	else
		PointChange(POINT_STAT, 270 - GetPoint(POINT_STAT));
	
	ComputePoints();

// Č¸şą
	PointChange(POINT_HP, GetMaxHP() - GetHP());
	PointChange(POINT_SP, GetMaxSP() - GetSP());

PointsPacket();

LogManager::instance().CharLog(this, 0, &quot;RESET_POINT&quot;, &quot;&quot;);
}

bool CHARACTER::IsChangeAttackPosition(LPCHARACTER target) const
{ 
	if (!IsNPC())
		return true;

DWORD dwChangeTime = AI_CHANGE_ATTACK_POISITION_TIME_NEAR;

if (DISTANCE_APPROX(GetX() - target-&gt;GetX(), GetY() - target-&gt;GetY()) &gt; 
		AI_CHANGE_ATTACK_POISITION_DISTANCE + GetMobAttackRange())
		dwChangeTime = AI_CHANGE_ATTACK_POISITION_TIME_FAR;

return get_dword_time() - m_dwLastChangeAttackPositionTime &gt; 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 &amp;&amp; bJob != pkSk-&gt;dwType)
				continue;

break;
		} while (true);

item-&gt;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-&gt;c_str());
	}
}

void CHARACTER::BeginStateEmpty()
{
	MonsterLog(&quot;!&quot;);
}

void CHARACTER::EffectPacket(int enumEffectType)
{
	TPacketGCSpecialEffect p;

p.header = HEADER_GC_SEPCIAL_EFFECT;
	p.type = enumEffectType;
	p.vid = GetVID();

PacketAround(&amp;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(&amp;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), 
				&quot;(locale.monster_chat[%i] and locale.monster_chat[%i][%d] or '')&quot;,
				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), &quot;(locale.monster_chat[%i] and locale.monster_chat[%i][number(1, table.getn(locale.monster_chat[%i]))] or '')&quot;, 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(&amp;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 &gt; 10000)
		return CDungeonManager::instance().FindByMapIndex(m_lWarpMapIndex);

return m_pkDungeon;
}

void CHARACTER::SetBlockMode(BYTE bFlag)
{
	m_pointsInstant.bBlockMode = bFlag;

ChatPacket(CHAT_TYPE_COMMAND, &quot;setblockmode %d&quot;, m_pointsInstant.bBlockMode);

SetQuestFlag(&quot;game_option.block_exchange&quot;, bFlag &amp; BLOCK_EXCHANGE ? 1 : 0);
	SetQuestFlag(&quot;game_option.block_party_invite&quot;, bFlag &amp; BLOCK_PARTY_INVITE ? 1 : 0);
	SetQuestFlag(&quot;game_option.block_guild_invite&quot;, bFlag &amp; BLOCK_GUILD_INVITE ? 1 : 0);
	SetQuestFlag(&quot;game_option.block_whisper&quot;, bFlag &amp; BLOCK_WHISPER ? 1 : 0);
	SetQuestFlag(&quot;game_option.block_messenger_invite&quot;, bFlag &amp; BLOCK_MESSENGER_INVITE ? 1 : 0);
	SetQuestFlag(&quot;game_option.block_party_request&quot;, bFlag &amp; BLOCK_PARTY_REQUEST ? 1 : 0);
}

void CHARACTER::SetBlockModeForce(BYTE bFlag)
{
	m_pointsInstant.bBlockMode = bFlag;
	ChatPacket(CHAT_TYPE_COMMAND, &quot;setblockmode %d&quot;, m_pointsInstant.bBlockMode);
}

bool CHARACTER::IsGuardNPC() const
{
	return IsNPC() &amp;&amp; (GetRaceNum() == 11000 || GetRaceNum() == 11002 || GetRaceNum() == 11004);
}

int CHARACTER::GetPolymorphPower() const
{
	if (test_server)
	{
		int value = quest::CQuestManager::instance().GetEventFlag(&quot;poly&quot;);
		if (value)
			return value;
	}
	return aiPolymorphPowerByLevel[MINMAX(0, GetSkillLevel(SKILL_POLYMORPH), 40)];
}

void CHARACTER::SetPolymorph(DWORD dwRaceNum, bool bMaintainStat)
{
	if (dwRaceNum &lt; JOB_MAX_NUM)
	{
		dwRaceNum = 0;
		bMaintainStat = false;
	}

if (m_dwPolymorphRace == dwRaceNum)
		return;

m_bPolyMaintainStat = bMaintainStat;
	m_dwPolymorphRace = dwRaceNum;

sys_log(0, &quot;POLYMORPH: %s race %u &quot;, 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&amp; flag) const
{
	quest::CQuestManager&amp; q = quest::CQuestManager::instance();
	quest::PC* pPC = q.GetPC(GetPlayerID());

if (NULL == pPC)
		return 0;

return pPC-&gt;GetFlag(flag);
}

void CHARACTER::SetQuestFlag(const std::string&amp; flag, int value)
{
	quest::CQuestManager&amp; q = quest::CQuestManager::instance();
	quest::PC* pPC = q.GetPC(GetPlayerID());

if (NULL == pPC)
		return;

pPC-&gt;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 &gt;= STONE_INFO_MAX_NUM || aStoneDrop[idx].dwMobVnum != stone_num)
	{
		m_dwDropMetinStone = 0;
	}
	else
	{
		const SStoneDropInfo &amp; 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 &lt; STONE_LEVEL_MAX_NUM; iStoneLevel ++)
			{
				int iLevelGradePortion = info.iLevelPct[iStoneLevel];
				if (iGradePct &lt;= iLevelGradePortion)
				{
					break;
				}
				else
				{
					iGradePct -= iLevelGradePortion;
					m_dwDropMetinStone += 100; // µą +a -&gt; +(a+1)ŔĚ µÉ¶§¸¶´Ů 100ľż Áő°ˇ
				}
			}
		}
	}
}

void CHARACTER::SendEquipment(LPCHARACTER ch)
{
	TPacketViewEquip p;
	p.header = HEADER_GC_VIEW_EQUIP;
	p.vid    = GetVID();
	for (int i = 0; i&lt;WEAR_MAX_NUM; i++)
	{
		LPITEM item = GetWear(i);
		if (item)
		{
			p.equips[i].vnum = item-&gt;GetVnum();
			p.equips[i].count = item-&gt;GetCount();

thecore_memcpy(p.equips[i].alSockets, item-&gt;GetSockets(), sizeof(p.equips[i].alSockets));
			thecore_memcpy(p.equips[i].aAttr, item-&gt;GetAttributes(), sizeof(p.equips[i].aAttr));
		}
		else
		{
			p.equips[i].vnum = 0;
		}
	}
	ch-&gt;GetDesc()-&gt;Packet(&amp;p, sizeof(p));
}

bool CHARACTER::CanSummon(int iLeaderShip)
{
	return (iLeaderShip &gt;= 20 || iLeaderShip &gt;= 12 &amp;&amp; m_dwLastDeadTime + 180 &gt; get_dword_time());
}

void CHARACTER::MountVnum(DWORD vnum)
{
	if (m_dwMountVnum == vnum)
		return;

m_dwMountVnum = vnum;
	m_dwMountTime = get_dword_time();

if (m_bIsObserver)
		return;

//NOTE : MountÇŃ´Ů°í ÇŘĽ Client SideŔÇ °´ĂĽ¸¦ »čÁ¦ÇĎÁř ľĘ´Â´Ů.
	//±×¸®°í ĽąöSideżˇĽ ĹŔŔ»¶§ Ŕ§Äˇ ŔĚµżŔş ÇĎÁö ľĘ´Â´Ů. żÖłÄÇĎ¸é Client SideżˇĽ Coliision Adjust¸¦ ÇŇĽö ŔÖ´ÂµĄ
	//°´ĂĽ¸¦ ĽŇ¸ę˝ĂÄ×´Ů°ˇ ĽąöŔ§Äˇ·Î ŔĚµż˝ĂĹ°¸é ŔĚ¶§ collision check¸¦ ÇĎÁö´Â ľĘŔ¸ąÇ·Î ąč°ćżˇ ł˘°ĹłŞ ¶Ő°í łŞ°ˇ´Â ą®Á¦°ˇ Á¸ŔçÇŃ´Ů.
	m_posDest.x = m_posStart.x = GetX();
	m_posDest.y = m_posStart.y = GetY();
	//EncodeRemovePacket(this);
	EncodeInsertPacket(this);

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

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

//MountÇŃ´Ů°í ÇŘĽ Client SideŔÇ °´ĂĽ¸¦ »čÁ¦ÇĎÁř ľĘ´Â´Ů.
		//EncodeRemovePacket(entity);
		//if (!m_bIsObserver)
		EncodeInsertPacket(entity);

//if (!entity-&gt;IsObserverMode())
		//	entity-&gt;EncodeInsertPacket(this);
	}

SetValidComboInterval(0);
	SetComboSequence(0);

ComputePoints();
}

namespace {
	class FuncCheckWarp
	{
		public:
			FuncCheckWarp(LPCHARACTER pkWarp)
			{
				m_lTargetY = 0;
				m_lTargetX = 0;

m_lX = pkWarp-&gt;GetX();
				m_lY = pkWarp-&gt;GetY();

m_bInvalid = false;
				m_bEmpire = pkWarp-&gt;GetEmpire();

char szTmp[64];

if (3 != sscanf(pkWarp-&gt;GetName(), &quot; %s %ld %ld &quot;, szTmp, &amp;m_lTargetX, &amp;m_lTargetY))
				{
					if (number(1, 100) &lt; 5)
						sys_err(&quot;Warp NPC name wrong : vnum(%d) name(%s)&quot;, pkWarp-&gt;GetRaceNum(), pkWarp-&gt;GetName());

m_bInvalid = true;

return;
				}

m_lTargetX *= 100;
				m_lTargetY *= 100;

m_bUseWarp = true;

if (pkWarp-&gt;IsGoto())
				{
					LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(pkWarp-&gt;GetMapIndex());
					m_lTargetX += pkSectreeMap-&gt;m_setting.iBaseX;
					m_lTargetY += pkSectreeMap-&gt;m_setting.iBaseY;
					m_bUseWarp = false;
				}
			}

bool Valid()
			{
				return !m_bInvalid;
			}

void operator () (LPENTITY ent)
			{
				if (!Valid())
					return;

if (!ent-&gt;IsType(ENTITY_CHARACTER))
					return;

LPCHARACTER pkChr = (LPCHARACTER) ent;

if (!pkChr-&gt;IsPC())
					return;

int iDist = DISTANCE_APPROX(pkChr-&gt;GetX() - m_lX, pkChr-&gt;GetY() - m_lY);

if (iDist &gt; 300)
					return;

if (m_bEmpire &amp;&amp; pkChr-&gt;GetEmpire() &amp;&amp; m_bEmpire != pkChr-&gt;GetEmpire())
					return;

if (pkChr-&gt;IsHack())
					return;

if (!pkChr-&gt;CanHandleItem(false, true))
					return;	
				
				if (m_bUseWarp)
					pkChr-&gt;WarpSet(m_lTargetX, m_lTargetY);
				else
				{
					pkChr-&gt;Show(pkChr-&gt;GetMapIndex(), m_lTargetX, m_lTargetY);
					pkChr-&gt;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&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;warp_npc_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (ch == NULL) { // &lt;Factor&gt;
		return 0;
	}

if (!ch-&gt;GetSectree())
	{
		ch-&gt;m_pkWarpNPCEvent = NULL;
		return 0;
	}

FuncCheckWarp f(ch);
	if (f.Valid())
		ch-&gt;GetSectree()-&gt;ForEachAround(f);

return passes_per_sec / 2;
}

void CHARACTER::StartWarpNPCEvent()
{
	if (m_pkWarpNPCEvent)
		return;

if (!IsWarp() &amp;&amp; !IsGoto())
		return;

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;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(&amp;pack, sizeof(pack));
	buf.write(&amp;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-&gt;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()-&gt;Packet(&amp;p, sizeof(p));
}

int CHARACTER::GetPremiumRemainSeconds(BYTE bType) const
{
	if (bType &gt;= 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))))
	{
		if (victim-&gt;GetMapIndex() &gt;= 10000)
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;player_in_dungeon&quot;));
			return false;
		}
		if (victim-&gt;GetMapIndex() == 202 &amp;&amp; GetLevel() &lt; 75)
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;lvl_to_low&quot;));
			return false;
		}
		int mapIdx = victim-&gt;GetMapIndex();
		if (IS_SUMMONABLE_ZONE(mapIdx))
		{
			if (CAN_ENTER_ZONE(this, mapIdx))
			{
				WarpSet(victim-&gt;GetX(), victim-&gt;GetY());
			}
			else
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ŔÖ´Â °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
				return false;
			}
		}
		else
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ŔÖ´Â °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return false;
		}
	}
	else
	{
		// ´Ů¸Ą Ľąöżˇ ·Î±×ŔÎµČ »ç¶÷ŔĚ ŔÖŔ˝ -&gt; ¸Ţ˝ĂÁö ş¸ł» ÁÂÇĄ¸¦ ąŢľĆżŔŔÚ
		// 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(&quot;»ó´ëąćŔĚ żÂ¶óŔÎ »óĹÂ°ˇ ľĆ´Ő´Ď´Ů.&quot;));
			return false;
		}

if (pcci-&gt;bChannel != g_bChannel)
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ %d Ă¤łÎżˇ ŔÖ˝Ŕ´Ď´Ů. (ÇöŔç Ă¤łÎ %d)&quot;), pcci-&gt;bChannel, g_bChannel);
			return false;
		}
		else if (false == IS_SUMMONABLE_ZONE(pcci-&gt;lMapIndex))
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ŔÖ´Â °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
			return false;
		}
		else
		{
			if (!CAN_ENTER_ZONE(this, pcci-&gt;lMapIndex))
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;»ó´ëąćŔĚ ŔÖ´Â °÷Ŕ¸·Î żöÇÁÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;));
				return false;
			}

TPacketGGFindPosition p;
			p.header = HEADER_GG_FIND_POSITION;
			p.dwFromPID = GetPlayerID();
			p.dwTargetPID = dwPID;
			pcci-&gt;pkDesc-&gt;Packet(&amp;p, sizeof(TPacketGGFindPosition));

if (test_server) 
				ChatPacket(CHAT_TYPE_PARTY, &quot;sent find position packet for teleport&quot;);
		}
	}
	return true;
}

// ADD_REFINE_BUILDING
CGuild* CHARACTER::GetRefineGuild() const
{
	LPCHARACTER chRefineNPC = CHARACTER_MANAGER::instance().Find(m_dwRefineNPCVID);

return (chRefineNPC ? chRefineNPC-&gt;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 &amp;&amp; chRefineNPC-&gt;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-&gt;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() &lt; PASSES_PER_SEC(limittime))
	{
		if (bSendMsg)
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;Ă˘°í¸¦ ż¬ČÄ %dĂĘ ŔĚł»żˇ´Â ´Ů¸Ą°÷Ŕ¸·Î ŔĚµżÇŇĽö ľř˝Ŕ´Ď´Ů.&quot;), limittime);

if (test_server)
			ChatPacket(CHAT_TYPE_INFO, &quot;[TestOnly]Pulse %d LoadTime %d PASS %d&quot;, iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(limittime));
		return true; 
	}

//°Ĺ·ˇ°ü·Ă Ă˘ ĂĽĹ©
	if (bCheckShopOwner)
	{
		if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
		{
			if (bSendMsg)
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;°Ĺ·ˇĂ˘,Ă˘°í µîŔ» ż¬ »óĹÂżˇĽ´Â ´Ů¸Ą°÷Ŕ¸·Î ŔĚµż,Áľ·á ÇŇĽö ľř˝Ŕ´Ď´Ů&quot;));

return true;
		}
	}
	else
	{
		if (GetExchange() || GetMyShop() || IsOpenSafebox() || IsCubeOpen())
		{
			if (bSendMsg)
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;°Ĺ·ˇĂ˘,Ă˘°í µîŔ» ż¬ »óĹÂżˇĽ´Â ´Ů¸Ą°÷Ŕ¸·Î ŔĚµż,Áľ·á ÇŇĽö ľř˝Ŕ´Ď´Ů&quot;));

return true;
		}
	}

//PREVENT_PORTAL_AFTER_EXCHANGE
	//±łČŻ ČÄ ˝Ă°ŁĂĽĹ©
	if (iPulse - GetExchangeTime()  &lt; PASSES_PER_SEC(limittime))
	{
		if (bSendMsg)
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;°Ĺ·ˇ ČÄ %dĂĘ ŔĚł»żˇ´Â ´Ů¸ĄÁöżŞŔ¸·Î ŔĚµż ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;), limittime );
		return true;
	}
	//END_PREVENT_PORTAL_AFTER_EXCHANGE

//PREVENT_ITEM_COPY
	if (iPulse - GetMyShopTime() &lt; PASSES_PER_SEC(limittime))
	{
		if (bSendMsg)
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;°Ĺ·ˇ ČÄ %dĂĘ ŔĚł»żˇ´Â ´Ů¸ĄÁöżŞŔ¸·Î ŔĚµż ÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;), limittime);
		return true;
	}

if (iPulse - GetRefineTime() &lt; PASSES_PER_SEC(limittime))
	{
		if (bSendMsg)
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;ľĆŔĚĹŰ °ł·®ČÄ %dĂĘ ŔĚł»żˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ¸¦ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů.&quot;), 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 &amp; 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(&amp;packet_script, sizeof(struct packet_script));
	buf.write(&amp;s[0], s.size());

if (IsPC())
	{
		GetDesc()-&gt;Packet(buf.read_peek(), buf.size());
	}
}

//
// Monarch
//
void CHARACTER::InitMC()
{
	for (int n = 0; n &lt; 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)) &lt;  GetMCL(e))
	{
		if (test_server)
			sys_log(0, &quot; Pulse %d cooltime %d, limit %d&quot;, iPulse, GetMC(e), GetMCL(e));
		
		return false;
	}
	
	if (test_server)
		sys_log(0, &quot; Pulse %d cooltime %d, limit %d&quot;, 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, &quot; Pulse %d cooltime %d, limit %d&quot;, iPulse, GetMC(e), GetMCL(e));

return  (GetMCL(e)) / passes_per_sec   -  (iPulse - GetMC(e)) / passes_per_sec;
}

bool CHARACTER::IsSiegeNPC() const
{
	return IsNPC() &amp;&amp; (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 &lt; thecore_pulse()));
}
//------------------------------------------------

ESex GET_SEX(LPCHARACTER ch)
{
	switch (ch-&gt;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-&gt;m_IsBerserk;
	else
		return false;
}

void CHARACTER::SetBerserk(bool mode)
{
	if (m_pkMobInst != NULL)
		m_pkMobInst-&gt;m_IsBerserk = mode;
}

bool CHARACTER::IsGodSpeed() const
{
	if (m_pkMobInst != NULL)
	{
		return m_pkMobInst-&gt;m_IsGodSpeed;
	}
	else
	{
		return false;
	}
}

void CHARACTER::SetGodSpeed(bool mode)
{
	if (m_pkMobInst != NULL)
	{
		m_pkMobInst-&gt;m_IsGodSpeed = mode;

if (mode == true)
		{
			SetPoint(POINT_ATT_SPEED, 250);
		}
		else
		{
			SetPoint(POINT_ATT_SPEED, m_pkMobData-&gt;m_table.sAttackSpeed);
		}
	}
}

bool CHARACTER::IsDeathBlow() const
{
	if (number(1, 100) &lt;= m_pkMobData-&gt;m_table.bDeathBlowPoint)
	{
		return true;
	}
	else
	{
		return false;
	}
}

struct FFindReviver
{
	FFindReviver()
	{
		pChar = NULL;
		HasReviver = false;
	}
	
	void operator() (LPCHARACTER ch)
	{
		if (ch-&gt;IsMonster() != true)
		{
			return;
		}

if (ch-&gt;IsReviver() == true &amp;&amp; pChar != ch &amp;&amp; ch-&gt;IsDead() != true)
		{
			if (number(1, 100) &lt;= ch-&gt;GetMobTable().bRevivePoint)
			{
				HasReviver = true;
				pChar = ch;
			}
		}
	}

LPCHARACTER pChar;
	bool HasReviver;
};

bool CHARACTER::HasReviverInParty() const
{
	LPPARTY party = GetParty();

if (party != NULL)
	{
		if (party-&gt;GetMemberCount() == 1) return false;

FFindReviver f;
		party-&gt;ForEachMemberPtr(f);
		return f.HasReviver;
	}

return false;
}

bool CHARACTER::IsRevive() const
{
	if (m_pkMobInst != NULL)
	{
		return m_pkMobInst-&gt;m_IsRevive;
	}

return false;
}

void CHARACTER::SetRevive(bool mode)
{
	if (m_pkMobInst != NULL)
	{
		m_pkMobInst-&gt;m_IsRevive = mode;
	}
}

#define IS_SPEED_HACK_PLAYER(ch) (ch-&gt;m_speed_hack_count &gt; SPEEDHACK_LIMIT_COUNT)

EVENTFUNC(check_speedhack_event)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;check_speedhack_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (NULL == ch || ch-&gt;IsNPC())
		return 0;

if (IS_SPEED_HACK_PLAYER(ch))
	{
		// write hack log
		LogManager::instance().SpeedHackLog(ch-&gt;GetPlayerID(), ch-&gt;GetX(), ch-&gt;GetY(), ch-&gt;m_speed_hack_count);

if (false == LC_IsEurope())
		{
			// close connection
			LPDESC desc = ch-&gt;GetDesc();

if (desc)
			{
				DESC_MANAGER::instance().DestroyDesc(desc);
				return 0;
			}
		}
	}

ch-&gt;m_speed_hack_count = 0;

ch-&gt;ResetComboHackCount();
	return PASSES_PER_SEC(60);
}

void CHARACTER::StartCheckSpeedHackEvent()
{
	if (m_pkCheckSpeedHackEvent)
		return;

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;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-&gt;GetID()) != m_known_guild.end()) return;

m_known_guild.insert(pGuild-&gt;GetID());

TPacketGCGuildName	pack;
	memset(&amp;pack, 0x00, sizeof(pack));

pack.header		= HEADER_GC_GUILD;
	pack.subheader	= GUILD_SUBHEADER_GC_GUILD_NAME;
	pack.size		= sizeof(TPacketGCGuildName);
	pack.guildID	= pGuild-&gt;GetID();
	memcpy(pack.guildName, pGuild-&gt;GetName(), GUILD_NAME_MAX_LEN);

desc-&gt;Packet(&amp;pack, sizeof(pack));
}

void CHARACTER::SendGuildName(DWORD dwGuildID)
{
	SendGuildName(CGuildManager::instance().FindGuild(dwGuildID));
}

EVENTFUNC(destroy_when_idle_event)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;( event-&gt;info );
	if ( info == NULL )
	{
		sys_err( &quot;destroy_when_idle_event&gt; &lt;Factor&gt; Null pointer&quot; );
		return 0;
	}

LPCHARACTER ch = info-&gt;ch;
	if (ch == NULL) { // &lt;Factor&gt;
		return 0;
	}

if (ch-&gt;GetVictim())
	{
		return PASSES_PER_SEC(300);
	}

sys_log(1, &quot;DESTROY_WHEN_IDLE: %s&quot;, ch-&gt;GetName());

ch-&gt;m_pkDestroyWhenIdleEvent = NULL;
	M2_DESTROY_CHARACTER(ch);
	return 0;
}

void CHARACTER::StartDestroyWhenIdleEvent()
{
	if (m_pkDestroyWhenIdleEvent)
		return;

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;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 &gt;= 10)
	// {
		// if (GetDesc())
			// if (GetDesc()-&gt;DelayedDisconnect(number(2, 7)))
			// {
				// sys_log(0, &quot;COMBO_HACK_DISCONNECT: %s count: %d&quot;, GetName(), m_iComboHackCount);
				// LogManager::instance().HackLog(&quot;Combo&quot;, 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()) &lt; limit_time)
		return false;

if ((iPulse - GetExchangeTime()) &lt; limit_time)
		return false;

if ((iPulse - GetMyShopTime()) &lt; limit_time)
		return false;

if ((iPulse - GetRefineTime()) &lt; limit_time)
		return false;

if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
		return false;

return true;
}

DWORD CHARACTER::GetNextExp() const
{
	if (PLAYER_EXP_TABLE_MAX &lt; 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); 
}

void ShopFix(int channel)
{
	
}
#ifdef __CHANNEL_CHANGE_SYSTEM__
bool CHARACTER::ChannelChange(int channel)
{
	if (!IsPC() || channel == g_bChannel)
		return false;
	
	long lAddr;
	WORD wPort;
	long x = GetX();
	long y = GetY();
	long lMapIndex = GetMapIndex();
	
	if (GetLevel() &lt; chChange_nLevel)
	{
		ChatPacket(CHAT_TYPE_INFO, &quot;You need to be at least Lv. %d for change CH In-Game.&quot;, chChange_nLevel);
		return false;
	}
	
	if (GetGold() &lt; chChange_nYang)
	{
		ChatPacket(CHAT_TYPE_INFO, &quot;You need to pay %d Yang for change CH In-Game.&quot;, chChange_nYang);
		return false;
	}
	
	if (chChange_map_allow_find(lMapIndex))
	{
		ChatPacket(CHAT_TYPE_INFO, &quot;You can't change the CH from this map!&quot;);
		return false;
	}
	char szQuery[512];
	snprintf(szQuery, sizeof(szQuery), &quot;SELECT port, host FROM %smap_list WHERE channel = %d AND map_index = %ld&quot;, get_table_postfix(), channel, lMapIndex);
	SQLMsg *msg = DBManager::instance().DirectQuery(szQuery);
	MYSQL_RES *res = msg-&gt;Get()-&gt;pSQLResult;
	if (!res)
	{
		ChatPacket(1, &quot;Cannot find map %d on channel %d&quot;, lMapIndex, channel);
		return false;
	}
	
	int rows;
	if ((rows = mysql_num_rows(res)) &lt;= 0)
	{
		ChatPacket(1, &quot;Cannot find map %d on channel %d&quot;, lMapIndex, channel);
		return false;
	}
	
	for (int i = 0; i &lt; rows; ++i)
	{
		MYSQL_ROW row = mysql_fetch_row(res);
		int cur = 0;
		str_to_number(wPort, row[cur++]);
		str_to_number(lAddr, row[cur++]);
	}
	
	if (chChange_port_allow_find(wPort))
	{
		ChatPacket(CHAT_TYPE_INFO, &quot;You can't go to the CH choosed!&quot;);
		return false;
	}
	
	if (g_iUserLimit &gt; 0)
	{
		int iTotal;
		int * paiEmpireUserCount;
		int iLocal;
		
		DESC_MANAGER::instance().GetUserCount(iTotal, &amp;paiEmpireUserCount, iLocal);
		if (g_iUserLimit &lt;= iTotal)
		{
			ChatPacket(1, &quot;Channel %d is FULL&quot;, channel);
			return false;
		}
	}
	
#ifdef FULL_YANG
	long long yang = GetGold()-chChange_nYang;
	SetGold(yang);
#else
	PointChange(POINT_GOLD, -chChange_nYang, false);
#endif
	//ChatPacket(CHAT_TYPE_COMMAND, &quot;channel %d&quot;, channel);
	Stop();

Save();

if (GetSectree())
	{
		GetSectree()-&gt;RemoveEntity(this);
		ViewCleanup();
		EncodeRemovePacket(this);

}
	
	m_lWarpMapIndex = lMapIndex;
	m_posWarp.x = x;
	m_posWarp.y = y;
	
	sys_log(0, &quot;WarpSet %s %d %d current map %d target map %d port %d&quot;, GetName(), x, y, GetMapIndex(), lMapIndex, wPort);
	
	TPacketGCWarp p;
	p.bHeader = HEADER_GC_WARP;
	p.lX = x;
	p.lY = y;
	p.lAddr = lAddr;
	p.wPort = wPort;

GetDesc()-&gt;Packet(&amp;p, sizeof(TPacketGCWarp));
	return true;
}
#endif
void CHARACTER::CostumeFix()
{
	//if (IsPC())
	//{
	//	if (GetQuestFlag(&quot;kostium.zmiana&quot;) == 1) 
	//	{
	//		SetPart(PART_MAIN, WEAR_BODY);
	//		UpdatePacket();
	//		ChatPacket(CHAT_TYPE_INFO, &quot;Updatuje na PART_BODY&quot;);
	//	}
	//	else
	//	{
	//		//SetPart(PART_MAIN, GetVnum()); 
	//		UpdatePacket();
	//		ChatPacket(CHAT_TYPE_INFO, &quot;Updatuje na item-&gt;GetVnum()&quot;);
	//	}
	//}
	if (IsPC())
	{
		UpdatePacket() ;
		ComputePoints() ;
	}
}

void CHARACTER::ChannelSwitch(int newChannel) {
	int ChannelPorts[5][3] = { {13000, 13001, 13002}, {16000, 16001, 16002}, {18000, 18001, 18002}, {20000, 20001, 20002}, {22000, 22001, 22002} }; //, {3005, 3055, 3105}, };

long lAddr, lMapIndex;
	WORD wPort;
	
	long x = GetX();
	long y = GetY();
	
	if (!CMapLocation::Instance().Get(x, y, lMapIndex, lAddr, wPort)) {
		
		sys_err(&quot;Can not find map location index[%ld] x[%ld] y[%ld] name[%s]&quot;, lMapIndex, x, y, GetName());
		return; 
	}
	
	if (lMapIndex &gt;= 10000 || (int)wPort == 13099	|| GetDungeon())	
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;CANNOT_CHANGE_CHANNEL&quot;));
		return;
	}

int newPort = 0;
	switch((int) wPort)
	{
		case 13000:
		case 16000:
		case 18000:
		case 20000:
		case 22000:
			newPort = ChannelPorts[newChannel-1][0];
			break;
		case 13001:
		case 16001:
		case 18001:
		case 20001:
		case 22001:
			newPort = ChannelPorts[newChannel-1][1];
			break;
		case 13002:
		case 16002:
		case 18002:
		case 20002:
		case 22002:
			newPort = ChannelPorts[newChannel-1][2];
			break;

default:
		break; 
	}

if (newPort == 0)
		return;
	
	if (!CanWarp())
		return;

ForgetMyAttacker();

Stop();
	Save();
	
	if (GetSectree()) {
		GetSectree()-&gt;RemoveEntity(this);
		ViewCleanup();
		EncodeRemovePacket(this); }
	
	TPacketGCWarp p;
	p.bHeader 	= HEADER_GC_WARP;
	p.lX 		= x;
	p.lY 		= y;
	p.lAddr		= lAddr;
	p.wPort		= newPort;
	
	GetDesc()-&gt;Packet(&amp;p, sizeof(TPacketGCWarp));
}
#ifdef ANTY_DAMAGE_HACK
void CHARACTER::SetLastTimeDmg(std::string name, int value)
{
	itertype(m_map_DmgTime) it =  m_map_DmgTime.find(name);
	if (it != m_map_DmgTime.end())
		it-&gt;second = value;
	else
		m_map_DmgTime.insert(make_pair(name, value));
}

int CHARACTER::GetLastTimeDmg(std::string name)
{
	itertype(m_map_DmgTime) it =  m_map_DmgTime.find(name);
	if (it != m_map_DmgTime.end())
		return it-&gt;second;
	else
		return 0;
}

void CHARACTER::ClearLastTimeDmg()
{
	m_map_DmgTime.clear();
}

#endif

#ifdef GIFT_SYSTEM
#include &lt;boost/algorithm/string.hpp&gt;
EVENTFUNC(gift_refresh_event)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;(event-&gt;info);
	if (info == NULL)
	{
		sys_err(&quot;gift_refresh_event&gt; &lt;Factor&gt; Null pointer&quot;);
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (NULL == ch || ch-&gt;IsNPC())
		return 0;
	ch-&gt;RefreshGift();
	return PASSES_PER_SEC(5 * 60);
}
void CHARACTER::StartRefreshGift()
{
	if (m_pkGiftRefresh)
		return;
	char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;ch = this;
	m_pkGiftRefresh = event_create(gift_refresh_event, info, PASSES_PER_SEC(1));	// 1o?
}
void SendGift(LPCHARACTER ch, TGiftItem item)
{
	char szSockets[1024] = { '\0' };
	int szSocketsLen=0;
	for (int soc = 0; soc &lt; ITEM_SOCKET_MAX_NUM; soc++)
		szSocketsLen += snprintf(szSockets+szSocketsLen, sizeof(szSockets)-szSocketsLen, &quot;%ld%s&quot;, item.alSockets[soc], (soc&lt;ITEM_SOCKET_MAX_NUM - 1 ? &quot;|&quot; : &quot;&quot;));
		
	char szAttrs[1024] = { '\0' };
	int szAttrsLen = 0;
	for (int attr = 0; attr &lt; ITEM_ATTRIBUTE_MAX_NUM; attr++)
		szAttrsLen += snprintf(szAttrs+szAttrsLen, sizeof(szAttrs)-szAttrsLen, &quot;%u,%d%s&quot;, item.aAttr[attr].bType, item.aAttr[attr].sValue, (attr&lt;ITEM_ATTRIBUTE_MAX_NUM - 1 ? &quot;|&quot; : &quot;&quot;));

char szCMD[1024] = {0};
	int szLength = 0;
#ifdef FULL_YANG
	szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, &quot;gift_item %d#%d#%lld#%d#%d#%s#%s#%s#%s&quot;,item.id, item.vnum, item.count, item.pos, item.dwDateAdd, item.szFrom, item.szReason, szSockets, szAttrs);
#else
	szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, &quot;gift_item %d#%d#%d#%d#%d#%s#%s#%s#%s&quot;,item.id, item.vnum, item.count, item.pos, item.dwDateAdd, item.szFrom, item.szReason, szSockets, szAttrs);
#endif
#ifdef ENABLE_TRANSMUTE_SYSTEM
	szLength+=snprintf(szCMD+szLength, sizeof(szCMD)-szLength, &quot;#%d&quot;, item.look);
#endif
	ch-&gt;ChatPacket(CHAT_TYPE_COMMAND, szCMD);
	memset(&amp;szSockets, 0, sizeof(szSockets));
	memset(&amp;szAttrs, 0, sizeof(szAttrs));
	memset(&amp;szCMD, 0, sizeof(szCMD));
}
void CHARACTER::LoadGiftPage(int page)
{
	page = MINMAX(1, page, m_mapGiftGrid.size());
	ChatPacket(CHAT_TYPE_COMMAND, &quot;gift_clear&quot;);
	GIFT_MAP::iterator it = m_mapGiftGrid.find(page);
	if (it == m_mapGiftGrid.end())
		return;
	m_dwLastGiftPage = page;
	for (int i = 0; i &lt; it-&gt;second.size(); i++)
		SendGift(this, it-&gt;second[i]);
	ChatPacket(CHAT_TYPE_COMMAND, &quot;gift_load&quot;);

}
static CGrid* grid;
void CHARACTER::AddGiftGrid(int page)
{
	if (m_mapGiftGrid.find(page) == m_mapGiftGrid.end())
	{
		std::vector&lt;TGiftItem&gt; vec;
		m_mapGiftGrid.insert(std::make_pair(page, vec));
	}

}
int CHARACTER::AddGiftGridItem(int page, int size)
{
	AddGiftGrid(page);
	int iPos = grid-&gt;FindBlank(1, size);

if (iPos &lt; 0)
		return -1;

if (!grid-&gt;IsEmpty(iPos, 1, size))
		return -1;

grid-&gt;Put(iPos, 1, size);
	return iPos;

}
void CHARACTER::RefreshGift()
{
	char szSockets[1024] = { '\0' };
	char *tempSockets = szSockets;
	for (int i = 0; i &lt; ITEM_SOCKET_MAX_NUM; i++)
	{
		tempSockets += sprintf(tempSockets, &quot;socket%d&quot;, i);

if (i&lt;ITEM_SOCKET_MAX_NUM - 1)
			tempSockets += sprintf(tempSockets, &quot;,&quot;);
	}

char szAttrs[1024] = { '\0' };
	char *tempAttrs = szAttrs;
	for (int i = 0; i &lt; ITEM_ATTRIBUTE_MAX_NUM; i++)
	{
		if (i &lt; 7)
			tempAttrs += sprintf(tempAttrs, &quot;attrtype%d,attrvalue%d&quot;, i, i);
		else
			tempAttrs += sprintf(tempAttrs, &quot;applytype%d,applyvalue%d&quot;, i - 7, i - 7);
		if (i&lt;ITEM_ATTRIBUTE_MAX_NUM - 1)
			tempAttrs += sprintf(tempAttrs, &quot;,&quot;);
	}
	std::auto_ptr&lt;SQLMsg&gt;pkMsg(DBManager::instance().DirectQuery(
		&quot;SELECT id,vnum,count,&quot;
#ifdef ENABLE_TRANSMUTE_SYSTEM
		&quot;look,&quot;
#endif
		&quot;UNIX_TIMESTAMP(date_add),REPLACE(reason,' ','_'),REPLACE(`from`,' ','_'),%s,%s FROM player_gift where  owner_id = %d and status = 'WAIT' ORDER BY date_add &quot;, 
		szSockets, szAttrs, GetPlayerID())
	);
	SQLResult * pRes = pkMsg-&gt;Get();
	m_mapGiftGrid.clear();
	grid = M2_NEW CGrid(15, 8);
	grid-&gt;Clear();
	int page = 1;
	if (pRes-&gt;uiNumRows&gt;0)
	{
		AddGiftGrid(page);
		MYSQL_ROW row;
		while ((row = mysql_fetch_row(pRes-&gt;pSQLResult)) != NULL)
		{
			int col = 0;
			TGiftItem item;
			memset(&amp;item, 0, sizeof(item));
			str_to_number(item.id, row[col++]);
			str_to_number(item.vnum, row[col++]);
			str_to_number(item.count, row[col++]);
#ifdef ENABLE_TRANSMUTE_SYSTEM
			str_to_number(item.look, row[col++]);
#endif
			str_to_number(item.dwDateAdd, row[col++]);
			strlcpy(item.szReason, row[col++], sizeof(item.szReason) - 1);
			strlcpy(item.szFrom, row[col++], sizeof(item.szFrom) - 1);
			for (int i = 0; i &lt; ITEM_SOCKET_MAX_NUM; i++)
				str_to_number(item.alSockets[i], row[col++]);
			for (int i = 0; i &lt; ITEM_ATTRIBUTE_MAX_NUM; i++)
			{
				str_to_number(item.aAttr[i].bType, row[col++]);
				str_to_number(item.aAttr[i].sValue, row[col++]);
			}

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(item.vnum);
			if (!item_table)
				continue;
			int iPos = AddGiftGridItem(page, item_table-&gt;bSize);
			if (iPos &lt; 0)
			{
				page++;
				grid-&gt;Clear();
				iPos = AddGiftGridItem(page, item_table-&gt;bSize);
				if (iPos &lt; 0)
				{
					sys_err(&quot;iPos &lt;0&quot;);
					break;
				}
			}
			item.pos = iPos;
			m_mapGiftGrid[page].push_back(item);

}
		M2_DELETE(grid);
		if (GetGiftPages()&gt;0)
			ChatPacket(CHAT_TYPE_COMMAND, &quot;gift_info %d&quot;, GetGiftPages());
	}
}
#endif

#ifdef OFFLINE_SHOP

extern std::map&lt;DWORD, DWORD&gt; g_ShopIndexCount;
extern std::map&lt;int, TShopCost&gt; g_ShopCosts;
int get_offline_shops_count()
{
	int cnt=0;
	CharacterVectorInteractor i;
	if (CHARACTER_MANAGER::instance().GetCharactersByRaceNum(30000, i))
	{
		CharacterVectorInteractor::iterator it = i.begin();
		while (it != i.end()) {
			LPCHARACTER pc = *it++;
			if (pc &amp;&amp; pc-&gt;IsPrivShop())
				++cnt;
		}
	}
	return cnt;
}
void CHARACTER::OpenMyShop(const char * c_pszSign, TShopItemTable * pTable, BYTE bItemCount, DWORD id)
{

if (g_ShopCosts.find(id) == g_ShopCosts.end())
	{
		sys_log(0, &quot;Shop days error %s %d&quot;, c_pszSign, id);
		return;
	}
	int days = g_ShopCosts[id].days;
	long long price = g_ShopCosts[id].price;
	if (price &gt; 0 &amp;&amp; GetGold() &lt; price)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_NEED_MONEY&quot;), price);
		return;
	}
	if (days == 0 &amp;&amp; GetPart(PART_MAIN) &gt; 2)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_987f5b44210444d9f99365cb415a9ee9&quot;));
		return;
	}

if (GetMyShop())
	{
		CloseMyShop();
		return;
	}

int gShopMax = quest::CQuestManager::Instance().GetEventFlag(&quot;shop_max&quot;);
	if (m_mapshops.size() &gt;= (gShopMax ? gShopMax : 2))
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_MAX_ERR&quot;));
		return;
	}

if (g_ShopIndexCount.count(GetMapIndex())&gt;0)
	{
		int shop_max = g_ShopIndexCount[GetMapIndex()];
#ifdef SHOP_ONLY_ALLOWED_INDEX
		bool block = (shop_max &gt; 0 ? (get_offline_shops_count() &gt;= shop_max): false);
#else
		bool block = (get_offline_shops_count() &gt;= shop_max);
#endif
		if (block)
		{
			ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_MAP_MAX&quot;));
			return;
		}
	}
#ifdef SHOP_ONLY_ALLOWED_INDEX
	else
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_CANNOT_OPEN_HERE&quot;));
		return;
	}
#endif
	if (GetMyShop())
	{
		CloseMyShop();
		return;
	}
#ifndef FULL_YANG
	int64_t nTotalMoney = 0;

for (int n = 0; n &lt; bItemCount; ++n)
	{
		nTotalMoney += static_cast&lt;int64_t&gt; ((pTable + n)-&gt;price);
	}

nTotalMoney += static_cast&lt;int64_t&gt; (GetGold());
#else
	long long nTotalMoney = GetGold();
	for (int n = 0; n &lt; bItemCount; ++n)
		nTotalMoney += (pTable + n)-&gt;price;
#endif

if (GOLD_MAX &lt;= nTotalMoney)
	{
		sys_err(&quot;[OVERFLOW_GOLD] Overflow (GOLD_MAX) id %u name %s&quot;, GetPlayerID(), GetName());
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_a63bef352db11de2b934bce71d8e11d6&quot;));
		return;
	}
	quest::PC * pPC = quest::CQuestManager::instance().GetPCForce(GetPlayerID());
	if (pPC-&gt;IsRunning())
		return;
	std::vector&lt;TShopItemTable *&gt; map_shop;
	for (BYTE i = 0; i &lt; bItemCount; ++i)
	{
		// ANTI_GIVE, ANTI_MYSHOP check
		LPITEM pkItem = GetItem((pTable + i)-&gt;pos);

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

if (item_table &amp;&amp; (IS_SET(item_table-&gt;dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP)))
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_7499a9fd04587f7f3d6af3c9d46b9d00&quot;));
				return;
			}

if (pkItem-&gt;IsEquipped())
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_31cc6cc69598ac44fdbd43e57bad25ff&quot;));
				return;
			}

if (pkItem-&gt;isLocked())
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_484fd2e80b394d521341cd089734e63e&quot;));
				return;
			}
			if (pkItem-&gt;GetOwner() != this)
			{
				return;
			}
#ifdef SOULBIND_SYSTEM
			if (pkItem-&gt;IsSoulBind())
			{
				ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_3225c935119ae0ac342911794a5ba0b7&quot;));
				return;
			}
#endif
		}
		if (days != 0)
			map_shop.push_back(pTable++);
	}
	if (days != 0 &amp;&amp; map_shop.size() == 0)
		return;
	m_stShopSign = c_pszSign;

if (m_stShopSign.length()&gt;30)
		m_stShopSign.resize(30);
#ifdef STRING_PROTECTION
	if (CBanwordManager::instance().CheckString(m_stShopSign.c_str(), m_stShopSign.length()) != &quot;&quot;)
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_b4a17db4bfe12e1bf505e59a4a47e50b&quot;));
		return;
	}
#else
	if (CBanwordManager::instance().CheckString(m_stShopSign.c_str(), m_stShopSign.length()))
	{
		ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;HASH_b4a17db4bfe12e1bf505e59a4a47e50b&quot;));
		return;
	}
#endif
	if (m_pkExchange)
		m_pkExchange-&gt;Cancel();
	if (price &gt; 0)
#ifdef FULL_YANG_OWN
		ChangeGold(-price);
#else
		PointChange(POINT_GOLD, -price);
#endif

if (days != 0)
	{
		CShopManager::instance().CreateOfflineShop(this, m_stShopSign.c_str(), map_shop, id);
		m_stShopSign.clear();
		return;
	}
	TPacketGCShopSign p;
	p.bHeader = HEADER_GC_SHOP_SIGN;
	p.dwVID = GetVID();
	strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));

PacketAround(&amp;p, sizeof(TPacketGCShopSign));

m_pkMyShop = CShopManager::instance().CreatePCShop(this, pTable, bItemCount);
	if (!m_pkMyShop)
	{
		sys_err(&quot;Cannot open normal shop %s %s&quot;, GetName(), m_stShopSign.c_str());
		return;
	}
	if (IsPolymorphed() == true)
	{
		RemoveAffect(AFFECT_POLYMORPH);
	}

if (GetHorse())
	{
		HorseSummon(false, true);
	}
	else if (GetMountVnum())
	{
		RemoveAffect(AFFECT_MOUNT);
		RemoveAffect(AFFECT_MOUNT_BONUS);
	}

SetPolymorph(30000, true);

}
void CHARACTER::SetShopSign(const char * name)
{
	m_stShopSign = name;
	TPacketGCShopSign p;
	p.bHeader = HEADER_GC_SHOP_SIGN;
	p.dwVID = GetVID();
	strlcpy(p.szSign, m_stShopSign.c_str(), sizeof(p.szSign));
	PacketAround(&amp;p, sizeof(TPacketGCShopSign));
}

TPrivShop CHARACTER::GetPrivShopTable(DWORD id)
{
	TPrivShop shop;
	memset(&amp;shop, 0, sizeof(TPrivShop));
	PSHOP_MAP::iterator it = m_mapshops.find(id);
	if (it != m_mapshops.end())
		return it-&gt;second;
	return shop;

}
void CHARACTER::UpdatePrivShopTable(DWORD id, TPrivShop shop)
{
	if (m_mapshops.find(id) != m_mapshops.end())
		m_mapshops[id] = shop;
	SendShops();
}
void CHARACTER::RemovePrivShopTable(DWORD id)
{
	if (m_mapshops.find(id) != m_mapshops.end())
		m_mapshops.erase(m_mapshops.find(id));
	SendShops();
}
void CHARACTER::UpdateShopItems()
{
	LPSHOP npcshop = GetMyShop();
	LPCHARACTER owner = CHARACTER_MANAGER::instance().FindByPID(GetPrivShopOwner());
	if (!npcshop || !IsPrivShop())
		return;
	npcshop-&gt;ClearItems();
	std::vector&lt;TShopItemTable *&gt; map_shop;
	char szSockets[1024] = { '\0' };
	char *tempSockets = szSockets;
	for (int i = 0; i &lt; ITEM_SOCKET_MAX_NUM; i++)
	{
		tempSockets += sprintf(tempSockets, &quot;socket%d&quot;, i);

if (i&lt;ITEM_SOCKET_MAX_NUM - 1)
			tempSockets += sprintf(tempSockets, &quot;,&quot;);
	}
	char szAttrs[1024] = { '\0' };
	char *tempAttrs = szAttrs;
	for (int i = 0; i &lt; ITEM_ATTRIBUTE_MAX_NUM; i++)
	{
		if (i &lt; 7)
			tempAttrs += sprintf(tempAttrs, &quot;attrtype%d,attrvalue%d&quot;, i, i);
		else
			tempAttrs += sprintf(tempAttrs, &quot;applytype%d,applyvalue%d&quot;, i - 7, i - 7);
		if (i&lt;ITEM_ATTRIBUTE_MAX_NUM - 1)
			tempAttrs += sprintf(tempAttrs, &quot;,&quot;);
	}
	std::auto_ptr&lt;SQLMsg&gt;Msg(DBManager::instance().DirectQuery(
		&quot;SELECT id,vnum,count,&quot;
#ifdef ENABLE_TRANSMUTE_SYSTEM
		&quot;look,&quot;
#endif
		&quot;display_pos,price,%s,%s from player_shop_items where shop_id='%d'&quot;, szSockets, szAttrs, GetPrivShop()));
	memset(&amp;szAttrs, 0, sizeof(szAttrs));
	memset(&amp;szSockets, 0, sizeof(szSockets));
	DWORD attr, soc;
	long val;
	SQLResult * Res = Msg-&gt;Get();
	if (Res-&gt;uiNumRows &gt; 0)
	{
		MYSQL_ROW row;
		while ((row = mysql_fetch_row(Res-&gt;pSQLResult)) != NULL)
		{

int col = 0;
			TShopItemTable *shop = new TShopItemTable;
			memset(shop, 0, sizeof(TShopItemTable));
			DWORD id;
			shop-&gt;pos.window_type = INVENTORY;
			str_to_number(id, row[col++]);
			str_to_number(shop-&gt;vnum, row[col++]);
			str_to_number(shop-&gt;count, row[col++]);
#ifdef ENABLE_TRANSMUTE_SYSTEM
			str_to_number(shop-&gt;look, row[col++]);
#endif
			str_to_number(shop-&gt;display_pos, row[col++]);
			//col++;
			str_to_number(shop-&gt;price, row[col++]);

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(shop-&gt;vnum);

if (!item_table)
			{
				sys_err(&quot;Shop: no item table by item vnum #%d&quot;, shop-&gt;vnum);
				continue;
			}
			for (int i = 0; i &lt; INVENTORY_MAX_NUM; ++i)
			{
				if (NULL != GetInventoryItem(i) &amp;&amp; GetInventoryItem(i)-&gt;GetRealID() == id)
					GetInventoryItem(i)-&gt;RemoveFromCharacter();
			}
			LPITEM item = ITEM_MANAGER::instance().CreateItem(shop-&gt;vnum, shop-&gt;count, id, false, -1, true);
			if (-1 == (shop-&gt;pos.cell = GetEmptyInventory(item_table-&gt;bSize)))
			{
				sys_err(&quot;no empty position in npc inventory&quot;);
				return;
			}
			if (item)
			{
				item-&gt;ClearAttribute();
				item-&gt;SetRealID(id);
#ifdef ENABLE_TRANSMUTE_SYSTEM
				item-&gt;SetLook(shop-&gt;look);
#endif
				for (int s = 0; s&lt;ITEM_SOCKET_MAX_NUM; s++)
				{
					str_to_number(soc, row[col++]);
					item-&gt;SetSocket(s, soc, false);
				}
				for (int at = 0; at&lt;ITEM_ATTRIBUTE_MAX_NUM; at++)
				{
					str_to_number(attr, row[col++]);
					str_to_number(val, row[col++]);
					item-&gt;SetForceAttribute(at, attr, val);
				}

item-&gt;AddToCharacter(this, shop-&gt;pos);
			}
			else
			{
				sys_err(&quot;%d is not item&quot;, shop-&gt;vnum);
				continue;
			}
			map_shop.push_back(shop);
		}
	}

if (map_shop.size() == 0 || map_shop.size() &gt; SHOP_HOST_ITEM_MAX_NUM)
	{
		DeleteMyShop();
		return;
	}
	npcshop-&gt;SetPrivShopItems(map_shop);
	for (int i = 0; i &lt; SHOP_HOST_ITEM_MAX_NUM; i++)
		npcshop-&gt;BroadcastUpdateItem(i);
	if (owner)
	{
		owner-&gt;LoadPrivShops();
		owner-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_EDIT_SUCCESS&quot;));
	}
}
void CHARACTER::LoadPrivShops()
{
	m_mapshops.clear();
	std::auto_ptr&lt;SQLMsg&gt;pkMsg(DBManager::instance().DirectQuery(&quot;SELECT id,shop_vid,replace(replace(name,' ','\\\\'),'#','_'),gold,item_count,(select count(id) from player_shop_items where shop_id=player_shop.id),DATEDIFF(date_close,now()) AS days,UNIX_TIMESTAMP(date_close) from player_shop WHERE player_id=%d&quot;, GetPlayerID()));
	SQLResult * pRes = pkMsg-&gt;Get();
	if (pRes-&gt;uiNumRows&gt;0)
	{

MYSQL_ROW row;
		while ((row = mysql_fetch_row(pRes-&gt;pSQLResult)) != NULL)
		{
			int col = 0;
			TPrivShop shop;
			memset(&amp;shop, 0, sizeof(TPrivShop));
			str_to_number(shop.shop_id, row[col++]);
			str_to_number(shop.shop_vid, row[col++]);
			strlcpy(shop.szSign, row[col++], sizeof(shop.szSign));
			if(strlen(shop.szSign) == 0)
				strlcpy(shop.szSign, LC_TEXT(&quot;SHOP_NONAME&quot;), sizeof(shop.szSign));

str_to_number(shop.gold, row[col++]);
			str_to_number(shop.item_count, row[col++]);
			str_to_number(shop.rest_count, row[col++]);
			str_to_number(shop.days, row[col++]);
			str_to_number(shop.date_close, row[col++]);
			m_mapshops.insert(std::make_pair(shop.shop_id, shop));
		}
	}
	SendShops();
}
void CHARACTER::SendShops(bool isGm)
{
	ChatPacket(CHAT_TYPE_COMMAND, &quot;shop_clear&quot;);
	PSHOP_MAP::iterator it = m_mapshops.begin();
	while (it != m_mapshops.end())
	{
		ChatPacket(CHAT_TYPE_COMMAND, &quot;shop_add %d %d %s %lld %d %d %d %d&quot;, it-&gt;second.shop_id, it-&gt;second.shop_vid, it-&gt;second.szSign, it-&gt;second.gold, it-&gt;second.item_count, it-&gt;second.rest_count, it-&gt;second.days, it-&gt;second.date_close);
		it++;
	}

}
void CHARACTER::SendShopCost()
{
	extern std::map&lt;int, TShopCost&gt; g_ShopCosts;
	ChatPacket(CHAT_TYPE_COMMAND, &quot;shop_cost_clear&quot;);
	std::map&lt;int, TShopCost&gt;::iterator it = g_ShopCosts.begin();
	while (it != g_ShopCosts.end())
	{
		ChatPacket(CHAT_TYPE_COMMAND, &quot;shop_cost %d %d %d %d&quot;, it-&gt;first, it-&gt;second.days, it-&gt;second.time, it-&gt;second.price);
		it++;
	}

}
void CHARACTER::OpenShop(DWORD id, const char *name, bool onboot)
{
	if (GetMyShop())
	{
		CloseMyShop();
		return;
	}
	if (IsPC())
		return;
	char szSockets[1024] = { '\0' };
	char *tempSockets = szSockets;
	for (int i = 0; i &lt; ITEM_SOCKET_MAX_NUM; i++)
	{
		tempSockets += sprintf(tempSockets, &quot;socket%d&quot;, i);

if (i&lt;ITEM_SOCKET_MAX_NUM - 1)
			tempSockets += sprintf(tempSockets, &quot;,&quot;);
	}
	char szAttrs[1024] = { '\0' };
	char *tempAttrs = szAttrs;
	for (int i = 0; i &lt; ITEM_ATTRIBUTE_MAX_NUM; i++)
	{
		if (i &lt; 7)
			tempAttrs += sprintf(tempAttrs, &quot;attrtype%d,attrvalue%d&quot;, i, i);
		else
			tempAttrs += sprintf(tempAttrs, &quot;applytype%d,applyvalue%d&quot;, i - 7, i - 7);
		if (i&lt;ITEM_ATTRIBUTE_MAX_NUM - 1)
			tempAttrs += sprintf(tempAttrs, &quot;,&quot;);
	}
	std::auto_ptr&lt;SQLMsg&gt;pkMsg(DBManager::instance().DirectQuery(
		&quot;SELECT id,vnum,count,&quot;
#ifdef ENABLE_TRANSMUTE_SYSTEM
		&quot;look,&quot;
#endif
		&quot;display_pos,price,%s,%s from player_shop_items where shop_id='%d'&quot;, szSockets, szAttrs, id));
	memset(&amp;szSockets, 0, sizeof(szSockets));
	memset(&amp;szAttrs, 0, sizeof(szAttrs));
	SQLResult * pRes = pkMsg-&gt;Get();
	BYTE bItemCount = pRes-&gt;uiNumRows;

TShopItemTable * m_pShopTable = new TShopItemTable[bItemCount];
	memset(&amp;m_pShopTable[0], 0, sizeof(TShopItemTable) * bItemCount);

std::vector&lt;TShopItemTable *&gt; map_shop;

if (bItemCount&gt;0)
	{
		bItemCount = 0;
		MYSQL_ROW row;
		int c = 0;
		while ((row = mysql_fetch_row(pRes-&gt;pSQLResult)) != NULL)
		{
			int col = 0;
			TShopItemTable *shop = new TShopItemTable;
			memset(shop, 0, sizeof(TShopItemTable));
			DWORD id;
			shop-&gt;pos.window_type = INVENTORY;
			str_to_number(id, row[col++]);
			str_to_number(shop-&gt;vnum, row[col++]);
			str_to_number(shop-&gt;count, row[col++]);
#ifdef ENABLE_TRANSMUTE_SYSTEM
			str_to_number(shop-&gt;look, row[col++]);
#endif

str_to_number(shop-&gt;display_pos, row[col++]);
			//col++;
			str_to_number(shop-&gt;price, row[col++]);

const TItemTable * item_table = ITEM_MANAGER::instance().GetTable(shop-&gt;vnum);

if (!item_table)
			{
				sys_err(&quot;Shop: no item table by item vnum #%d&quot;, shop-&gt;vnum);
				continue;
			}
			if (-1 == (shop-&gt;pos.cell = GetEmptyInventory(item_table-&gt;bSize)))
			{
				sys_err(&quot;no empty position in npc inventory&quot;);
				return;
			}

LPITEM item = ITEM_MANAGER::instance().CreateItem(shop-&gt;vnum, shop-&gt;count, 0, false, -1, true);

if (item)
			{
				item-&gt;ClearAttribute();
				item-&gt;SetSkipSave(true);
				item-&gt;SetRealID(id);
#ifdef ENABLE_TRANSMUTE_SYSTEM
				item-&gt;SetLook(shop-&gt;look);
#endif

for (int s = 0; s&lt;ITEM_SOCKET_MAX_NUM; s++)
				{
					DWORD soc;
					str_to_number(soc, row[col++]);
					item-&gt;SetSocket(s, soc, false);
				}

for (int at = 0; at&lt;ITEM_ATTRIBUTE_MAX_NUM; at++)
				{
					DWORD attr;
					long val;
					str_to_number(attr, row[col++]);
					str_to_number(val, row[col++]);
					item-&gt;SetForceAttribute(at, attr, val);
				}

item-&gt;AddToCharacter(this, shop-&gt;pos);
			}
			else
			{
				sys_err(&quot;%d is not item&quot;, shop-&gt;vnum);
				continue;
			}

map_shop.push_back(shop);
			++bItemCount;
		}
	}

if (bItemCount == 0 &amp;&amp; !onboot || bItemCount &gt; SHOP_HOST_ITEM_MAX_NUM)
		return;

m_stShopSign = name;

if (m_stShopSign.length()&gt;30)
		m_stShopSign.resize(30);
	if (m_stShopSign.length() == 0 &amp;&amp; !onboot)
		return;

TPacketGCShopSign p;

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

PacketAround(&amp;p, sizeof(TPacketGCShopSign));

m_pkMyShop = CShopManager::instance().CreateNPCShop(this, map_shop);

}
void CHARACTER::DeleteMyShop()
{
	if (GetMyShop())
	{
		LPCHARACTER owner = CHARACTER_MANAGER::instance().FindByPID(GetPrivShopOwner());
		if(get_global_time() - GetShopEditModeTick() &lt; 20)
		{
			if (owner)
			{
				owner-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT( &quot;SHOP_SUCCESS_TOO_FAST&quot;));
			}else{

TPacketShopClose packet;
				packet.shop_id = GetPrivShop();
				packet.pid = GetPrivShopOwner();
				packet.error = true;
				packet.reload = false;
				db_clientdesc-&gt;DBPacket(HEADER_GD_SHOP_CLOSE, 0, &amp;packet, sizeof(packet));
			}
			return;
		}
		std::auto_ptr&lt;SQLMsg&gt;pkMsg(DBManager::instance().DirectQuery(&quot;SELECT gold FROM player_shop where id='%d'&quot;, GetPrivShop()));
		SQLResult * pRes = pkMsg-&gt;Get();
		if (pRes-&gt;uiNumRows&gt;0)
		{
			MYSQL_ROW row;
			while ((row = mysql_fetch_row(pRes-&gt;pSQLResult)) != NULL)
			{
				long long gold;
				str_to_number(gold, row[0]);
				if (gold&gt;0)
				{
					DBManager::instance().DirectQuery(&quot;INSERT INTO player_gift SET \
								   					owner_id=%d,vnum=1,count='%s',reason=\&quot;%s\&quot;,`from`=replace(\&quot;%s\&quot;,' ','_'),status='WAIT',date_add=NOW()&quot;,
						GetPrivShopOwner(), row[0], LC_TEXT(&quot;SHOP_REASON&quot;), GetName());
				}

}
			GetMyShop()-&gt;GetItems();
			if (owner)
			{
#ifdef GIFT_SYSTEM
				owner-&gt;RefreshGift();
#endif
				owner-&gt;RemovePrivShopTable(GetPrivShop());
				owner-&gt;SendShops();
				owner-&gt;ChatPacket(CHAT_TYPE_INFO, LC_TEXT(&quot;SHOP_SUCCESS_CLOSE&quot;));
			}
			else {
				TPacketShopClose packet;
				packet.shop_id = GetPrivShop();
				packet.pid = GetPrivShopOwner();
				packet.error = false;
				packet.reload = false;
				db_clientdesc-&gt;DBPacket(HEADER_GD_SHOP_CLOSE, 0, &amp;packet, sizeof(packet));
			}

std::unique_ptr&lt;SQLMsg&gt; (DBManager::instance().DirectQuery(&quot;delete from player_shop where id='%d'&quot;, GetPrivShop()));
			CloseMyShop();
		}
		return;
	}
	M2_DESTROY_CHARACTER(this);
}

EVENTFUNC(RefreshShopEvent)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;(event-&gt;info);
	if (info == NULL)
	{
		sys_err(&quot;ishop_refresh_event&gt; &lt;Factor&gt; Null pointer&quot;);
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (NULL == ch)
		return 0;

ch-&gt;SendShops();
	ch-&gt;SendShopCost();
	if (ch-&gt;GetGiftPages()&gt;0)
		ch-&gt;ChatPacket(CHAT_TYPE_COMMAND, &quot;gift_info %d&quot;, ch-&gt;GetGiftPages());
	return PASSES_PER_SEC(10);
}
void CHARACTER::StartRefreshShopEvent()
{
	if (m_pkRefreshShopEvent)
		return;

char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();

info-&gt;ch = this;

m_pkRefreshShopEvent = event_create(RefreshShopEvent, info, PASSES_PER_SEC(1));	// 1o?
}

EVENTFUNC(ShopEditModeEvent)
{
	char_event_info* info = dynamic_cast&lt;char_event_info*&gt;(event-&gt;info);
	if (info == NULL)
	{
		sys_err(&quot;ShopEditModeEvent&gt; &lt;Factor&gt; Null pointer&quot;);
		return 0;
	}

LPCHARACTER	ch = info-&gt;ch;

if (NULL == ch)
		return 0;
	if(!ch-&gt;GetMyShop() || !ch-&gt;IsPrivShop())
		return 0;

if(ch-&gt;GetShopEditMode() &amp;&amp; get_global_time() - ch-&gt;GetShopEditModeTick() &gt; 5)
		ch-&gt;SetShopEditMode(false);
	return PASSES_PER_SEC(6);
}

void CHARACTER::SetShopEditMode(bool val)
{
	m_bShopEditMode = val;
	GetMyShop()-&gt;SetLocked(val);
	if(val)
		GetMyShop()-&gt;RemoveGuests(this);
	else
		UpdateShopItems();
	std::unique_ptr&lt;SQLMsg&gt; (DBManager::instance().DirectQuery(&quot;UPDATE player_shop SET edit_mode=%d WHERE id=%d&quot;, val, GetPrivShop()));
}

void CHARACTER::SetShopEditModeTick()
{
	m_dwShopEditModeTick = get_global_time();
}

void CHARACTER::StartShopEditModeEvent()
{
	if (m_pkEditShopEvent)
		return;
	char_event_info* info = AllocEventInfo&lt;char_event_info&gt;();
	info-&gt;ch = this;
	m_pkEditShopEvent = event_create(ShopEditModeEvent, info, PASSES_PER_SEC(1));	// 1o?
}
#endif

Private - Private paste aren't shown in recent listings.

Delete After - When should we delete your paste?

Spam protection -

Reply to "teser"