#include <mmo/ArcadiaServer.h>
#include <toolkit/XRandom.h>
#include <toolkit/XSTLUtil.h>

#include "LogClient/LogClient.h"
#include "ErrorCode/ErrorCode.h"

#include "StructSummon.h"
#include "GameContent.h"
#include "SendMessage.h"
#include "StructItem.h"
#include "StructPlayer.h"
#include "StructMonster.h"
#include "DB_Commands.h"
#include "StructSkill.h"
#include "GameProc.h"
#include "GameMessage.h"
#include "CompeteManager.h"
#include "GameAllocator.h"
#include "LuaVM.h"


void StructSummon::BindProperty()
{
	StructSummon temp( "for bind property" );
	temp.Bind( "handle", (int *)&temp.m_hHandle );
	temp.Bind( "hp", &temp.m_nHP );
	temp.Bind( "mp", &temp.m_nMP );
	temp.Bind( "sp", &temp.m_nSP );
	temp.Bind( "max_hp", &temp.m_nMaxHP );
	temp.Bind( "max_mp", &temp.m_nMaxMP );
	temp.Bind( "max_sp", &temp.m_nMaxSP );
	temp.BindCString( "name", temp.m_szName, _countof( temp.m_szName ) );
	temp.Bind( "exp", &temp.m_nEXP );
	temp.Bind( "jp", &temp.m_nJobPoint );
	temp.Bind( "job_level", &temp.m_nJobLevel );
	temp.Bind( "jlv", &temp.m_nJobLevel );
	temp.Bind( "ev_1_ID", &temp.m_nPrevJobId[0] );
	temp.Bind( "ev_2_ID", &temp.m_nPrevJobId[1] );
	temp.Bind( "ev_1_level", &temp.m_nPrevJobLevel[0] );
	temp.Bind( "ev_2_level", &temp.m_nPrevJobLevel[1] );
	temp.Bind( "job", &temp.m_nJob );
	temp.Bind( "level", &temp.m_nLevel );	
	temp.Bind( "lv", &temp.m_nLevel );	
	temp.Bind( "max_level", &temp.m_nMaxReachedLevel );
	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( "race", &temp.m_nRace );
	temp.Bind( "x", &temp.mv.x );
	temp.Bind( "y", &temp.mv.y );
	temp.Bind( "weight", &temp.m_fWeight );	
	temp.Bind( "max_weight", const_cast< __int64 * >( &temp.m_Attribute.fMaxWeight.get() ) );	
	temp.Bind( "speed", const_cast< __int64 * >( &temp.m_Attribute.fMoveSpeed.get() ) );
	temp.Bind( "attack_point", const_cast< __int64 * >( &temp.m_Attribute.fAttackPointRight.get() ) );
	temp.Bind( "attack_point_right", const_cast< __int64 * >( &temp.m_Attribute.fAttackPointRight.get() ) );
	temp.Bind( "attack_point_left", const_cast< __int64 * >( &temp.m_Attribute.fAttackPointLeft.get() )  );
	temp.Bind( "defence", const_cast< __int64 * >( &temp.m_Attribute.fDefence.get() ) );
	temp.Bind( "magic_def", const_cast< __int64 * >( &temp.m_Attribute.fMagicDefence.get() ) );
	temp.Bind( "magic_pt", const_cast< __int64 * >( &temp.m_Attribute.fMagicPoint.get() ) );
	temp.Bind( "accuracy", const_cast< __int64 * >( &temp.m_Attribute.fAccuracyRight.get() ) );
	temp.Bind( "accuracy", const_cast< __int64 * >( &temp.m_Attribute.fAccuracyRight.get() ) );
	temp.Bind( "accuracy", const_cast< __int64 * >( &temp.m_Attribute.fAccuracyLeft.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( "avoid", const_cast< __int64 * >( &temp.m_Attribute.fAvoid.get() ) );
	temp.Bind( "block_chance", const_cast< __int64 * >( &temp.m_Attribute.fBlockChance.get() ) );
	temp.Bind( "summon_state", &temp.m_bIsSummoned );
	temp.Bind( "evolution_depth", &temp.m_nTransformLevel );
	// Epic 3 이전까지 진화 시스템에서는 진화시 레벨이 초기화 되므로
	// 따로 계산이 필요했으나 Epic 4부터 현재 레벨을 총 레벨로 보면 됨
	temp.Bind( "total_level", &temp.m_nLevel );
}

StructSummon* StructSummon::AllocSummon( struct StructPlayer* pMaster, unsigned idx )
{
	StructSummon* p;

	struct _myIntializer : GameAllocateFunctor
	{
		_myIntializer( int _idx ) : m_nIdx( _idx ) {}
		
		virtual void operator()( void * pObj, AR_HANDLE handle )
		{
			new (pObj) StructSummon( handle, m_nIdx );
		}

		unsigned m_nIdx;
	};

	AR_HANDLE handle = allocSummonStruct( &p, _myIntializer( idx ) );

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

	p->m_pMaster = pMaster;
	p->CalculateStat();

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

	p->m_nMaxReachedLevel = 1;
	p->m_nJobPoint = 1;

	p->m_fCM = 0;

	// 소환수는 id + 1000 이 직업 ID 임.


	if( p->GetRidingInfo() == SummonBase::RIDING_LENT )
	{
		// 라이딩 스킬 넣어줘야 함.
		p->SetSkill( StructSkill::SKILL_UID_SUMMON_SKILL, StructSkill::SKILL_CREATURE_RIDING, 1, 0 );
	}
	return p;
}

char StructSummon::GetRidingInfo() const
{
	return m_pContentInfo->is_riding_only;
}

void StructSummon::FreeSummon( StructSummon* p )
{
	// _oprint( "DEL SUMMON : %08X\n", p );

	prepareFreeSummonStruct( p );

	p->StructSummon::~StructSummon();

	freeSummonStruct( p );
}

void StructSummon::onSPChange()
{
	if( GetMaster() )
		SendSPMsg( GetMaster(), this );
}

void StructSummon::AddExp( __int64 exp, __int64 jp, bool bApplyStamina, bool bForce )
{
    __int64 exp_limit = 0;

    // exp나 jp가 크면 float은 오류가 너무 많이 나므로 double로 계산 해줌
    //exp *= static_cast< double >( m_fEXPMod + 1.0f ); //pet exp cap
    jp *= static_cast< double >( m_fEXPMod + 1.0f );

	if (!bForce && m_pMaster)
		exp = exp ; //Azia Mafia Fix Leveling Pets
	//std::min( exp, static_cast< __int64 >( GameRule::GetSummonEXPLimit( GetLevel() ) ) );


    // 획득 가능 한계 경험치를 체크하여 더 이상 경험치 획득 불가능 상태면 획득 취소
    switch( GetTransformLevel() )
    {
    case SummonBase::EVOLVE_GROWTH:
        exp_limit = GameContent::GetNeedSummonExp( GameRule::GROWTH_SUMMON_MAX_LEVEL ) - 1;

        if( exp_limit <= m_nEXP )
            return;

        else if( GameContent::GetNeedSummonExp( GameRule::GROWTH_SUMMON_MAX_LEVEL - 1 ) < m_nEXP )
        {
            exp = std::min( __int64(exp), exp_limit - m_nEXP );
        }
        break;
    case SummonBase::EVOLVE_EVOLVE:
        exp_limit = GameContent::GetNeedSummonExp( GameRule::EVOLVE_SUMMON_MAX_LEVEL ) - 1;

        if( exp_limit <= m_nEXP )
            return;

        else if( GameContent::GetNeedSummonExp( GameRule::EVOLVE_SUMMON_MAX_LEVEL - 1 ) < m_nEXP )
        {
            exp = std::min( __int64( exp ), exp_limit - m_nEXP );
        }
        break;
    default:
        exp_limit = GameContent::GetNeedSummonExp( GameRule::NORMAL_SUMMON_MAX_LEVEL ) - 1;

        if( exp_limit <= m_nEXP )
            return;

        else if( GameContent::GetNeedSummonExp( GameRule::NORMAL_SUMMON_MAX_LEVEL - 1 ) < m_nEXP )
        {
            exp = std::min( __int64( exp ), exp_limit - m_nEXP );
        }
        break;

    }

    StructCreature::AddExp( exp, jp );
}

void StructSummon::onExpChange()
{
	int nLevel = 1;
	int nJP = 0;

	int nMaxLevel = 0;
	int nEvolvableLevel = 0;

	switch( GetTransformLevel() )
	{
	case SummonBase::EVOLVE_NORMAL:
		nMaxLevel = GameRule::NORMAL_SUMMON_MAX_LEVEL;
		nEvolvableLevel = GameRule::NORMAL_SUMMON_EVOLVE_LEVEL;
		break;
	case SummonBase::EVOLVE_GROWTH:
		nMaxLevel = GameRule::GROWTH_SUMMON_MAX_LEVEL;
		nEvolvableLevel = GameRule::GROWTH_SUMMON_EVOLVE_LEVEL;
		break;
	case SummonBase::EVOLVE_EVOLVE:
		nMaxLevel = GameRule::EVOLVE_SUMMON_MAX_LEVEL;
		nEvolvableLevel = nMaxLevel;
		break;
	}

	// 레벨업 처리 전에 m_nMaxReachedLevel(기존 도달 최대 레벨-렙다 후 렙업시 jp획득 방지용)을 확인
	if( m_nMaxReachedLevel < m_nLevel )
		m_nMaxReachedLevel = m_nLevel;

	while( true )
	{
		if( nLevel >= nMaxLevel ) break;

		// 레벨업에 필요한 경험치 테이블 검사로 레벨업 가능한 모든 구간을 처리
		__int64 nNeedExp = GameContent::GetNeedSummonExp( nLevel );

		if( nNeedExp == 0 )
			break;

		if( nNeedExp > m_nEXP )
			break;

		++nLevel;

		if( m_nMaxReachedLevel < nLevel )
		{
			++nJP;

			// 오버브리드의 경우에는 JP를 1개 더 줌
			if( nLevel > nEvolvableLevel )
				++nJP;
		}
	}

	if( GetMaster() )
		SendExpMsg( GetMaster(), this );

	if( nLevel && nLevel != m_nLevel )
	{
		__int64 nCardUID = 0;

		if( GetParentCard() )
		{
			nCardUID = GetParentCard()->GetItemUID();
		}

		LOG::Log11N4S( LM_SUMMON_LEVEL_UP, GetMaster()->GetAccountID(), GetMaster()->GetSID(), GetSID(), m_nLevel, nLevel, GetPrevJobLevel( 0 ), GetPrevJobLevel( 1 ), GetJobId(), m_nJobPoint, ( nLevel > m_nLevel ) ? nJP : 0, nCardUID, GetMaster()->GetAccountName(), LOG::STR_NTS, GetMaster()->GetName(), LOG::STR_NTS, GetName(), LOG::STR_NTS, GetSummonName(), LOG::STR_NTS );

		if( nLevel > m_nLevel )
		{
			int prev_hp = GetHP();
			int prev_mp = GetMP();

			m_nJobLevel = m_nLevel = nLevel;
			m_nJobPoint += nJP;

			if( m_nMaxReachedLevel < m_nLevel )
				m_nMaxReachedLevel = m_nLevel;

			CalculateStat();

			if( !IsDead() )
			{
				m_nHP = m_nMaxHP;
				m_nMP = m_nMaxMP;
			}

			if( IsInWorld() )
			{
				BroadcastHPMPMsg( this, m_nHP - prev_hp, m_nMP - prev_mp );
			}
			else if( GetMaster() )
			{
				SendHPMPMsg( GetMaster(), this, m_nHP - prev_hp, m_nMP - prev_mp );
			}

			if( GetMaster() )
				SendPropertyMessage( GetMaster(), GetHandle(), "jp", m_nJobPoint );
		}
		else
		{
			m_nJobLevel = m_nLevel = nLevel;

			CalculateStat();
		}

		DBQuery( new DB_UpdateSummon( this ) );

		if( GetParentCard() && GetMaster() )
			SendItemMessage( GetMaster(), GetParentCard() );

		if( IsInWorld() )
			BroadcastLevelMsg( this );
		if( GetMaster() )
			SendLevelMsg( GetMaster(), this );
	}
}

void StructSummon::onEnergyChange()
{
	TS_SC_ENERGY msg;
	msg.handle = GetHandle();
	msg.energy = GetEnergyCount();

	if( IsInWorld() )
	{
	ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
}
	else if( GetMaster() )
	{
		PendMessage( GetMaster(), &msg );
	}
}

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


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

int StructSummon::GetSummonNameId()
{
	return m_pContentInfo->name_id;
}

const char*		StructSummon::GetName() const
{
	return m_szName;
}

int StructSummon::GetSummonCode()
{
	return m_pContentInfo->uid;
}

int StructSummon::GetSummonType()
{
	if( m_nChangingGroup != CREATURE_NONE )
		return m_nChangingGroup;

	return m_pContentInfo->type;
}

int StructSummon::GetSummonElementalType()
{
	return m_pContentInfo->magic_type;
}

bool StructSummon::SetSummonInfo( unsigned idx )
{
	m_pContentInfo = GameContent::GetSummonInfo( idx );

	m_nTransformLevel = m_pContentInfo->evolve_type;

	m_nJob = idx;

	return true;
}

int StructSummon::GetJobDepth() const
{
	return GetTransformLevel()-1;
}

void StructSummon::SetName( const char *szName )
{
	s_strcpy( m_szName, _countof( m_szName ), szName );
}

StructSummon::StructSummon( AR_HANDLE handle, unsigned idx )
{
	m_hHandle = handle;

	m_nAccountId = 0;
	m_nLastProcessTime = 0;

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

	m_nTransformLevel = 0;

	SetSummonInfo( idx );

	m_nStatus = 0;

	m_nSP = m_nMaxSP = 1000;
	m_fMaxSPAmplifier = 0.0f;
	m_fSPRegenAddAmplifier = 0.0f;

	m_bIsSummoned = false;

	m_bIsRidable = true;
	
	m_pMaster = 0;
	m_pItem = NULL;

	m_nSID = 0;

	m_nJobLevel = m_nLevel = m_nMaxReachedLevel = 1;

	m_cSlotIndex = 0;

	m_nMaxItemWear = 2;

	memset( m_szName, 0, sizeof(m_szName) );

	//ArcadiaServer::Instance().SetObjectPriority( this, ArObject::UPDATE_PRIORITY_NORMAL );

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

	m_nLastCantAttackTime = 0;
	m_nSPRegenAdd = 0;

#ifdef _MEM_USAGE_DEBUG
	XSEH::IncreaseAllocCount( "StructSummon" );
#endif
}

StructSummon::~StructSummon()
{
	if( IsInWorld() ) 
	{
		ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( this ) );
		RemoveSummonFromWorld( this );
	}

#ifdef _MEM_USAGE_DEBUG
	XSEH::DecreaseAllocCount( "StructSummon" );
#endif
}

bool StructSummon::ProcDelete()
{
	FreeSummon( this );

	return true;
}

bool StructSummon::IsUsingBow() const
{
	for( int i = 0 ; i < m_nMaxItemWear ; ++i )
	{
		if( m_anWear[i] && m_anWear[i]->IsBow() )
			return true;
	}

	return false;
}

bool StructSummon::IsUsingCrossBow() const
{
	for( int i = 0 ; i < m_nMaxItemWear ; ++i )
	{
		if( m_anWear[i] && m_anWear[i]->IsCrossBow() )
			return true;
	}

	return false;
}

bool StructSummon::TranslateWearPosition( ItemBase::ItemWearType & pos, struct StructItem* pItem, std::vector< int > * vpOverlappItemList)
{
	struct StructItem* pWearedItem;
	if( !StructCreature::TranslateWearPosition( pos, pItem, vpOverlappItemList ) ) return false;

	//AziaMafia PetSlot Off PetCardMode
	//if( !pItem->GetInstanceFlag().IsOn( ItemInstance::ITEM_FLAG_CARD ) ) return false;
	

	if( pos > ItemBase::MAX_ITEM_WEAR || pos < 0 )
	{
		return false;
	}

	// 날아온 포지션은 쌩깐다.
	if( pos == (ItemBase::ItemWearType) ItemBase::MAX_ITEM_WEAR )
	{
		// 아티팩트 아이템은 4번째 슬롯부터 장착할 수 있다.
		if( pItem->IsArtifact() )
		{
			// 같은 계열의 소환수일 때만 장착 가능 (단, 아티팩트의 소환수코드가 없으면 모든 크리쳐용 아티팩트)
			int nSummonCode = pItem->GetSummonCode();
			if( nSummonCode )
			{
				int nJobId = GetPrevJobId( 0 );
				if( !nJobId ) nJobId = GetJobId();
				if( nJobId != nSummonCode )
					return false;
			}
		}

		//AziaMafia PetSlot
		for( int i = 0; i < StructSummon::SUMMON_MAX_ITEM_WEAR; ++i )
		{
			switch ( i )
			{
			case 0: 
			{
				if (!pItem->IsSkin1())
					continue;
			}
			break;

			case 1: 
			case 2:
			case 6:
			case 7:
			case 8:
			case 14:
			{
				if (!pItem->IsWeapon() 
					&& !pItem->IsArmor() 
					&& !pItem->IsHelmet() 
					&& !pItem->IsGloves() 
					&& !pItem->IsBoots() 
					&& !pItem->IsShield()
					// && !pItem->IsBelt()
					)
					continue;
			}
				  break;
			case 3:
			case 9:
			case 11:
			case 13:
			{
				if (!pItem->IsEarRing() 
					&& !pItem->IsRing() 
					&& !pItem->IsAmulet() 
					&& !pItem->IsBelt()
					)
					continue;
			}
			break;
			case 4:
			case 5:
			case 10:
			case 12:
			{
				if (!pItem->IsArtifact())
					continue;
			}
			break;
			}

			pWearedItem = m_anWear[i];

			//AziaMafia PetSlot
			//if (!pItem->IsArtifact() && pWearedItem && pWearedItem->GetItemGroup() == pItem->GetItemGroup())
			if ( ( pItem->IsEarRing() || pItem->IsRing() || pItem->IsAmulet() || pItem->IsBelt() ) && pWearedItem && pWearedItem->GetItemClass() == pItem->GetItemClass() )
				return false;
			
			if (!pItem->IsArtifact() && !pItem->IsEarRing() && !pItem->IsRing() && !pItem->IsAmulet() && !pItem->IsBelt() && pWearedItem && pWearedItem->GetItemGroup() == pItem->GetItemGroup())
				return false;


			if( pWearedItem == pItem )
				return false;

			if( !pWearedItem && pos == ItemBase::MAX_ITEM_WEAR )
			{
				pos = (ItemBase::ItemWearType) i;
				break;
			}
		}
	}
	else if( pos >= m_nMaxItemWear )
	{
		return false;
	}
	else if( vpOverlappItemList )
	{
		// 장착 위치에 무언가 입고 있다면
		if( m_anWear[ pos ] )
		{
			vpOverlappItemList->push_back( pos );
		}
	}


	if (pos >= m_nMaxItemWear)
	{
		return false;
	}

	return true;
}


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

__int64	StructSummon::GetDeadEXPPenalty()
{
	return GameContent::GetNeedSummonExp( GetLevel() ) * ( 0.15 / ( GetLevel() - 1 ) + 0.0005 );
}

bool StructSummon::IsEXPLimitReached()
{
	__int64 exp_limit = 0;

	exp_limit = GameContent::GetNeedSummonExp( GameRule::nMaxCreatureLevel ) - 1;

	return ( exp_limit <= m_nEXP );
}

void StructSummon::onDead( StructCreature *pFrom, bool decreaseEXPOnDead )
{
	StructPlayer * pMaster = GetMaster();

	if( pMaster->IsRiding() && pMaster->GetRideObject() == this )
	{
		pMaster->UnMount( StructPlayer::UNMOUNT_FALL, pFrom );
	}

	StructCreature::onDead( pFrom, decreaseEXPOnDead );

	StructPlayer * pKiller = NULL;

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

	char * szKillerType = "UNKN";
	int nKillerID = 0;

	if( pFrom->IsPlayer() )		{ szKillerType = "PLYR"; nKillerID = static_cast< StructPlayer* >( pFrom )->GetPlayerUID(); }
	if( pFrom->IsMonster() )	{ szKillerType = "MNST"; nKillerID = static_cast< StructMonster* >( pFrom )->GetMonsterId(); }
	if( pFrom->IsSummon() )		{ szKillerType = "SUMN"; nKillerID = static_cast< StructSummon* >( pFrom )->GetSummonSID(); }	

	__int64 nLostExp = 0;

	// 대련 중에 범위 스킬 등으로 플레이어가 죽은 직후 소환수가 같이 죽으면
	// 주인의 CompeteID는 0이지만 대련 중의 사망이었으므로 페널티 안 받게 주인이 대련 사망 상태인지도 체크해야 함
	if( ( !pMaster->IsInBattleArena() && !pMaster->IsInDeathmatch() && !pMaster->IsInBattleField() && !pMaster->IsInStartedCompete( true ) && !( pMaster->IsDead() && pMaster->IsCompeteDead() ) ) || !pKiller )
	{
		if( pKiller && pKiller != pMaster )
		{
			pMaster->ProcImmoralPoint( pKiller, 0, false );
		}


		if( GetLevel() > 5 && pFrom->IsMonster() && !pMaster->IsInSiegeOrRaidDungeon() && !pMaster->IsInBattleField() && decreaseEXPOnDead )
		{
			//Azia MAfia FIX Loose XP
			nLostExp = GetDeadEXPPenalty();

			SetEXP( GetEXP() - nLostExp );
		}

		// 장착 중인 아이템의 에테리얼 내구도 감소 처리(던전 시즈/레이드는 예외)
		if( !pMaster->IsInSiegeOrRaidDungeon() )
		{
			// 몬스터에게 죽은 경우나 주인에 의한 자살일 때 장착 중인 아이템의 에테리얼 내구도 감소 처리
			if( (!pKiller || pKiller == pMaster) && !GameRule::bItemDurabilitySwitch)	// Credits to AziaMafia: Durability consumption switch
			{
				bool bNeedToCalculateStat = false;

				for( int i = 0 ; i < m_nMaxItemWear ; ++i )
				{
					StructItem * pItem = m_anWear[ i ];

					if( !pItem || !pItem->GetMaxEtherealDurability() || !pItem->GetCurrentEtherealDurability() )
						continue;

					// 최대 내구도의 10% 감소(곱하기 상수화하면 소수자리 오차 발생하므로 나누기 정수 연산으로 적용함)
					int nDecrement = pItem->GetMaxEtherealDurability() / 10;

					pItem->AddCurrentEtherealDurability( nDecrement * -1 );
					SendItemMessage( pMaster, pItem );

					bNeedToCalculateStat |= ( pItem->GetCurrentEtherealDurability() == 0 );
				}

				if( bNeedToCalculateStat )
					CalculateStat();
			}

			// 몬스터에게 죽은 경우나 주인 이외의 플레이어에 의해 죽었을 때 강화 크리처의 내구도 감소
			GetParentCard()->SetInstanceFlagOff( ItemInstance::ITEM_FLAG_SUMMON_DURABILITY );
			if( (!pKiller || pKiller != pMaster ) && !GameRule::bItemDurabilitySwitch)	// Credits to AziaMafia: Durability consumption switch
			{
				if( GetParentCard()->GetItemEnhance() != 0 )
				{
					GetParentCard()->SetInstanceFlagOn( ItemInstance::ITEM_FLAG_SUMMON_DURABILITY );
					GetParentCard()->SetCurrentEtherealDurability( GetParentCard()->GetCurrentEtherealDurability() - 1 );
					SendItemMessage( this->GetMaster(), GetParentCard() );
				}
			}
		}
	}

	//Azia MAfia FIX Loose XP
	SetLastDecreasedEXP(nLostExp);
	//SetLastDecreasedEXP( 0 );

	ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_NORMAL );
	LOG::Log11N4S( LM_SUMMON_DEATH, pMaster->GetAccountID(), pMaster->GetSID(), GetSID(), nKillerID, nLostExp, 0, 0, 0, GetX(), GetY(), GetEXP(), pMaster->GetAccountName(), LOG::STR_NTS, pMaster->GetName(), LOG::STR_NTS, GetName(), LOG::STR_NTS, szKillerType, LOG::STR_NTS );
}

void StructSummon::onJPChange()
{
	SendPropertyMessage( this->GetMaster(), GetHandle(), "jp", GetJobPoint() );
}

void StructSummon::onRegisterSkill( int skill_uid, int skill_id, int skill_level, bool is_new_skill )
{
	if( is_new_skill )
	{
		// 새로 배우는거면 insert
		DBQuery( new DB_InsertSkill( this, skill_uid, 0, 0/*JP*/, GetSummonSID(), skill_id, skill_level, 0 ) );
	}
	else
	{
		// 아니면 update
		DBQuery( new DB_UpdateSkill( this, skill_uid, skill_level, GetRemainCoolTime( skill_id ) ) );
	}

	::SendSkillMessage( GetMaster(), this, skill_id );
}

__int64 StructSummon::getJPAfterSkillReset()
{
	int nJP = m_nMaxReachedLevel;

	// 강화 크리처의 추가 잡포인트
	if( GetParentCard() )
		nJP += GameContent::GetCreatureEnhanceInfo( GetParentCard()->GetItemEnhance() )->jp_addition;

	// 오버 브리드 레벨 계산
	switch( GetTransformLevel() )
	{
	case SummonBase::EVOLVE_EVOLVE:
		{
			// 2차 진화시 오버브리드 JP 처리
			int nEvolveLevel = GetPrevJobLevel( 1 );
			nJP += ( nEvolveLevel > GameRule::GROWTH_SUMMON_EVOLVE_LEVEL ) ? nEvolveLevel - GameRule::GROWTH_SUMMON_EVOLVE_LEVEL : 0;
			// 1차 진화시 오버브리드 JP 처리
			nEvolveLevel = GetPrevJobLevel( 0 );
			nJP += ( nEvolveLevel > GameRule::NORMAL_SUMMON_EVOLVE_LEVEL ) ? nEvolveLevel - GameRule::NORMAL_SUMMON_EVOLVE_LEVEL : 0;
		}
		break;
	case SummonBase::EVOLVE_GROWTH:
		{
			// 1차 진화시 오버브리드 JP 처리
			int nEvolveLevel = GetPrevJobLevel( 0 );
			nJP += ( nEvolveLevel > GameRule::NORMAL_SUMMON_EVOLVE_LEVEL ) ? nEvolveLevel - GameRule::NORMAL_SUMMON_EVOLVE_LEVEL : 0;
			// 현재 오버브리드 진행 중일 경우 JP 처리
			nJP += ( m_nMaxReachedLevel > GameRule::GROWTH_SUMMON_EVOLVE_LEVEL ) ? m_nMaxReachedLevel - GameRule::GROWTH_SUMMON_EVOLVE_LEVEL : 0;
		}
		break;
	case SummonBase::EVOLVE_NORMAL:
		{
			// 현재 오버브리드 진행 중일 경우 JP 처리
			nJP += ( m_nMaxReachedLevel > GameRule::NORMAL_SUMMON_EVOLVE_LEVEL ) ? m_nMaxReachedLevel - GameRule::NORMAL_SUMMON_EVOLVE_LEVEL : 0;
		}
		break;
	default:
		break;
	}

	return nJP;
}

int	StructSummon::IsLearnableSkill( int nSkillID, int nSkillLevel, int *nSkillTreeID )
{
	int nResult = RESULT_ACCESS_DENIED;

	// 우선 전 진화 단계에서 배울 수 있는 스킬 트리로 한번 검색해주고.
	for( int i = 0 ; i < 2 && ( nResult == RESULT_ACCESS_DENIED || nResult == RESULT_LIMIT_MAX || nResult == RESULT_NOT_ENOUGH_JOB_LEVEL ) ; ++i )
	{
		int nSummonID = GetPrevJobId( i );
		if( !nSummonID )
			continue;

		const SummonBase *pBase = GameContent::GetSummonInfo( nSummonID );
		if( !pBase )
			continue;
		int nLevel = GetPrevJobLevel( i );

		for( int j = 0 ; j < 5 ; ++j )
		{
			if( !pBase->skill_tree_id[ j ] )
				continue;

			nResult = GameContent::isLearnableSkill( this, nSkillID, nSkillLevel, pBase->skill_tree_id[ j ], nLevel );
			if( nResult == RESULT_SUCCESS )
			{
				*nSkillTreeID = pBase->skill_tree_id[ j ];
				break;
			}
		}
	}

	// 전 진화단계에서 못 찾았다면 현재 소환수 코드로 한번 더 검색 (단 ERROR 조건이 밑 3개가 아니라면 검사할 필요가 없음.)
	if( nResult == RESULT_ACCESS_DENIED || nResult == RESULT_LIMIT_MAX || nResult == RESULT_NOT_ENOUGH_JOB_LEVEL )
	{
		const SummonBase *pBase = GameContent::GetSummonInfo( GetJobId() );
		if( !pBase )
			return nResult;

		int nLevel = GetJobLevel();

		for( int i = 0 ; i < 5 ; ++i )
		{
			if( !pBase->skill_tree_id[ i ] )
				continue;

			nResult = GameContent::isLearnableSkill( this, nSkillID, nSkillLevel, pBase->skill_tree_id[ i ], nLevel );
			if( nResult == RESULT_SUCCESS )
			{
				*nSkillTreeID = pBase->skill_tree_id[ i ];
				break;
			}
		}
	}

	return nResult;
}

void StructSummon::onResetSkill( const int jobDepth )
{
	GetMaster()->Save();

	::SendSkillMessage( GetMaster(), this, -1, true );
}

void StructSummon::onRemoveSkill( StructSkill* removedSkill )
{
	DBQuery( new DB_DeleteSkill( this, removedSkill->GetSkillUID() ) );
}

void StructSummon::procMoveSpeedChangement()
{
	if( !IsMoving() )
		return;

	ArPosition pos = GetCurrentPosition( GetArTime() );

	// 이동 불가가 되었다면 현재 위치에 정지
	if( !IsMovable() )
	{
		ArcadiaServer::Instance().SetMove( this, pos, pos, 0, true, GetArTime() );
	}
	// 이동 중이었고 이동 가능 상태라면 현재 이동 속도와 스텟상의 이동 속도가 다를 경우 다시 이동 시킴
	else
	{
		unsigned char nSpeed = GetRealMoveSpeed();

		// 라이딩 소환수여서 주인이 타고 있는 상태라면 라이딩 이속 적용
		StructPlayer * pMaster = GetMaster();
		if( pMaster && pMaster->IsRiding() && pMaster->GetRideObject() == this )
		{
			nSpeed = pMaster->GetRealRidingSpeed();
		}
		// 라이딩 상태가 아니라면 주인과 이속 싱크 상태(onMoveRequest에서 pMsg->speed_sync 처리 참조)에 대한 처리를 해야 하지만
		// 현재 이동 중인 속도가 싱크에 의한 이속인지 아닌지 알 수가 없으므로 여기서는 그냥 스텟상 고유 이속으로 이동되도록 함
		// (이 위치는 이동 중에 버프가 걸리거나 풀리는 경우만이므로 그런 이속 증폭의 혜택을 못 받는 걸로 무마!)

		if( GetSpeed() != nSpeed )
		{
			const std::vector< ArMoveVector::MOVE_INFO > & vMoveVector( GetTargetPosList() );
			std::vector< ArPosition > vMovePos;

			for( std::vector< ArMoveVector::MOVE_INFO >::const_iterator it = vMoveVector.begin() ; it != vMoveVector.end() ; ++it )
				vMovePos.push_back( (*it).end );

			ArcadiaServer::Instance().SetMultipleMove( this, pos, vMovePos, nSpeed, true, GetArTime() );
		}
	}
}

void StructSummon::onAfterRemoveState( StructState & state, const bool bByDead )
{
	// 부활에 의한 지속효과 복구 기능을 구현하려면 bByDead가 true일 경우에 만료 처리를 하지 않고 DB에 저장하도록 해야한다.
	// StructPlayer의 onAfterRemoveState 참조
	state.Expire( this );

	SetNeedToUpdateState();

	StructCreature::onAfterRemoveState( state );
}

void StructSummon::onUpdateState( StructState & state, bool bIsExpire )
{
	if( GetMaster() && GetMaster()->IsInWorld() )
	{
		SendStateMessage( GetMaster(), GetHandle(), &state, bIsExpire );
	}

	StructCreature::onUpdateState( state, bIsExpire );

	if( state.GetBaseEffectID() && this->GetPriority() < ArSchedulerObject::UPDATE_PRIORITY_HIGH )
	{
		ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_HIGH );
	}
}

void StructSummon::onChangeProperty( const std::string & strKey, const char *data )
{
	const char *szKey = strKey.c_str();

	if( !_stricmp( szKey, "lv" ) || !_stricmp( szKey, "level" ) )
	{
		// m_nLevel은 이미 증가된 상태이므로 잡 포인트 획득 및 기타 처리가
		// 정상적으로 onExpChange에서 이루어지지 않게 됨
		// 명령어에 의해서만 프로퍼티가 변경되므로 그냥 1에서 업한 것처럼 처리
		m_nLevel = 0;
		SetEXP( ( atoi(data) > 1 ) ? GameContent::GetNeedSummonExp( atoi(data) - 1 ) : 0 );

		return;
	}
	else if( !_stricmp( szKey, "exp" ) )
	{
		onExpChange();

		return;
	}
	else if( !_stricmp( szKey, "hp" ) )
	{
		BroadcastHPMPMsg( this, atoi( data ), 0 );

		return;
	}
	else if( !_stricmp( szKey, "mp" ) )
	{
		BroadcastHPMPMsg( this, 0, atoi( data ) );

		return;
	}

	SendPropertyMessage( GetMaster(), GetHandle(), szKey, GetAsString( szKey ).c_str() );
}

void StructSummon::DBQuery( GameDBManager::DBProc *pWork )
{
	THREAD_SYNCRONIZE( m_bQueryLock );

	if( m_lQueryList.empty() )
	{
		DB().Push( pWork );
	}

	m_lQueryList.push_back( pWork );
}

void StructSummon::onEndQuery()
{
	THREAD_SYNCRONIZE( m_bQueryLock );

	m_lQueryList.pop_front();

	if( !m_lQueryList.empty() )
	{
		DB().Push( m_lQueryList.front() );
	}
}

bool StructSummon::IsDeleteable()
{
	THREAD_SYNCRONIZE( m_bQueryLock );

	// 스케쥴러에 등록되어 있으면 삭제 불가 && 다른 쓰레드에서 참조중이면 삭제 불가
	if( !GameObject::IsDeleteable() ) return false;

	// DB 쿼리 미결된게 있다면 삭제 불가
	if( !m_lQueryList.empty() ) return false;

	return true;
}

bool StructSummon::IsEnemy( StructCreature* pTarget, bool bIncludeHiding )
{
	return GetMaster()->IsEnemy( pTarget, bIncludeHiding );
}

bool StructSummon::IsVisible( StructCreature *pTarget )
{
	StructPlayer * pMaster = GetMaster();
	return ( pMaster ) ? pMaster->IsVisible( pTarget ) : StructCreature::IsVisible( pTarget );
}

bool StructSummon::IsSkillCastable()
{
	if( IsRidable() && GetMaster() && GetMaster()->GetRideObject() == this ) return false;

	return StructCreature::IsSkillCastable();
}

bool StructSummon::IsMagicCastable()
{
	if( IsRidable() && GetMaster() && GetMaster()->GetRideObject() == this ) return false;

	return StructCreature::IsMagicCastable();
}

ItemBase::ItemWearType StructSummon::GetAbsoluteWearPos( ItemBase::ItemWearType & pos )
{
	if( pos < ItemBase::MAX_ITEM_WEAR && pos >= 0 )
	{
		for( int i = 0; i < ItemBase::MAX_ITEM_WEAR; ++i )
		{
			if( !m_anWear[i] ) continue;

			ItemBase::ItemWearType type = m_anWear[i]->GetWearType();

			if( type == pos )
			{
				return static_cast< ItemBase::ItemWearType >( i );
			}

			if( type == ItemBase::WEAR_TWOFINGER_RING && pos == ItemBase::WEAR_RING )
			{
				return static_cast< ItemBase::ItemWearType >( i );
			}

			if( type == ItemBase::WEAR_TWOHAND && pos == ItemBase::WEAR_WEAPON )
			{
				return static_cast< ItemBase::ItemWearType >( i );
			}

			if( type == ItemBase::WEAR_SUMMON_ONLY && i == pos )
			{
				return static_cast< ItemBase::ItemWearType >( i );
			}
		}
	}

	return static_cast< ItemBase::ItemWearType >( -1 );
}

struct StructItem* StructSummon::GetWearedItem( ItemBase::ItemWearType idx ) const
{
	if( idx < ItemBase::MAX_ITEM_WEAR && idx >= 0 )
	{
		for( int i = 0; i < ItemBase::MAX_ITEM_WEAR; ++i )
		{
			if( !m_anWear[i] ) continue;

			ItemBase::ItemWearType type = m_anWear[i]->GetWearType();

			if( type == idx )
			{
				return m_anWear[i];
			}

			if( type == ItemBase::WEAR_TWOFINGER_RING && idx == ItemBase::WEAR_RING )
			{
				return m_anWear[i];
			}

			if( type == ItemBase::WEAR_TWOHAND && idx == ItemBase::WEAR_WEAPON )
			{
				return m_anWear[i];
			}

			if( type == ItemBase::WEAR_SUMMON_ONLY && i == idx )
			{
				return m_anWear[i];
			}
		}
	}

	return NULL;
}

struct StructItem* StructSummon::GetSummonWearedItem(ItemBase::ItemWearType idx) const
{
	if (idx < ItemBase::MAX_ITEM_WEAR && idx >= 0)
		return m_anWear[idx];

	return NULL;
}

void StructSummon::ProcEtherealDurabilityConsumption( const bool bIsAttacker, const DamageType eDamageType, const int nDamage )
{
	// 실제 소모량 = (기본 소모량) * (소모율) * (상황에 따른 소모율)

	// 기본 소모량
	const int nBaseConsumption = GameRule::GetEtherealDurabilityBaseConsumption( bIsAttacker, eDamageType );

	// 기본 소모량이 0이면 소모율과 상황에 다른 소모율이 몇이어도 소모되지 않음
	if( !nBaseConsumption )
		return;

	// 소모율(계산값)
	c_fixed10 fConsumeRate( GameRule::GetEtherealDurabilityConsumeRate( GetLevel(), GetJobId(), bIsAttacker, nDamage ) );

	// 상황에 따른 보정치(기본값 100%)
	c_fixed10 fEnvironmentalConsumeRate( 1 );

	StructPlayer * pMaster = GetMaster();
	// 상태에 따른 소모율 계산(소환수 자신은 관계 없고 주인의 상태를 따름)
	if( pMaster && pMaster->IsInWorld() )
	{
		// 대련 상대끼리나 데스매치 존, 배틀아레나 안에서는 5%(대련 상대가 아닌 대상에게 피격당할 경우 대련 상태가 풀리므로 별도 체크 안 함)
		// 본래대로라면 대련이 시작된 이후, 즉 IsInStartedCompete() 함수로 체크해야 하나 매 공격마다 체크하기엔 부하가 있으므로 일단 예외로 둠
		if( pMaster->GetCompeteID() || pMaster->IsInDeathmatch() || pMaster->IsInBattleArena() )
			fEnvironmentalConsumeRate = GameRule::ETHEREAL_DURABILITY_ENVIRONMENTAL_CONSUME_RATE_ON_PVP;
		// PK On 상태면 200%
		else if( pMaster->IsPKOn() || pMaster->IsPKOffing() )
			fEnvironmentalConsumeRate = GameRule::ETHEREAL_DURABILITY_ENVIRONMENTAL_CONSUME_RATE_ON_PK;
	}

	// 장착된 아이템에 에테리얼 내구도 감소 적용
	bool bNeedToCalculateStat = false;
	for( int i = 0 ; i < m_nMaxItemWear ; ++i )
	{
		static __declspec( thread ) StructItem * pItemForDebugging;
		StructItem * pItem = m_anWear[ i ];

		pItemForDebugging = pItem;

		// 아이템이 없거나 공격 시인데 무기가 아니거나 피격 시인데 무기면 패스
		if( !pItem || bIsAttacker != pItem->IsWeapon() )
			continue;

		if( !pItem->ProcEtherealDurabilityConsumption( nBaseConsumption, fConsumeRate, fEnvironmentalConsumeRate ) )
			continue;

		if( pMaster && pMaster->IsInWorld() )
			SendItemMessage( pMaster, pItem );

		// 새로 파괴된 아이템이 있으면 스텟 재 계산
		if( !pItem->GetCurrentEtherealDurability() )
		{
			StructPlayer *pPlayer = GetMaster();
			if( pPlayer )
			{
				LOG::Log11N4S( LM_ITEM_ETHEREAL_EXHAUST, 
					pPlayer->GetAccountID(), pPlayer->GetSID(), // N1, N2
					pItem->GetItemEnhance() * 100 + pItem->GetItemLevel(), pItem->GetItemCode(), // N3, N4
					GetSID(), 0, 0, pItem->GetMaxEtherealDurability(), // N5, N6, N7, N8
					GetX(), GetY(), pItem->GetItemUID(), // N9, N10, N11
					pPlayer->GetAccountName(), LOG::STR_NTS,
					pPlayer->GetName(), LOG::STR_NTS,
					GetName(), LOG::STR_NTS,
					bIsAttacker?"ATTACKING":"BEING_ATTACKED", LOG::STR_NTS );
			}
			bNeedToCalculateStat = true;
		}
	}

	// 스텟 재계산이 필요할 경우 재계산
	if( bNeedToCalculateStat )
		CalculateStat();
}

unsigned short StructSummon::putonItem( ItemBase::ItemWearType pos , struct StructItem * pItem )
{
	StructPlayer *pMaster = GetMaster();

	//AziaMafia PetSlot
	//if (!pMaster || !pMaster->IsInWorld() || !pMaster->IsLoginComplete() || !pItem->GetInstanceFlag().IsOn(ItemInstance::ITEM_FLAG_CARD))
	if( !pMaster || !pMaster->IsInWorld() || !pMaster->IsLoginComplete()  )
	{
		return RESULT_ACCESS_DENIED;
	}

	unsigned short nRet = StructCreature::putonItem( pos, pItem );
	if( nRet != RESULT_SUCCESS )
		return nRet;

	// floyd 2008. 7..3
	// http://bug.nflavor.com/view.php?id=3380 관련 문제를 수정하다가 StructCreate::putonItem에서 옮겨옴
	pItem->SetOwnSummonInfo( GetHandle(), GetSID() );

	// 아이템 착용에 의한 스크립트 실행
	if( !pItem->GetItemBase().strScript.empty() )
	{
		std::string strScript( pItem->GetItemBase().strScript );

		const char * pszProcScript = "on_equip_item";
		// 스크립트 내용에 on_equip_item이 있을 경우 파라미터 추가
		if( strstr( strScript.c_str(), pszProcScript ) )
		{
			// on_equip_item( 아이템 코드, 착용자 타입, 착용자 핸들, [소환수인 경우에만]Summon 코드값, [소환수인 경우에만]주인 핸들, 착용 위치 )
			std::string strOnEquipItem;
			XStringUtil::Format( strOnEquipItem, "on_equip_item( %d, %d, %u, %d, %u, %d )",
				pItem->GetItemCode(), StructItem::TARGET_TYPE_SUMMON, GetHandle(), GetSummonCode(), ( GetMaster() ) ? GetMaster()->GetHandle() : 0, pos );

			XStringUtil::Replace( strScript, pszProcScript, strlen( pszProcScript ), strOnEquipItem.c_str(), strOnEquipItem.length() );
		}

		// 일부 스크립트 함수에 의한 기능에서 대화 중인 NPC 핸들 값에 의해 제어되는 부분이 있으므로
		// 아이템에 의한 스크립트 실행 동안은 대화 중인 NPC 핸들을 0으로 설정함
		AR_HANDLE nContactNPCHandle = pMaster->GetContactNPCHandle();
		pMaster->SetContactNPCHandle( 0 );

		LUA()->RunString( strScript.c_str() );

		// 대화 중인 NPC 핸들 값을 원래대로 되돌림
		pMaster->SetContactNPCHandle( nContactNPCHandle );
	}

	// 착용된 아이템은 더 이상 무게에 포함되지 않으므로 뺀다
	if( m_anWear[ pos ] == pItem )
		pMaster->GetInventory()->AddWeightModifier( -pItem->GetWeight() );

	pMaster->UpdateWeightWithInventory();

	pMaster->UpdateQuestStatusByItemUpgrade();

	return RESULT_SUCCESS;
}

unsigned short StructSummon::putoffItem( ItemBase::ItemWearType pos )
{
	StructPlayer *pMaster = GetMaster();

	if( !pMaster || !pMaster->IsInWorld() || !pMaster->IsLoginComplete() )
	{
		return RESULT_ACCESS_DENIED;
	}

	if( !m_anWear[ pos ] )
		return RESULT_NOT_EXIST;

	StructItem *pItem = m_anWear[ pos ];

	// floyd 2008. 7..3
	// http://bug.nflavor.com/view.php?id=3380
	// 크리쳐가 착용했던 장비의 소환수 정보를 지워주지 않아서 드물지만 복잡한 프로세스를 거치면 캐릭터가 장비하고 있는데도, 크리쳐가 입고 있는 것으로 인식하게 됨
	pItem->SetOwnSummonInfo( 0, 0 );
	unsigned short nRet = StructCreature::putoffItem( pos );

	// 착용되지 않은 아이템은 무게에 다시 포함되어야 함
	if( m_anWear[ pos ] == NULL )
		pMaster->GetInventory()->AddWeightModifier( pItem->GetWeight() );

	pMaster->UpdateWeightWithInventory();

	pMaster->UpdateQuestStatusByItemUpgrade();

	return nRet;
}

bool StructSummon::DoEvolution( int nTargetCode )
{
	//ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( this ) );

	int prev_hp = GetHP();
	int prev_mp = GetMP();

	if( GetMaster()->IsRiding() && GetMaster()->GetRideObject() == this )
		return false;

	int nCurrentCode = m_pContentInfo->uid;
	int nCurrentLevel = GetLevel();

	if( nTargetCode == 0 )
	{
		if( m_pContentInfo->evolve_target != 0 )
			nTargetCode = m_pContentInfo->evolve_target;
		else
			return false;
	}

	SetSummonInfo( nTargetCode );

	CalculateStat();

	GetMaster()->Save();

	TS_SC_SUMMON_EVOLUTION msg;

	msg.summon_handle = GetHandle();			// 소환수 핸들
	msg.card_handle = GetParentCard()->GetHandle();
	s_strcpy( msg.name, _countof( msg.name ), GetName() );	// 소환수 이름
	msg.code = GetSummonCode();

	if( IsInWorld() )
	{
		ArcadiaServer::Instance().Broadcast( GetRX(), GetRY(), GetLayer(), &msg );
	}
	else if( GetMaster() )
	{
		PendMessage( GetMaster(), &msg );
	}

	if( !IsVisibleRegion( GetRX(), GetRY(), GetMaster()->GetRX(), GetMaster()->GetRY() ) )
	{
		PendMessage( GetMaster(), &msg );
	}

	SendStatInfo( GetMaster(), this );	// 소환수 스탯정보 얻어서
										// 보내주자

	SendHPMPMsg( GetMaster(), this, GetHP() - prev_hp, GetMP() - prev_mp );	// HP/MP
	SendLevelMsg( GetMaster(), this );	// 레벨
	SendExpMsg( GetMaster(), this );	// 경치

	SendSPMsg( GetMaster(), this );

	__int64 nCardUID = 0;

	StructItem * pItem = GetParentCard();
	if( pItem )
	{
		nCardUID = pItem->GetItemUID();

		int depth = GetTransformLevel();
		int i;
		for( i = 0; i < depth - 1; ++i )
		{
			pItem->SetSocketCode( i + 1, GetPrevJobLevel( i ) );
		}
		pItem->SetSocketCode( i + 1, GetLevel() );
		pItem->SetSummonCode( GetSummonCode() );
		pItem->DBQuery( new DB_UpdateItem( pItem ) );

		if( GetMaster() )
		{
			SendItemMessage( GetMaster(), GetParentCard() );
		}
	}

	LOG::Log11N4S( LM_SUMMON_EVOLUTION,	GetMaster()->GetAccountID(), 
		GetMaster()->GetSID(), GetSID(), 
		nCurrentCode, nTargetCode, 
		nCurrentLevel, GetPrevJobId( 0 ), 
		GetPrevJobLevel( 0 ), GetPrevJobId( 1 ),
		GetPrevJobLevel( 1 ), nCardUID, 
		GetMaster()->GetAccountName(), LOG::STR_NTS, 
		GetMaster()->GetName(), LOG::STR_NTS, 
		GetName(), LOG::STR_NTS, 
		"", 0 );

	return true;
}

bool StructSummon::Reborn()
{
	bool bSuccess = true;

	if( GetMaster()->IsRiding() && GetMaster()->GetRideObject() == this )
		return false;

	// 스킬 리셋부터 하고
	bSuccess = ResetSkill( SRM_SUMMON_ENHANCE );
	if( !bSuccess ) return bSuccess;

	int nTargetCode = m_nPrevJobId[0];
	if( !nTargetCode )
		nTargetCode = m_pContentInfo->uid;

	m_nEXP = 0;
	m_nTransformLevel = 1;
	m_nJobLevel = m_nLevel = m_nMaxReachedLevel = 1;
	m_nPrevJobId[0] = m_nPrevJobId[1] = m_nPrevJobId[2] = 0;
	m_nPrevJobLevel[0] = m_nPrevJobLevel[1] = m_nPrevJobLevel[2] = 0;
	m_nLastDecreasedEXP = 0;

	if( GetParentCard() )
	{
		GetParentCard()->SetInstanceFlagOff( ItemInstance::ITEM_FLAG_SUMMON_DURABILITY );
		for( int i = 1; i < ItemBase::MAX_SOCKET_NUMBER; ++i )
		{
			GetParentCard()->SetSocketCode( i, 0 );
		}
	}

	bSuccess = DoEvolution( nTargetCode );
	if( !bSuccess ) return bSuccess;

	// 크리쳐 강화의 경우 JP 보너스 추가가 있고 레벨이 1로 초기화되기 때문에 JP를 새로 계산해 반납해준다. 
	// 나중에 새로운 JP 계산 시스템이나 한두개의 스킬만 JP를 반납하는 등의 시스템이 생기면 
	// 아래 getJPAfterSkillReset 코드를 통해 고려해줘야한다.
	SetJP( getJPAfterSkillReset() );
	SetTalentPoint( getTPAfterSkillReset() );

	return bSuccess;
}

bool StructSummon::IsAlly( StructCreature *pTarget )
{
	return GetMaster()->IsAlly( pTarget );
}

int StructSummon::onDamage( StructCreature * pFrom, Elemental::Type elementalType, DamageType damageType, int nDamage, bool bCritical )
{
	StructPlayer * pMaster = GetMaster();

	if( ( pMaster->IsRiding() && pMaster->GetRideObject() == this )
		&& ( damageType == DT_NORMAL_PHYSICAL_DAMAGE || damageType == DT_NORMAL_MAGICAL_DAMAGE || damageType == DT_NORMAL_PHYSICAL_LEFT_HAND_DAMAGE || damageType == DT_NORMAL_PHYSICAL_SKILL_DAMAGE ) )
	{
		if( ( bCritical && XRandom() % 100 <= pMaster->GetUnMountProbabilityOnCriticalDamage() ) || XRandom() % 100 <= pMaster->GetUnMountProbabilityOnDamage() )
		{
			pMaster->UnMount( StructPlayer::UNMOUNT_FALL, pFrom );
		}
	}

	if( m_fSoulConnectionRatio && pMaster )
	{
		int nPassDamage = std::min( int( nDamage * m_fSoulConnectionRatio), pMaster->GetHP() );
		if( nPassDamage )
		{
			pMaster->damage( pFrom, nPassDamage );
			nDamage -= nPassDamage;

			// Master를 중심으로 VisibleRegion에 Lock이 걸려있다는 보장은 없으나 일단 대충;;
			// 이 부분이 문제가 될 경우 주인에게 락을 따로 걸고 데미지를 주기 위한 방법을
			// 강구해야 함
			BroadcastHPMPMsg( pMaster, 0 - nPassDamage, 0 );
		}
	}

	AR_TIME t = GetArTime();
	ArPosition pos = GetCurrentPosition( t );

	if( pMaster && pMaster->IsInStartedCompete( true ) )
	{
		StructPlayer * pAttackPlayer = NULL;
		if( pFrom->IsPlayer() )
			pAttackPlayer = static_cast< StructPlayer * >( pFrom );
		else if( pFrom->IsSummon() )
			pAttackPlayer = static_cast< StructSummon * >( pFrom )->GetMaster();

		if( !pAttackPlayer || pMaster->GetCompeteID() != pAttackPlayer->GetCompeteID() )
		{
			CompeteManager::Instance().RetireCompeteWithPlayer( pMaster, COMPETE_END_BY_INTERRUPT );
		}
	}

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

}

int StructSummon::GetCreatureGroup() const
{
	if( m_nChangingGroup != CREATURE_NONE )
		return m_nChangingGroup;

	return m_pContentInfo->type;
}

void StructSummon::onCantAttack( AR_HANDLE target, AR_TIME t )
{
	if( m_nLastCantAttackTime + 100 < t )
	{
		m_nLastCantAttackTime = t;

		SendCantAttackMsg( GetMaster(), GetHandle(), target, RESULT_TOO_FAR );
	}
}

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

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

int StructSummon::GetTransformLevel() const
{
	return m_pContentInfo->evolve_type;
}

int StructSummon::GetEvolveTarget() const
{
	return m_pContentInfo->evolve_target;
}

unsigned char StructSummon::GetRidingMoveSpeed()
{
	// 튼튼한 발굽 등의 라이딩 속도 증가 아이템이 크리처 라이딩에도 적용 될 수 있게 변경 (2013-12-20)
	return ( m_pContentInfo->riding_speed + GetMaster()->GetRideSpeedModifier() ) / 7.0 * m_fRideSpeedMod;
}

char StructSummon::GetRate() const
{
	return m_pContentInfo->rate;
}