#include "stdafx.h"

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

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

#include "char.h"

#include "config.h"

#include "utils.h"

#include "crc32.h"

#include "char_manager.h"

#include "desc_client.h"

#include "desc_manager.h"

#include "buffer_manager.h"

#include "item_manager.h"

#include "motion.h"

#include "vector.h"

#include "packet.h"

#include "cmd.h"

#include "fishing.h"

#include "exchange.h"

#include "battle.h"

#include "affect.h"

#include "shop.h"

#include "shop_manager.h"

#include "safebox.h"

#include "regen.h"

#include "pvp.h"

#include "party.h"

#include "start_position.h"

#include "questmanager.h"

#include "log.h"

#include "p2p.h"

#include "guild.h"

#include "guild_manager.h"

#include "dungeon.h"

#include "messenger_manager.h"

#include "unique_item.h"

#include "priv_manager.h"

#include "war_map.h"

#include "xmas_event.h"

#include "banword.h"

#include "target.h"

#include "wedding.h"

#include "mob_manager.h"

#include "mining.h"

#include "monarch.h"

#include "castle.h"

#include "arena.h"

#include "dev_log.h"

#include "horsename_manager.h"

#include "pcbang.h"

#include "gm.h"

#include "map_location.h"

#include "BlueDragon_Binder.h"

#include "HackShield.h"

#include "skill_power.h"

#include "XTrapManager.h"

#include "buff_on_attributes.h"

#ifdef __PET_SYSTEM__

#include "PetSystem.h"

#endif

#include "DragonSoul.h"

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

#include "offline_shop.h"

#include "offlineshop_manager.h"

#include "offlineshop_config.h"

#endif

extern bool offlineshop_map_allow_find(int mapIndex);

extern const BYTE g_aBuffOnAttrPoints;

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

extern int g_nPortalLimitTime;

extern int test_server;

extern bool IS_SUMMONABLE_ZONE(int map_index); // char_item.cpp

bool CAN_ENTER_ZONE(const LPCHARACTER& ch, int map_index);

bool CAN_ENTER_ZONE(const LPCHARACTER& ch, int map_index)

{

switch (map_index)

{

case 301:

case 302:

case 303:

case 304:

if (ch->GetLevel() < 90)

return false;

}

return true;

}

// <Factor> DynamicCharacterPtr member function definitions

LPCHARACTER DynamicCharacterPtr::Get() const {

LPCHARACTER p = NULL;

if (is_pc) {

p = CHARACTER_MANAGER::instance().FindByPID(id);

} else {

p = CHARACTER_MANAGER::instance().Find(id);

}

return p;

}

DynamicCharacterPtr& DynamicCharacterPtr::operator=(LPCHARACTER character) {

if (character == NULL) {

Reset();

return *this;

}

if (character->IsPC()) {

is_pc = true;

id = character->GetPlayerID();

} else {

is_pc = false;

id = character->GetVID();

}

return *this;

}

CHARACTER::CHARACTER()

{

m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateIdle, &CHARACTER::EndStateEmpty);

m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateMove, &CHARACTER::EndStateEmpty);

m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateBattle, &CHARACTER::EndStateEmpty);

Initialize();

}

CHARACTER::~CHARACTER()

{

Destroy();

}

void CHARACTER::Initialize()

{

CEntity::Initialize(ENTITY_CHARACTER);

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

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

// Offline Shop

m_pkOfflineShop = NULL;

m_pkChrOfflineShopOwner = NULL;

m_pkOfflineShopUpdateEvent = NULL;

// End Of Offline Shop

#endif

m_pGuild = NULL;

m_pkChrTarget = NULL;

m_pkMuyeongEvent = NULL;

m_pkWarpNPCEvent = NULL;

m_pkDeadEvent = NULL;

m_pkStunEvent = NULL;

m_pkSaveEvent = NULL;

m_pkRecoveryEvent = NULL;

m_pkTimedEvent = NULL;

m_pkFishingEvent = NULL;

m_pkWarpEvent = NULL;

// MINING

m_pkMiningEvent = NULL;

// END_OF_MINING

m_pkPoisonEvent = NULL;

m_pkFireEvent = NULL;

m_pkCheckSpeedHackEvent = NULL;

m_speed_hack_count = 0;

m_pkAffectEvent = NULL;

m_afAffectFlag = TAffectFlag(0, 0);

m_pkDestroyWhenIdleEvent = NULL;

m_pkChrSyncOwner = NULL;

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

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

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

m_bCharType = CHAR_TYPE_MONSTER;

SetPosition(POS_STANDING);

m_dwPlayStartTime = m_dwLastMoveTime = get_dword_time();

GotoState(m_stateIdle);

m_dwStateDuration = 1;

m_dwLastAttackTime = get_dword_time() - 20000;

m_bAddChrState = 0;

m_pkChrStone = NULL;

m_pkSafebox = NULL;

m_iSafeboxSize = -1;

m_iSafeboxLoadTime = 0;

m_pkMall = NULL;

m_iMallLoadTime = 0;

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

m_lWarpMapIndex = 0;

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

m_lExitMapIndex = 0;

m_pSkillLevels = NULL;

m_dwMoveStartTime = 0;

m_dwMoveDuration = 0;

m_dwFlyTargetID = 0;

m_dwNextStatePulse = 0;

m_dwLastDeadTime = get_dword_time()-180000;

m_bSkipSave = false;

m_bItemLoaded = false;

m_bHasPoisoned = false;

m_pkDungeon = NULL;

m_iEventAttr = 0;

m_kAttackLog.dwVID = 0;

m_kAttackLog.dwTime = 0;

m_bNowWalking = m_bWalking = false;

ResetChangeAttackPositionTime();

m_bDetailLog = false;

m_bMonsterLog = false;

m_bDisableCooltime = false;

m_iAlignment = 0;

m_iRealAlignment = 0;

m_iKillerModePulse = 0;

m_bPKMode = PK_MODE_PEACE;

m_dwQuestNPCVID = 0;

m_dwQuestByVnum = 0;

m_pQuestItem = NULL;

m_szMobileAuth[0] = '\0';

m_dwUnderGuildWarInfoMessageTime = get_dword_time()-60000;

m_bUnderRefine = false;

// REFINE_NPC

m_dwRefineNPCVID = 0;

// END_OF_REFINE_NPC

m_dwPolymorphRace = 0;

m_bStaminaConsume = false;

ResetChainLightningIndex();

m_dwMountVnum = 0;

m_chHorse = NULL;

m_chRider = NULL;

m_pWarMap = NULL;

m_pWeddingMap = NULL;

m_bChatCounter = 0;

ResetStopTime();

m_dwLastVictimSetTime = get_dword_time() - 3000;

m_iMaxAggro = -100;

m_bSendHorseLevel = 0;

m_bSendHorseHealthGrade = 0;

m_bSendHorseStaminaGrade = 0;

m_dwLoginPlayTime = 0;

m_pkChrMarried = NULL;

m_posSafeboxOpen.x = -1000;

m_posSafeboxOpen.y = -1000;

// EQUIP_LAST_SKILL_DELAY

m_dwLastSkillTime = get_dword_time();

// END_OF_EQUIP_LAST_SKILL_DELAY

// MOB_SKILL_COOLTIME

memset(m_adwMobSkillCooltime, 0, sizeof(m_adwMobSkillCooltime));

// END_OF_MOB_SKILL_COOLTIME

m_isinPCBang = false;

// ARENA

m_pArena = NULL;

m_nPotionLimit = quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count");

// END_ARENA

//PREVENT_TRADE_WINDOW

m_isOpenSafebox = 0;

//END_PREVENT_TRADE_WINDOW

//PREVENT_REFINE_HACK

m_iRefineTime = 0;

//END_PREVENT_REFINE_HACK

//RESTRICT_USE_SEED_OR_MOONBOTTLE

m_iSeedTime = 0;

//END_RESTRICT_USE_SEED_OR_MOONBOTTLE

//PREVENT_PORTAL_AFTER_EXCHANGE

m_iExchangeTime = 0;

//END_PREVENT_PORTAL_AFTER_EXCHANGE

//

m_iSafeboxLoadTime = 0;

m_iMyShopTime = 0;

InitMC();

m_deposit_pulse = 0;

SET_OVER_TIME(this, OT_NONE);

m_strNewName = "";

m_known_guild.clear();

m_dwLogOffInterval = 0;

m_bComboSequence = 0;

m_dwLastComboTime = 0;

m_bComboIndex = 0;

m_iComboHackCount = 0;

m_dwSkipComboAttackByTime = 0;

m_dwMountTime = 0;

m_dwLastGoldDropTime = 0;

m_HackShieldCheckEvent = NULL;

m_HackShieldCheckMode = false;

m_bIsLoadedAffect = false;

cannot_dead = false;

#ifdef __PET_SYSTEM__

m_petSystem = 0;

m_bIsPet = false;

#endif

m_fAttMul = 1.0f;

m_fDamMul = 1.0f;

m_pointsInstant.iDragonSoulActiveDeck = -1;

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

m_iSyncHackCount = 0;

}

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

{

static int s_crc = 172814;

char crc_string[128+1];

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

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

if (isPC)

m_stName = c_pszName;

}

void CHARACTER::Destroy()

{

CloseMyShop();

if (m_pkRegen)

{

if (m_pkDungeon) {

// Dungeon regen may not be valid at this point

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

--m_pkRegen->count;

}

} else {

// Is this really safe?

--m_pkRegen->count;

}

m_pkRegen = NULL;

}

if (m_pkDungeon)

{

SetDungeon(NULL);

}

#ifdef __PET_SYSTEM__

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

m_petSystem = 0;

}

#endif

HorseSummon(false);

if (GetRider())

GetRider()->ClearHorseInfo();

if( IsPC() )

{

if (isHackShieldEnable)

{

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

}

}

if (GetDesc())

{

GetDesc()->BindCharacter(NULL);

// BindDesc(NULL);

}

if (m_pkExchange)

m_pkExchange->Cancel();

SetVictim(NULL);

if (GetShop())

{

GetShop()->RemoveGuest(this);

SetShop(NULL);

}

ClearStone();

ClearSync();

ClearTarget();

if (NULL == m_pkMobData)

{

DragonSoul_CleanUp();

ClearItem();

}

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

LPPARTY party = m_pkParty;

if (party)

{

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

{

M2_DELETE(party);

}

else

{

party->Unlink(this);

if (!IsPC())

party->Quit(GetVID());

}

SetParty(NULL); // ���ص� ���� �����ϰ�.

}

if (m_pkMobInst)

{

M2_DELETE(m_pkMobInst);

m_pkMobInst = NULL;

}

m_pkMobData = NULL;

if (m_pkSafebox)

{

M2_DELETE(m_pkSafebox);

m_pkSafebox = NULL;

}

if (m_pkMall)

{

M2_DELETE(m_pkMall);

m_pkMall = NULL;

}

m_set_pkChrSpawnedBy.clear();

StopMuyeongEvent();

event_cancel(&m_pkWarpNPCEvent);

event_cancel(&m_pkRecoveryEvent);

event_cancel(&m_pkDeadEvent);

event_cancel(&m_pkSaveEvent);

event_cancel(&m_pkTimedEvent);

event_cancel(&m_pkStunEvent);

event_cancel(&m_pkFishingEvent);

event_cancel(&m_pkPoisonEvent);

event_cancel(&m_pkFireEvent);

event_cancel(&m_pkPartyRequestEvent);

//DELAYED_WARP

event_cancel(&m_pkWarpEvent);

event_cancel(&m_pkCheckSpeedHackEvent);

//END_DELAYED_WARP

// RECALL_DELAY

//event_cancel(&m_pkRecallEvent);

// END_OF_RECALL_DELAY

// MINING

event_cancel(&m_pkMiningEvent);

// END_OF_MINING

StopHackShieldCheckCycle();

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

{

LPEVENT pkEvent = it->second;

event_cancel(&pkEvent);

}

m_mapMobSkillEvent.clear();

//event_cancel(&m_pkAffectEvent);

ClearAffect();

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

{

if (NULL != it->second)

{

M2_DELETE(it->second);

}

}

m_map_buff_on_attrs.clear();

event_cancel(&m_pkDestroyWhenIdleEvent);

if (m_pSkillLevels)

{

M2_DELETE_ARRAY(m_pSkillLevels);

m_pSkillLevels = NULL;

}

CEntity::Destroy();

if (GetSectree())

GetSectree()->RemoveEntity(this);

if (m_bMonsterLog)

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

}

const char * CHARACTER::GetName() const

{

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

}

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

{

if (GetPart(PART_MAIN) > 2)

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("����� ����� ���� ���� �� �� �ֽ�ϴ�."));

return;

}

if (GetMyShop()) // �̹� ���� ���� ����� �ݴ´�.

{

CloseMyShop();

return;

}

// �������� ��Ʈ�� ����� ���� �� �� ���.

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

// GetPCForce�� NULL�� �� ����Ƿ� ��� Ȯ������ ���

if (pPC->IsRunning())

return;

if (bItemCount == 0)

return;

int64_t nTotalMoney = 0;

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

{

nTotalMoney += static_cast<int64_t>((pTable+n)->price);

}

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

if (GOLD_MAX <= nTotalMoney)

{

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

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("20�� ��� �ʰ��Ͽ� ���� ���� ���ϴ�"));

return;

}

char szSign[SHOP_SIGN_MAX_LEN+1];

strlcpy(szSign, c_pszSign, sizeof(szSign));

m_stShopSign = szSign;

if (m_stShopSign.length() == 0)

return;

if (LC_IsCanada() == false)

{

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

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("��Ӿ �� ���Ե� ��� �̸���� ���� �� �� ���ϴ�."));

return;

}

}

// MYSHOP_PRICE_LIST

std::map<DWORD, DWORD> itemkind; // ������ ��� ����, first: vnum, second: ���� �� ����

// END_OF_MYSHOP_PRICE_LIST

std::set<TItemPos> cont;

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

{

if (cont.find((pTable + i)->pos) != cont.end())

{

sys_err("MYSHOP: duplicate shop item detected! (name: %s)", GetName());

return;

}

// ANTI_GIVE, ANTI_MYSHOP check

LPITEM pkItem = GetItem((pTable + i)->pos);

if (pkItem)

{

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

if (item_table && (IS_SET(item_table->dwAntiFlags, ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_MYSHOP)))

{

ChatPacket(CHAT_TYPE_INFO, LC_TEXT("���ȭ ������� ���λ������ �Ǹ��� �� ���ϴ�."));

return;

}

if (pkItem->GetType() == ITEM_WEAPON || pkItem->GetType() == ITEM_ARMOR || pkItem->GetType() == ITEM_BELT)

{

char szEventFlag[30];

snprintf(szEventFlag, sizeof(szEventFlag), "%d.Engel", pkItem->GetID());

if (*szEventFlag)

{

if (quest::CQuestManager::instance().GetEventFlag(szEventFlag))

{

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

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 ij�ÿ� ������.

//

TPacketMyshopPricelistHeader header;

TItemPriceInfo info;

header.dwOwnerID = GetPlayerID();

header.byCount = itemkind.size();

TEMP_BUFFER buf;

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

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

{

info.dwVnum = it->first;

info.dwPrice = it->second;

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

}

db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_UPDATE, 0, buf.read_peek(), buf.size());

}

// END_OF_MYSHOP_PRICE_LIST

else if (CountSpecifyItem(50200))

RemoveSpecifyItem(50200, 1);

else

return; // ���� ����� �ߴ�.

if (m_pkExchange)

m_pkExchange->Cancel();

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

strlcpy(p.szSign, c_pszSign, sizeof(p.szSign));

PacketAround(&p, sizeof(TPacketGCShopSign));

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

if (IsPolymorphed() == true)

{

RemoveAffect(AFFECT_POLYMORPH);

}

if (GetHorse())

{

HorseSummon( false, true );

}

// new mount �̿� �߿�, ���� ��� ���� �ڵ� unmount

// StopRiding��� ������Ʈ���� ó���ϸ� ����� �� �׷��� ���س���� �� �� ���.

else if (GetMountVnum())

{

RemoveAffect(AFFECT_MOUNT);

RemoveAffect(AFFECT_MOUNT_BONUS);

}

//if (!LC_IsNewCIBN())

SetPolymorph(30000, true);

}

void CHARACTER::CloseMyShop()

{

if (GetMyShop())

{

m_stShopSign.clear();

CShopManager::instance().DestroyPCShop(this);

m_pkMyShop = NULL;

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

p.szSign[0] = '\0';

PacketAround(&p, sizeof(p));

//if (!LC_IsNewCIBN())

SetPolymorph(GetJob(), true);

}

}

void EncodeMovePacket(TPacketGCMove & pack, DWORD dwVID, BYTE bFunc, BYTE bArg, DWORD x, DWORD y, DWORD dwDuration, DWORD dwTime, BYTE bRot)

{

pack.bHeader = HEADER_GC_MOVE;

pack.bFunc = bFunc;

pack.bArg = bArg;

pack.dwVID = dwVID;

pack.dwTime = dwTime ? dwTime : get_dword_time();

pack.bRot = bRot;

pack.lX = x;

pack.lY = y;

pack.dwDuration = dwDuration;

}

void CHARACTER::RestartAtSamePos()

{

if (m_bIsObserver)

return;

EncodeRemovePacket(this);

EncodeInsertPacket(this);

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

while (it != m_map_view.end())

{

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

EncodeRemovePacket(entity);

if (!m_bIsObserver)

EncodeInsertPacket(entity);

if( entity->IsType(ENTITY_CHARACTER) )

{

LPCHARACTER lpChar = (LPCHARACTER)entity;

if( lpChar->IsPC() || lpChar->IsNPC() || lpChar->IsMonster() )

{

if (!entity->IsObserverMode())

entity->EncodeInsertPacket(this);

}

}

else

{

if( !entity->IsObserverMode())

{

entity->EncodeInsertPacket(this);

}

}

}

}

// Entity�� ���� ��Ÿ���ٰ� ��Ŷ� ������.

void CHARACTER::EncodeInsertPacket(LPENTITY entity)

{

LPDESC d;

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

return;

// ����̸� ��� ��� �ڵ�

LPCHARACTER ch = (LPCHARACTER) entity;

ch->SendGuildName(GetGuild());

// ����̸� ��� ��� �ڵ�

TPacketGCCharacterAdd pack;

pack.header = HEADER_GC_CHARACTER_ADD;

pack.dwVID = m_vid;

pack.bType = GetCharType();

pack.angle = GetRotation();

pack.x = GetX();

pack.y = GetY();

pack.z = GetZ();

pack.wRaceNum = GetRaceNum();

if (IsPet())

{

pack.bMovingSpeed = 150;

}

else

{

pack.bMovingSpeed = GetLimitPoint(POINT_MOV_SPEED);

}

pack.bAttackSpeed = GetLimitPoint(POINT_ATT_SPEED);

pack.dwAffectFlag[0] = m_afAffectFlag.bits[0];

pack.dwAffectFlag[1] = m_afAffectFlag.bits[1];

pack.bStateFlag = m_bAddChrState;

int iDur = 0;

if (m_posDest.x != pack.x || m_posDest.y != pack.y)

{

iDur = (m_dwMoveStartTime + m_dwMoveDuration) - get_dword_time();

if (iDur <= 0)

{

pack.x = m_posDest.x;

pack.y = m_posDest.y;

}

}

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

if (IsPC() == true || m_bCharType == CHAR_TYPE_NPC)

{

TPacketGCCharacterAdditionalInfo addPacket;

memset(&addPacket, 0, sizeof(TPacketGCCharacterAdditionalInfo));

addPacket.header = HEADER_GC_CHAR_ADDITIONAL_INFO;

addPacket.dwVID = m_vid;

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

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

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

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

addPacket.awPart[CHR_EQUIPPART_ACCE] = GetPart(PART_ACCE);

addPacket.bPKMode = m_bPKMode;

addPacket.dwMountVnum = GetMountVnum();

addPacket.bEmpire = m_bEmpire;

if (IsPC() == true && (LC_IsEurope() == true || LC_IsCanada() == true || LC_IsSingapore() == true))

{

addPacket.dwLevel = GetLevel();

}

else

{

addPacket.dwLevel = 0;

}

if (false)

{

LPCHARACTER ch = (LPCHARACTER) entity;

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

{

goto show_all_info;

}

else

{

memset(addPacket.name, 0, CHARACTER_NAME_MAX_LEN);

addPacket.dwGuildID = 0;

addPacket.sAlignment = 0;

}

}

else

{

show_all_info:

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

if (GetGuild() != NULL)

{

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

}

else

{

addPacket.dwGuildID = 0;

}

addPacket.sAlignment = m_iAlignment / 10;

}

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

}

if (iDur)

{

TPacketGCMove pack;

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

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

TPacketGCWalkMode p;

p.vid = GetVID();

p.header = HEADER_GC_WALK_MODE;

p.mode = m_bNowWalking ? WALKMODE_WALK : WALKMODE_RUN;

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

}

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

{

LPCHARACTER ch = (LPCHARACTER) entity;

if (ch->IsWalking())

{

TPacketGCWalkMode p;

p.vid = ch->GetVID();

p.header = HEADER_GC_WALK_MODE;

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

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

}

}

if (GetMyShop())

{

TPacketGCShopSign p;

p.bHeader = HEADER_GC_SHOP_SIGN;

p.dwVID = GetVID();

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

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

}

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

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

{

TPacketGCShopSign p;

p.bHeader = HEADER_GC_OFFLINE_SHOP_SIGN;

p.dwVID = GetVID();

if (m_stOfflineShopSign.empty())

{

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

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

{

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

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

}

}

else

{

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

}

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

}

#endif

if (entity->IsType(ENTITY_CHARACTER))

{

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

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

}

}

void CHARACTER::EncodeRemovePacket(LPENTITY entity)

{

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

return;

LPDESC d;

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

return;

TPacketGCCharacterDelete pack;

pack.header = HEADER_GC_CHARACTER_DEL;

pack.id = m_vid;

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

if (entity->IsType(ENTITY_CHARACTER))

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

}

void CHARACTER::UpdatePacket()

{

if (GetSectree() == NULL) return;

TPacketGCCharacterUpdate pack;

TPacketGCCharacterUpdate pack2;

pack.header = HEADER_GC_CHARACTER_UPDATE;

pack.dwVID = m_vid;

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

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

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

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

pack.awPart[CHR_EQUIPPART_ACCE] = GetPart(PART_ACCE);

pack.bMovingSpeed = GetLimitPoint(POINT_MOV_SPEED);

pack.bAttackSpeed = GetLimitPoint(POINT_ATT_SPEED);

pack.bStateFlag = m_bAddChrState;

pack.dwAffectFlag[0] = m_afAffectFlag.bits[0];

pack.dwAffectFlag[1] = m_afAffectFlag.bits[1];

pack.dwGuildID = 0;

pack.sAlignment = m_iAlignment / 10;

pack.dwLevel = GetLevel();

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

}

#ifdef ENABLE_OFFLINE_SHOP_SYSTEM

if (GetOfflineShop())

{

GetOfflineShop()->RemoveGuest(this);

SetOfflineShop(NULL);

}

#endif

if (GetArena() != NULL)

{

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

}

if (GetParty() != NULL)

{

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

}

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

// P2P Logout

TPacketGGLogout p;

p.bHeader = HEADER_GG_LOGOUT;

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

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

char buf[51];

snprintf(buf, sizeof(buf), "%s %d %d %ld %d",

inet_ntoa(GetDesc()->GetAddr().sin_addr), GetGold(), g_bChannel, GetMapIndex(), GetAlignment());

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

if (LC_IsYMIR() || LC_IsKorea() || LC_IsBrazil())

{

long playTime = GetRealPoint(POINT_PLAYTIME) - m_dwLoginPlayTime;

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

if (LC_IsBrazil() != true)

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

}

if (m_pWarMap)

SetWarMap(NULL);

if (m_pWeddingMap)

{

SetWeddingMap(NULL);

}

if (GetGuild())

GetGuild()->LogoutMember(this);

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

if (GetParty())

GetParty()->Unlink(this);

// �׾�� �� ��Ӳ���� ����ġ �ٰ� �ϱ�

if (IsStun() || IsDead())

{

DeathPenalty(0);

PointChange(POINT_HP, 50 - GetHP());

}

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

{

SaveReal();

}

FlushDelayedSaveItem();

SaveAffect();

m_bIsLoadedAffect = false;

m_bSkipSave = true; // �� ���Ŀ��� ���̻� �����ϸ� �ȵȴ�.

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

CloseSafebox();

CloseMall();

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

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

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

if (g_TeenDesc)

{

int offset = 0;

char buf[245] = {0};

buf[0] = HEADER_GT_LOGOUT;

offset += 1;

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

offset += 2;

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

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

offset += 4;

g_TeenDesc->Packet(buf, offset);

}

if (GetDesc())

{

GetDesc()->BindCharacter(NULL);

// BindDesc(NULL);

}

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

M2_DESTROY_CHARACTER(this);

}

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

{

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

if (!sectree)

{

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

return false;

}

SetMapIndex(lMapIndex);

bool bChangeTree = false;

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

bChangeTree = true;

if (bChangeTree)

{

if (GetSectree())

GetSectree()->RemoveEntity(this);

ViewCleanup();

}

if (!IsNPC())

{

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

if (GetStamina() < GetMaxStamina())

StartAffectEvent();

}

else if (m_pkMobData)

{

m_pkMobInst->m_posLastAttacked.x = x;

m_pkMobInst->m_posLastAttacked.y = y;

m_pkMobInst->m_posLastAttacked.z = z;

}

if (bShowSpawnMotion)

{

SET_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

m_afAffectFlag.Set(AFF_SPAWN);

}

SetXYZ(x, y, z);

m_posDest.x = x;

m_posDest.y = y;

m_posDest.z = z;

m_posStart.x = x;

m_posStart.y = y;

m_posStart.z = z;

if (bChangeTree)

{

EncodeInsertPacket(this);

sectree->InsertEntity(this);

UpdateSectree();

}

else

{

ViewReencode();

sys_log(0, " in same sectree");

}

REMOVE_BIT(m_bAddChrState, ADD_CHARACTER_STATE_SPAWN);

SetValidComboInterval(0);

return true;

}

// BGM_INFO

struct BGMInfo

{

std::string name;

float vol;

};

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

static BGMInfoMap gs_bgmInfoMap;

static bool gs_bgmVolEnable = false;

void CHARACTER_SetBGMVolumeEnable()

{

gs_bgmVolEnable = true;

sys_log(0, "bgm_info.set_bgm_volume_enable");

}

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

{

BGMInfo newInfo;

newInfo.name = name;

newInfo.vol = vol;

gs_bgmInfoMap[mapIndex] = newInfo;

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

}

const BGMInfo& CHARACTER_GetBGMInfo(unsigned mapIndex)

{

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

if (gs_bgmInfoMap.end() == f)

{

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

return s_empty;

}

return f->second;

}

bool CHARACTER_IsBGMVolumeEnable()

{

return gs_bgmVolEnable;

}

// END_OF_BGM_INFO

void CHARACTER::MainCharacterPacket()

{

const unsigned mapIndex = GetMapIndex();

const BGMInfo& bgmInfo = CHARACTER_GetBGMInfo(mapIndex);

// SUPPORT_BGM

if (!bgmInfo.name.empty())

{

if (CHARACTER_IsBGMVolumeEnable())

{

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

TPacketGCMainCharacter4_BGM_VOL mainChrPacket;

mainChrPacket.header = HEADER_GC_MAIN_CHARACTER4_BGM_VOL;

mainChrPacket.dwVID = m_vid;

mainChrPacket.wRaceNum = GetRaceNum();

mainChrPacket.lx = GetX();

mainChrPacket.ly = GetY();

mainChrPacket.lz = GetZ();

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

mainChrPacket.skill_group = GetSkillGroup();

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

mainChrPacket.fBGMVol = bgmInfo.vol;

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

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

}

else

{

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

TPacketGCMainCharacter3_BGM mainChrPacket;

mainChrPacket.header = HEADER_GC_MAIN_CHARACTER3_BGM;

mainChrPacket.dwVID = m_vid;

mainChrPacket.wRaceNum = GetRaceNum();

mainChrPacket.lx = GetX();

mainChrPacket.ly = GetY();

mainChrPacket.lz = GetZ();

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

mainChrPacket.skill_group = GetSkillGroup();

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

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

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

}

//if (m_stMobile.length())

// ChatPacket(CHAT_TYPE_COMMAND, "sms");

}

// END_OF_SUPPORT_BGM

else

{

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

TPacketGCMainCharacter pack;

pack.header = HEADER_GC_MAIN_CHARACTER;

pack.dwVID = m_vid;

pack.wRaceNum = GetRaceNum();

pack.lx = GetX();

pack.ly = GetY();

pack.lz = GetZ();

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

pack.skill_group = GetSkillGroup();

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

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

if (m_stMobile.length())

ChatPacket(CHAT_TYPE_COMMAND, "sms");

}

}

void CHARACTER::PointsPacket()

{

if (!GetDesc())

return;

TPacketGCPoints pack;

pack.header = HEADER_GC_CHARACTER_POINTS;

pack.points[POINT_LEVEL] = GetLevel();

pack.points[POINT_EXP] = GetExp();

pack.points[POINT_NEXT_EXP] = GetNextExp();

pack.points[POINT_HP] = GetHP();

pack.points[POINT_MAX_HP] = GetMaxHP();

pack.points[POINT_SP] = GetSP();

pack.points[POINT_MAX_SP] = GetMaxSP();

pack.points[POINT_GOLD] = GetGold();

pack.points[POINT_STAMINA] = GetStamina();

pack.points[POINT_MAX_STAMINA] = GetMaxStamina();

for (int i = POINT_ST; i < POINT_MAX_NUM; ++i)

pack.points[i] = GetPoint(i);

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

if (!IsAcceOpen())

{

LPITEM item;

for (int j = 0; j < INVENTORY_AND_EQUIP_SLOT_MAX; ++j)

{

if ((item = GetInventoryItem(j)))

if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_ACCE && item->GetSocket(0) == 1)

item->SetSocket(0, 0);

}

}

}

bool CHARACTER::ChangeSex()

{

int src_race = GetRaceNum();

switch (src_race)

{

case MAIN_RACE_WARRIOR_M:

m_points.job = MAIN_RACE_WARRIOR_W;

break;

case MAIN_RACE_WARRIOR_W:

m_points.job = MAIN_RACE_WARRIOR_M;

break;

case MAIN_RACE_ASSASSIN_M:

m_points.job = MAIN_RACE_ASSASSIN_W;

break;

case MAIN_RACE_ASSASSIN_W:

m_points.job = MAIN_RACE_ASSASSIN_M;

break;

case MAIN_RACE_SURA_M:

m_points.job = MAIN_RACE_SURA_W;

break;

case MAIN_RACE_SURA_W:

m_points.job = MAIN_RACE_SURA_M;

break;

case MAIN_RACE_SHAMAN_M:

m_points.job = MAIN_RACE_SHAMAN_W;

break;

case MAIN_RACE_SHAMAN_W:

m_points.job = MAIN_RACE_SHAMAN_M;

break;

default:

sys_err("CHANGE_SEX: %s unknown race %d", GetName(), src_race);

return false;

}

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

return true;

}

WORD CHARACTER::GetRaceNum() const

{

if (m_dwPolymorphRace)

return m_dwPolymorphRace;

if (m_pkMobData)

return m_pkMobData->m_table.dwVnum;

return m_points.job;

}

void CHARACTER::SetRace(BYTE race)

{

if (race >= MAIN_RACE_MAX_NUM)

{

sys_err("CHARACTER::SetRace(name=%s, race=%d).OUT_OF_RACE_RANGE", GetName(), race);

return;

}

m_points.job = race;

}

BYTE CHARACTER::GetJob() const

{

unsigned race = m_points.job;

unsigned job;

if (RaceToJob(race, &job))

return job;

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

return JOB_WARRIOR;

}

void CHARACTER::SetLevel(BYTE level)

{

m_points.level = level;

if (IsPC())

{

if (level < PK_PROTECT_LEVEL)

SetPKMode(PK_MODE_PROTECT);

else if (GetGMLevel() != GM_PLAYER)

SetPKMode(PK_MODE_PROTECT);

else if (m_bPKMode == PK_MODE_PROTECT)

SetPKMode(PK_MODE_PEACE);

}

}

void CHARACTER::SetEmpire(BYTE bEmpire)

{

m_bEmpire = bEmpire;

}

void CHARACTER::SetPlayerProto(const TPlayerTable * t)

{

if (!GetDesc() || !*GetDesc()->GetHostName())

sys_err("cannot get desc or hostname");

else

SetGMLevel();

m_bCharType = CHAR_TYPE_PC;

m_dwPlayerID = t->id;

m_iAlignment = t->lAlignment;

m_iRealAlignment = t->lAlignment;

m_points.voice = t->voice;

m_points.skill_group = t->skill_group;

m_pointsInstant.bBasePart = t->part_base;

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

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

m_points.iRandomHP = t->sRandomHP;

m_points.iRandomSP = t->sRandomSP;

// REMOVE_REAL_SKILL_LEVLES

if (m_pSkillLevels)

M2_DELETE_ARRAY(m_pSkillLevels);

m_pSkillLevels = M2_NEW TPlayerSkill[SKILL_MAX_NUM];

thecore_memcpy(m_pSkillLevels, t->skills, sizeof(TPlayerSkill) * SKILL_MAX_NUM);

// END_OF_REMOVE_REAL_SKILL_LEVLES

if (t->lMapIndex >= 10000)

{

m_posWarp.x = t->lExitX;

m_posWarp.y = t->lExitY;

m_lWarpMapIndex = t->lExitMapIndex;

}

SetRealPoint(POINT_PLAYTIME, t->playtime);

m_dwLoginPlayTime = t->playtime;

SetRealPoint(POINT_ST, t->st);

SetRealPoint(POINT_HT, t->ht);

SetRealPoint(POINT_DX, t->dx);

SetRealPoint(POINT_IQ, t->iq);

SetPoint(POINT_ST, t->st);

SetPoint(POINT_HT, t->ht);

SetPoint(POINT_DX, t->dx);

SetPoint(POINT_IQ, t->iq);

SetPoint(POINT_STAT, t->stat_point);

SetPoint(POINT_SKILL, t->skill_point);

SetPoint(POINT_SUB_SKILL, t->sub_skill_point);

SetPoint(POINT_HORSE_SKILL, t->horse_skill_point);

SetPoint(POINT_STAT_RESET_COUNT, t->stat_reset_count);

SetPoint(POINT_LEVEL_STEP, t->level_step);

SetRealPoint(POINT_LEVEL_STEP, t->level_step);

SetRace(t->job);

SetLevel(t->level);

SetExp(t->exp);

SetGold(t->gold);

SetMapIndex(t->lMapIndex);

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

ComputePoints();

SetHP(GetMaxHP());

SetSP(GetMaxSP());

SetStamina(t->stamina);

//GM�϶� ��ȣ���

if (!test_server)

{

if (GetGMLevel() > GM_LOW_WIZARD)

{

m_afAffectFlag.Set(AFF_YMIR);

m_bPKMode = PK_MODE_PROTECT;

}

}

if (GetLevel() < PK_PROTECT_LEVEL)

m_bPKMode = PK_MODE_PROTECT;

m_stMobile = t->szMobile;

SetHorseData(t->horse);

if (GetHorseLevel() > 0)

UpdateHorseDataByLogoff(t->logoff_interval);

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

m_dwLogOffInterval = t->logoff_interval;

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

if (GetGMLevel() != GM_PLAYER)

{

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

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

}

#ifdef __PET_SYSTEM__

// NOTE: �ϴ� ij���Ͱ� PC�� ��쿡�� PetSystem� ������ ��. ��� �ӽŴ� �޸� ����� NPC���� �ϱ� �..

if (m_petSystem)

{

m_petSystem->Destroy();

delete m_petSystem;

}

m_petSystem = M2_NEW CPetSystem(this);

#endif

}

EVENTFUNC(kill_ore_load_event)

{

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

if ( info == NULL )

{

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

return 0;

}

LPCHARACTER ch = info->ch;

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

return 0;

}

ch->m_pkMiningEvent = NULL;

M2_DESTROY_CHARACTER(ch);

return 0;

}

void CHARACTER::SetProto(const CMob * pkMob)

{

if (m_pkMobInst)

M2_DELETE(m_pkMobInst);

m_pkMobData = pkMob;

m_pkMobInst = M2_NEW CMobInstance;

m_bPKMode = PK_MODE_FREE;

const TMobTable * t = &m_pkMobData->m_table;

m_bCharType = t->bType;

SetLevel(t->bLevel);

SetEmpire(t->bEmpire);

SetExp(t->dwExp);

SetRealPoint(POINT_ST, t->bStr);

SetRealPoint(POINT_DX, t->bDex);

SetRealPoint(POINT_HT, t->bCon);

SetRealPoint(POINT_IQ, t->bInt);

ComputePoints();

SetHP(GetMaxHP());

SetSP(GetMaxSP());

////////////////////

m_pointsInstant.dwAIFlag = t->dwAIFlag;

SetImmuneFlag(t->dwImmuneFlag);

AssignTriggers(t);

ApplyMobAttribute(t);

if (IsStone())

{

DetermineDropMetinStone();

}

if (IsWarp() || IsGoto())

{

StartWarpNPCEvent();

}

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

// XXX X-mas santa hardcoding

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

{

SetPoint(POINT_ATT_GRADE_BONUS, 10);

if (g_iUseLocale)

SetPoint(POINT_DEF_GRADE_BONUS, 6);

else

SetPoint(POINT_DEF_GRADE_BONUS, 15);

//��Ÿ��

//m_dwPlayStartTime = get_dword_time() + 10 * 60 * 1000;

//�ż��� ����

m_dwPlayStartTime = get_dword_time() + 30 * 1000;

if (test_server)

m_dwPlayStartTime = get_dword_time() + 30 * 1000;

}

// XXX CTF GuildWar hardcoding

if (warmap::IsWarFlag(GetRaceNum()))

{

m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);

m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);

m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlag, &CHARACTER::EndStateEmpty);

}

if (warmap::IsWarFlagBase(GetRaceNum()))

{

m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);

m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);

m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateFlagBase, &CHARACTER::EndStateEmpty);

}

if (m_bCharType == CHAR_TYPE_HORSE ||

GetRaceNum() == 20101 ||

GetRaceNum() == 20102 ||

GetRaceNum() == 20103 ||

GetRaceNum() == 20104 ||

GetRaceNum() == 20105 ||

GetRaceNum() == 20106 ||

GetRaceNum() == 20107 ||

GetRaceNum() == 20108 ||

GetRaceNum() == 20109

)

{

m_stateIdle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateHorse, &CHARACTER::EndStateEmpty);

m_stateMove.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateMove, &CHARACTER::EndStateEmpty);

m_stateBattle.Set(this, &CHARACTER::BeginStateEmpty, &CHARACTER::StateHorse, &CHARACTER::EndStateEmpty);

}

// MINING

if (mining::IsVeinOfOre (GetRaceNum()))

{

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

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

}

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

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

SetPart(PART_ACCE, GetOriginalPart(PART_ACCE));

SetPoint(POINT_PARTY_ATTACKER_BONUS, lAttackerBonus);

SetPoint(POINT_PARTY_TANKER_BONUS, lTankerBonus);

SetPoint(POINT_PARTY_BUFFER_BONUS, lBufferBonus);

SetPoint(POINT_PARTY_SKILL_MASTER_BONUS, lSkillMasterBonus);

SetPoint(POINT_PARTY_HASTE_BONUS, lHasteBonus);

SetPoint(POINT_PARTY_DEFENDER_BONUS, lDefenderBonus);

SetPoint(POINT_HP_RECOVERY, lHPRecovery);

SetPoint(POINT_SP_RECOVERY, lSPRecovery);

// PC_BANG_ITEM_ADD

SetPoint(POINT_PC_BANG_EXP_BONUS, 0);

SetPoint(POINT_PC_BANG_DROP_BONUS, 0);

// END_PC_BANG_ITEM_ADD

int iMaxHP, iMaxSP;

int iMaxStamina;

if (IsPC())

{

// �ִ� ����/��ŷ�

iMaxHP = JobInitialPoints[GetJob()].max_hp + m_points.iRandomHP + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].hp_per_ht;

iMaxSP = JobInitialPoints[GetJob()].max_sp + m_points.iRandomSP + GetPoint(POINT_IQ) * JobInitialPoints[GetJob()].sp_per_iq;

iMaxStamina = JobInitialPoints[GetJob()].max_stamina + GetPoint(POINT_HT) * JobInitialPoints[GetJob()].stamina_per_con;

{

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

if (NULL != pkSk)

{

pkSk->SetPointVar("k", 1.0f * GetSkillPower(SKILL_ADD_HP) / 100.0f);

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

}

}

// �⺻ ����

SetPoint(POINT_MOV_SPEED, 100);

SetPoint(POINT_ATT_SPEED, 100);

PointChange(POINT_ATT_SPEED, GetPoint(POINT_PARTY_HASTE_BONUS));

SetPoint(POINT_CASTING_SPEED, 100);

}

else

{

iMaxHP = m_pkMobData->m_table.dwMaxHP;

iMaxSP = 0;

iMaxStamina = 0;

SetPoint(POINT_ATT_SPEED, m_pkMobData->m_table.sAttackSpeed);

SetPoint(POINT_MOV_SPEED, m_pkMobData->m_table.sMovingSpeed);

SetPoint(POINT_CASTING_SPEED, m_pkMobData->m_table.sAttackSpeed);

}

if (IsPC())

{

// �� Ÿ�� ��� ���� �⺻ ������ ���� ���� ���Ⱥ��� ����� ��� �����.

// ��� ���� ���� ������ ���� �����̹Ƿ�, ���/����� ��ü ���� ����

// ��ä����� �� �ö󰡰� �� ���̴�.

if (GetMountVnum())

{

if (GetHorseST() > GetPoint(POINT_ST))

PointChange(POINT_ST, GetHorseST() - GetPoint(POINT_ST));

if (GetHorseDX() > GetPoint(POINT_DX))

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

if (GetHorseHT() > GetPoint(POINT_HT))

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

if (GetHorseIQ() > GetPoint(POINT_IQ))

PointChange(POINT_IQ, GetHorseIQ() - GetPoint(POINT_IQ));

}

}

ComputeBattlePoints();

// �⺻ HP/SP ���

if (iMaxHP != GetMaxHP())

{

SetRealPoint(POINT_MAX_HP, iMaxHP); // �⺻HP�� RealPoint�� ������ ��´�.

}

PointChange(POINT_MAX_HP, 0);

if (iMaxSP != GetMaxSP())

{

SetRealPoint(POINT_MAX_SP, iMaxSP); // �⺻SP�� RealPoint�� ������ ��´�.

}

PointChange(POINT_MAX_SP, 0);

SetMaxStamina(iMaxStamina);

m_pointsInstant.dwImmuneFlag = 0;

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

{

LPITEM pItem = GetWear(i);

if (pItem)

{

pItem->ModifyPoints(true);

SET_BIT(m_pointsInstant.dwImmuneFlag, GetWear(i)->GetImmuneFlag());

}

}

// ��ȥ�� �ý���

// ComputePoints������ �ɸ����� ��� �Ӽ���� �ʱ�ȭ�ϰ�,

// ������, ���� � ��õ� ��� �Ӽ���� �����ϱ� ������,

// ��ȥ�� �ý��۵� ActiveDeck�� �ִ� ��� ��ȥ���� �Ӽ���� �ٽ� �����Ѿ� �Ѵ�.

if (DragonSoul_IsDeckActivated())

{

for (int i = WEAR_MAX_NUM + DS_SLOT_MAX * DragonSoul_GetActiveDeck();

i < WEAR_MAX_NUM + DS_SLOT_MAX * (DragonSoul_GetActiveDeck() + 1); i++)

{

LPITEM pItem = GetWear(i);

if (pItem)

{

if (DSManager::instance().IsTimeLeftDragonSoul(pItem))

pItem->ModifyPoints(true);

}

}

}

if (GetHP() > GetMaxHP())

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

if (GetSP() > GetMaxSP())

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

ComputeSkillPoints();

RefreshAffect();

CPetSystem* pPetSystem = GetPetSystem();

if (NULL != pPetSystem)

{

pPetSystem->RefreshBuff();

}

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

{

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

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

val = GetMaxHP();

}

break;

case POINT_MAX_SP:

{

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

int i = 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)i;

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;

boost::unordered_map<BYTE, int>::iterator iter = m_SkillDamageBonus.find(bSkillVnum);

if (iter == m_SkillDamageBonus.end())

m_SkillDamageBonus.insert(std::make_pair(bSkillVnum, iChange));

else

iter->second += iChange;

}

// END_OF_SKILL_DAMAGE_BONUS

break;

case APPLY_STR:

case APPLY_DEX:

case APPLY_MAX_HP:

case APPLY_MAX_SP:

case APPLY_MAX_HP_PCT:

case APPLY_MAX_SP_PCT:

case APPLY_ATT_SPEED:

case APPLY_MOV_SPEED:

case APPLY_CAST_SPEED:

case APPLY_HP_REGEN:

case APPLY_SP_REGEN:

case APPLY_POISON_PCT:

case APPLY_STUN_PCT:

case APPLY_SLOW_PCT:

case APPLY_CRITICAL_PCT:

case APPLY_PENETRATE_PCT:

case APPLY_ATTBONUS_HUMAN:

case APPLY_ATTBONUS_ANIMAL:

case APPLY_ATTBONUS_ORC:

case APPLY_ATTBONUS_MILGYO:

case APPLY_ATTBONUS_UNDEAD:

case APPLY_ATTBONUS_DEVIL:

case APPLY_ATTBONUS_WARRIOR: // 59

case APPLY_ATTBONUS_ASSASSIN: // 60

case APPLY_ATTBONUS_SURA: // 61

case APPLY_ATTBONUS_SHAMAN: // 62

case APPLY_ATTBONUS_MONSTER: // 63

case APPLY_STEAL_HP:

case APPLY_STEAL_SP:

case APPLY_MANA_BURN_PCT:

case APPLY_DAMAGE_SP_RECOVER:

case APPLY_BLOCK:

case APPLY_DODGE:

case APPLY_RESIST_SWORD:

case APPLY_RESIST_TWOHAND:

case APPLY_RESIST_DAGGER:

case APPLY_RESIST_BELL:

case APPLY_RESIST_FAN:

case APPLY_RESIST_BOW:

case APPLY_RESIST_FIRE:

case APPLY_RESIST_ELEC:

case APPLY_RESIST_MAGIC:

case APPLY_RESIST_WIND:

case APPLY_RESIST_ICE:

case APPLY_RESIST_EARTH:

case APPLY_RESIST_DARK:

case APPLY_REFLECT_MELEE:

case APPLY_REFLECT_CURSE:

case APPLY_ANTI_CRITICAL_PCT:

case APPLY_ANTI_PENETRATE_PCT:

case APPLY_POISON_REDUCE:

case APPLY_KILL_SP_RECOVER:

case APPLY_EXP_DOUBLE_BONUS:

case APPLY_GOLD_DOUBLE_BONUS:

case APPLY_ITEM_DROP_BONUS:

case APPLY_POTION_BONUS:

case APPLY_KILL_HP_RECOVER:

case APPLY_IMMUNE_STUN:

case APPLY_IMMUNE_SLOW:

case APPLY_IMMUNE_FALL:

case APPLY_BOW_DISTANCE:

case APPLY_ATT_GRADE_BONUS:

case APPLY_DEF_GRADE_BONUS:

case APPLY_MAGIC_ATT_GRADE:

case APPLY_MAGIC_DEF_GRADE:

case APPLY_CURSE_PCT:

case APPLY_MAX_STAMINA:

case APPLY_MALL_ATTBONUS:

case APPLY_MALL_DEFBONUS:

case APPLY_MALL_EXPBONUS:

case APPLY_MALL_ITEMBONUS:

case APPLY_MALL_GOLDBONUS:

case APPLY_SKILL_DAMAGE_BONUS:

case APPLY_NORMAL_HIT_DAMAGE_BONUS:

// DEPEND_BONUS_ATTRIBUTES

case APPLY_SKILL_DEFEND_BONUS:

case APPLY_NORMAL_HIT_DEFEND_BONUS:

// END_OF_DEPEND_BONUS_ATTRIBUTES

case APPLY_PC_BANG_EXP_BONUS :

case APPLY_PC_BANG_DROP_BONUS :

case APPLY_RESIST_WARRIOR :

case APPLY_RESIST_ASSASSIN :

case APPLY_RESIST_SURA :

case APPLY_RESIST_SHAMAN :

case APPLY_ENERGY: // 82 ���

case APPLY_DEF_GRADE: // 83 ����. DEF_GRADE_BONUS�� Ŭ�󿡼� �ι�� ������� �ǵ��� ���(...)�� �ִ�.

case APPLY_COSTUME_ATTR_BONUS: // 84 �ڽ�Ƭ �����ۿ� ��� �Ӽ�ġ ���ʽ�

case APPLY_MAGIC_ATTBONUS_PER: // 85 ���� ��ݷ� +x%

case APPLY_MELEE_MAGIC_ATTBONUS_PER: // 86 ���� + �и� ��ݷ� +x%

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

break;

default:

sys_err("Unknown apply type %d name %s", bApplyType, GetName());

break;

}

}

void CHARACTER::MotionPacketEncode(BYTE motion, LPCHARACTER victim, struct packet_motion * packet)

{

packet->header = HEADER_GC_MOTION;

packet->vid = m_vid;

packet->motion = motion;

if (victim)

packet->victim_vid = victim->GetVID();

else

packet->victim_vid = 0;

}

void CHARACTER::Motion(BYTE motion, LPCHARACTER victim)

{

struct packet_motion pack_motion;

MotionPacketEncode(motion, victim, &pack_motion);

PacketAround(&pack_motion, sizeof(struct packet_motion));

}

EVENTFUNC(save_event)

{

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

if ( info == NULL )

{

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

return 0;

}

LPCHARACTER ch = info->ch;

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

return 0;

}

sys_log(1, "SAVE_EVENT: %s", ch->GetName());

ch->Save();

ch->FlushDelayedSaveItem();

return (save_event_second_cycle);

}

void CHARACTER::StartSaveEvent()

{

if (m_pkSaveEvent)

return;

char_event_info* info = AllocEventInfo<char_event_info>();

info->ch = this;

m_pkSaveEvent = event_create(save_event, info, save_event_second_cycle);

}

void CHARACTER::MonsterLog(const char* format, ...)

{

if (!test_server)

return;

if (IsPC())

return;

char chatbuf[CHAT_MAX_LEN + 1];

int len = snprintf(chatbuf, sizeof(chatbuf), "%u)", (DWORD)GetVID());

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

len = sizeof(chatbuf) - 1;

va_list args;

va_start(args, format);

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

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

len += (sizeof(chatbuf) - len) - 1;

else

len += len2;

// \0 ���� ����

++len;

va_end(args);

TPacketGCChat pack_chat;

pack_chat.header = HEADER_GC_CHAT;

pack_chat.size = sizeof(TPacketGCChat) + len;

pack_chat.type = CHAT_TYPE_TALKING;

pack_chat.id = (DWORD)GetVID();

pack_chat.bEmpire = 0;

TEMP_BUFFER buf;

buf.write(&pack_chat, sizeof(TPacketGCChat));

buf.write(chatbuf, len);

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

}

void CHARACTER::ChatPacket(BYTE type, const char * format, ...)

{

LPDESC d = GetDesc();

if (!d || !format)

return;

char chatbuf[CHAT_MAX_LEN + 1];

va_list args;