#include <map>

#include <toolkit/XConsole.h>
#include <mmo/ArcadiaServer.h>
#include <toolkit/XRandom.h>
#include <logging/FileLog.h>
#include <toolkit/XStringUtil.h>

#include "LogClient/LogClient.h"

#include "StructMonster.h"
#include "Constant.h"
#include "GameContent.h"
#include "SendMessage.h"
#include "StructItem.h"
#include "StructPlayer.h"
#include "StructSummon.h"
#include "StructRoamer.h"
#include "PartyManager.h"
#include "GuildManager.h"
#include "Extern.h"
#include "GameRule.h"
#include "GameProc.h"
#include "GameMessage.h"
#include "StructEventItemManager.h"
#include "DungeonManager.h"
#include "InstanceDungeonManager.h"
#include "StructSkill.h"
#include "GameAllocator.h"
#include "LuaVM.h"
#include "ThreadPlayerHelper.h"
#include "toolkit/XEnv.h"


#ifdef _MONSTER_DEBUG
#define _monster_debug_output _oprint
#else
#define _monster_debug_output 
#endif

XCriticalSection	m_csHate( "m_csHate" );

struct takePriority
{
	StructItem::ITEM_PICKUP_ORDER ItemPickupOrder;
};


void StructMonster::BindProperty()
{
	StructMonster temp( 0, 0 );
	temp.Bind( "hp", &temp.m_nHP );
	temp.Bind( "mp", &temp.m_nMP );
	temp.Bind( "max_hp", &temp.m_nMaxHP );
	temp.Bind( "max_mp", &temp.m_nMaxMP );
	temp.Bind( "level", &temp.m_nLevel );
	temp.Bind( "lv", &temp.m_nLevel );
	temp.Bind( "str", const_cast< __int64 * >( &temp.m_Stat.strength.get() ) );
	temp.Bind( "agi", const_cast< __int64 * >( &temp.m_Stat.agility.get() ) );
	temp.Bind( "dex", const_cast< __int64 * >( &temp.m_Stat.dexterity.get() ) );
	temp.Bind( "int", const_cast< __int64 * >( &temp.m_Stat.intelligence.get() ) );
	temp.Bind( "luck", const_cast< __int64 * >( &temp.m_Stat.luck.get() ) );
	temp.Bind( "vital", const_cast< __int64 * >( &temp.m_Stat.vital.get() ) );
	temp.Bind( "mental", const_cast< __int64 * >( &temp.m_Stat.mentality.get() ) );
	temp.Bind( "x", &temp.mv.x );
	temp.Bind( "y", &temp.mv.y );
	temp.Bind( "layer", &temp.layer );
	temp.Bind( "speed", const_cast< __int64 * >( &temp.m_Attribute.fMoveSpeed.get() ) );
	temp.Bind( "critical", const_cast< __int64 * >( &temp.m_Attribute.fCritical.get() ) );
	temp.Bind( "critical_power", const_cast< __int64 * >( &temp.m_Attribute.fCriticalPower.get() ) );
	temp.Bind( "attack_point", const_cast< __int64 * >( &temp.m_Attribute.fAttackPointRight.get() ) );
	temp.Bind( "attack_right",		const_cast< __int64 * >( &temp.m_Attribute.fAttackPointRight.get() ) );
	temp.Bind( "attack_left",		const_cast< __int64 * >( &temp.m_Attribute.fAttackPointLeft.get() ) );
	temp.Bind( "defence", const_cast< __int64 * >( &temp.m_Attribute.fDefence.get() ) );
	temp.Bind( "block_defence",		const_cast< __int64 * >( &temp.m_Attribute.fBlockDefence.get() ) );
	temp.Bind( "magic_pt", const_cast< __int64 * >( &temp.m_Attribute.fMagicPoint.get() ) );
	temp.Bind( "magic_def", const_cast< __int64 * >( &temp.m_Attribute.fMagicDefence.get() ) );
	temp.Bind( "accuracy", const_cast< __int64 * >( &temp.m_Attribute.fAccuracyRight.get() ) );
	temp.Bind( "accuracy_left", const_cast< __int64 * >( &temp.m_Attribute.fAccuracyLeft.get() ) );
	temp.Bind( "avoid", const_cast< __int64 * >( &temp.m_Attribute.fAvoid.get() ) );
	temp.Bind( "magic_avoid", const_cast< __int64 * >( &temp.m_Attribute.fMagicAvoid.get() ) );
	temp.Bind( "block_chance", const_cast< __int64 * >( &temp.m_Attribute.fBlockChance.get() ) );
	temp.Bind( "speed", const_cast< __int64 * >( &temp.m_Attribute.fMoveSpeed.get() ) );
	temp.Bind( "attack_range", const_cast< __int64 * >( &temp.m_Attribute.fAttackRange.get() ) );
	temp.Bind( "attack_speed", const_cast< __int64 * >( &temp.m_Attribute.fAttackSpeed.get() ) );
	temp.Bind( "perfect_block", const_cast< __int64 * >( &temp.m_Attribute.fPerfectBlock.get() ) );
	temp.Bind( "physical_ignore", const_cast< __int64 * >( &temp.m_Attribute.fPhysicalDefIgnore.get() ) );
	temp.Bind( "physical_ignore_ratio", const_cast< __int64 * >( &temp.m_Attribute.fPhysicalDefIgnoreRatio.get() ) );
	temp.Bind( "magical_ignore", const_cast< __int64 * >( &temp.m_Attribute.fMagicalDefIgnore.get() ) );
	temp.Bind( "magical_ignore_ratio", const_cast< __int64 * >( &temp.m_Attribute.fMagicalDefIgnoreRatio.get() ) );
	temp.Bind( "physical_penetration", const_cast< __int64 * >( &temp.m_Attribute.fPhysicalPenetration.get() ) );
	temp.Bind( "physical_penetration_ratio", const_cast< __int64 * >( &temp.m_Attribute.fPhysicalPenetrationRatio.get() ) );
	temp.Bind( "magical_penetration", const_cast< __int64 * >( &temp.m_Attribute.fMagicalPenetration.get() ) );
	temp.Bind( "magical_penetration_ratio", const_cast< __int64 * >( &temp.m_Attribute.fMagicalPenetrationRatio.get() ) );
}


StructMonster* StructMonster::AllocMonster( unsigned idx, unsigned char difficulty )
{
	StructMonster* p;

	struct _myIntializer : GameAllocateFunctor
	{
		_myIntializer( int _idx, unsigned char _difficulty ) : m_nIdx( _idx ), m_nDifficulty( _difficulty ) {}
		
		virtual void operator()( void * pObj, AR_HANDLE handle )
		{
			new (pObj) StructMonster( handle, m_nIdx, m_nDifficulty );
		}

		unsigned m_nIdx;
		unsigned char m_nDifficulty;
	};

	AR_HANDLE handle = allocMonsterStruct( &p, _myIntializer( idx, difficulty ) );

	// new (p) StructMonster( handle, idx );

	if( !p->GetMonsterId() )
	{
		freeMonsterStruct( p );
		FILELOG( "Invalid Monster Id : %d", idx );
		return NULL;
	}

	for( std::vector< MonsterBase::MONSTER_SKILL_INFO >::const_iterator it = p->m_pContentInfo->skill_info_list->begin() ; it != p->m_pContentInfo->skill_info_list->end() ; ++it )
	{
		if( (*it).skill_id )
		{
			p->SetSkill( StructSkill::SKILL_UID_MONSTER_SKILL, (*it).skill_id, (*it).skill_lv, 0 );
		}
	}

	p->CalculateStat();

	p->m_nHP = p->m_nMaxHP;
	p->m_nMP = p->m_nMaxMP;

	return p;
}
void StructMonster::FreeMonster( StructMonster* p )
{
	// _oprint( "DEL MONSTER : %08X\n", p );

	// { 임시
	/*
	extern std::vector< StructNPC* >		g_vNPC;
	std::vector< StructNPC* >::iterator it;
	for( it = g_vNPC.begin(); it != g_vNPC.end(); it++ )
	{
		if( *it != p ) continue;
		g_vNPC.erase( it );
		break;
	}
	*/
	// }

	prepareFreeMonsterStruct( p );

	p->StructMonster::~StructMonster();

	freeMonsterStruct( p );
}

StructMonster::StructMonster( AR_HANDLE handle, unsigned idx, unsigned char difficulty )
{
	m_hHandle = handle;

	m_nRegenTime = GetArTime();
	m_bRespawnByScript = false;

	m_nArObjectType = ArObject::MOVABLE_OBJECT;
	//SetTag( static_cast< GameObject* >( this ) );

	m_nStatus = STATUS_NORMAL;
	
	m_bComeBackHome = false;
	if ( idx != 0 )
	{
		// idx == 0은 임시 객체임을 의미함 
		SetMonsterInfo( idx );
		m_vTriggerFlag.reserve( m_pContentInfo->trigger_list->size() );
		for( size_t nCount = 0 ; nCount < m_pContentInfo->trigger_list->size() ; ++nCount )
			m_vTriggerFlag.push_back( 0 );
	}

	m_nLastTrackTime = 0;
	m_nTotalDamage = 0;
	m_nStatus = 0;

	m_nGenerateCode = BY_NONE;

	m_pDeleteHandler = NULL;
	m_nLifeTime = 0;
	m_nDungeonId = 0;
	m_bIsDungeonRaidMonster = false;
	m_bIsDungeonOwnerGuardian = false;
	m_bIsDungeonSiegerGuardian = false;

	m_nInstanceRespawnID = 0;

	m_hFirstAttacker	= 0;
	m_nFirstAttackTime	= 0;
	m_nHateCheckTime	= 0;

	m_vHateModifierByState.clear();
	m_bNeedToFindEnemy = false;

	m_hTamer			= 0;
	m_nTamedTime		= INFINITE_TIME;

	m_RespawnX = m_RespawnY = 0;
	m_nMaxHate = 0;

	m_bTamedSuccess = false;
	m_nTamingSkillLevel = 0;
	m_pTamingSkill = NULL;

	m_nLastEnemyDistance = 0;
	m_nLastHateUpdateTime = 0;

	// 임시 : 랜덤하게 다른방향 보게 하자.. -_-;
	mv.face = (float)XRandom() / 100;	

	m_bIsWandering = true;

#ifndef _USE_NEW_ROAMING_ONLY
	m_pWayPointInfo = NULL;
	m_nWayPointIdx = 0;
#endif
	m_pRoamer = NULL;

	m_bContinueAttack = false;

	m_nDifficulty = difficulty;
}

StructMonster::~StructMonster()
{
	_monster_debug_output( "DELETE : %I64d\n", GetHandle() );
}

bool StructMonster::ProcDelete()
{
	FreeMonster( this );

	return true;
}

bool StructMonster::SetMonsterInfo( unsigned idx )
{
	m_nLevel = GameContent::GetMonsterInfo( idx )->level;
	m_pContentInfo = GameContent::GetMonsterInfo( idx );
	m_Stat = GameContent::GetStatInfo( m_pContentInfo->stat_id );

	return true;
}

int StructMonster::GetMonsterId()
{
	return m_pContentInfo->uid;
}

const char*		StructMonster::GetName() const
{
	return GameContent::GetString( m_pContentInfo->name_id );
}

int StructMonster::GetNameID() const  //AziaMafia get_monster_info
{
	return m_pContentInfo->name_id;
}

unsigned char StructMonster::GetRace() const
{
	return CREATURE_ETC;
}

float StructMonster::GetScale() const
{
	return m_pContentInfo->scale;
}

float StructMonster::GetSize() const
{
	return m_pContentInfo->size;
}

StructMonster::MONSTER_STATUS StructMonster::GetStatus() const
{
	return static_cast< MONSTER_STATUS >( m_nStatus );
}

void StructMonster::SetStatus( MONSTER_STATUS status )
{
	if( m_nStatus == STATUS_DEAD )
	{
		return;
	}

	if( status != m_nStatus && status != STATUS_DEAD && status != STATUS_NORMAL && m_nStatus == STATUS_NORMAL )
	{
		ResetTriggerCondition();
	}

	if( m_nStatus != status )
	{
		m_nStatus = status;

		BroadcastStatusMessage( this );
	}
	else
	{
		m_nStatus = status;
	}

}

bool StructMonster::IsFirstAttacker() const
{
	return ( m_pContentInfo->attack_type & MonsterBase::AT_FIRST_ATTACK );
}

bool StructMonster::IsGroupRevenger() const
{
	return ( m_pContentInfo->attack_type & MonsterBase::AT_RESPONSE_RACE );
}

bool StructMonster::IsCastRevenger() const
{
	return ( m_pContentInfo->attack_type & MonsterBase::AT_RESPONSE_CASTING );
}

bool StructMonster::IsBattleRevenger() const
{
	return ( m_pContentInfo->attack_type & MonsterBase::AT_RESPONSE_BATTLE );
}

int StructMonster::GetMonsterGroup() const
{
	return m_pContentInfo->monster_group;
}

bool StructMonster::IsGroupFirstAttacker() const
{
	return ( m_pContentInfo->attack_type & MonsterBase::AT_GROUP_FIRST_ATTACK );
}

bool StructMonster::IsTameable() const
{
	return !!m_pContentInfo->taming_code;
}

const c_fixed10 & StructMonster::GetTamePercetage() const
{
	ItemBase::ItemCode TameCode = GetTameItemCode();
		
	return m_pContentInfo->taming_percentage;
}

float StructMonster::GetTameExpAdjust() const
{
	return m_pContentInfo->taming_exp_adjust;
}

int StructMonster::GetTameCode() const
{
	return m_pContentInfo->taming_code;
}


bool StructMonster::IsMonsterCreatureTame() const
{
	if( m_pContentInfo->creature_taming_code_group )
		return true;

	return false;
}

int StructMonster::GetMonsterCreatureTameGroupCode() const
{
	if( IsMonsterCreatureTame() )
	{
		return m_pContentInfo->creature_taming_code_group;
	}

	return 0;
}


int StructMonster::GetMonsterCreatureTameCode() const
{
	if( IsMonsterCreatureTame() )
	{
		return GameContent::GetMonsterCreatureTameCode( GetMonsterCreatureTameGroupCode() );
	}

	return 0;
}

int StructMonster::GetMonsterCreatureTameItemCode() const
{
	if( IsMonsterCreatureTame() )
	{
		// 무조건 하나의 그룹에 있는 몬스터들은 무조건 동일한 크리쳐 카드를 써야 한다.
		return static_cast< ItemBase::ItemCode >( GameContent::GetSummonInfo( GetMonsterCreatureTameCode() )->card_id );
	}

	return 0;
}

ItemBase::ItemCode StructMonster::GetTameItemCode() const
{
	if( !m_pContentInfo->taming_code && !m_pContentInfo->creature_taming_code_group ) 
		return 0;

	// taming_code와 creature_taming_code_group 가 전부 값이 존재하면 안됨. 하나는 0이어야 함
	if( m_pContentInfo->taming_code && m_pContentInfo->creature_taming_code_group ) 
		return 0;

	// 기존 크리쳐 카드
	if( m_pContentInfo->taming_code )
	{
		return static_cast< ItemBase::ItemCode >( GameContent::GetSummonInfo( m_pContentInfo->taming_code )->card_id );
	}
	
	// 모든 몬스터 크리쳐 카드 ( 소울 테이밍 카드 )
	if( m_pContentInfo->creature_taming_code_group )
	{
		return GetMonsterCreatureTameItemCode();
	}

	return 0;
}

int StructMonster::AddHate( AR_HANDLE handle, int pt, bool bBroadcast, bool bProcRoamingMonster )
{
	if( IsDead() || IsEnvironmentMonster() )
		return 0;

	AR_TIME t = GetArTime();

	StructCreature::iterator it = StructCreature::get( handle );
	if( !(*it) ) return 0;

	if( !IsEnemy( (*it) ) )
		return 0;

	int nHate = addHate( handle, pt )->nHate;

	// 동일 로밍 그룹 몬스터 헤이트 분배
	if( bProcRoamingMonster && GetRoamer() )
	{
		GetRoamer()->PendHateShare( GetHandle(), handle, m_fHateRatio * pt );
	}

	if( pt < 0 )
	{
		findNextEnemy();
	}
	// 동족 인식 방송을 해야 하는 놈들이라도 그룹 로밍 몹이면 동족 인식 처리 안 함
	else if( bBroadcast && IsGroupRevenger() && !GetRoamer() )
	{
		// 자. 동족 몹들아~ 반격하자아~
		std::vector< AR_HANDLE > vResult;
		ArcadiaServer::Instance().EnumMovableObject( GetPos(), GetLayer(), GetFirstAttackRange() * 0.8f, &vResult, false, true );

		for( std::vector< AR_HANDLE >::iterator it = vResult.begin(); it != vResult.end(); ++it )
		{
			StructCreature* pCreature = static_cast< StructCreature* >( StructCreature::raw_get( *it ) );

			if( !pCreature )
				continue;

			if( pCreature->IsMonster() && pCreature != this )
			{
				if( static_cast< StructMonster * >( pCreature )->GetMonsterGroup() == GetMonsterGroup() )
				{
					static_cast< StructMonster * >( pCreature )->AddHate( handle, m_fHateRatio * pt, false );
				}
			}
		}
	}

	return nHate;
}

int StructMonster::RemoveHate( AR_HANDLE handle, int pt )
{
	_HATE_TAG * pHateTag = getHateTag( handle, GetArTime() );

	if( pHateTag )
	{
		if( pt < pHateTag->nHate )
		{
			pHateTag->nHate -= pt;

			if( handle == m_hEnemy && !IsDead() )
			{
				findNextEnemy();
			}

			return pHateTag->nHate;

		}
		else
		{
			removeFromHateList( handle );

			
			if( handle == m_hEnemy )
			{
				// 문제 생기나?
				m_hEnemy = 0;
				findNextEnemy();
			}

			return 0;
		}
	}

	return -1;
}

int	StructMonster::GetHate( AR_HANDLE handle )
{
	_HATE_TAG * pHateTag = getHateTag( handle );
	if( pHateTag ) return pHateTag->nHate;
	return 0;
}

_HATE_TAG * StructMonster::getHateTag( AR_HANDLE handle, AR_TIME t )
{
	THREAD_SYNCRONIZE( &m_csHate );

	_HATE_TAG * pHateTag = NULL;

	std::vector< _HATE_TAG >::reverse_iterator it;
	for( it = m_vHateList.rbegin(); it != m_vHateList.rend(); it++ )
	{
		if( (*it).uid == handle )
		{
			pHateTag = &(*it);

			if( t )
				pHateTag->nTime = t;
			break;
		}
	}

	return pHateTag;
}

_DAMAGE_TAG * StructMonster::getDamageTag( AR_HANDLE handle, AR_TIME t )
{
	_DAMAGE_TAG * pDamageTag = NULL;

	std::vector< _DAMAGE_TAG >::iterator it;
	for( it = m_vDamageList.begin(); it != m_vDamageList.end();  )
	{
		if( (*it).uid == handle )
		{
			pDamageTag = &(*it);

			if( t )
				pDamageTag->nTime = t;
			break;
		}

		// 5분이 지나도록 공방이 없었다면 damage list 에서 제거
		if( (*it).nTime + 30000 < t )
		{
			m_nTotalDamage -= (*it).nDamage;
			it = m_vDamageList.erase( it );
			continue;
		}

		it++;
	}

	return pDamageTag;
}

_HATE_TAG * StructMonster::addHate( AR_HANDLE handle, int nHate )
{
	_HATE_TAG * pHateTag = NULL;
	AR_TIME t = GetArTime();

	pHateTag = getHateTag( handle, t );

	if( !pHateTag )
	{
		THREAD_SYNCRONIZE( &m_csHate );

		m_vHateList.push_back( _HATE_TAG( t, handle, 0 ) );
		pHateTag = &m_vHateList.back();

		StructCreature::iterator it = StructCreature::get( handle );

		(*it)->AddToEnemyList( GetHandle() );
	}

	pHateTag->nHate += nHate;
	if( pHateTag->nHate < 0 )
		pHateTag->nHate = 0;

	pHateTag->nLastMaxHate = pHateTag->nHate;

	if( !pHateTag->bIsActive )
	{
		//pHateTag->bIsActive = true;
		//
		//int nFrenzyLev = 0;
		//AR_TIME nFrenzyTime = 0;
		//
		//if( pHateTag->nBadAttackCount == 1 )
		//{
		//	nFrenzyLev = 1;
		//	nFrenzyTime = 300;
		//}
		//else
		//{
		//	nFrenzyLev = 2;
		//	nFrenzyTime = 500;
		//}
		//
		//AddState( StructState::FRENZY, GetHandle(), nFrenzyLev, t, t + nFrenzyTime );

		pHateTag->nHate = 0;
	}


	if( !IsAttacking() )
	{
		m_nMaxHate = pHateTag->nHate;

		StructCreature::iterator it = StructCreature::get( handle );

		StructCreature * pTarget = (*it);

		if( pTarget )
		{
			//pTarget->OnUpdate();
			StartAttack( handle, false );
		}
	}
	else if( m_hEnemy != handle && pHateTag->nHate > m_nMaxHate )
	{
		m_nMaxHate = pHateTag->nHate;
		m_hEnemy = handle;
	}
	else if( m_hEnemy == handle )
	{
		m_nMaxHate = pHateTag->nHate;
	}

	return pHateTag;
}

_DAMAGE_TAG * StructMonster::addDamage( AR_HANDLE handle, int nDamage )
{
	_DAMAGE_TAG * pDamageTag = NULL;
	AR_TIME t = GetArTime();

	pDamageTag = getDamageTag( handle, t );

	if( !pDamageTag )
	{
		m_vDamageList.push_back( _DAMAGE_TAG( t, handle, 0 ) );
		pDamageTag = &m_vDamageList.back();
	}

	m_nTotalDamage += nDamage;
	pDamageTag->nDamage += nDamage;

	return pDamageTag;
}

void StructMonster::clearHateList()
{
	THREAD_SYNCRONIZE( &m_csHate );

	std::vector< _HATE_TAG >::iterator it;
	
	for( it = m_vHateList.begin(); it != m_vHateList.end(); it++ )
	{
		StructCreature::iterator itTarget = StructCreature::get( (*it).uid );

		if( *itTarget )
		{
			( *itTarget )->RemoveFromEnemyList( GetHandle() );
		}

	}

	m_vHateList.clear();
}

bool StructMonster::removeFromHateList( AR_HANDLE handle )
{
	THREAD_SYNCRONIZE( &m_csHate );

	bool bSuccess = false;
	std::vector< _HATE_TAG >::iterator it;
	
	for( it = m_vHateList.begin(); it != m_vHateList.end(); it++ )
	{
		if( (*it).uid == handle )
		{
			m_vHateList.erase( it );
			bSuccess = true;
			break;
		}
	}

	if( bSuccess )
	{
		StructCreature::iterator itTarget = StructCreature::get( handle );

		if( *itTarget )
		{
			( *itTarget )->RemoveFromEnemyList( GetHandle() );
		}
	}

	return bSuccess;

}

bool StructMonster::removeFromDamageList( AR_HANDLE handle )
{
	bool bSuccess = false;
	std::vector< _DAMAGE_TAG >::iterator it;
	
	for( it = m_vDamageList.begin(); it != m_vDamageList.end(); it++ )
	{
		if( (*it).uid == handle )
		{
			m_nTotalDamage -= (*it).nDamage;
			m_vDamageList.erase( it );
			bSuccess = true;
			break;
		}
	}

	return bSuccess;
}

int	StructMonster::onDamage( StructCreature * pFrom, Elemental::Type elementalType, DamageType damageType, int nDamage, bool bCritical )
{
	nDamage = std::min( GetHP(), nDamage );

	if( !nDamage )
		return StructCreature::onDamage( pFrom, elementalType, damageType, nDamage, bCritical );

	AR_TIME t = GetArTime();
	int nHate = nDamage;

	if( !m_hFirstAttacker ) 
	{
		if( pFrom->IsSummon() )
		{
			if( static_cast< StructSummon * >( pFrom )->GetMaster() )
			{
				m_hFirstAttacker = static_cast< StructSummon * >( pFrom )->GetMaster()->GetHandle();
			}
			// 주인 없는 소환수가 친 경우 선공자 처리 안 함(어차피 소환수 곧 없어지고 몹은 제자리로...)
		}
		else
		{
			m_hFirstAttacker = pFrom->GetHandle();
		}
		m_nFirstAttackTime = t;
	}

	bool bIsTamer = false;

	// Damage 증가
	if( pFrom->IsSummon() )
	{
		// 소환수가 때린거라면 실제로는 주인이 데미지를 입힌걸로 처리.
		StructSummon * pSummon = static_cast< StructSummon* >( pFrom );

		if( pSummon->GetMaster() )
		{
			addDamage( pSummon->GetMaster()->GetHandle(), nDamage );

			// 테이머의 소환수가 때린거라면 테이밍 유지시간 증가
			if( GetTamer() == pSummon->GetMaster()->GetHandle() ) bIsTamer = true;
		}
	}
	else
	{
		addDamage( pFrom->GetHandle(), nDamage );

		// 테이머가 때린거라면 테이밍 유지시간 증가
		if( GetTamer() == pFrom->GetHandle() ) bIsTamer = true;
	}

	// 테이밍 유지시간 증가
	if( bIsTamer ) m_nTamedTime = t + GameRule::TAMING_INTERVAL;

	return StructCreature::onDamage( pFrom, elementalType, damageType, nDamage, bCritical );
}

bool StructMonster::StartAttack( AR_HANDLE target, bool bNeedFastReaction )
{
	if( StructCreature::StartAttack( target, bNeedFastReaction ) )
	{
		SetStatus( StructMonster::STATUS_ATTACK );

		return true;
	}

	return false;
}

AR_HANDLE StructMonster::GetTamer() const
{
	return m_hTamer;
}

void StructMonster::SetTamer( AR_HANDLE handle, StructSkill* pTamingSkill )
{
	m_hTamer = handle;
	m_nTamedTime = GetArTime() + GameRule::TAMING_INTERVAL;
	m_pTamingSkill = pTamingSkill;
	// FireSkill 이후 RequestSkillLevel은 초기화 되는데 크리처 테이밍은 전투후에 다시 이 정보가 필요하므로 스킬레벨만 따로 데이터 보관.
	if( pTamingSkill )
		m_nTamingSkillLevel = pTamingSkill->GetRequestedSkillLevel();
	else
		m_nTamingSkillLevel = 0;
}

int StructMonster::GetLevel() const
{
	return m_pContentInfo->level;
}

const CreatureStat &	StructMonster::GetBaseStat() const
{
	return GameContent::GetStatInfo( m_pContentInfo->stat_id );
}

static void addChaos( StructCreature *pCorpse, StructPlayer *pPlayer, float chaos )
{
	// 더이상 저장할 수 없으면 즐
	if( pPlayer->GetMaxChaos() <= pPlayer->GetChaos() )
		return;

	// 멀리 떨어져 있으면 KIN
	AR_TIME t = GetArTime();
	AR_UNIT distance = pCorpse->GetCurrentPosition( t ).GetDistance( pPlayer->GetCurrentPosition( t ) );	
	if( distance > RANGE_LIMIT ) return;

	TS_SC_GET_CHAOS msg;

	int nChaos = GameRule::GetIntValueByRandom< int >( chaos );

	msg.hPlayer = pPlayer->GetHandle();
	msg.hCorpse = pCorpse->GetHandle();
	msg.nChaos = nChaos;
	msg.nBonusType = TS_SC_GET_CHAOS::CHAOS_BONUS_NONE;
	msg.nBonusPercent = 0;
	msg.nBonus = 0;

	// 중독 방지 시스템 관련 제한 체크
	AR_TIME nContinuousPlayTime = pPlayer->GetContinuousPlayTime();
	if( pPlayer->IsGameTimeLimited() && nContinuousPlayTime >= GameRule::nMaxHealthyGameTime )
	{
		chaos = GameRule::GetGameTimeLimitPenalty( nContinuousPlayTime ) * chaos;
	}
	else
	{
		switch( pPlayer->GetPCBangMode() )
		{
		case GameRule::PCBANG_ALLY_BONUS:
			msg.nBonus = GameRule::fAllyPCBangChaosBonusRate * nChaos;
			msg.nBonusType = TS_SC_GET_CHAOS::CHAOS_BONUS_PCBANG;
			msg.nBonusPercent = GameRule::fAllyPCBangChaosBonusRate * 100;
			break;
		case GameRule::PCBANG_PREMIUM_BONUS:
			msg.nBonus = GameRule::fPremiumPCBangChaosBonusRate * nChaos;
			msg.nBonusType = TS_SC_GET_CHAOS::CHAOS_BONUS_PREMIUM_PCBANG;
			msg.nBonusPercent = GameRule::fPremiumPCBangChaosBonusRate * 100;
			break;
		default:
			break;
		}

		// 보너스 획득 라크가 0이면 보너스 메시지도 안 띄움
		if( !msg.nBonus )
		{
			msg.nBonusType = TS_SC_GET_CHAOS::CHAOS_BONUS_NONE;
		}
		msg.nChaos += msg.nBonus;
	}

	// 라크 획득이 음수일 경우 중단
	if( chaos <= 0.0f )
		return;

	ArcadiaServer::Instance().Broadcast( pCorpse->GetRX(), pCorpse->GetRY(),pCorpse->GetLayer(), &msg );

	pPlayer->AddChaos( msg.nChaos );

	LOG::Log11N4S( LM_LAC_TAKE, pPlayer->GetAccountID(), pPlayer->GetSID(), 0, 0, msg.nChaos, pPlayer->GetChaos(), 0, 0, 0, 0, 0, pPlayer->GetAccountName(), LOG::STR_NTS, pPlayer->GetName(), LOG::STR_NTS, "", 0, "", 0 );
	
}

static void addChaos( StructCreature *pCorpse, int nPartyID, float chaos )
{
	struct myPartyFunctor1 : PartyManager::PartyFunctor
	{
		myPartyFunctor1()
		{
			t = GetArTime();
		}

		virtual bool operator()( AR_HANDLE handle )
		{
			StructPlayer::iterator pit = StructPlayer::get( handle );
			StructPlayer *pPlayer = *pit;
			if( !pPlayer || !pPlayer->IsInWorld() ) return true;

			// 멀리 떨어져 있으면 KIN			
			AR_UNIT distance = pos.GetDistance( pPlayer->GetPos() );	
			if( distance > RANGE_LIMIT ) return true;

			vPlayers.push_back( pPlayer );

			return true;
		}

		ArPosition pos;
		AR_TIME t;
		std::vector< StructPlayer * > vPlayers;
	} _tmp;

	_tmp.pos = pCorpse->GetCurrentPosition( GetArTime() );

	PartyManager::GetInstance().DoEachMember( nPartyID, _tmp );

	std::vector< StructPlayer * >::iterator it;

	float fSharedChaos = chaos / _tmp.vPlayers.size();

	for( it = _tmp.vPlayers.begin(); it != _tmp.vPlayers.end(); ++it )
	{
		addChaos( pCorpse, (*it), fSharedChaos );
	}
}

static void addEXP( StructCreature *pCorpse, StructPlayer *pPlayer, float exp, float jp )
{
	if( pPlayer->IsDead() )
		return;

	float fJP = jp;

	// { ImmoralPoint 보정
	if( pPlayer->GetImmoralPoint() > 0 && pCorpse->GetLevel() >= pPlayer->GetLevel() )
	{
		float fIPDec = -1;
		if( pPlayer->GetImmoralPoint() >= GameRule::CRIME_LIMIT )
		{
			fIPDec = -0.5f;
		}
		if( pPlayer->GetPartyID() )
		{
			fIPDec *= ( 2 / (float)( PartyManager::GetInstance().GetMemberCount( pPlayer->GetPartyID() ) + 1 ) );
		}

		bool bIsNeedToSendStatus = false;

		if( pPlayer->GetImmoralPoint() >= GameRule::CRIME_LIMIT && ( pPlayer->GetImmoralPoint() + fIPDec ) < GameRule::CRIME_LIMIT )
		{
			bIsNeedToSendStatus = true;
		}
		else if( pPlayer->GetImmoralPoint() >= GameRule::MORAL_LIMIT && ( pPlayer->GetImmoralPoint() + fIPDec ) < GameRule::MORAL_LIMIT )
		{
			bIsNeedToSendStatus = true;
		}

		pPlayer->SetImmoralPoint( pPlayer->GetImmoralPoint() + fIPDec );

		// 모럴 포인트 개념 추가로 음수 이모럴 포인트도 유효
		//if( pPlayer->GetImmoralPoint() <= 0 )
		//{
		//	bIsNeedToSendStatus = true;
		//	pPlayer->SetImmoralPoint( 0 );
		//}

		if( bIsNeedToSendStatus )
		{
			BroadcastStatusMessage( pPlayer );
		}
	}
	// }

	/*	개인 몫으로 분배된 경험치에, 잡힌 몬스터가 분배받을자의 레벨보다 낮으면 레벨차 패널티를 부가한다.
		몬스터LV < 플레이어LV 이면,
		플레이어가 받을 EXP = 분배된 EXP * { 1- ((플레이어LV-몬스터Lv) * 0.05) }
		플레이어가 받을 JP = 분배된 JP * { 1- ((플레이어LV-몬스터Lv) * 0.05) }*/
#ifdef _EXPDEBUG
	_cprint( "경험치 계산! : %s Lv%d    %s Lv%d\n", pCorpse->GetName(), pCorpse->GetLevel(), pPlayer->GetName(), pPlayer->GetLevel() );
	_cprint( "경험치 1 : %f,%f (%s)\n", exp, fJP, pPlayer->GetName() );
#endif

	int nLevelDiff = pCorpse->GetLevel() - pPlayer->GetLevel();

	if( nLevelDiff > 21 )
	{
		exp = exp * std::max( ( 1.8f - ( nLevelDiff - 21 ) * 0.075 ), 0.0 );
		fJP = fJP * std::max( ( 1.8f - ( nLevelDiff - 21 ) * 0.075 ), 0.0 );
	}
	else
	{
		//AziaMafia Fix Xp Malus

		//original
		exp = exp * std::max( ( 1.095f - ( -nLevelDiff ) * 0.031 ), 0.0 );
		fJP = fJP * std::max( ( 1.095f - ( -nLevelDiff ) * 0.031 ), 0.0 );
		
		
		//Debut Modif AziaMafia
		/*
		if (-nLevelDiff <= 5 || nLevelDiff > 0 )
		{
			exp = exp * std::max( ( 1.095f - ( -nLevelDiff ) * 0.031 ), 0.0 );
			fJP = fJP * std::max( ( 1.095f - ( -nLevelDiff ) * 0.031 ), 0.0 );
		}
		else if (-nLevelDiff > 5 && -nLevelDiff < 10 )
		{
			exp = exp * std::max((0.365f - (-nLevelDiff) * 0.011), 0.0);
			fJP = fJP * std::max((0.365f - (-nLevelDiff) * 0.011), 0.0);
		}
		else
		{
			exp = exp * 0.0f;
			fJP = fJP * 0.0f;
		}
		*/
		//Fin Modif AziaMafia

	}

#ifdef _EXPDEBUG
	_cprint( "경험치 2 : %f,%f (%s)\n", exp, fJP, pPlayer->GetName() );
#endif
/* 보너스 jp 사라짐
	float fBonusJP = 0.0f;
	if( pPlayer->GetJobLevel() >= fJP*2 ) fBonusJP = fJP * 2;
	else fBonusJP = pPlayer->GetJobLevel();

#ifdef _EXPDEBUG
	_cprint( "경험치 3 : %f,%f (%s)\n", exp, fJP, pPlayer->GetName() );
#endif

	if( pPlayer->GetLevel() > pCorpse->GetLevel() )
	{
		int nGap = pPlayer->GetLevel() - pCorpse->GetLevel();
		if( nGap >= 10 ) fBonusJP = 0;
		else if( 10 > nGap && nGap >= 3 ) 
		{
			fBonusJP = fBonusJP * ( 1 - ( nGap - 2 )  * 0.1f );
		}
	}

	fJP += fBonusJP;
*/
#ifdef _EXPDEBUG
	_cprint( "경험치 4 : %f,%f (%s)\n", exp, fJP, pPlayer->GetName() );
#endif 

	// 멀리 떨어져 있으면 KIN
	AR_TIME t = GetArTime();
	AR_UNIT distance = pCorpse->GetCurrentPosition( t ).GetDistance( pPlayer->GetCurrentPosition( t ) );	
	if( distance > RANGE_LIMIT ) return;



	std::string new_item;
	std::string strResult;
	//XStringUtil::Format(new_item, "return LootBot( '%s' , 3)", pPlayer->GetName());
	//LUA()->RunString(new_item.c_str(), &strResult);
	//if (strResult == "true") return;

	if (exp < 1)    return;       // AziaMafia Fix Exp  exp = 1;
	if (fJP < 0) fJP = 0;

	//AziaMafia AddExp Script
	ThreadPlayerHelper TPHelper(pPlayer);
	//char szScript[1024] = { 0, };
	//s_sprintf(szScript, _countof(szScript), "by_add_exp(%i , \"%s\")", pCorpse->GetLevel(), pPlayer->GetName());
	//LUA()->RunString(szScript);

	// 테이밍 한 플레이어면 경험치 조정
	if( pCorpse->IsMonster() && static_cast< StructMonster* >( pCorpse )->GetTamer() == pPlayer->GetHandle() && static_cast< StructMonster* >( pCorpse )->IsTamingSuccessed() )
	{
		exp *= static_cast< StructMonster* >( pCorpse )->GetTameExpAdjust();
		fJP *= static_cast< StructMonster* >( pCorpse )->GetTameExpAdjust();
	}

	float fEXPMod	=	GameRule::fEXPRate;
	float fCPMod	=	GameRule::fEXPRate;

	exp = fEXPMod * exp;
	fJP = fCPMod  * fJP;




	__int64 nEXP = GameRule::GetIntValueByRandom< __int64 >( exp );
	__int64 nJP = GameRule::GetIntValueByRandom< __int64 >( fJP );
	pPlayer->AddExp( nEXP, nJP );


#ifdef _EXPDEBUG
	_cprint( "경험치 5 : %d,%d (%s)\n", nEXP, nJP, pPlayer->GetName() );
#endif

	// 힐러, 버퍼, 디버퍼 등, 공헌도를 따질 수 없는 직업을 위해 경험치 배분을 기준으로 Kill 체크를 한다.
	// 소환수 경험치 배분도 동일한 룰에 의해 시야 거리 밖이면 핸들러를 호출하지 않도록 한다.
	ArPosition pos				= pPlayer->GetCurrentPosition( t );
	StructSummon *pMainSummon	= pPlayer->GetMainSummon();
	StructSummon *pSubSummon	= pPlayer->GetSubSummon();
	
	pPlayer->OnKill( pCorpse );
	if( pMainSummon && pos.GetDistance( pMainSummon->GetCurrentPosition( t ) ) <= GameRule::VISIBLE_RANGE )
		pMainSummon->OnKill( pCorpse );
	if( pSubSummon && pos.GetDistance( pSubSummon->GetCurrentPosition( t ) ) <= GameRule::VISIBLE_RANGE )
		pSubSummon->OnKill( pCorpse );
}

static void addEXP( StructCreature *pCorpse, int nPartyID, int exp, int jp )
{
	struct myPartyFunctor1 : PartyManager::PartyFunctor
	{
		myPartyFunctor1()
		{
			t = GetArTime();
			nMaxLevel = 0;
			nTotalLevel = 0;
			nCount = 0;
			nTotalCount = 0;
			nMinLevel = GameRule::MAX_LEVEL;
		}

		virtual bool operator()( AR_HANDLE handle )
		{
			++nTotalCount;

			StructPlayer::iterator pit = StructPlayer::get( handle );
			StructPlayer *pPlayer = *pit;
			if( !pPlayer || !pPlayer->IsInWorld() ) return true;

			// 멀리 떨어져 있으면 KIN		
			if( layer != pPlayer->GetLayer() )
				return true;

			AR_UNIT distance = pos.GetDistance( pPlayer->GetPos() );	
			if( distance > RANGE_LIMIT ) return true;

			pOneManPlayer = pPlayer; // One Man Party 처리를 위해

			if( nMaxLevel < pPlayer->GetLevel() ) nMaxLevel = pPlayer->GetLevel();
			if( nMinLevel > pPlayer->GetLevel() ) nMinLevel = pPlayer->GetLevel();
			nTotalLevel += pPlayer->GetLevel();

			nCount++;

			return true;
		}

		ArPosition pos;
		unsigned char layer;
		AR_TIME t;
		int nTotalCount;
		int nCount;
		int nMaxLevel;
		int nMinLevel;
		int nTotalLevel;
		StructPlayer * pOneManPlayer;
	} _tmp;
	_tmp.pos = pCorpse->GetCurrentPosition( GetArTime() );
	_tmp.layer = pCorpse->GetLayer();

	PartyManager::GetInstance().DoEachMember( nPartyID, _tmp );

	// 파티원이 없으면
	if( _tmp.nCount < 1 )
	{
		return;
	}

	// 적용되는 파티원이 혼자이면..
	if( _tmp.nCount < 2 )
	{
		addEXP( pCorpse, _tmp.pOneManPlayer, exp, jp );
		return;
	}

	struct myPartyFunctor : PartyManager::PartyFunctor
	{
		virtual bool operator()( AR_HANDLE handle )
		{
			StructPlayer::iterator pit = StructPlayer::get( handle );
			StructPlayer *pPlayer = *pit;
			if( !pPlayer ) return true;

			// 파티원 개인에게 돌아갈 경험치 = ( ( 개인Lv / 전 파티원 Lv 총합 ) * 파티에 분배된 경험치) * 레벨차보정팩터
			// 파티별로 할당된 경험치가 파티원들에게 분배된다. 이때는 데미지량, 공헌도에 관계없이 파티원의 LV에 따라 분배한다. 힐러, 버퍼, 디버퍼등, 공헌도를 따질 수 없는 직업이 다수 존재하기 때문이다.
			float fT = ( (float)pPlayer->GetLevel() / nTotalLevel );
			float fEXP = nSharedEXP * fT;
			float fJP  = nSharedJP * fT;


			// 파티내 최고레벨 플레이어보다 15레벨 이상 낮은 레벨의 플레이어는 10레벨 단위로 10%씩의 경험치 패널티를 받는다. (100레벨차부터는 100% 패널티로 경험치를 전혀 얻지 못한다.)
			// 레벨차보정팩터 = 1 - [ { (파티내 최고레벨 아바타의 Lv - 자신의 Lv)*0.1} * 0.1] 단, 레벨차 보정팩터가 0이하일경우 0으로 고정, 1이상일경우 1로 고정한다.					
			float fLevelPenalty = 1 - int( ( nMaxLevel - pPlayer->GetLevel() - GameRule::nPartyExpPenaltyLevel ) * 0.1f ) * 0.1f;
			fLevelPenalty = std::max( 0.0f, std::min( 1.0f, fLevelPenalty ) );
			fEXP *= fLevelPenalty;
			fJP *= fLevelPenalty;

			// fPartyEXPRate[ n ] = 파티원이 n+2명일때 적용 되는 계수 (예: 파티원 2명 -> fPartEXPRate[0] 참조)
			if( nMembers > 1 )
			{
				fEXP	*= GameRule::fPartyEXPRate[ nMembers - 2];
				fJP		*= GameRule::fPartyEXPRate[ nMembers - 2];
			}

			if( fEXP < 1 ) fEXP = 1;
			

			addEXP( pCorpse, pPlayer, fEXP, fJP );

			return true;
		}

		StructCreature *pCorpse;
		int nMaxLevel;
		int nTotalLevel;
		__int64 nSharedEXP;
		int nSharedJP;
		int nMembers;
	} _fo;

	int nLevelDiff = _tmp.nMaxLevel - _tmp.nMinLevel;

	if( _tmp.nTotalCount + 40 > nLevelDiff && nLevelDiff >= _tmp.nTotalCount + GameRule::nPartyExpPenaltyLevel )
	{
		float fLevelPenalty = 1 - pow( ( nLevelDiff - _tmp.nCount - GameRule::nPartyExpPenaltyLevel ), 1.1f ) * 0.02f;

		exp *= fLevelPenalty;
		jp *= fLevelPenalty;
	}
	else if( nLevelDiff >= _tmp.nTotalCount + 40 )
	{
		exp = 0;
		jp = 0;
	}

	_fo.nMaxLevel	= _tmp.nMaxLevel;
	_fo.nTotalLevel	= _tmp.nTotalLevel;

	// AziaMafia Group XP
	// _fo.nSharedEXP	= exp * ( 1 + _tmp.nCount * _tmp.nCount * 2 * 0.01 );
	_fo.nSharedEXP = exp ; // original

	_fo.nSharedJP	= jp * ( 1 + _tmp.nCount * _tmp.nCount * 2 * 0.01 );
	_fo.pCorpse		= pCorpse;
	_fo.nMembers	= _tmp.nCount;

	PartyManager::GetInstance().DoEachMember( nPartyID, _fo );
}

void StructMonster::calcPartyContribute( StructCreature * pKiller, std::vector< VIRTUAL_PARTY > &vPartyContribute )
{
	if( m_vDamageList.empty() ) return;

	struct PARTY_DAMAGE
	{
		PARTY_DAMAGE()
		{
			nDamage = 0;
			nLevel = 0;
		}

		PARTY_DAMAGE( int _damage, int _level ) : nDamage( _damage ), nLevel( _level ) { }
		int	nDamage;
		int nLevel;
	};
	// 공헌도 맵
	AR_TIME									t = GetArTime();
	AR_HANDLE								hKiller = 0;
	std::vector< VIRTUAL_PARTY >::iterator	itVector;
	std::map< int, PARTY_DAMAGE >			mapPartyDamageContribute;
	std::map< int, PARTY_DAMAGE >::iterator	itMap;
	int										nTamerPartyID = 0;
	int										nFirstAttackPartyID = 0;
	int										nLastAttackPartyID = 0;	
	float									fMaxDamageAdd = 0.1f;	// 최다 뎀지 보너스

	vPartyContribute.reserve( m_vDamageList.size() );

	// 1분 이상 지났으면 선공 보너스 사라짐
	if( m_nFirstAttackTime + GameRule::MAX_FIRST_ATTACK_BONUS_TIME < t )
	{
		fMaxDamageAdd = 0.4f;		// 선공 보너스를 최다 뎀지 입힌 파티에게로..
		m_hFirstAttacker = NULL;
	}

	// 막타 넣은사람 찾기
	if( pKiller->IsSummon() )
	{
		StructPlayer * pPlayer = static_cast< StructSummon* >( pKiller )->GetMaster();
		if( pPlayer )
		{
			hKiller = pPlayer->GetHandle();
			nLastAttackPartyID = pPlayer->GetPartyID();
		}
	}
	else if( pKiller->IsPlayer() ) 
	{
		hKiller = pKiller->GetHandle();
		nLastAttackPartyID = static_cast< StructPlayer* >( pKiller )->GetPartyID();
	}

	// mapPartyDamageContribute 구성
	std::vector< _DAMAGE_TAG >::iterator it;
	for( it = m_vDamageList.begin(); it != m_vDamageList.end(); it++ )	
	{
		StructCreature::iterator pit( StructCreature::get( (*it).uid ) );
		StructCreature *pCreature = *pit;

		if( !pCreature ) continue;

		StructPlayer *pPlayer = ( pCreature->IsPlayer() ? static_cast< StructPlayer * >( pCreature ) : NULL );
		StructSummon *pSummon = ( pCreature->IsSummon() ? static_cast< StructSummon * >( pCreature ) : NULL );

		if( !pPlayer && !pSummon ) continue;

		if( !pPlayer ) pPlayer = pSummon->GetMaster();

		// 파티 데미지 계산
		if( pPlayer->IsInParty() ) 
		{
			// 테이머 파티 저장
			if( GetTamer() == pPlayer->GetHandle() ) nTamerPartyID = pPlayer->GetPartyID();

			itMap = mapPartyDamageContribute.find( pPlayer->GetPartyID() );

			if( itMap == mapPartyDamageContribute.end() ) 
			{
				mapPartyDamageContribute[ pPlayer->GetPartyID() ] = PARTY_DAMAGE( (*it).nDamage, pPlayer->GetLevel() );
			}
			else 
			{
				itMap->second.nDamage += (*it).nDamage;

				if( itMap->second.nLevel < pPlayer->GetLevel() ) itMap->second.nLevel = pPlayer->GetLevel();
			}

			// 선공 파티 저장
			if( pPlayer->GetHandle() == m_hFirstAttacker ) 
			{
				nFirstAttackPartyID = pPlayer->GetPartyID();
			}
		}
		else
		{	
			for( itVector = vPartyContribute.begin(); itVector != vPartyContribute.end(); ++itVector )
			{
				if( (*itVector).hPlayer == pPlayer->GetHandle() )
				{
					(*itVector).nDamage += (*it).nDamage;
					break;
				}
			}

			if( itVector == vPartyContribute.end() ) vPartyContribute.push_back( VIRTUAL_PARTY( pPlayer->GetHandle(), (*it).nDamage, pPlayer->GetLevel() ) );
		}
	}

	for( itMap = mapPartyDamageContribute.begin(); itMap != mapPartyDamageContribute.end(); ++itMap )
	{
		vPartyContribute.push_back( VIRTUAL_PARTY( itMap->first, itMap->second.nDamage, itMap->second.nLevel ) );
	}
	
	// TODO: 게임 종료한 사용자의 경우 여기로 떨어질 수 있으므로, 여기서 바로 RETURN할 수 있도록.
	// assert( vPartyContribute.size() != 0 );

	// 뎀지순으로 정렬
	std::sort( vPartyContribute.begin(), vPartyContribute.end(), VIRTUAL_PARTY::greaterByDamage );

	for( itVector = vPartyContribute.begin(); itVector != vPartyContribute.end(); ++itVector )
	{
		float fContribute = 0.0f;

		// { 테이머 파티 셋팅
		if( nTamerPartyID != 0 && nTamerPartyID == (*itVector).nPartyID )
		{
			(*itVector).bTamer = true;
		}
		// )

		// 공헌도 = ( 데미지양 / 그 몬스터가 입은 총 데미지양) * 0.5
		if( m_nTotalDamage ) fContribute = ( (float) (*itVector).nDamage / m_nTotalDamage ) * 0.5f;

		// 최다 데미지 보너스
		if( itVector == vPartyContribute.begin() ) fContribute += fMaxDamageAdd;

		// { 선공 보너스 - 공헌도 0.3 추가
		if( nFirstAttackPartyID != 0 )
		{
			if( (*itVector).nPartyID == nFirstAttackPartyID ) fContribute += 0.3f;
		}
		else if( m_hFirstAttacker && (*itVector).hPlayer == m_hFirstAttacker ) fContribute += 0.3f;
		// }

		// { 막타 보너스 - 공헌도 0.1 추가
		if( nLastAttackPartyID != 0 )
		{
			if( (*itVector).nPartyID == nLastAttackPartyID ) fContribute += 0.1f;	// 파티
		}
		else
		{
			if( (*itVector).hPlayer == hKiller ) fContribute += 0.1f;				// 솔로
		}
		// }

		(*itVector).fContribute = fContribute;
	}
}

void StructMonster::procEXP( StructCreature *pKiller, std::vector< VIRTUAL_PARTY > & vPartyContribute )
{
	if( m_vDamageList.empty() ) return;

	// 	최종EXP = 기본EXP * [ 1 + { (친사람수 -1) * 0.2} ] (단, 6명까지만.) // deleted
	int nEXP = m_pContentInfo->exp;
	int nJP = m_pContentInfo->jp;

	std::vector< VIRTUAL_PARTY >::iterator	itVector;
	for( itVector = vPartyContribute.begin(); itVector != vPartyContribute.end(); ++itVector )
	{
		// { 공헌도에 따른 경험치/JP 계산
		int nSharedEXP = nEXP * (*itVector).fContribute;
		float fSharedJP = nJP * (*itVector).fContribute;
		if( nSharedEXP < 1 ) nSharedEXP = 1;	// EXP 는 최소 1
		// }

		// { 테이밍 보너스
		if( (*itVector).hPlayer )
		{
			if( (*itVector).hPlayer == GetTamer() ) 
			{
				nSharedEXP	*= GetTameExpAdjust();
				fSharedJP	*= GetTameExpAdjust();
			}
		}
		else
		{
			if( (*itVector).bTamer )
			{
				nSharedEXP	*= GetTameExpAdjust();
				fSharedJP	*= GetTameExpAdjust();
			}
		}
		// }

		if( (*itVector).hPlayer )
		{
			StructPlayer::iterator pit( StructPlayer::get( (*itVector).hPlayer ) );
			if( *pit )
			{
				addEXP( this, *pit, nSharedEXP, fSharedJP );	// 솔로일경우
			}
		}
		else
		{
			addEXP( this, (*itVector).nPartyID, nSharedEXP, fSharedJP );	// 파티일경우
		}
	}
}
void StructMonster::procDropChaos( StructCreature *pKiller, std::vector< VIRTUAL_PARTY > & vPartyContribute, float fDropRatePenalty, float fPCBangDropRateBonus )
{
	if( m_pContentInfo->chaos_drop_percentage * GameRule::fChaosDropRate * fDropRatePenalty * fPCBangDropRateBonus > XRandom() % 100 )
	{
		c_fixed10 fGameTimeLimitPenalty;
		fGameTimeLimitPenalty.set( 0 );

		THREAD_SYNCRONIZE( &m_csHate );

		// 중독 방지 시스템에 의해 몬스터 공격자가 모두 해로운 게임 시간이면 드랍 안 함
		// 페널티 수치를 공격자 내 최고 수치로 적용(드랍율은 변동 없이 드랍량만 변경)
		for( std::vector< struct _HATE_TAG >::iterator it = m_vHateList.begin() ; it != m_vHateList.end() ; ++it )
		{
			if( (*it).uid )
			{
				StructCreature::iterator pit = StructCreature::get( (*it).uid );
				if( *pit )
				{
					StructPlayer *pPlayer = NULL;

					if( (*pit)->IsPlayer() )
						pPlayer = static_cast< StructPlayer * >( *pit );
					else if( (*pit)->IsSummon() )
						pPlayer = static_cast< StructSummon * >( *pit )->GetMaster();

					if( !pPlayer || !pPlayer->IsLoginComplete() || pPlayer->GetLogoutTime() || !pPlayer->IsInWorld() )
						continue;

					if( pPlayer->IsGameTimeLimited() )
					{
						c_fixed10 fCurrentPlayerPenalty = GameRule::GetGameTimeLimitPenalty( pPlayer->GetContinuousPlayTime() );

						if( fGameTimeLimitPenalty < fCurrentPlayerPenalty )
						{
							fGameTimeLimitPenalty = fCurrentPlayerPenalty;
						}
					}
					else
					{
						fGameTimeLimitPenalty.set( 10000 );
						break;
					}
				}
			}
		}

		// 원샷 킬 하면 킬러의 Hate가 Add되기 전에 StructMonster::onDead 가 불려서 이쪽으로 와버림
		// ( m_vHateList.empty() == true )가 되므로 그냥 겸사겸사 킬러에 대해서 한 번 더 검사
		if( fGameTimeLimitPenalty == 0 )
		{
			if( pKiller )
			{
				StructPlayer *pPlayer = NULL;

				if( pKiller->IsPlayer() )
					pPlayer = static_cast< StructPlayer * >( pKiller );
				else if( pKiller->IsSummon() )
					pPlayer = static_cast< StructSummon * >( pKiller )->GetMaster();

				if( pPlayer && pPlayer->IsLoginComplete() && !pPlayer->GetLogoutTime() && pPlayer->IsInWorld() )
				{
					if( pPlayer->IsGameTimeLimited() )
					{
						c_fixed10 fCurrentPlayerPenalty = GameRule::GetGameTimeLimitPenalty( pPlayer->GetContinuousPlayTime() );

						if( fGameTimeLimitPenalty < fCurrentPlayerPenalty )
						{
							fGameTimeLimitPenalty = fCurrentPlayerPenalty;
						}
					}
					else
					{
						fGameTimeLimitPenalty.set( 10000 );
					}
				}
			}
		}

		if( fGameTimeLimitPenalty == 0 )
		{
			return;
		}

		// 여기까지는 int 절사
		float chaos = (int)( fGameTimeLimitPenalty * XRandom( m_pContentInfo->chaos_min, m_pContentInfo->chaos_max ) );

		if( GetDungeonId() )
		{
			int nTaxRate = 0;
			int nGuildID = 0;

			DungeonManager::Instance().GetTaxRate( GetDungeonId(), &nTaxRate, &nGuildID );
			int dungeon_tax = chaos * nTaxRate / 100.0f;

			if( nGuildID )
				GuildManager::GetInstance().GiveTax( nGuildID, StructGold( 0 ), dungeon_tax );

			chaos -= dungeon_tax;
		}

		std::vector< VIRTUAL_PARTY >::iterator	itVector;

		for( itVector = vPartyContribute.begin(); itVector != vPartyContribute.end(); ++itVector )
		{
			float fSharedChaos = chaos * (*itVector).fContribute;

			if( (*itVector).hPlayer )
			{
				StructPlayer::iterator pit( StructPlayer::get( (*itVector).hPlayer ) );
				if( *pit ) addChaos( this, *pit, fSharedChaos );	// 솔로일경우
			}
			else
			{
				addChaos( this, (*itVector).nPartyID, fSharedChaos );
			}
		}
	}
}

void StructMonster::procDropGold( const ArPosition & pos, StructCreature * pKiller, struct takePriority* pPriority, std::vector< VIRTUAL_PARTY > & vPartyContribute, float fDropRatePenalty, float fPCBangDropRateBonus )
{
	float fGoldDropRate = GameRule::fGoldDropRate * fDropRatePenalty * fPCBangDropRateBonus;

	if( m_pContentInfo->gold_drop_percentage * fGoldDropRate > XRandom() % 100 )
	{
		c_fixed10 fGameTimeLimitPenalty;
		fGameTimeLimitPenalty.set( 0 );

		StructPlayer* pPlayer = NULL; // AziaMafia

		THREAD_SYNCRONIZE( &m_csHate );

		// 중독 방지 시스템에 의해 몬스터 공격자가 모두 해로운 게임 시간이면 드랍 안 함
		// 페널티 수치를 공격자 내 최고 수치로 적용(드랍율은 변동 없이 드랍량만 변경)
		for( std::vector< struct _HATE_TAG >::iterator it = m_vHateList.begin() ; it != m_vHateList.end() ; ++it )
		{
			if( (*it).uid )
			{
				StructCreature::iterator pit = StructCreature::get( (*it).uid );
				if( *pit )
				{
					pPlayer = NULL;

					if( (*pit)->IsPlayer() )
						pPlayer = static_cast< StructPlayer * >( *pit );
					else if( (*pit)->IsSummon() )
						pPlayer = static_cast< StructSummon * >( *pit )->GetMaster();

					if( !pPlayer || !pPlayer->IsLoginComplete() || pPlayer->GetLogoutTime() || !pPlayer->IsInWorld() )
						continue;

					if( pPlayer->IsGameTimeLimited() )
					{
						c_fixed10 fCurrentPlayerPenalty = GameRule::GetGameTimeLimitPenalty( pPlayer->GetContinuousPlayTime() );

						if( fGameTimeLimitPenalty < fCurrentPlayerPenalty )
						{
							fGameTimeLimitPenalty = fCurrentPlayerPenalty;
						}
					}
					else
					{
						fGameTimeLimitPenalty.set( 10000 );
						break;
					}
				}
			}
		}

		// 원샷 킬 하면 킬러의 Hate가 Add되기 전에 StructMonster::onDead 가 불려서 이쪽으로 와버림
		// ( m_vHateList.empty() == true )가 되므로 그냥 겸사겸사 킬러에 대해서 한 번 더 검사
		if( fGameTimeLimitPenalty == 0 )
		{
			if( pKiller )
			{
				pPlayer = NULL; //StructPlayer *pPlayer = NULL;

				if( pKiller->IsPlayer() )
					pPlayer = static_cast< StructPlayer * >( pKiller );
				else if( pKiller->IsSummon() )
					pPlayer = static_cast< StructSummon * >( pKiller )->GetMaster();

				if( pPlayer && pPlayer->IsLoginComplete() && !pPlayer->GetLogoutTime() && pPlayer->IsInWorld() )
				{
					if( pPlayer->IsGameTimeLimited() )
					{
						c_fixed10 fCurrentPlayerPenalty = GameRule::GetGameTimeLimitPenalty( pPlayer->GetContinuousPlayTime() );

						if( fGameTimeLimitPenalty < fCurrentPlayerPenalty )
						{
							fGameTimeLimitPenalty = fCurrentPlayerPenalty;
						}
					}
					else
					{
						fGameTimeLimitPenalty.set( 10000 );
					}
				}
			}
		}

		if( fGameTimeLimitPenalty == 0 )
		{
			return;
		}

		StructGold gold( fGameTimeLimitPenalty * XRandom( m_pContentInfo->gold_min, m_pContentInfo->gold_max ) );

		if( gold < 0 )							gold.SetRawData( 1 );
		if( gold > GameRule::MAX_GOLD_DROP )	gold = GameRule::MAX_GOLD_DROP;
		
		if( GetDungeonId() )
		{
			int nTaxRate = 0;
			int nGuildID = 0;

			DungeonManager::Instance().GetTaxRate( GetDungeonId(), &nTaxRate, &nGuildID );
			StructGold dungeon_tax( gold.GetRawData() * nTaxRate / 100.0f );

			if( nGuildID )
				GuildManager::GetInstance().GiveTax( nGuildID, dungeon_tax, 0 );

			gold -= dungeon_tax;
		}

		if( gold >= 0 )
		{
			StructItem* pItem = StructItem::AllocGold( gold, ItemInstance::BY_MONSTER );
			ArPosition valid_pos;
			if( GameContent::GetValidRandomPos( pos, valid_pos, ITEM_DROP_LENGTH ) == false )
			{
				pKiller ? valid_pos = pKiller->GetPos() : valid_pos = pos;
				/*
				if( pKiller )
				{
					#ifdef _DEBUG
						_cprint( "gold drop valid pos failed. set killer pos." );
						FILELOG( "gold drop valid pos failed. set killer pos." );
					#endif

					valid_pos = pKiller->GetPos();
					if( GameContent::IsBlocked( valid_pos.x, valid_pos.y ) == true )
					{
						#ifdef _DEBUG
							_cprint( "killer pos is blocked." );
							FILELOG( "killer pos is blocked." );
						#endif
					}
				}
				else
				{
					#ifdef _DEBUG
						_cprint( "gold drop valid pos failed. killer == NULL" );
						FILELOG( "gold drop valid pos failed. killer == NULL\n" );
					#endif

					valid_pos = pos;
				}
				*/
			}

			pItem->SetCurrentXY( valid_pos.x, valid_pos.y );
			pItem->SetCurrentLayer( GetLayer() );
			pItem->SetPickupOrder( pPriority->ItemPickupOrder );

			if (GameRule::bDirectInventoryLoot)
			{
				//Credits to AziaMafia: Direct inventory looting
				MonsterDropItemToInventory(pPlayer, pItem);
			}
			else
			{
				MonsterDropItemToWorld(this, pItem);
			}
		}
	}
}

void StructMonster::dropItem(const ArPosition& pos, StructCreature* pKiller, struct takePriority* pPriority, std::vector< VIRTUAL_PARTY >& vPartyContribute, ItemBase::ItemCode code, const __int64& count, int level, bool bIsEventItem, int nFlagIndex)
{
	if (!count)
	{
		FILELOG("dropItem: count was 0. (x: %f, y: %f, code: %d, Killer: %s)", pos.GetX(), pos.GetY(), code, pKiller->GetName());
		return;
	}


	// Due to the anti-poisoning system, monster attackers do not drop if all harmful game time
	bool bHarmfulUsersOnly = true;
	StructPlayer* pPlayer = NULL; // AziaMafia

	for (std::vector< struct _HATE_TAG >::iterator it = m_vHateList.begin(); it != m_vHateList.end(); ++it)
	{
		if ((*it).uid)
		{
			StructCreature::iterator pit = StructCreature::get((*it).uid);
			if (*pit)
			{

				//StructPlayer* pPlayer = NULL;

				if ((*pit)->IsPlayer())
					pPlayer = static_cast<StructPlayer*>(*pit);
				else if ((*pit)->IsSummon())
					pPlayer = static_cast<StructSummon*>(*pit)->GetMaster();

				if (!pPlayer || !pPlayer->IsLoginComplete() || pPlayer->GetLogoutTime() || !pPlayer->IsInWorld())
					continue;

				if (!pPlayer->IsGameTimeLimited() || pPlayer->GetContinuousPlayTime() < GameRule::nMaxTiredGameTime)
				{
					bHarmfulUsersOnly = false;
					break;
				}
			}
		}
	}

	// If you do a one-shot kill, StructMonster::onDead is called before the killer's Hate is added and you come here.
	// ( m_vHateList.empty() == true ), so just check one more time for the killer
	if (bHarmfulUsersOnly)
	{
		if (pKiller)
		{
			pPlayer = NULL;

			if (pKiller->IsPlayer())
				pPlayer = static_cast<StructPlayer*>(pKiller);
			else if (pKiller->IsSummon())
				pPlayer = static_cast<StructSummon*>(pKiller)->GetMaster();

			if (pPlayer && pPlayer->IsLoginComplete() && !pPlayer->GetLogoutTime() && pPlayer->IsInWorld()
				&& (!pPlayer->IsGameTimeLimited() || pPlayer->GetContinuousPlayTime() < GameRule::nMaxTiredGameTime))
			{
				bHarmfulUsersOnly = false;
			}
		}
	}

	if (bHarmfulUsersOnly)
	{
		return;
	}

	StructItem* pItem = StructItem::AllocItem(0, code, count, ItemInstance::BY_MONSTER, level);
	ArPosition valid_pos;
	if (GameContent::GetValidRandomPos(pos, valid_pos, ITEM_DROP_LENGTH) == false)
	{
		if (pKiller)
		{
			_cprint("item drop valid pos failed. set killer pos.");
			FILELOG("item drop valid pos failed. set killer pos.");

			valid_pos = pKiller->GetPos();
			if (GameContent::IsBlocked(valid_pos.x, valid_pos.y) == true)
			{
				_cprint("killer pos is blocked (x: %i; y: %i).", valid_pos.x, valid_pos.y);
				FILELOG("killer pos is blocked (x: %i; y: %i).", valid_pos.x, valid_pos.y);
			}
		}
		else
		{
			_cprint("item drop valid pos failed. killer == NULL");
			FILELOG("item drop valid pos failed. killer == NULL\n");

			valid_pos = pos;
		}
	}

	pItem->SetCurrentXY(valid_pos.x, valid_pos.y);
	pItem->SetCurrentLayer(GetLayer());
	pItem->SetPickupOrder(pPriority->ItemPickupOrder);

	// If nFlag is a valid flag, set that flag
	if (nFlagIndex >= 0 && nFlagIndex < pItem->GetInstanceFlag().TOTAL_BITS)
		pItem->SetInstanceFlagOn(nFlagIndex);

	if (bIsEventItem)
	{
		pItem->SetEventDropFlag(true);
		pItem->SetInstanceFlagOn(ItemInstance::ITEM_FLAG_EVENT);
	}


	if (GameRule::bDirectInventoryLoot)
	{
		//Credits to AziaMafia: Direct inventory looting
		MonsterDropItemToInventory(pPlayer, pItem);
	}
	else
	{
		MonsterDropItemToWorld(this, pItem);
	}
}

static bool checkDrop( int code, int percentage, StructCreature * pKiller, float fDropRatePenalty, float fPCBangDropRateBonus )
{
	StructPlayer *pPlayer = NULL;

	if( pKiller->IsPlayer() )
		pPlayer = static_cast< StructPlayer * >( pKiller );
	else if( pKiller->IsSummon() )
		pPlayer = static_cast< StructSummon * >( pKiller )->GetMaster();

	float fCreatureCardMod = 1.0f;

	// Apply item drop chance
	float fMod = ( 1.0f + pPlayer->GetItemChance() * 0.01f );

	if( code > 0 )
	{
		// Apply increased drop rate for summon cards
		if( StructItem::GetItemBase( code ).nGroup == ItemBase::GROUP_SUMMONCARD )
		{
			fCreatureCardMod = pKiller->GetCreatureCardChance();
		}

		// For quest items(usually not dropped by monsters, but occasionally used — e.g., collectable junk items), drop rate penalties are not applied
		if( StructItem::GetItemBase( code ).Flag.IsOn( ItemBase::FLAG_QUEST ) )
		{
			fDropRatePenalty = 1.0f;
		}

		const bool alwaysDropBossCard = ENV().GetInt("game.always_drop_boss_card", 0) != 0;
		if (alwaysDropBossCard && StructItem::GetItemBase(code).nGroup == ItemBase::GROUP_EQUIPMENT_ON_BELT)
		{
			fDropRatePenalty = 1.0f;
		}
	}

	// When killing monsters in Deathmatch, no level penalty is applied
	if( pPlayer && pPlayer->IsInDeathmatch() )
		fDropRatePenalty = 1.0f;



	// After probability calculation, KIN
	float fItemDropRate = GameRule::fItemDropRate;

	if (pPlayer->IsPKOn() )
		fItemDropRate += GameRule::fPlayerKillerBonusRate;


	if( code >=  540200 && code <= 540204 )
	{
		fItemDropRate *= GameRule::fCardDropRate;
	}

	if( XRandom( 1, 100000000 ) > ( percentage * fMod * fItemDropRate * fDropRatePenalty * fPCBangDropRateBonus ) * fCreatureCardMod ) return false;

	return true;
}

void StructMonster::dropItemGroup( const ArPosition & pos, StructCreature * pKiller, struct takePriority* pPriority, std::vector< VIRTUAL_PARTY > & vPartyContribute, int nDropGroupID, const __int64 & count, int level, int nFlagIndex )
{
	std::map< ItemBase::ItemCode, __int64 > mapDropItem;

	for( int i = 0 ; i < static_cast< int >( count ) ; ++i )
	{
		ItemBase::ItemCode nItemID = nDropGroupID;
		__int64 nItemCount = 1;

		do
		{
			GameContent::SelectItemIDFromDropGroup( nItemID, nItemID, nItemCount );
		} while( nItemID < 0 );

		// 꽝이 아니고 아이템이 선택된 경우에만 드랍 대상으로 추가
		if( nItemID > 0 )
		{
			std::map< ItemBase::ItemCode, __int64 >::iterator it = mapDropItem.find( nItemID );
			if( it == mapDropItem.end() )
			{
				mapDropItem.insert( std::make_pair( nItemID, nItemCount ) );
			}
			else
			{
				(*it).second += nItemCount;
			}
		}
	}

	for( std::map< ItemBase::ItemCode, __int64 >::const_iterator it = mapDropItem.begin() ; it != mapDropItem.end() ; ++it )
	{
		dropItem( pos, pKiller, pPriority, vPartyContribute, (*it).first, (*it).second, level, false, nFlagIndex );
	}
}

void StructMonster::procDropItem( const ArPosition & pos, StructCreature * pKiller, takePriority* pPriority, std::vector< VIRTUAL_PARTY > & vPartyContribute, float fDropRatePenalty, float fPCBangDropRateBonus )
{
	if( m_pContentInfo && m_pContentInfo->item_drop_list )
	{
		if( StructEventItemManager::GetInstance().IsStartingDungeonDropRateEvent() )
		{
			int nDungeonID = DungeonManager::Instance().GetDungeonID( GetX(), GetY() );
			if( !nDungeonID )
			{
				nDungeonID = InstanceDungeonManager::Instance().GetInstanceDungeonID( ArPosition( GetX(), GetY() ) );
			}

			if( nDungeonID )
			{
				fPCBangDropRateBonus *= StructEventItemManager::GetInstance().GetEventDungeonDropRate( nDungeonID );
			}
		}

		for( std::vector< MonsterBase::MONSTER_ITEM_DROP_INFO >::const_iterator it = m_pContentInfo->item_drop_list->begin() ; it != m_pContentInfo->item_drop_list->end() ; ++it )
		{
			const MonsterBase::MONSTER_ITEM_DROP_INFO & item_drop = (*it);

			if( !item_drop.item_id ) continue;

			if( !checkDrop( item_drop.item_id, item_drop.percentage, pKiller, fDropRatePenalty, fPCBangDropRateBonus ) ) continue;

			// 갯수
			__int64 item_count = XRandom( item_drop.min_count, item_drop.max_count );
			if( item_count < item_drop.min_count || item_count > item_drop.max_count )
			{
				_cprint( "StructMonster::procDropItem(...) : invalid item count! [%d][%d]\n", item_drop.item_id, item_count );
				FILELOG( "StructMonster::procDropItem(...) : invalid item count! [%d][%d]", item_drop.item_id, item_count );
				continue;
			}

			// 레벨
			int item_level = XRandom( item_drop.min_level, item_drop.max_level );

			if (item_count > 0)
			{
				if (item_drop.item_id < 0)
				{

					dropItemGroup(pos, pKiller, pPriority, vPartyContribute, item_drop.item_id, item_count, item_level, ItemInstance::ITEM_FLAG_NONE);
				}
				else
				{
					dropItem(pos, pKiller, pPriority, vPartyContribute, item_drop.item_id, item_count, item_level, false, ItemInstance::ITEM_FLAG_NONE);
				}
			}
		}

		// 이벤트 드랍
		ItemBase::ItemCode nEventItemCode = StructEventItemManager::GetInstance().GetActiveDrop( GetArTime(), fDropRatePenalty );
		if( nEventItemCode && GameContent::IsValidItemCode( nEventItemCode ) )
		{
			dropItem( pos, pKiller, pPriority, vPartyContribute, nEventItemCode, 1, 1, true, ItemInstance::ITEM_FLAG_NONE );
			
			StructPlayer *pPlayer = NULL;
			if( pKiller )
			{
				if( pKiller->IsPlayer() )
					pPlayer = static_cast< StructPlayer * >( pKiller );
				else if( pKiller->IsSummon() )
					pPlayer = static_cast< StructSummon * >( pKiller )->GetMaster();
			}

			if( pPlayer )
			{
				LOG::Log11N4S( LM_ITEM_EVENT_DROP, pPlayer->GetAccountID(), 
					pPlayer->GetSID(), 0,
					nEventItemCode, 1,
					this->GetMonsterId(), this->GetX(),
					this->GetY(), 0, 
					0, 0, 
					pPlayer->GetAccountName(), LOG::STR_NTS, 
					pPlayer->GetName(), LOG::STR_NTS, 
					"", 0, 
					"", 0 );
			}
			else
			{
				LOG::Log11N4S( LM_ITEM_EVENT_DROP, 0, 
					0, 0,
					nEventItemCode, 1,
					this->GetMonsterId(), this->GetX(),
					this->GetY(), 0, 
					0, 0, 
					"", 0, 
					"", 0, 
					"", 0, 
					"", 0 );
			}
		}

	}

	// 퀘스트 및 호칭 처리
	procQuestAndTitle( pos, pKiller, pPriority, vPartyContribute, fDropRatePenalty );
}

void StructMonster::onDead( StructCreature * pKiller, bool decreaseEXPOnDead )
{
	std::vector< VIRTUAL_PARTY > vPartyContribute;

	StructCreature::onDead( pKiller, decreaseEXPOnDead );

	SetStatus( STATUS_DEAD );
	_monster_debug_output( "DEAD : %I64d\n", GetHandle() );

	// Remove from scanner
	quadTreeItem.RemoveMe();

	m_bTamedSuccess = false;

	// Taming Processing
	if( GetTamer() ) 
	{
		StructPlayer::iterator it = StructPlayer::get( GetTamer() );
		if( *it ) m_bTamedSuccess = ProcTame( this );
	}

	calcPartyContribute( pKiller, vPartyContribute );

	// Scenery distribution (changed to apply experience points only when the experience points obtained in the monster DB are above the above)
	if( GetMonsterBase()->exp > 0 )
	{
		procEXP( pKiller, vPartyContribute );
	}

	StructPlayer* pKillPlayer = NULL;
	if( pKiller != nullptr && pKiller != NULL )
	{
		if( pKiller->IsPlayer() )
		{
			pKillPlayer = static_cast< StructPlayer* >( pKiller );
		}
		else if( pKiller->IsSummon() )
		{
			StructSummon* pKillSummon = static_cast< StructSummon* >( pKiller );
			if( pKillSummon != NULL )
			{
				pKillPlayer = pKillSummon->GetMaster();
			}
		}
	}

	// If there is a script to run on death, run the script (need to re-determine where to run it and what parameters to pass to Lua)
	if( GetMonsterBase()->script_on_dead[ 0 ] )
	{
		ThreadPlayerHelper TPHepler( pKillPlayer );

		char szScriptBuffer[ 256 ];
		s_strcpy( szScriptBuffer, _countof( szScriptBuffer ), GetMonsterBase()->script_on_dead );

		char szElementBuffer[ 32 ];
		s_sprintf( szElementBuffer, _countof( szElementBuffer ), "%d", (int)GetX() );
		XStringUtil::Replace( szScriptBuffer, _countof( szScriptBuffer ), "#@pos_x@#", szElementBuffer );
		s_sprintf( szElementBuffer, _countof( szElementBuffer ), "%d", (int)GetY() );
		XStringUtil::Replace( szScriptBuffer, _countof( szScriptBuffer ), "#@pos_y@#", szElementBuffer );
		s_sprintf( szElementBuffer, _countof( szElementBuffer ), "%d", (int)GetLayer() );
		XStringUtil::Replace( szScriptBuffer, _countof( szScriptBuffer ), "#@pos_layer@#", szElementBuffer );		
		s_sprintf( szElementBuffer, _countof( szElementBuffer ), "%u", GetHandle() );
		XStringUtil::Replace( szScriptBuffer, _countof( szScriptBuffer ), "#@monster_handle@#", szElementBuffer );

		LUA()->RunString( szScriptBuffer );
	}

	// Log when a boss-level monster dies
	if( GetMonsterType() >= MonsterBase::MONSTER_TYPE_HIGHEST_1_STAR )
	{
		int nDungeonID = 0;
		if(pKillPlayer != NULL && pKillPlayer->IsInDungeon() )
		{
			nDungeonID = DungeonManager::Instance().GetDungeonID( pKillPlayer->GetX(), pKillPlayer->GetY() );
		}
		else if( pKillPlayer->IsInInstanceDungeon() )
		{
			nDungeonID = InstanceDungeonManager::Instance().GetInstanceDungeonID( ArPosition( pKillPlayer->GetX(), pKillPlayer->GetY() ) );
		}

		LOG::Log11N4S( LM_MONSTER_KILL, pKillPlayer->GetAccountID(),
			pKillPlayer->GetPlayerUID(), pKillPlayer->GetPartyID(),
			GetMonsterId(), nDungeonID,
			GetX(), GetY(),
			pKillPlayer->GetX(), pKillPlayer->GetY(),
			GetLayer(), 0,
			pKillPlayer->GetAccountName(), LOG::STR_NTS, 
			pKillPlayer->GetName(), LOG::STR_NTS, 
			"", 0, 
			"", 0 );
	}

	// Drop if not tamed
	if( !m_bTamedSuccess )
	{
		std::sort( vPartyContribute.begin(), vPartyContribute.end(), VIRTUAL_PARTY::greaterByContribute );

		ArPosition pos = GetCurrentPosition( GetArTime() );

		takePriority Priority;
		std::vector< VIRTUAL_PARTY >::iterator itContribute;

		// { 획득 우선순위 생성
		int nCount = 0;

		for( itContribute = vPartyContribute.begin(); itContribute != vPartyContribute.end(); ++itContribute )
		{
			// 레이드 보스 몬스터의 경우는 파티가 바로 해산되므로 소유권을 없애야 함
			if( IsDungeonRaidMonster() && GetMonsterType() >= MonsterBase::MONSTER_TYPE_HIGHEST_1_STAR )
			{
				Priority.ItemPickupOrder.hPlayer[nCount] = 0;
				Priority.ItemPickupOrder.nPartyID[nCount] = 0;
			}
			else if( (*itContribute).hPlayer )
			{
				Priority.ItemPickupOrder.hPlayer[nCount] = (*itContribute).hPlayer;
				Priority.ItemPickupOrder.nPartyID[nCount] = 0;
			}
			else
			{
				Priority.ItemPickupOrder.hPlayer[nCount] = 0;
				Priority.ItemPickupOrder.nPartyID[nCount] = (*itContribute).nPartyID;
			}

			if( ++nCount >= 3 )
			{
				break;
			}
		}
		// }

		// 최고 우선순위 보유자 정보 적용
		itContribute = vPartyContribute.begin();

		int nMaxPriorityLevel = ( vPartyContribute.empty() ) ? 0 : (*itContribute).nLevel;
		float fMaxContribute = ( vPartyContribute.empty() ) ? 0.0f : (*itContribute).fContribute;

		float fDropRatePenalty = 1.0f;
		int nLevelDiff = nMaxPriorityLevel - GetLevel();

		if( nLevelDiff >= 10 )
		{
			fDropRatePenalty = std::max( 1 - ( nLevelDiff - 10 ) * 0.05f, 0.0f );
		}

		if (GetLevel() >= 150 )
		{
			fDropRatePenalty = 1.0f;
		}

		// Check if PC Bang premium pass exist
		bool bPremiumPCBang = false;

		// If there is no aggro information (one-shot kill), apply based on the killer
		if( vPartyContribute.empty() )
		{
			StructPlayer *pKillPlayer = NULL;
			if( pKiller->IsPlayer() )
				pKillPlayer = static_cast< StructPlayer * >( pKiller );
			else if( pKiller->IsSummon() )
				pKillPlayer = static_cast< StructSummon * >( pKiller )->GetMaster();

			bPremiumPCBang = pKillPlayer && pKillPlayer->GetPCBangMode() == GameRule::PCBANG_PREMIUM_BONUS;
		}
		// If the highest priority was assigned to the player
		else if( (*itContribute).hPlayer )
		{
			StructPlayer::iterator pit = StructPlayer::get( (*itContribute).hPlayer );
			bPremiumPCBang = (*pit) && static_cast< StructPlayer * >( (*pit) )->GetPCBangMode() == GameRule::PCBANG_PREMIUM_BONUS;
		}
		// 최고 우선순위가 파티에게 있었을 경우
		else if( (*itContribute).nPartyID )
		{
			// 파티 멤버 중 더블 플러스 PC방 멤버 찾기
			struct partyPCBangBonusChecker : public PartyManager::PartyFunctor
			{
				partyPCBangBonusChecker( const ArPosition & posKiller )
					: m_posKiller( posKiller )
					, m_bPremiumPCBang( false )
				{}

				virtual bool operator()( AR_HANDLE handle )
				{
					if( m_bPremiumPCBang )
						return true;

					StructPlayer::iterator pit = StructPlayer::get( handle );
					StructPlayer *pPlayer = *pit;
					if( !pPlayer || !pPlayer->IsInWorld() ) return true;

					// 멀리 떨어져 있으면 KIN
					if( m_posKiller.GetDistance( pPlayer->GetPos() ) > RANGE_LIMIT ) return true;

					// 파티 멤버 중 더블 플러스 PC방 유저 있는지 찾기
					if( pPlayer->GetPCBangMode() == GameRule::PCBANG_PREMIUM_BONUS )
						m_bPremiumPCBang = true;

					return true;
				}

				const ArPosition &	m_posKiller;
				bool				m_bPremiumPCBang;
			} _fo( GetPos() );

			PartyManager::GetInstance().DoEachMember( (*itContribute).nPartyID, _fo );

			bPremiumPCBang = _fo.m_bPremiumPCBang;
		}

		c_fixed10 difficultyBonus = GameRule::GetDifficultyBonus( m_nDifficulty );

		float fGoldDropRateBonus = 1.0f * difficultyBonus;
		float fItemDropRateBonus = 1.0f * difficultyBonus;
		float fChaosDropRateBonus = 1.0f * difficultyBonus;

		if( bPremiumPCBang )
		{
			fGoldDropRateBonus = GameRule::fPremiumPCBangGoldBonusDropRate;
			fItemDropRateBonus = GameRule::fPremiumPCBangItemBonusDropRate;
			fChaosDropRateBonus = GameRule::fPremiumPCBangChaosBonusDropRate;
		}

		

		// Collect 1 LAK quest
		if( pKiller->IsPlayer() && static_cast< StructPlayer * >( pKiller )->GetChaos() < 1 && static_cast< StructPlayer * >( pKiller )->GetQuestProgress( StructQuest::QUEST_CODE_CHAOS_COLLECT ) == QuestInstance::IN_PROGRESS )
		{
			addChaos( this, static_cast< StructPlayer * >( pKiller ), 1.0f );
		}

		if( pKiller != nullptr && !IsDungeonRaidMonster() )
		{
			// Drop Gold
			procDropGold( pos, pKiller, &Priority, vPartyContribute, fDropRatePenalty, fGoldDropRateBonus );
			// Drop Chaos
			procDropChaos(pKiller, vPartyContribute, fDropRatePenalty, fChaosDropRateBonus);
			// Drop Item  
			procDropItem( pos, pKiller, &Priority, vPartyContribute, fDropRatePenalty, fItemDropRateBonus );

		}
	}

	// Hate list
	std::vector< _HATE_TAG >::iterator it;

	StructCreature::onDead( pKiller,decreaseEXPOnDead );

	for( it = m_vHateList.begin(); it != m_vHateList.end(); ++it )
	{
		StructCreature::iterator itEnemy = StructCreature::get( (*it).uid );

		if( *itEnemy )
		{
			(*itEnemy)->RemoveFromEnemyList( GetHandle() );
		}
	}
}

void StructMonster::procQuestAndTitle( const ArPosition & pos, StructCreature *pKiller, struct takePriority* pPriority, std::vector< VIRTUAL_PARTY > & vPartyContribute, float fDropRatePenalty )
{
	if( vPartyContribute.empty() ) 
	{
		// assert( 0 );
		return;
	}
	
	VIRTUAL_PARTY & vp_tag = vPartyContribute.front();
	std::vector< struct StructPlayer * > vPlayer;

	// 대상 선택
	if( vp_tag.hPlayer )
	{
		StructPlayer::iterator pit = StructPlayer::get( vp_tag.hPlayer );
		StructPlayer *pPlayer = *pit;

		if( pPlayer ) vPlayer.push_back( pPlayer );
	}
	else
	{
		struct myPartyFunctor : PartyManager::PartyFunctor
		{
			myPartyFunctor( ArPosition p, std::vector< struct StructPlayer * > * pList ) : pos( p ), pList( pList )
			{
			}

			virtual bool operator()( AR_HANDLE handle )
			{
				StructPlayer::iterator pit = StructPlayer::get( handle );
				StructPlayer *pPlayer = *pit;
				if( !pPlayer || !pPlayer->IsInWorld() ) return true;

				// 멀리 떨어져 있으면 KIN			
				AR_UNIT distance = pos.GetDistance( pPlayer->GetPos() );	
				if( distance > RANGE_LIMIT ) return true;

				pList->push_back( pPlayer );
				
				return true;
			}

			ArPosition pos;			
			std::vector< struct StructPlayer * > *pList;
		} _tmp( pos, &vPlayer );

		PartyManager::GetInstance().DoEachMember( vp_tag.nPartyID, _tmp );
	}

	for( std::vector< struct StructPlayer * >::iterator it = vPlayer.begin(); it != vPlayer.end(); ++it )
	{
		// 퀘스트 처리
		// 킬수 처리
		(*it)->UpdateQuestStatusByMonsterKill( GetMonsterId() );

		// 사냥 수집 퀘스트의 경우 드랍그룹 적용
		std::vector< StructQuest* > vQuestList;		
		(*it)->GetQuestByMonster( GetMonsterId(), vQuestList, QuestBase::TYPE_FLAG_HUNT_ITEM | QuestBase::TYPE_FLAG_HUNT_ITEM_FROM_ANY_MONSTSERS );
		for( std::vector< StructQuest* >::iterator it2 = vQuestList.begin(); it2 != vQuestList.end(); ++it2 )
		{
			StructQuest *pQuest = (*it2);
			if( pQuest && pQuest->GetQuestBase().nDropGroupId && !pQuest->IsFinishable() )
			{
				if( pQuest->GetQuestType() == QuestBase::QUEST_HUNT_ITEM_DROP_PENALTY )
				{
					unsigned int	n64Random	= XRandom( 1, 100000000 );
					unsigned int	n64Rate		= 100000000 * fDropRatePenalty;
					if( n64Rate > n64Random )
					{
						dropItemGroup( pos, pKiller, pPriority, vPartyContribute, pQuest->GetQuestBase().nDropGroupId, 1, 1, ItemInstance::ITEM_FLAG_NONE );
					}
				}
				else
				{
					dropItemGroup( pos, pKiller, pPriority, vPartyContribute, pQuest->GetQuestBase().nDropGroupId, 1, 1, ItemInstance::ITEM_FLAG_NONE );
				}
			}
		}

		// 호칭 처리
		(*it)->UpdateTitleConditionByMonsterKill( GetMonsterId(), GetTameCode() );
	}
}

AR_UNIT StructMonster::GetFirstAttackRange() const
{
	return m_pContentInfo->visible_range;
}

bool StructMonster::IsEnemy( StructCreature* pTarget, bool bIncludeHiding )
{
	if( !StructCreature::IsEnemy( pTarget, bIncludeHiding ) )
		return false;

	if( pTarget->IsNPC() )
		return false;

	return true;
}

bool StructMonster::IsAlly( StructCreature* pTarget )
{
	if( pTarget->IsMonster() )
	{
		return true;
	}
	else if( IsOriginalDungeonOwnerGuardian() || IsOriginalDungeonSiegerGuardian() )
	{
		StructPlayer * pPlayer = NULL;

		if( pTarget->IsPlayer() )
		{
			pPlayer = static_cast< StructPlayer * >( pTarget );
		}
		else if( pTarget->IsSummon() )
		{
			pPlayer = static_cast< StructSummon * >( pTarget )->GetMaster();
		}

		if( pPlayer && pPlayer->GetPartyID() )
		{
			int dungeon_id = DungeonManager::Instance().GetDungeonID( GetX(), GetY() );

			if( dungeon_id )
			{
				int guild_id = PartyManager::GetInstance().GetAttackTeamGuildID( pPlayer->GetPartyID() );

				if( guild_id == DungeonManager::Instance().GetOriginalOwnGuildID( dungeon_id ) )
				{
					if( IsOriginalDungeonOwnerGuardian() )
						return true;
				}
				else
				{
					if( IsOriginalDungeonSiegerGuardian() )
						return true;
				}
			}
			
		}

	}
	return StructCreature::IsAlly( pTarget );
}

int StructMonster::GetCreatureGroup() const
{
	if( m_nChangingGroup != CREATURE_NONE ) 
		return m_nChangingGroup;
	
	return m_pContentInfo->group;
}

bool StructMonster::IsAttackable()
{
	if( m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_ENVIRONMENT ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_DUNGEON_CONNECTOR ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_AUTO_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_RUNAWAY ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_IMMORTAL_DUMMY ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_DEFENCE_SKILL )
		return false;

	return StructCreature::IsAttackable();

}

bool StructMonster::IsEnvironmentMonster() const
{
	return m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_ENVIRONMENT;
}

bool StructMonster::IsDungeonConnector() const
{
	return m_pContentInfo->race == MonsterBase::MONSTER_RACE_DUNGEON_CONNECTOR;
}

bool StructMonster::IsAgent() const
{
	return m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_AGENT;
}

bool StructMonster::IsAutoTrap() const
{
	return m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_AUTO_TRAP;
}

bool StructMonster::IsRunaway() const
{
	return m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_RUNAWAY;
}

bool StructMonster::IsMovable()
{
	if( m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_DUNGEON_CONNECTOR ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_AUTO_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_NOT_MOVABLE ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_IMMORTAL_DUMMY ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_DEFENCE_SKILL )
		return false;

	return StructCreature::IsMovable();
}

bool StructMonster::IsKnockbackable()
{
	if( m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_DUNGEON_CONNECTOR ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_AUTO_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_TRAP ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_NOT_MOVABLE ||
		m_pContentInfo->fight_type == MonsterBase::FIGHT_TYPE_IMMORTAL_DUMMY ||
		IsBossMonster() )
		return false;

	return StructCreature::IsKnockbackable();
}

bool StructMonster::IsSkillCastable()
{
	if( !IsActable() || GetState( StructState::MUTE ) ) return false;
	if( IsSitDown() ) return false;
	if( IsUsingSkill() ) return false;
	return m_StatusFlag.IsOn( STATUS_SKILL_CASTABLE );
}

bool StructMonster::IsMagicCastable()
{
	if( !IsActable() || GetState( StructState::MUTE ) ) return false;
	if( IsSitDown() ) return false;
	if( IsUsingSkill() ) return false;
	return m_StatusFlag.IsOn( STATUS_MAGIC_CASTABLE );
}

bool StructMonster::IsBossMonster() const
{
	if( m_pContentInfo->monster_type >= MonsterBase::MONSTER_TYPE_HIGH_3_STAR )
		return true;

	return false;
}

bool StructMonster::IsDungeonCore() const
{
	return ( m_pContentInfo->race == MonsterBase::MONSTER_RACE_DUNGEON_CORE );
}

AR_UNIT StructMonster::GetChaseRange() const
{
	return m_pContentInfo->chase_range * GameRule::DEFAULT_UNIT_SIZE;
}