#include "stdafx.h"

#include "../../common/teen_packet.h"

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

#include "char.h"

#include "config.h"

#include "utils.h"

#include "crc32.h"

#include "char_manager.h"

#include "desc_client.h"

#include "desc_manager.h"

#include "buffer_manager.h"

#include "item_manager.h"

#include "motion.h"

#include "vector.h"

#include "packet.h"

#include "cmd.h"

#include "fishing.h"

#include "exchange.h"

#include "battle.h"

#include "affect.h"

#include "shop.h"

#include "shop_manager.h"

#include "safebox.h"

#include "regen.h"

#include "pvp.h"

#include "party.h"

#include "start_position.h"

#include "questmanager.h"

#include "log.h"

#include "p2p.h"

#include "guild.h"

#include "guild_manager.h"

#include "dungeon.h"

#include "messenger_manager.h"

#include "unique_item.h"

#include "priv_manager.h"

#include "war_map.h"

#include "xmas_event.h"

#include "banword.h"

#include "target.h"

#include "wedding.h"

#include "mob_manager.h"

#include "mining.h"

#include "monarch.h"

#include "castle.h"

#include "arena.h"

#include "dev_log.h"

#include "horsename_manager.h"

#include "pcbang.h"

#include "gm.h"

#include "map_location.h"

#include "BlueDragon_Binder.h"

#include "HackShield.h"

#include "skill_power.h"

#include "XTrapManager.h"

#include "buff_on_attributes.h"

#ifdef __SEND_TARGET_INFO__

#include <algorithm>

#include <iterator>

using namespace std;

#endif

#ifdef __PET_SYSTEM__

#include "PetSystem.h"

#endif

#include "DragonSoul.h"

#include "../../common/CommonDefines.h"

#include "../../common/service.h"

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

#include "offline_shop.h"

#include "offlineshop_manager.h"

#include "offlineshop_config.h"

#endif

extern bool offlineshop_map_allow_find(int mapIndex);

extern const BYTE g_aBuffOnAttrPoints;

extern bool RaceToJob(unsigned race, unsigned *ret_job);

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

}

#ifdef NEW_ICEDAMAGE_SYSTEM

const DWORD CHARACTER::GetNoDamageRaceFlag()

{

return m_dwNDRFlag;

}

void CHARACTER::SetNoDamageRaceFlag(DWORD dwRaceFlag)

{

if (dwRaceFlag>=MAIN_RACE_MAX_NUM) return;

if (IS_SET(m_dwNDRFlag, 1<<dwRaceFlag)) return;

SET_BIT(m_dwNDRFlag, 1<<dwRaceFlag);

}

void CHARACTER::UnsetNoDamageRaceFlag(DWORD dwRaceFlag)

{

if (dwRaceFlag>=MAIN_RACE_MAX_NUM) return;

if (!IS_SET(m_dwNDRFlag, 1<<dwRaceFlag)) return;

REMOVE_BIT(m_dwNDRFlag, 1<<dwRaceFlag);

}

void CHARACTER::ResetNoDamageRaceFlag()

{

m_dwNDRFlag = 0;

}

const std::set<DWORD> & CHARACTER::GetNoDamageAffectFlag()

{

return m_setNDAFlag;

}

void CHARACTER::SetNoDamageAffectFlag(DWORD dwAffectFlag)

{

m_setNDAFlag.insert(dwAffectFlag);

}

void CHARACTER::UnsetNoDamageAffectFlag(DWORD dwAffectFlag)

{

m_setNDAFlag.erase(dwAffectFlag);

}

void CHARACTER::ResetNoDamageAffectFlag()

{

m_setNDAFlag.clear();

}

#endif

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

#ifdef __SEND_TARGET_INFO__

dwLastTargetInfoPulse = 0;

#endif

m_iMoveCount = 0;

m_pkRegen = NULL;

regen_id_ = 0;

m_posRegen.x = m_posRegen.y = m_posRegen.z = 0;

m_posStart.x = m_posStart.y = 0;

m_posDest.x = m_posDest.y = 0;

m_fRegenAngle = 0.0f;

m_pkMobData = NULL;

m_pkMobInst = NULL;

m_pkShop = NULL;

m_pkChrShopOwner = NULL;

m_pkMyShop = NULL;

m_pkExchange = NULL;

m_pkParty = NULL;

m_pkPartyRequestEvent = NULL;

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

m_pkOfflineShop = NULL;

m_pkChrOfflineShopOwner = NULL;

m_pkOfflineShopUpdateEvent = NULL;

m_bOfflineShopStatus = 0;

#endif

m_pGuild = NULL;

m_pkChrTarget = NULL;

m_pkMuyeongEvent = NULL;

m_pkWarpNPCEvent = NULL;

m_pkDeadEvent = NULL;

m_pkStunEvent = NULL;

m_pkSaveEvent = NULL;

m_pkRecoveryEvent = NULL;

m_pkTimedEvent = NULL;

m_pkFishingEvent = NULL;

m_pkWarpEvent = NULL;

// MINING

m_pkMiningEvent = NULL;

// END_OF_MINING

m_pkPoisonEvent = NULL;

#ifdef ENABLE_WOLFMAN_CHARACTER

m_pkBleedingEvent = NULL;

#endif

m_pkFireEvent = NULL;

m_pkCheckSpeedHackEvent = NULL;

m_speed_hack_count = 0;

m_pkAffectEvent = NULL;

m_afAffectFlag = TAffectFlag(0, 0);

m_pkDestroyWhenIdleEvent = NULL;

m_pkChrSyncOwner = NULL;

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

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

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

m_bCharType = CHAR_TYPE_MONSTER;

SetPosition(POS_STANDING);

m_dwPlayStartTime = m_dwLastMoveTime = get_dword_time();

GotoState(m_stateIdle);

m_dwStateDuration = 1;

m_dwLastAttackTime = get_dword_time() - 20000;

m_bAddChrState = 0;

m_pkChrStone = NULL;

m_pkSafebox = NULL;

m_iSafeboxSize = -1;

m_iSafeboxLoadTime = 0;

m_pkMall = NULL;

m_iMallLoadTime = 0;

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

m_lWarpMapIndex = 0;

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

m_lExitMapIndex = 0;

m_pSkillLevels = NULL;

m_dwMoveStartTime = 0;

m_dwMoveDuration = 0;

m_dwFlyTargetID = 0;

m_dwNextStatePulse = 0;

m_dwLastDeadTime = get_dword_time()-180000;

m_bSkipSave = false;

m_bItemLoaded = false;

m_bHasPoisoned = false;

#ifdef ENABLE_WOLFMAN_CHARACTER

m_bHasBled = false;

#endif

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;

#ifdef ENABLE_NEWSTUFF

m_dwLastItemDropTime = 0;

m_dwLastBoxUseTime = 0;

m_dwLastBuySellTime = 0;

#endif

m_HackShieldCheckEvent = NULL;

m_HackShieldCheckMode = false;

m_bIsLoadedAffect = false;

cannot_dead = false;

#ifdef __PET_SYSTEM__

m_petSystem = 0;

m_bIsPet = false;

#endif

#ifdef NEW_ICEDAMAGE_SYSTEM

m_dwNDRFlag = 0;

m_setNDAFlag.clear();

#endif

m_fAttMul = 1.0f;

m_fDamMul = 1.0f;

m_pointsInstant.iDragonSoulActiveDeck = -1;

#ifdef ENABLE_ANTI_CMD_FLOOD

m_dwCmdAntiFloodCount = 0;

m_dwCmdAntiFloodPulse = 0;

#endif

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

m_iSyncHackCount = 0;

#ifdef __SASH_SYSTEM__

m_bSashCombination = false;

m_bSashAbsorption = false;

#endif

#ifdef __CHANGELOOK_SYSTEM__

m_bChangeLook = false;

#endif

}

void CHARACTER::Create(const char * c_pszName, DWORD vid, bool isPC)

{

static int s_crc = 172814;

char crc_string[128+1];

snprintf(crc_string, sizeof(crc_string), "%s%p%d", c_pszName, this, ++s_crc);

m_vid = VID(vid, GetCRC32(crc_string, strlen(crc_string)));

if (isPC)

m_stName = c_pszName;

}

void CHARACTER::Destroy()

{

CloseMyShop();

if (m_pkRegen)

{

if (m_pkDungeon) {

// Dungeon regen may not be valid at this point

if (m_pkDungeon->IsValidRegen(m_pkRegen, regen_id_)) {

--m_pkRegen->count;

}

} else {

// Is this really safe?

--m_pkRegen->count;

}

m_pkRegen = NULL;

}

if (m_pkDungeon)

{

SetDungeon(NULL);

}

#ifdef __PET_SYSTEM__

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

m_petSystem = 0;

}

#endif

HorseSummon(false);

if (GetRider())

GetRider()->ClearHorseInfo();

if( IsPC() )

{

if (isHackShieldEnable)

{

CHackShieldManager::instance().DeleteClientHandle(GetPlayerID());

}

}

if (GetDesc())

{

GetDesc()->BindCharacter(NULL);

// BindDesc(NULL);

}

if (m_pkExchange)

m_pkExchange->Cancel();

SetVictim(NULL);

if (GetShop())

{

GetShop()->RemoveGuest(this);

SetShop(NULL);

}

ClearStone();

ClearSync();

ClearTarget();

if (NULL == m_pkMobData)

{

DragonSoul_CleanUp();

ClearItem();

}

// <Factor> m_pkParty becomes NULL after CParty destructor call!

LPPARTY party = m_pkParty;

if (party)

{

if (party->GetLeaderPID() == GetVID() && !IsPC())

{

M2_DELETE(party);

}

else

{

party->Unlink(this);

if (!IsPC())

party->Quit(GetVID());

}

SetParty(NULL);

}

if (m_pkMobInst)

{

M2_DELETE(m_pkMobInst);

m_pkMobInst = NULL;

}

m_pkMobData = NULL;

if (m_pkSafebox)

{

M2_DELETE(m_pkSafebox);

m_pkSafebox = NULL;

}

if (m_pkMall)

{

M2_DELETE(m_pkMall);

m_pkMall = NULL;

}

for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)

{

if (NULL != it->second)

{

M2_DELETE(it->second);

}

}

m_map_buff_on_attrs.clear();

m_set_pkChrSpawnedBy.clear();

StopMuyeongEvent();

event_cancel(&m_pkWarpNPCEvent);

event_cancel(&m_pkRecoveryEvent);

event_cancel(&m_pkDeadEvent);

event_cancel(&m_pkSaveEvent);

event_cancel(&m_pkTimedEvent);

event_cancel(&m_pkStunEvent);

event_cancel(&m_pkFishingEvent);

event_cancel(&m_pkPoisonEvent);

#ifdef ENABLE_WOLFMAN_CHARACTER

event_cancel(&m_pkBleedingEvent);

#endif

event_cancel(&m_pkFireEvent);

event_cancel(&m_pkPartyRequestEvent);

//DELAYED_WARP

event_cancel(&m_pkWarpEvent);

event_cancel(&m_pkCheckSpeedHackEvent);

//END_DELAYED_WARP

// RECALL_DELAY

//event_cancel(&m_pkRecallEvent);

// END_OF_RECALL_DELAY

// MINING

event_cancel(&m_pkMiningEvent);

// END_OF_MINING

StopHackShieldCheckCycle();

for (itertype(m_mapMobSkillEvent) it = m_mapMobSkillEvent.begin(); it != m_mapMobSkillEvent.end(); ++it)

{

LPEVENT pkEvent = it->second;

event_cancel(&pkEvent);

}

m_mapMobSkillEvent.clear();

//event_cancel(&m_pkAffectEvent);

ClearAffect();

event_cancel(&m_pkDestroyWhenIdleEvent);

if (m_pSkillLevels)

{

M2_DELETE_ARRAY(m_pSkillLevels);

m_pSkillLevels = NULL;

}

CEntity::Destroy();

if (GetSectree())

GetSectree()->RemoveEntity(this);

if (m_bMonsterLog)

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

}

const char * CHARACTER::GetName() const

{

return m_stName.empty() ? (m_pkMobData ? m_pkMobData->m_table.szLocaleName : "") : m_stName.c_str();

}

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

{

if (GetPart(PART_MAIN) > 2)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°©¿ÊÀ» ¹ş¾î¾ß °³ÀÎ »óÁ¡À» ¿­ ¼ö ÀÖ½À´Ï´Ù."));

return;

}

if (GetMyShop())

{

CloseMyShop();

return;

}

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

if (strlen(szSign) == 0)

{

ChatPacket(CHAT_TYPE_INFO, "Gecersiz cevrimdisi pazar ismi girdiniz!");

return;

}

if (strstr(szSign, "%") || strstr(szSign, "'"))

{

ChatPacket(CHAT_TYPE_INFO, "Gecersiz cevrimdisi pazar ismi girdiniz!");

return;

}

m_stShopSign = szSign;

if (m_stShopSign.length() == 0)

return;

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;

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

}

#ifdef __SOULBINDING_SYSTEM__

if (pkItem->IsBind() || pkItem->IsUntilBind())

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't sell this item because is binded!"));

return;

}

#endif

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

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

}

else if (GetMountVnum())

{

RemoveAffect(AFFECT_MOUNT);

RemoveAffect(AFFECT_MOUNT_BONUS);

}

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 ENABLE_WOLFMAN_CHARACTER

SetPolymorph(m_points.job, true);

// SetPolymorph(0, true);

#else

SetPolymorph(GetJob(), true);

#endif

}

}

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

}

}

}

}

// #define ENABLE_SHOWNPCLEVEL

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

#ifdef __SASH_SYSTEM__

addPacket.awPart[CHR_EQUIPPART_SASH] = GetPart(PART_SASH);

#endif

addPacket.bPKMode = m_bPKMode;

addPacket.dwMountVnum = GetMountVnum();

addPacket.bEmpire = m_bEmpire;

#ifdef ENABLE_SHOWNPCLEVEL

if (1)

#else

if (IsPC() == true)

#endif

{

addPacket.dwLevel = GetLevel();

}

else

{

addPacket.dwLevel = 0;

}

#ifdef ENABLE_RARITY_SYSTEM

LPITEM weapon = GetWear(WEAR_WEAPON);

addPacket.lWeaponRarity = weapon ? weapon->GetAttributeValue(6) : 0;

#endif

if (false)

{

LPCHARACTER ch = (LPCHARACTER) entity;

if (GetEmpire() == ch->GetEmpire() || ch->GetGMLevel() > GM_PLAYER || m_bCharType == CHAR_TYPE_NPC)

{

goto show_all_info;

}

else

{

memset(addPacket.name, 0, CHARACTER_NAME_MAX_LEN);

addPacket.dwGuildID = 0;

addPacket.sAlignment = 0;

}

}

else

{

show_all_info:

strlcpy(addPacket.name, GetName(), sizeof(addPacket.name));

if (GetGuild() != NULL)

{

addPacket.dwGuildID = GetGuild()->GetID();

#ifdef ENABLE_LEADER_SYSTEM

CGuild* pGuild = this->GetGuild();

if (pGuild->GetMasterPID() == GetPlayerID())

addPacket.dwNewIsGuildName = 3;

else if (pGuild->NewIsGuildGeneral(GetPlayerID()) == true)

addPacket.dwNewIsGuildName = 2;

else

addPacket.dwNewIsGuildName = 1;

#endif

}

else

{

addPacket.dwGuildID = 0;

#ifdef ENABLE_LEADER_SYSTEM

addPacket.dwNewIsGuildName = 0;

#endif

}

addPacket.sAlignment = m_iAlignment / 10;

}

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

}

if (iDur)

{

TPacketGCMove pack;

EncodeMovePacket(pack, GetVID(), FUNC_MOVE, 0, m_posDest.x, m_posDest.y, iDur, 0, (BYTE) (GetRotation() / 5));

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

TPacketGCWalkMode p;

p.vid = GetVID();

p.header = HEADER_GC_WALK_MODE;

p.mode = m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;

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

}

if (entity->IsType(ENTITY_CHARACTER) && GetDesc())

{

LPCHARACTER ch = (LPCHARACTER) entity;

if (ch->IsWalking())

{

TPacketGCWalkMode p;

p.vid = ch->GetVID();

p.header = HEADER_GC_WALK_MODE;

p.mode = ch->m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;

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

}

}

if (GetMyShop())

{

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

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

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

}

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

if (IsOfflineShopNPC() && GetRaceNum() == 30000)

{

TPacketGCShopSign p;

p.bHeader = HEADER_GC_OFFLINE_SHOP_SIGN;

p.dwVID = GetVID();

if (m_stOfflineShopSign.empty())

{

std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT sign FROM player.offline_shop_npc WHERE owner_id = %u", GetOfflineShopRealOwner()));

if (pMsg->Get()->uiNumRows > 0)

{

MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);

strlcpy(p.szSign, row[0], sizeof(p.szSign));

}

}

else

{

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

}

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

}

#endif

if (entity->IsType(ENTITY_CHARACTER))

{

sys_log(3, "EntityInsert %s (RaceNum %d) (%d %d) TO %s",

GetName(), GetRaceNum(), GetX() / SECTREE_SIZE, GetY() / SECTREE_SIZE, ((LPCHARACTER)entity)->GetName());

}

}

void CHARACTER::EncodeRemovePacket(LPENTITY entity)

{

if (entity->GetType() != ENTITY_CHARACTER)

return;

LPDESC d;

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

return;

TPacketGCCharacterDelete pack;

pack.header = HEADER_GC_CHARACTER_DEL;

pack.id = m_vid;

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

if (entity->IsType(ENTITY_CHARACTER))

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

}

void CHARACTER::UpdatePacket()

{

if (GetSectree() == NULL) return;

TPacketGCCharacterUpdate pack;

TPacketGCCharacterUpdate pack2;

pack.header = HEADER_GC_CHARACTER_UPDATE;

pack.dwVID = m_vid;

pack.awPart[CHR_EQUIPPART_ARMOR] = GetPart(PART_MAIN);

pack.awPart[CHR_EQUIPPART_WEAPON] = GetPart(PART_WEAPON);

pack.awPart[CHR_EQUIPPART_HEAD] = GetPart(PART_HEAD);

pack.awPart[CHR_EQUIPPART_HAIR] = GetPart(PART_HAIR);

#ifdef __SASH_SYSTEM__

pack.awPart[CHR_EQUIPPART_SASH] = GetPart(PART_SASH);

#endif

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

#ifdef ENABLE_LEADER_SYSTEM

CGuild* pGuild = this->GetGuild();

if (pGuild)

{

if (pGuild->GetMasterPID() == GetPlayerID())

pack.dwNewIsGuildName = 3;

else if (pGuild->NewIsGuildGeneral(GetPlayerID()) == true)

pack.dwNewIsGuildName = 2;

else

pack.dwNewIsGuildName = 1;

}

else

{

pack.dwNewIsGuildName = 0;

}

#endif

#ifdef ENABLE_RARITY_SYSTEM

LPITEM weapon = GetWear(WEAR_WEAPON);

pack.lWeaponRarity = weapon ? weapon->GetAttributeValue(6) : 0;

#endif

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

}

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

if (GetOfflineShop())

{

GetOfflineShop()->RemoveGuest(this);

SetOfflineShop(NULL);

}

#endif

if (GetArena() != NULL)

{

GetArena()->OnDisconnect(GetPlayerID());

}

if (GetParty() != NULL)

{

GetParty()->UpdateOfflineState(GetPlayerID());

}

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

// P2P Logout

TPacketGGLogout p;

p.bHeader = HEADER_GG_LOGOUT;

strlcpy(p.szName, GetName(), sizeof(p.szName));

P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGLogout));

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

#ifdef ENABLE_PCBANG_FEATURE

{

long playTime = GetRealPoint(POINT_PLAYTIME) - m_dwLoginPlayTime;

LogManager::instance().LoginLog(false, GetDesc()->GetAccountTable().id, GetPlayerID(), GetLevel(), GetJob(), playTime);

if (0)

CPCBangManager::instance().Log(GetDesc()->GetHostName(), GetPlayerID(), playTime);

}

#endif

if (m_pWarMap)

SetWarMap(NULL);

if (m_pWeddingMap)

{

SetWeddingMap(NULL);

}

if (GetGuild())

GetGuild()->LogoutMember(this);

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

if (GetParty())

GetParty()->Unlink(this);

if (IsStun() || IsDead())

{

DeathPenalty(0);

PointChange(POINT_HP, 50 - GetHP());

}

if (!CHARACTER_MANAGER::instance().FlushDelayedSave(this))

{

SaveReal();

}

FlushDelayedSaveItem();

SaveAffect();

m_bIsLoadedAffect = false;

m_bSkipSave = true;

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

CloseSafebox();

CloseMall();

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

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

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

if (g_TeenDesc)

{

int offset = 0;

char buf[245] = {0};

buf[0] = HEADER_GT_LOGOUT;

offset += 1;

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

offset += 2;

TAccountTable &acc_table = GetDesc()->GetAccountTable();

memcpy(buf+offset, &acc_table.id, 4);

offset += 4;

g_TeenDesc->Packet(buf, offset);

}

if (GetDesc())

{

GetDesc()->BindCharacter(NULL);

// BindDesc(NULL);

}

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

M2_DESTROY_CHARACTER(this);

}

bool CHARACTER::Show(long lMapIndex, long x, long y, long z, bool bShowSpawnMotion/* = false */)

{

LPSECTREE sectree = SECTREE_MANAGER::instance().Get(lMapIndex, x, y);

if (!sectree)

{

sys_log(0, "cannot find sectree by %dx%d mapindex %d", x, y, lMapIndex);

return false;

}

SetMapIndex(lMapIndex);

bool bChangeTree = false;

if (!GetSectree() || GetSectree() != sectree)

bChangeTree = true;

if (bChangeTree)

{

if (GetSectree())

GetSectree()->RemoveEntity(this);

ViewCleanup();

}

if (!IsNPC())

{

sys_log(0, "SHOW: %s %dx%dx%d", GetName(), x, y, z);

if (GetStamina() < GetMaxStamina())

StartAffectEvent();

}

else if (m_pkMobData)

{

m_pkMobInst->m_posLastAttacked.x = x;

m_pkMobInst->m_posLastAttacked.y = y;

m_pkMobInst->m_posLastAttacked.z = z;

}

if (bShowSpawnMotion)

{

SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

m_afAffectFlag.Set(AFF_SPAWN);

}

SetXYZ(x, y, z);

m_posDest.x = x;

m_posDest.y = y;

m_posDest.z = z;

m_posStart.x = x;

m_posStart.y = y;

m_posStart.z = z;

if (bChangeTree)

{

EncodeInsertPacket(this);

sectree->InsertEntity(this);

UpdateSectree();

}

else

{

ViewReencode();

sys_log(0, " in same sectree");

}

REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

SetValidComboInterval(0);

return true;

}

// BGM_INFO

struct BGMInfo

{

std::string name;

float vol;

};

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

static BGMInfoMap gs_bgmInfoMap;

static bool gs_bgmVolEnable = false;

void CHARACTER_SetBGMVolumeEnable()

{

gs_bgmVolEnable = true;

sys_log(0, "bgm_info.set_bgm_volume_enable");

}

void CHARACTER_AddBGMInfo(unsigned mapIndex, const char* name, float vol)

{

BGMInfo newInfo;

newInfo.name = name;

newInfo.vol = vol;

gs_bgmInfoMap[mapIndex] = newInfo;

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

}

const BGMInfo& CHARACTER_GetBGMInfo(unsigned mapIndex)

{

BGMInfoMap::iterator f = gs_bgmInfoMap.find(mapIndex);

if (gs_bgmInfoMap.end() == f)

{

static BGMInfo s_empty = {"", 0.0f};

return s_empty;

}

return f->second;

}

bool CHARACTER_IsBGMVolumeEnable()

{

return gs_bgmVolEnable;

}

// END_OF_BGM_INFO

void CHARACTER::MainCharacterPacket()

{

const unsigned mapIndex = GetMapIndex();

const BGMInfo& bgmInfo = CHARACTER_GetBGMInfo(mapIndex);

// SUPPORT_BGM

if (!bgmInfo.name.empty())

{

if (CHARACTER_IsBGMVolumeEnable())

{

sys_log(1, "bgm_info.play_bgm_vol(%d, name='%s', vol=%f)", mapIndex, bgmInfo.name.c_str(), bgmInfo.vol);

TPacketGCMainCharacter4_BGM_VOL mainChrPacket;

mainChrPacket.header = HEADER_GC_MAIN_CHARACTER4_BGM_VOL;

mainChrPacket.dwVID = m_vid;

mainChrPacket.wRaceNum = GetRaceNum();

mainChrPacket.lx = GetX();

mainChrPacket.ly = GetY();

mainChrPacket.lz = GetZ();

mainChrPacket.empire = GetDesc()->GetEmpire();

mainChrPacket.skill_group = GetSkillGroup();

strlcpy(mainChrPacket.szChrName, GetName(), sizeof(mainChrPacket.szChrName));

mainChrPacket.fBGMVol = bgmInfo.vol;

strlcpy(mainChrPacket.szBGMName, bgmInfo.name.c_str(), sizeof(mainChrPacket.szBGMName));

GetDesc()->Packet(&mainChrPacket, sizeof(TPacketGCMainCharacter4_BGM_VOL));

}

else

{

sys_log(1, "bgm_info.play(%d, '%s')", mapIndex, bgmInfo.name.c_str());

TPacketGCMainCharacter3_BGM mainChrPacket;

mainChrPacket.header = HEADER_GC_MAIN_CHARACTER3_BGM;

mainChrPacket.dwVID = m_vid;

mainChrPacket.wRaceNum = GetRaceNum();

mainChrPacket.lx = GetX();

mainChrPacket.ly = GetY();

mainChrPacket.lz = GetZ();

mainChrPacket.empire = GetDesc()->GetEmpire();

mainChrPacket.skill_group = GetSkillGroup();

strlcpy(mainChrPacket.szChrName, GetName(), sizeof(mainChrPacket.szChrName));

strlcpy(mainChrPacket.szBGMName, bgmInfo.name.c_str(), sizeof(mainChrPacket.szBGMName));

GetDesc()->Packet(&mainChrPacket, sizeof(TPacketGCMainCharacter3_BGM));

}

//if (m_stMobile.length())

// ChatPacket(CHAT_TYPE_COMMAND, "sms");

}

// END_OF_SUPPORT_BGM

else

{

sys_log(0, "bgm_info.play(%d, DEFAULT_BGM_NAME)", mapIndex);

TPacketGCMainCharacter pack;

pack.header = HEADER_GC_MAIN_CHARACTER;

pack.dwVID = m_vid;

pack.wRaceNum = GetRaceNum();

pack.lx = GetX();

pack.ly = GetY();

pack.lz = GetZ();

pack.empire = GetDesc()->GetEmpire();

pack.skill_group = GetSkillGroup();

strlcpy(pack.szName, GetName(), sizeof(pack.szName));

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

if (m_stMobile.length())

ChatPacket(CHAT_TYPE_COMMAND, "sms");

}

}

void CHARACTER::PointsPacket()

{

if (!GetDesc())

return;

TPacketGCPoints pack;

pack.header = HEADER_GC_CHARACTER_POINTS;

pack.points[POINT_LEVEL] = GetLevel();

pack.points[POINT_EXP] = GetExp();

pack.points[POINT_NEXT_EXP] = GetNextExp();

pack.points[POINT_HP] = GetHP();

pack.points[POINT_MAX_HP] = GetMaxHP();

pack.points[POINT_SP] = GetSP();

pack.points[POINT_MAX_SP] = GetMaxSP();

pack.points[POINT_GOLD] = GetGold();

#ifdef __COINS_SYSTEM__

pack.points[POINT_COINS] = GetCoins();

#endif

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;

#ifdef ENABLE_WOLFMAN_CHARACTER

case MAIN_RACE_WOLFMAN_M:

m_points.job = MAIN_RACE_WOLFMAN_M;

break;

#endif

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;

}

#ifdef __COINS_SYSTEM__

long CHARACTER::GetEp() const

{

std::auto_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT coins FROM account.account WHERE id = '%d';", GetDesc()->GetAccountTable().id));

if (pMsg->Get()->uiNumRows == 0)

return 0;

MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);

DWORD ep = 0;

str_to_number(ep, row[0]);

return ep;

}

void CHARACTER::SetCoins(long coins)

{

DBManager::instance().DirectQuery("UPDATE account.account SET coins = '%d' WHERE id = '%d';", coins, GetDesc()->GetAccountTable().id);

m_coins = coins;

}

void CHARACTER::SetEp(long coins)

{

m_coins = coins;

SetPoint(POINT_COINS, coins);

}

#endif

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

#ifdef __SASH_SYSTEM__

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

#endif

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

if (!test_server)

{

if (GetGMLevel() > GM_LOW_WIZARD)

{

m_afAffectFlag.Set(AFF_YMIR);

m_bPKMode = PK_MODE_PROTECT;

}

}

if (GetLevel() < PK_PROTECT_LEVEL)

m_bPKMode = PK_MODE_PROTECT;

m_stMobile = t->szMobile;

SetHorseData(t->horse);

if (GetHorseLevel() > 0)

UpdateHorseDataByLogoff(t->logoff_interval);

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

m_dwLogOffInterval = t->logoff_interval;

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

if (GetGMLevel() != GM_PLAYER)

{

LogManager::instance().CharLog(this, GetGMLevel(), "GM_LOGIN", "");

sys_log(0, "GM_LOGIN(gmlevel=%d, name=%s(%d), pos=(%d, %d)", GetGMLevel(), GetName(), GetPlayerID(), GetX(), GetY());

}

#ifdef __PET_SYSTEM__

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

}

m_petSystem = M2_NEW CPetSystem(this);

#endif

SetOfflineShopVID(COfflineShopManager::instance().FindMyOfflineShop(GetPlayerID()));

}

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

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

if (GetRaceNum() == xmas::MOB_SANTA_VNUM)

{

SetPoint(POINT_ATT_GRADE_BONUS, 10);

SetPoint(POINT_DEF_GRADE_BONUS, 6);

m_dwPlayStartTime = get_dword_time() + 30 * 1000;

if (test_server)

m_dwPlayStartTime = get_dword_time() + 30 * 1000;

}

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;

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;

return m_pkMobData->m_table.bRank;

}

BYTE CHARACTER::GetMobSize() const

{

if (!m_pkMobData)

return MOBSIZE_MEDIUM;

return m_pkMobData->m_table.bSize;

}

WORD CHARACTER::GetMobAttackRange() const

{

switch (GetMobBattleType())

{

case BATTLE_TYPE_RANGE:

case BATTLE_TYPE_MAGIC:

return m_pkMobData->m_table.wAttackRange + GetPoint(POINT_BOW_DISTANCE);

default:

return m_pkMobData->m_table.wAttackRange;

}

}

BYTE CHARACTER::GetMobBattleType() const

{

if (!m_pkMobData)

return BATTLE_TYPE_MELEE;

return (m_pkMobData->m_table.bBattleType);

}

void CHARACTER::ComputeBattlePoints()

{

if (IsPolymorphed())

{

DWORD dwMobVnum = GetPolymorphVnum();

const CMob * pMob = CMobManager::instance().Get(dwMobVnum);

int iAtt = 0;

int iDef = 0;

if (pMob)

{

iAtt = GetLevel() * 2 + GetPolymorphPoint(POINT_ST) * 2;

iDef = GetLevel() + GetPolymorphPoint(POINT_HT) + pMob->m_table.wDef;

}

SetPoint(POINT_ATT_GRADE, iAtt);

SetPoint(POINT_DEF_GRADE, iDef);

SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));

SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));

}

else if (IsPC())

{

SetPoint(POINT_ATT_GRADE, 0);

SetPoint(POINT_DEF_GRADE, 0);

SetPoint(POINT_CLIENT_DEF_GRADE, 0);

SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));

SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));

int iAtk = GetLevel() * 2;

int iStatAtk = 0;

switch (GetJob())

{

case JOB_WARRIOR:

case JOB_SURA:

iStatAtk = (2 * GetPoint(POINT_ST));

break;

case JOB_ASSASSIN:

iStatAtk = (4 * GetPoint(POINT_ST) + 2 * GetPoint(POINT_DX)) / 3;

break;

case JOB_SHAMAN:

iStatAtk = (4 * GetPoint(POINT_ST) + 2 * GetPoint(POINT_IQ)) / 3;

break;

#ifdef ENABLE_WOLFMAN_CHARACTER

case JOB_WOLFMAN:

iStatAtk = (2 * GetPoint(POINT_ST));

break;

#endif

default:

sys_err("invalid job %d", GetJob());

iStatAtk = (2 * GetPoint(POINT_ST));

break;

}

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

iStatAtk = (2 * GetPoint(POINT_ST));

iAtk += iStatAtk;

if (GetMountVnum())

{

if (GetJob() == JOB_SURA && GetSkillGroup() == 1)

{

iAtk += (iAtk * GetHorseLevel()) / 60;

}

else

{

iAtk += (iAtk * GetHorseLevel()) / 30;

}

}

//

// ATK Setting

//

iAtk += GetPoint(POINT_ATT_GRADE_BONUS);

PointChange(POINT_ATT_GRADE, iAtk);

// DEF = LEV + CON + ARMOR

int iShowDef = GetLevel() + GetPoint(POINT_HT);

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

int iArmor = 0;

LPITEM pkItem;

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

if ((pkItem = GetWear(i)) && pkItem->GetType() == ITEM_ARMOR)

{

if (pkItem->GetSubType() == ARMOR_BODY || pkItem->GetSubType() == ARMOR_HEAD || pkItem->GetSubType() == ARMOR_FOOTS || pkItem->GetSubType() == ARMOR_SHIELD)

{

iArmor += pkItem->GetValue(1);

iArmor += (2 * pkItem->GetValue(5));

}

}

if( true == IsHorseRiding() )

{

if (iArmor < GetHorseArmor())

iArmor = GetHorseArmor();

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

if (pHorseName != NULL && strlen(pHorseName))

{

iArmor += 20;

}

}

iArmor += GetPoint(POINT_DEF_GRADE_BONUS);

iArmor += GetPoint(POINT_PARTY_DEFENDER_BONUS);

// INTERNATIONAL_VERSION

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

{

int iAtt = GetLevel() * 2 + GetPoint(POINT_ST) * 2;

int iDef = GetLevel() + GetPoint(POINT_HT) + GetMobTable().wDef;

SetPoint(POINT_ATT_GRADE, iAtt);

SetPoint(POINT_DEF_GRADE, iDef);

SetPoint(POINT_MAGIC_ATT_GRADE, GetPoint(POINT_ATT_GRADE));

SetPoint(POINT_MAGIC_DEF_GRADE, GetPoint(POINT_DEF_GRADE));

}

}

void CHARACTER::ComputePoints()

{

long lStat = GetPoint(POINT_STAT);

long lStatResetCount = GetPoint(POINT_STAT_RESET_COUNT);

long lSkillActive = GetPoint(POINT_SKILL);

long lSkillSub = GetPoint(POINT_SUB_SKILL);

long lSkillHorse = GetPoint(POINT_HORSE_SKILL);

long lLevelStep = GetPoint(POINT_LEVEL_STEP);

long lAttackerBonus = GetPoint(POINT_PARTY_ATTACKER_BONUS);

long lTankerBonus = GetPoint(POINT_PARTY_TANKER_BONUS);

long lBufferBonus = GetPoint(POINT_PARTY_BUFFER_BONUS);

long lSkillMasterBonus = GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);

long lHasteBonus = GetPoint(POINT_PARTY_HASTE_BONUS);

long lDefenderBonus = GetPoint(POINT_PARTY_DEFENDER_BONUS);

long lHPRecovery = GetPoint(POINT_HP_RECOVERY);

long lSPRecovery = GetPoint(POINT_SP_RECOVERY);

#ifdef __COINS_SYSTEM__

long lcoins = GetCoins();

#endif

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

#ifdef __SASH_SYSTEM__

SetPart(PART_SASH, GetOriginalPart(PART_SASH));

#endif

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

#ifdef __COINS_SYSTEM__

SetPoint(POINT_COINS, lcoins);

#endif

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

if (iMaxHP != GetMaxHP())

{

SetRealPoint(POINT_MAX_HP, iMaxHP);

}

PointChange(POINT_MAX_HP, 0);

if (iMaxSP != GetMaxSP())

{

SetRealPoint(POINT_MAX_SP, iMaxSP);

}

PointChange(POINT_MAX_SP, 0);

SetMaxStamina(iMaxStamina);

int iCurHP = this->GetHP();

int iCurSP = this->GetSP();

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

}

}

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

if (IsPC())

{

if (this->GetHP() != iCurHP)

this->PointChange(POINT_HP, iCurHP-this->GetHP());

if (this->GetSP() != iCurSP)

this->PointChange(POINT_SP, iCurSP-this->GetSP());

}

CPetSystem* pPetSystem = GetPetSystem();

if (NULL != pPetSystem)

{

pPetSystem->RefreshBuff();

}

UpdatePacket();

if (GetHP() > GetMaxHP())

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

if (GetSP() > GetMaxSP())

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

}

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

return 0;

}

if (!ch->IsPC())

{

if (ch->IsAffectFlag(AFF_POISON))

return PASSES_PER_SEC(MAX(1, ch->GetMobTable().bRegenCycle));

#ifdef ENABLE_WOLFMAN_CHARACTER

if (ch->IsAffectFlag(AFF_BLEEDING))

return PASSES_PER_SEC(MAX(1, ch->GetMobTable().bRegenCycle));

#endif

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

{

ch->CheckTarget();

//ch->UpdateSectree();

ch->UpdateKillerMode();

if (ch->IsAffectFlag(AFF_POISON) == true)

{

return 3;

}

#ifdef ENABLE_WOLFMAN_CHARACTER

if (ch->IsAffectFlag(AFF_BLEEDING))

return 3;

#endif

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

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;

}

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;

return true;

}

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

const float fDist = DISTANCE_SQRT(id.coord.x - old_id.coord.x, id.coord.y - old_id.coord.y);

sys_log(0, "SECTREE DIFFER: %s %dx%d was %dx%d dist %.1fm",

GetName(),

id.coord.x,

id.coord.y,

old_id.coord.x,

old_id.coord.y,

fDist);

}

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)

{

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;

#ifdef ENABLE_WOLFMAN_CHARACTER

case WEAPON_CLAW:

dwMode = MOTION_MODE_CLAW;

break;

#endif

}

}

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

}

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

if (amount)

{

quest::CQuestManager::instance().LevelUp(GetPlayerID());

int biodurum = GetQuestFlag("bio.durum");

if (biodurum == 0 && GetLevel() >= 30)

{

SetQuestFlag("bio.durum",1);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 31 && GetLevel() >= 40)

{

SetQuestFlag("bio.durum",2);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 41 && GetLevel() >= 50)

{

SetQuestFlag("bio.durum",3);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 51 && GetLevel() >= 60)

{

SetQuestFlag("bio.durum",4);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 61 && GetLevel() >= 70)

{

SetQuestFlag("bio.durum",5);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 71 && GetLevel() >= 80)

{

SetQuestFlag("bio.durum",6);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 81 && GetLevel() >= 85)

{

SetQuestFlag("bio.durum",7);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 86 && GetLevel() >= 90)

{

SetQuestFlag("bio.durum",8);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 91 && GetLevel() >= 92)

{

SetQuestFlag("bio.durum",9);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

else if (biodurum == 93 && GetLevel() >= 94)

{

SetQuestFlag("bio.durum",10);

SetQuestFlag("bio.verilen",0);

SetQuestFlag("bio.ruhtasi",0);

SetQuestFlag("bio.kalan",get_global_time());

int bioverilen = GetQuestFlag("bio.verilen");

int biokalan = GetQuestFlag("bio.kalan");

biodurum = GetQuestFlag("bio.durum");

ChatPacket(CHAT_TYPE_COMMAND, "biyolog %d %d %d %d ", BiyologSistemi[biodurum][0], bioverilen, BiyologSistemi[biodurum][1], biokalan);

}

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;

#ifdef ENABLE_WOLFMAN_CHARACTER

if (GetJob() == JOB_WOLFMAN)

{

if ((5 <= val) && (GetSkillGroup()!=1))

{

ClearSkill();

// set skill group

SetSkillGroup(1);

// set skill points

SetRealPoint(POINT_SKILL, GetLevel()-1);

SetPoint(POINT_SKILL, GetRealPoint(POINT_SKILL));

PointChange(POINT_SKILL, 0);

// update points (not required)

// ComputePoints();

// PointsPacket();

}

}

#endif

PointChange(POINT_NEXT_EXP, GetNextExp(), false);

case POINT_NEXT_EXP:

val = GetNextExp();

bAmount = false;

break;

case POINT_EXP:

{

DWORD exp = GetExp();

DWORD next_exp = GetNextExp();

if (g_bChinaIntoxicationCheck)

{

if (IsOverTime(OT_NONE))

{

dev_log(LOG_DEB0, "<EXP_LOG> %s = NONE", GetName());

}

else if (IsOverTime(OT_3HOUR))

{

amount = (amount / 2);

dev_log(LOG_DEB0, "<EXP_LOG> %s = 3HOUR", GetName());

}

else if (IsOverTime(OT_5HOUR))

{

amount = 0;

dev_log(LOG_DEB0, "<EXP_LOG> %s = 5HOUR", GetName());

}

}

if ((amount < 0) && (exp < (DWORD)(-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);

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() <= g_iStatusPointGetLevelLimit) &&

(GetLevel() <= gPlayerMaxLevel) )

PointChange(POINT_STAT, 1);

break;

case 4:

{

int iHP = number(JobInitialPoints[GetJob()].hp_per_lv_begin, JobInitialPoints[GetJob()].hp_per_lv_end);

int iSP = number(JobInitialPoints[GetJob()].sp_per_lv_begin, JobInitialPoints[GetJob()].sp_per_lv_end);

m_points.iRandomHP += iHP;

m_points.iRandomSP += iSP;

if (GetSkillGroup())

{

if (GetLevel() >= 5)

PointChange(POINT_SKILL, 1);

if (GetLevel() >= 9)

PointChange(POINT_SUB_SKILL, 1);

}

PointChange(POINT_MAX_HP, iHP);

PointChange(POINT_MAX_SP, iSP);

PointChange(POINT_LEVEL, 1, false, true);

val = 0;

}

break;

}

if (GetLevel() <= 10)

AutoGiveItem(27001, 2);

else if (GetLevel() <= 30)

AutoGiveItem(27002, 2);

else

{

AutoGiveItem(27002, 2);

// AutoGiveItem(27003, 2);

}

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

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

PointChange(POINT_STAMINA, GetMaxStamina() - GetStamina());

SetPoint(POINT_LEVEL_STEP, val);

SetRealPoint(POINT_LEVEL_STEP, val);

Save();

}

else

val = GetPoint(POINT_LEVEL_STEP);

break;

case POINT_HP:

{

if (IsDead() || IsStun())

return;

int prev_hp = GetHP();

amount = MIN(GetMaxHP() - GetHP(), amount);

SetHP(GetHP() + amount);

val = GetHP();

BroadcastTargetPacket();

if (GetParty() && IsPC() && val != prev_hp)

GetParty()->SendPartyInfoOneToAll(this);

}

break;

case POINT_SP:

{

if (IsDead() || IsStun())

return;

amount = MIN(GetMaxSP() - GetSP(), amount);

SetSP(GetSP() + amount);

val = GetSP();

}

break;

case POINT_STAMINA:

{

if (IsDead() || IsStun())

return;

int prev_val = GetStamina();

amount = MIN(GetMaxStamina() - GetStamina(), amount);

SetStamina(GetStamina() + amount);

val = GetStamina();

if (val == 0)

{

SetNowWalking(true);

}

else if (prev_val == 0)

{

ResetWalking();

}

if (amount < 0 && val != 0)

return;

}

break;

case POINT_MAX_HP:

{

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

int hp = GetRealPoint(POINT_MAX_HP);

int add_hp = MIN(3500, hp * GetPoint(POINT_MAX_HP_PCT) / 100);

add_hp += GetPoint(POINT_MAX_HP);

add_hp += GetPoint(POINT_PARTY_TANKER_BONUS);

SetMaxHP(hp + add_hp);

val = GetMaxHP();

}

break;

case POINT_MAX_SP:

{

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

int sp = GetRealPoint(POINT_MAX_SP);

int add_sp = MIN(800, sp * GetPoint(POINT_MAX_SP_PCT) / 100);

add_sp += GetPoint(POINT_MAX_SP);

add_sp += GetPoint(POINT_PARTY_SKILL_MASTER_BONUS);

SetMaxSP(sp + add_sp);

val = GetMaxSP();

}

break;

case POINT_MAX_HP_PCT:

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

val = GetPoint(type);

PointChange(POINT_MAX_HP, 0);

break;

case POINT_MAX_SP_PCT:

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

val = GetPoint(type);

PointChange(POINT_MAX_SP, 0);

break;

case POINT_MAX_STAMINA:

SetMaxStamina(GetMaxStamina() + amount);

val = GetMaxStamina();

break;

case POINT_GOLD:

{

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

if (GOLD_MAX <= nTotalMoney)

{

sys_err("[OVERFLOW_GOLD] OriGold %d AddedGold %d id %u Name %s ", GetGold(), amount, GetPlayerID(), GetName());

LogManager::instance().CharLog(this, GetGold() + amount, "OVERFLOW_GOLD", "");

return;

}

if (g_bChinaIntoxicationCheck && 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;

#ifdef __COINS_SYSTEM__

case POINT_COINS:

{

SetCoins(GetCoins() + amount);

val = GetCoins();

}

break;

#endif

case POINT_SKILL:

case POINT_STAT:

case POINT_SUB_SKILL:

case POINT_STAT_RESET_COUNT:

case POINT_HORSE_SKILL:

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

val = GetPoint(type);

SetRealPoint(type, val);

break;

case POINT_DEF_GRADE:

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

val = GetPoint(type);

PointChange(POINT_CLIENT_DEF_GRADE, amount);

break;

case POINT_CLIENT_DEF_GRADE:

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

val = GetPoint(type);

break;

case POINT_ST:

case POINT_HT:

case POINT_DX:

case POINT_IQ:

case POINT_HP_REGEN:

case POINT_SP_REGEN:

case POINT_ATT_SPEED:

case POINT_ATT_GRADE:

case POINT_MOV_SPEED:

case POINT_CASTING_SPEED:

case POINT_MAGIC_ATT_GRADE:

case POINT_MAGIC_DEF_GRADE:

case POINT_BOW_DISTANCE:

case POINT_HP_RECOVERY:

case POINT_SP_RECOVERY:

case POINT_ATTBONUS_HUMAN:

case POINT_ATTBONUS_ANIMAL:

case POINT_ATTBONUS_ORC:

case POINT_ATTBONUS_MILGYO:

case POINT_ATTBONUS_UNDEAD:

case POINT_ATTBONUS_DEVIL:

case POINT_ATTBONUS_MONSTER:

case POINT_ATTBONUS_SURA:

case POINT_ATTBONUS_ASSASSIN:

case POINT_ATTBONUS_WARRIOR:

case POINT_ATTBONUS_SHAMAN:

#ifdef ENABLE_WOLFMAN_CHARACTER

case POINT_ATTBONUS_WOLFMAN:

#endif

case POINT_POISON_PCT:

#ifdef ENABLE_WOLFMAN_CHARACTER

case POINT_BLEEDING_PCT:

#endif

case POINT_STUN_PCT:

case POINT_SLOW_PCT:

case POINT_BLOCK:

case POINT_DODGE:

case POINT_CRITICAL_PCT:

case POINT_RESIST_CRITICAL:

case POINT_PENETRATE_PCT:

case POINT_RESIST_PENETRATE:

case POINT_CURSE_PCT:

case POINT_STEAL_HP:

case POINT_STEAL_SP:

case POINT_MANA_BURN_PCT:

case POINT_DAMAGE_SP_RECOVER:

case POINT_RESIST_NORMAL_DAMAGE:

case POINT_RESIST_SWORD:

case POINT_RESIST_TWOHAND:

case POINT_RESIST_DAGGER:

case POINT_RESIST_BELL:

case POINT_RESIST_FAN:

case POINT_RESIST_BOW:

#ifdef ENABLE_WOLFMAN_CHARACTER

case POINT_RESIST_CLAW:

#endif

case POINT_RESIST_FIRE:

case POINT_RESIST_ELEC:

case POINT_RESIST_MAGIC:

case POINT_RESIST_WIND:

case POINT_RESIST_ICE:

case POINT_RESIST_EARTH:

case POINT_RESIST_DARK:

case POINT_REFLECT_MELEE:

case POINT_REFLECT_CURSE:

case POINT_POISON_REDUCE:

#ifdef ENABLE_WOLFMAN_CHARACTER

case POINT_BLEEDING_REDUCE:

#endif

case POINT_KILL_SP_RECOVER:

case POINT_KILL_HP_RECOVERY:

case POINT_HIT_HP_RECOVERY:

case POINT_HIT_SP_RECOVERY:

case POINT_MANASHIELD:

case POINT_ATT_BONUS:

case POINT_DEF_BONUS:

case POINT_SKILL_DAMAGE_BONUS:

case POINT_NORMAL_HIT_DAMAGE_BONUS:

// 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 :

#ifdef ENABLE_WOLFMAN_CHARACTER

case POINT_RESIST_WOLFMAN :

#endif

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)

{

// ChatPacket(CHAT_TYPE_INFO, "IMMUNE_STUN SET_BIT type(%u) amount(%d)", type, amount);

SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_STUN);

}

else

{

// ChatPacket(CHAT_TYPE_INFO, "IMMUNE_STUN REMOVE_BIT type(%u) amount(%d)", type, amount);

REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_STUN);

}

break;

case POINT_IMMUNE_SLOW:

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

val = GetPoint(type);

if (val)

{

SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_SLOW);

}

else

{

REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_SLOW);

}

break;

case POINT_IMMUNE_FALL:

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

val = GetPoint(type);

if (val)

{

SET_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_FALL);

}

else

{

REMOVE_BIT(m_pointsInstant.dwImmuneFlag, IMMUNE_FALL);

}

break;

case POINT_ATT_GRADE_BONUS:

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

PointChange(POINT_ATT_GRADE, amount);

val = GetPoint(type);

break;

case POINT_DEF_GRADE_BONUS:

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

PointChange(POINT_DEF_GRADE, amount);

val = GetPoint(type);

break;

case POINT_MAGIC_ATT_GRADE_BONUS:

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

PointChange(POINT_MAGIC_ATT_GRADE, amount);

val = GetPoint(type);

break;

case POINT_MAGIC_DEF_GRADE_BONUS:

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

PointChange(POINT_MAGIC_DEF_GRADE, amount);

val = GetPoint(type);

break;

case POINT_VOICE:

case POINT_EMPIRE_POINT:

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