error beim compilen der source (DNA System)

[Crowley™]

hey leute, bekomme folgenden error:

WorldServer fatal error LNK1120: 1 unaufgelöste externe Verweise
WorldServer error LNK2019: Nicht aufgelöstes externes Symbol '"public: int __thiscall CProject::LoadMonsterDNA(char const *)" (?LoadMonsterDNA@CProject@@QAEHPBD@Z)', verwiesen in Funktion '"public: int __thiscall CProject::OpenProject(char const *)" (?OpenProject@CProject@@QAEHPBD@Z)'

wäre nett wenn mir wer helfen könnte den error zu fixen.
mfg. Crowley

[Jopsi332]

du hast iwo ein #endif oder ein #ifdef zu viel / zuwenig

[Crowley™]

hm. habe schon alles durchgeguckt. hättest du vlt kurz zeit drauf zugucken?

[Lumi]

Zeig uns doch mal den Ausschnitt von Zeile 1208.

[Crowley™]

ja da ist nichts und da gehört auch nichts rein

hier die ganze datei:

#include "stdafx.h"
#include "DefineObj.h"
#include "defineSkill.h"
#include "ActionMover.h"
#include "User.h"
#include "defineitem.h"
#include "AttackArbiter.h"
#ifdef __MONSTER_WEAPON
#include "guild.h"
extern	CGuildMng			g_GuildMng;

extern	CUserMng			g_UserMng;
#include "party.h"
extern	CPartyMng	g_PartyMng;

#include "dpdatabaseclient.h"
extern	CDPDatabaseClient	g_dpDBClient;

#ifdef __EVENT_MONSTER
#include "EventMonster.h"
#endif // __EVENT_MONSTER

#if __VER >= 12 // __NEW_ITEMCREATEMON_SERVER
#include "CreateMonster.h"
#endif // __NEW_ITEMCREATEMON_SERVER

//////////////////////////////////////////////////////////////////////
// ATTACK_INFO
//////////////////////////////////////////////////////////////////////

ATK_TYPE ATTACK_INFO::GetAtkType() const
{
	ATK_TYPE type = ATK_GENERIC;

	if( dwAtkFlags & AF_MELEESKILL )
	{
		type = ATK_MELEESKILL;
	}
	else if( dwAtkFlags & AF_MAGICSKILL )
	{
		type = ATK_MAGICSKILL;
	}	
	else if( dwAtkFlags & AF_MAGIC )		// ÀÏ¹Ý ¿Ïµå °ø°Ý
	{
		type = ATK_MAGIC;
	}
	else if( dwAtkFlags & AF_FORCE )		// ¹Ý»ç µ¥¹ÌÁö°°Àº °æ¿ì 
	{
		type = ATK_FORCE;
	}

	return type;
}

// ¹æ¾î·Â ¹«½ÃÀÇ °æ¿ìÀΰ¡?
BOOL ATTACK_INFO::CanIgnoreDEF() const		
{
	int nSkill = GetSkill();
	switch ( nSkill )
	{
	case SI_BIL_PST_ASALRAALAIKUM :
		return TRUE;
	case SI_JST_YOYO_HITOFPENYA :
		return TRUE;
	}

	if( dwAtkFlags & AF_FORCE )		// ¹Ì¸®°è»ê µÈ µ¥¹ÌÁöÀÇ °æ¿ì, ¹æ¾î·Â ¹«½Ã (¿¹: ¹Ý»ç, »çÀÌű ¿ù)  
		return TRUE;
	return FALSE;
}

int ATTACK_INFO::GetChargeLevel() const 
{
	if( IsSkillAttack( dwAtkFlags ) )
		return 0;
	
	return ( nParam & 0xFF);			// ¿ÏµåÃæÀü·®
}

int ATTACK_INFO::GetSkillLevel() const 
{
	ASSERT( IsSkillAttack( dwAtkFlags ) );
	return ( nParam & 0xFF);	
}

int ATTACK_INFO::GetAttackCount() const 
{
	return ( nParam >> 8) & 0xFF;		// ÀÏ¹Ý 0, Áö¼Óµ¥¹ÌÁö 1ÀÌ»ó 
}

int ATTACK_INFO::GetSkill() const
{
	if( IsSkillAttack( dwAtkFlags ) )
		return ( nParam >> 16) & 0xFFFF;	// ½ºÅ³À̾ú´Ù¸é ½ºÅ³ID
	else
		return 0;
}

BOOL ATTACK_INFO::IsRangeAttack() const
{
	return ( dwAtkFlags & AF_RANGE );
}

//////////////////////////////////////////////////////////////////////
// CAttackArbiter
//////////////////////////////////////////////////////////////////////

CAttackArbiter::CAttackArbiter( DWORD dwMsg, CMover* pAttacker, CMover* pDefender, DWORD dwAtkFlags, int nParam, BOOL bTarget, int nReflect )
		: m_dwMsg( dwMsg ), 
		  m_pAttacker( pAttacker ), 
		  m_pDefender( pDefender ), 
		  m_dwAtkFlags( dwAtkFlags ), 
		  m_nParam( nParam ),
		  m_bTarget( bTarget ),
		  m_nReflect( nReflect )		  
{
#if __VER >= 11 // __REFLECTDMG_AFTER
	m_nReflectDmg = 0;
#endif // __REFLECTDMG_AFTER
}

CAttackArbiter::~CAttackArbiter()
{
}

int CAttackArbiter::OnDamageMsgW()
{
	if( !CheckValidDamageMsg() )
	{
/*	ºÒÇÊ¿äÇÑ ÄÚµå
#if __VER >= 8 // __S8_PK
		if( m_pAttacker->IsPlayer() && m_pDefender->IsPlayer() )
		{
			HITTYPE type = m_pAttacker->GetHitType( m_pDefender, m_bTarget, m_nReflect );
			if( type == HITTYPE_PK )
			{
				if( m_nReflect )
					return 0;
				
				if( m_pAttacker->IsChaotic() || m_pDefender->IsChaotic() )
					return 0;
#ifdef __JEFF_11_4
				CWorld* pWorld	= m_pDefender->GetWorld();
				if( pWorld && pWorld->IsArena() )
					return 0;
#endif	// __JEFF_11_4

				if( m_pDefender->IsPKPink() )
					m_pAttacker->SetPKPink( GetTickCount() + SEC(prj.m_PKSetting.nReadyAttack) );
				else
					m_pAttacker->SetPKPink( GetTickCount() + SEC(prj.m_PKSetting.nGeneralAttack) );
				g_UserMng.AddPKPink( m_pAttacker, 1 );
			}
		}
#endif // __VER >= 8 __S8_PK
*/
		return 0;
	}
	ATTACK_INFO info;
	info.dwAtkFlags = m_dwAtkFlags;
	info.pAttacker  = m_pAttacker;
	info.pDefender  = m_pDefender;
	info.nParam     = m_nParam;
	info.nParts     = PARTS_RWEAPON;

	int nDamage = 0;
	BYTE cbHandFlag	= GetHandFlag();
	for( BYTE cbFlag = 0x01; cbFlag <= 0x02; ++cbFlag )	
	{
		if( cbHandFlag & cbFlag )
		{
			info.nParts = (cbFlag & 0x01) ? PARTS_RWEAPON : PARTS_LWEAPON;
#ifdef __EVENTLUA_SPAWN
			if( m_pDefender->IsNPC() && prj.m_EventLua.IsEventSpawnMonster( m_pDefender->GetIndex() ) && !m_pAttacker->IsMode( ONEKILL_MODE ) )
			{
				nDamage = 1;
				continue;
			}
#endif // __EVENTLUA_SPAWN
#if __VER < 11 // __REMOVE_ENDURANCE
			m_pDefender->Abrade( m_pAttacker, info.nParts );
#endif // __REMOVE_ENDURANCE
			int n = CalcDamage( &info );					// µ¥¹ÌÁö¸¦ ±¸ÇÑ´Ù. (m_dwAtkFlagsµµ º¯°æµÉ ¼ö ÀÖ´Ù) 
			if( n > 0 )
			{
				ProcessAbnormal( n, &info );				// ½ºÅÏ, ¾ÏÈæ, µ¶, ¹Ý»ç »óÅÂó¸® 
#if __VER >= 9 // __ULTIMATE
				StealHP( n, info.GetAtkType() );								// ÈíÇ÷ 
#else // __ULTIMATE
				StealHP( n );								// ÈíÇ÷ 
#endif // __ULTIMATE
				nDamage += n;
			}
		}
	}

#if __VER >= 8 // __GUILDCOMBAT_85
	if( m_pAttacker->IsPlayer() && m_pDefender->IsPlayer() )
	{
		nDamage -= (nDamage * m_pDefender->GetParam( DST_PVP_DMG_RATE, 0) / 100);
#if __VER >= 9 // __CHAO_DMGDEC
		if( !m_pAttacker->IsGuildCombatTarget( m_pDefender ) )
		{
			int nDamageDecRate = m_pAttacker->GetPKValue() * 5;
			if( nDamageDecRate > 99 )
				nDamageDecRate = 99;
			nDamage -= (int)( nDamage * ( (float)nDamageDecRate/(float)100) );
		}
#endif // __CHAO_DMGDEC
	}
#endif // __VER >= 8
#ifdef __MONSTER_WEAPON
	if(info.pAttacker->bWeaponMonster)
	{
		MonsterDNA* pDNA = prj.m_aMonsterDNA.GetAt(info.pAttacker->GetIndex());

		if(pDNA)
		{
			nDamage *= (int)(pDNA->fAttackFactor * 10);
			if(nDamage < 0)
				nDamage = INT_MAX;
			nDamage /= 10;
		}
	}
#endif
	nDamage = max( nDamage, 1 );
	int nHP = MinusHP( &nDamage );							// HP °¨¼Ò ½ÃÅ´ 

#if __VER >= 14 // __INSTANCE_DUNGEON
	if( CMonsterSkill::GetInstance()->MonsterTransform( m_pDefender, nHP ) )
		return 0;
#endif // __INSTANCE_DUNGEON

	if( m_pDefender->m_pActMover->IsSit() )					// ¾É±âÇØÁ¦ & À̵¿À» ¸ØÃã 
		m_pDefender->m_pActMover->ResetState( OBJSTA_MOVE_ALL );
	m_pDefender->m_pActMover->SendActMsg( OBJMSG_STAND );	
	
	m_pDefender->OnAttacked( m_pAttacker, nDamage, m_bTarget, m_nReflect );		// °ø°ÝÀÚ ÇÇ°ÝÀÚ ÀúÀå, °æÇèÄ¡ Áö±ÞÀ² º¯°æ	
	if( nHP > 0 )
	{
		OnDamaged( nDamage );								// µ¥¹ÌÁö ¸ð¼Ç ÃëÇϱâ, µ¥¹ÌÁö Àü¼Û, ¹üÁËÀÚ¼³Á¤ 
		// MinusHP()¿¡¼* °¡Á®¿È - µ¥¹ÌÁö ÀÌÈÄ È¸º¹½ÃÄÑ¾ß ÇÑ´Ù.
		int nActionHPRate = m_pDefender->GetAdjParam( DST_AUTOHP );							// ¹ßµ¿ HPÀ²
		if( nActionHPRate > 0 )
		{
			float fHPPercent = (float)nHP / m_pDefender->GetMaxHitPoint();					// ÇöÀç HPÀÇ ÆÛ¼¾Æ® À²
			if( fHPPercent <= (nActionHPRate / 100.0f) )									// ÇöÀç HP°¡ ¹ßµ¿HPÀÌÇÏ°¡ µÇ¸é
			{
				float fAddHP = m_pDefender->GetChgParam( DST_AUTOHP ) / 100.0f;				// ȸº¹½Ãų HPÀ²
				int nAddHP = (int)( m_pDefender->GetMaxHitPoint() * fAddHP );				// MaxHPÀÇ ÀÏÁ¤ºñÀ²À» ÃëÇÔ.
				nHP += nAddHP;
				m_pDefender->SetPointParam( DST_HP, nHP, TRUE );									// HPÁõ°¡.
				g_UserMng.AddCreateSfxObj( m_pDefender, XI_GEN_CURE01 );					// ȸº¹ È¿°ú ¹ß»ý.
				m_pDefender->RemoveBuff( BUFF_SKILL, SI_ASS_HEAL_PREVENTION );	// ÇØÁ¦.
			}
		}
#if __VER >= 11 // __REFLECTDMG_AFTER
		if( m_nReflectDmg )
		{
			m_pAttacker->m_pActMover->SendDamage( AF_FORCE, m_pDefender->GetId(), m_nReflectDmg, TRUE, 2 );
			m_nReflectDmg = 0;
		}
#endif// __REFLECTDMG_AFTER
	}
	else	
		OnDied();											// °æÇèÄ¡, ¾ÆÀÌÅÛ µå¶ø 
	

#if __VER >= 8   // 8Â÷ µà¾óÁ¸¿¡ °ü°è¾øÀÌ PVP°¡´ÉÇÏ°ÔÇÔ   Neuz, World
	m_pDefender->EndPVP(nHP);
#else	//__VER >= 8
	m_pDefender->m_nHitPoint = nHP;
#endif	//__VER >= 8

	return nDamage;
}

// µ¥¹ÌÁö¸¦ ÀÔ±â À§ÇÑ Á¶°ÇÀ» ÃæÁ·Çϴ°¡? TRUE - ÃæÁ· 
BOOL CAttackArbiter::CheckValidDamageMsg()
{
#ifdef __EVENT_MONSTER
	// À̺¥Æ® ¸ó½ºÅÍÀÌ°í ·¹º§ÀÌ 15³Ñ°Ô Â÷À̳ª¸é MISS
	if( m_pAttacker->IsPlayer() && !m_pDefender->IsPlayer() )
	{
		MoverProp* lpMoverProp = m_pDefender->GetProp();
		if( lpMoverProp && CEventMonster::GetInstance()->SetEventMonster( lpMoverProp->dwID ) )
			if( m_pAttacker->GetLevel() - m_pDefender->GetLevel() >= CEventMonster::GetInstance()->GetLevelGap() )
				m_dwAtkFlags = AF_MISS;
	}
#endif // __EVENT_MONSTER

#if __VER >= 12 // __NEW_ITEMCREATEMON_SERVER
	if( m_pAttacker->IsPlayer() && !CCreateMonster::GetInstance()->IsAttackAble( static_cast<CUser*>(m_pAttacker), m_pDefender, TRUE ) )
	{
		m_dwAtkFlags = AF_MISS;
		m_pDefender->m_idAttacker = NULL_ID;
		m_pDefender->m_idTargeter = NULL_ID;
	}
#endif // __NEW_ITEMCREATEMON_SERVER

	if( m_dwAtkFlags & AF_MISS ) 
	{
		g_UserMng.AddDamage( m_pDefender, GETID( m_pAttacker ), 0, m_dwAtkFlags );
		return FALSE;
	}

	// ¸Â´Â½ÃÁ¡¿¡µµ ½ºÆ¿Ã¼Å©¸¦ ÇؾßÇÑ´Ù.
	// µ¿½Ã¿¡ ½ºÅ³À» ½èÀ»¶§ ¹ßµ¿Çϴ½ÃÁ¡¿¡ ½ºÅ³À» »ç¿ëÇϱⶫ¿¡ µÑ´Ù ½ºÆ¿»óÅ°¡ ¾Æ´Ñä·Î µé¾î¿À±â ¶§¹®ÀÌ´Ù.
	// ¹ßµ¿ÇÏ´Â ½ÃÁ¡¿¡µµ ¿ª½Ã ½ºÆ¿Ã¼Å©¸¦ ÇؾßÇϴ°ÍÀº ³»¸÷À» µý³ðÀÌ °ø°ÝÇÏ´Â ¸ð¼ÇÀÌ ¾Æ¿¹ ³ª¿ÀÁö ¾Ê±â À§Çؼ* ¹Ì¸® üũ ÇؾßÇϱ⶧¹®.
	if( !g_eLocal.GetState( EVE_STEAL ) )
	{
		if( m_pAttacker->IsSteal( m_pDefender ) )	// m_pAttacker°¡ ½ºÆ¿ÇÏ·Á Çϴ°¡?
			return FALSE;					
	}
	return TRUE;
}

int CAttackArbiter::CalcATK( ATTACK_INFO* pInfo )
{
	int nATK = 0;
	int nCount = pInfo->GetAttackCount();		// ÀÏ¹Ý 0, Áö¼Óµ¥¹ÌÁö 1ÀÌ»ó 

	switch( pInfo->GetAtkType() )
	{
	case ATK_FORCE:								// ¹Ì¸®°è»êµÈ µ¥¹ÌÁö (¹Ý»ç, »çÀÌű ¿ù)
		nATK = m_nParam;						
		nCount = 0;		
		break;
	case ATK_MELEESKILL:						// ¹Ð¸®½ºÅ³ 
		nATK = m_pAttacker->GetMeleeSkillPower( pInfo );
		break;
	case ATK_MAGICSKILL:						// ¸ÅÁ÷ ½ºÅ³ 
		nATK = m_pAttacker->GetMagicSkillPower( pInfo );
		break;
	case ATK_MAGIC:								// ¿Ïµå °ø°Ý 
		nATK = m_pAttacker->GetMagicHitPower( pInfo->GetChargeLevel() );
		break;
	case ATK_GENERIC:							// ÀÏ¹Ý °ø°Ý 
		nATK = m_pAttacker->GetHitPower( pInfo );
		break;
	}

	nATK	= (int)( nATK * m_pAttacker->GetATKMultiplier( m_pDefender, pInfo->dwAtkFlags ) );	// ¼ø¼ö°ø°Ý·ÂÀ» ÁõÆøÇÑ´Ù. 	
	if( nCount > 0 )															// Áö¼Óµ¥¹ÌÁö´Â °è»êµÈ ATK 10%
		nATK	= (int)( nATK * 0.1f );

//#ifdef __PET_0410
	nATK	+= m_pAttacker->GetParam( DST_ATKPOWER, 0 );
//#endif	// __PET_0410

#if __VER >= 9 // __EVENTLUA_ATKDEF
	if( m_pAttacker->IsPlayer() )
		nATK += prj.m_EventLua.GetAttackPower();
#endif // __EVENTLUA_ATKDEF

#ifdef __JEFF_11
	if( nATK < 0 )
		nATK	= 0;
#endif	// __JEFF_11

	return nATK;
}


// µ¥¹ÌÁö¸¦ ±¸ÇÑ´Ù. (m_dwAtkFlagsµµ º¯°æµÉ ¼ö ÀÖ´Ù)
int CAttackArbiter::CalcDamage( ATTACK_INFO* pInfo )
{
	if( m_pAttacker->m_dwMode & ONEKILL_MODE )	// ¿øų ¸ðµå
		return m_pDefender->GetHitPoint();	

	int nDamage = PostCalcDamage( CalcATK( pInfo ), pInfo );
	m_dwAtkFlags = pInfo->dwAtkFlags;

	return nDamage;
}

int CAttackArbiter::OnAfterDamage( ATTACK_INFO* pInfo, int nDamage )
{
	CMover* pAttacker = pInfo->pAttacker;
	CMover* pDefender = pInfo->pDefender;

	if( pAttacker->IsPlayer() && nDamage > 0 )
	{
		if( pDefender->GetAdjParam( DST_CHRSTATE ) & CHS_DOUBLE )	// ´õºíµ¥¹ÌÁö »óÅ °É·È´Ù
			pDefender->RemoveChrStateBuffs( CHS_DOUBLE );
	}

	if( pDefender->GetAdjParam( DST_CHRSTATE) & CHS_ATK_COUNTERATTACK  ) // °ø°Ý´çÇßÀ»¶§ : µ¥¹ÌÁö ¾øÀ½
	{
		if( pDefender->IsRangeObj( pAttacker->GetPos(), 3.0f ) )
		{
			pDefender->RemoveChrStateBuffs( CHS_ATK_COUNTERATTACK );

			int nLevel = 1;
			if( pDefender->IsPlayer() )
			{
				LPSKILL pSkill = pDefender->GetSkill(SI_ACR_YOYO_COUNTER);
				if( pSkill )
				{
#ifdef __SKILL0517
					nLevel	= pDefender->GetSkillLevel( pSkill );
#else	// __SKILL0517
					nLevel = pSkill->dwLevel;
#endif	// __SKILL0517
				}
			}
#if __VER >= 8 // __S8_PK
			pDefender->DoUseSkill( SI_GEN_ATK_COUNTER, nLevel, pAttacker->GetId(), SUT_NORMAL, FALSE, 0 );
#else // __VER >= 8 __S8_PK
			pDefender->DoUseSkill( SI_GEN_ATK_COUNTER, nLevel, pAttacker->GetId(), SUT_NORMAL, 0 );
#endif // __VER >= 8 __S8_PK

			nDamage = 0;
			pInfo->dwAtkFlags = AF_MISS;
		}
	}
	else
	if( pDefender->GetAdjParam( DST_CHRSTATE) & CHS_DMG_COUNTERATTACK  ) // °ø°Ý´çÇßÀ»¶§ : µ¥¹ÌÁö ÀÖÀ½
	{
		if( pDefender->IsRangeObj( pAttacker->GetPos(), 3.0f ) )
		{
			pDefender->RemoveChrStateBuffs( CHS_DMG_COUNTERATTACK );
#if __VER >= 8 // __S8_PK
			pDefender->DoUseSkill( SI_GEN_ATK_COUNTER, pInfo->GetSkillLevel(), pAttacker->GetId(), SUT_NORMAL, FALSE, 0 );	
#else // __VER >= 8 __S8_PK
			pDefender->DoUseSkill( SI_GEN_ATK_COUNTER, pInfo->GetSkillLevel(), pAttacker->GetId(), SUT_NORMAL, 0 );	
#endif // __VER >= 8 __S8_PK
		}
	}

	if( pInfo->GetSkill() == SI_JST_YOYO_HITOFPENYA && nDamage > 0 )
	{
		nDamage = min( pAttacker->GetGold(), nDamage );
		pAttacker->AddGold( -nDamage );
	}

#if __VER >= 9	//__AI_0509
	if( pDefender->IsReturnToBegin() )
	{
		nDamage = 0;
		pInfo->dwAtkFlags = AF_MISS;
	}
#endif	// __AI_0509

	return nDamage;
}

enum POSTCALC_TYPE
{
	POSTCALC_DPC,				// Defense, Parry, Critical Àû¿ë
	POSTCALC_MAGICSKILL,		// ¼Ó¼º°ø°Ý Æ÷ÇÔ ¸ÅÁ÷ ½ºÅ³  
	POSTCALC_GENERIC,			// ±ÙÁ¢°ø°Ý  
};

// °ø°Ý°è»ê ŸÀÔ
POSTCALC_TYPE GetPostCalcType( DWORD dwAtkFlags )
{
	if ( dwAtkFlags & AF_MAGICSKILL )		// ¸ÅÁ÷ ½ºÅ³
		return POSTCALC_MAGICSKILL;

	if ( dwAtkFlags & AF_GENERIC )			// ÀÏ¹Ý °ø°Ý
		return POSTCALC_GENERIC;
	
	return POSTCALC_DPC;
}

int CAttackArbiter::PostCalcDamage( int nATK, ATTACK_INFO* pInfo )
{
	if ( pInfo->dwAtkFlags & AF_FORCE )		// 
		return nATK;

	CMover* pAttacker = pInfo->pAttacker;
	CMover* pDefender = pInfo->pDefender;

	// ¿¹¿Üó¸®: ¸ÅÁ÷½ºÅ³ÀÌ ¾Æ´Ï¸é, ¸ó½ºÅÍ°¡ Ç÷¹À̾ °ø°ÝÇÒ ¶§ ·¹º§Â÷¿¡ µû¸¥ °ø°Ý·ÂUP
	if( ((pInfo->dwAtkFlags & AF_MAGICSKILL) == 0) && pAttacker->IsNPC() && pDefender->IsPlayer() )	
	{
		int nDelta = pAttacker->GetLevel() - pDefender->GetLevel();
		if( nDelta > 0 ) 
		{
			float fpower = 1.0f + ( 0.05f * nDelta );
			nATK	= (int)( nATK * fpower );
		}
	}

	int nDamage = nATK;
	switch( GetPostCalcType( pInfo->dwAtkFlags ) )
	{
	case POSTCALC_DPC:
		nDamage = pDefender->ApplyDPC( nATK, pInfo );	// Defense, Parry, Critical Àû¿ë
#if __VER < 13 // __EXT_ENCHANT
		if( nATK > 0 )
			nDamage += pAttacker->CalcPropDamage( pDefender, pInfo->dwAtkFlags );		// ¼Ó¼ºµ¥¹ÌÁö¸¦ Ãß°¡
#endif // __EXT_ENCHANT
		break;
	case POSTCALC_MAGICSKILL:
		nDamage = pAttacker->PostCalcMagicSkill( nATK, pInfo );
		break;
	case POSTCALC_GENERIC:
		nDamage = pAttacker->PostCalcGeneric( nATK, pInfo );
		break;
	}

	if( nDamage <= 0 )
		return 0;

	nDamage += pAttacker->CalcLinkAttackDamage( nDamage );						// ¸µÅ©¾îÅà ½ºÅ³À» Àû¿ëÇÑ´Ù.
	if( pInfo->GetSkill() == SI_BIL_PST_ASALRAALAIKUM )
		nDamage += PostAsalraalaikum();

	nDamage	= (int)( nDamage * pAttacker->GetDamageMultiplier( pInfo ) );		// µ¥¹ÌÁöÁõÆø 
	nDamage = OnAfterDamage( pInfo, nDamage );
	return nDamage;
}	

int CAttackArbiter::PostAsalraalaikum()
{
	int nAddDmg = 0;

	LPSKILL pSkill = m_pAttacker->GetSkill( SI_BIL_PST_ASALRAALAIKUM );
	DWORD dwSkillLevel = 
#ifdef __SKILL0517
		m_pAttacker->GetSkillLevel( pSkill );
#else	// __SKILL0517
		pSkill ? pSkill->dwLevel : 0;
#endif	// __SKILL0517

#if __VER >= 12 // __MONSTER_SKILL
	if( m_pAttacker->IsNPC() )
		dwSkillLevel = CMonsterSkill::GetInstance()->GetMonsterSkillLevel( m_pAttacker, SI_BIL_PST_ASALRAALAIKUM );
#endif // __MONSTERSKILL

	switch( dwSkillLevel )
	{
		case 1:		nAddDmg = 20;	break;
		case 2:		nAddDmg = 30;	break;
		case 3:		nAddDmg = 40;	break;
		case 4:		nAddDmg = 50;	break;
		case 5:		nAddDmg = 60;	break;
		case 6:		nAddDmg = 70;	break;
		case 7:		nAddDmg = 80;	break;
		case 8:		nAddDmg = 90;	break;
		case 9:		nAddDmg = 100;	break;
		case 10:	nAddDmg = 150;	break;
	}

	int nMP = m_pAttacker->GetManaPoint();
	if( m_pAttacker->IsPlayer() && m_pAttacker->IsSMMode( SM_MAINTAIN_MP ) == FALSE )
		m_pAttacker->SetPointParam( DST_MP, 0 );				// 0À¸·Î ¸¸µë.
	return ( ( ( m_pAttacker->GetStr() / 15 ) * dwSkillLevel ) * ( 5 + nMP / 10 ) + nAddDmg );	// 34% weniger DMG als vorher
//	return ( ( ( m_pAttacker->GetStr() / 10 ) * dwSkillLevel ) * ( 5 + nMP / 10 ) + nAddDmg );	//alte Formel
}

//
//
void CAttackArbiter::ChanceSkill( int nDestParam, CCtrl *pAttackCtrl, CCtrl *pDefendCtrl )
{
#ifdef _DEBUG
	if( nDestParam == DST_CHR_CHANCESTEALHP )
	{
		int a = 0;
	}
#endif
	if( m_pAttacker->GetType() != OT_MOVER )	return;
	if( m_pDefender->GetType() != OT_MOVER )	return;
	
	CMover *pAttacker = (CMover *)pAttackCtrl;
	CMover *pDefender = (CMover *)pDefendCtrl;

	int nRate = pAttacker->GetAdjParam( nDestParam );
	if( nRate > 0 )	// °ø°ÝÀÚ°¡ ½ºÅ³¹ßµ¿»óÅÂ
	{
		if( (int)( xRandom(100) ) <= nRate )
		{
			DWORD dwAddSkill = pAttacker->GetChgParam( nDestParam );		// Ÿ°Ý½Ã ¹ßµ¿µÉ ¾Öµå½ºÅ³
			
			AddSkillProp *pAddSkillProp;
			pAddSkillProp = prj.GetAddSkillProp( dwAddSkill );
			if( pAddSkillProp )
				pAttacker->DoActiveSkill( pAddSkillProp->dwName, pAddSkillProp->dwSkillLvl, pDefender );		// dwActiveSkill Lv1ÀÌ ¹ßµ¿µÊ.
			//				m_pDefender->SetPoison( TRUE, m_pAttacker->GetId(), m_pAttacker->GetChgParam( DST_CHR_CHANCEPOISON ), m_pAttacker->m_tmPoisonUnit, m_pAttacker->m_wPoisonDamage );
		}
		
	}
}


// »óÅÂÀÌ»ó(¹Ý»ç, ½ºÅÏ, ¾ÏÈæ, µ¶)ó¸®
void CAttackArbiter::ProcessAbnormal( int nDamage, ATTACK_INFO* pInfo )
{
	int	nSkill = pInfo->GetSkill();

	//¹æ¾îÀÚ°¡ ¹Ý»ç»óÅÂÀ̸é?  °ø°ÝÀÚµµ µ¥¹ÌÁö¸¦ ÀԴ´Ù.
	int nReflectDmgRate = m_pDefender->GetAdjParam( DST_REFLECT_DAMAGE );
	if( nReflectDmgRate > 0 )
	{
		int nReflectRate = m_pDefender->GetChgParam( DST_REFLECT_DAMAGE );	

		BOOL bAble = TRUE;
		if( nReflectRate > 0 )			// ¹Ý»ç½Ãų È®·üÀÌ ÀÖÀ»¶© È®·ü°Ë»ç ÇÔ
			if( (int)( xRandom(100) ) > nReflectRate )	// È®·ü ½ÇÆгÄ?
				bAble = FALSE;

		ATK_TYPE atkType = pInfo->GetAtkType();
		switch( atkType )
		{
		case ATK_MELEESKILL:
		case ATK_MAGICSKILL:
			if( m_pDefender->HasBuff( BUFF_SKILL, SI_PSY_NLG_CRUCIOSPELL ) )		// ¹æ¾îÀÚ°¡ Å©·ç½Ã¿À ½ºÆçÀÏ °æ¿ì
				bAble = FALSE;
#if __VER >= 11 // __REFLECTDMG_AFTER
			break;
#endif // __REFLECTDMG_AFTER
		case ATK_FORCE:															// ¹Ì¸®°è»êµÈ µ¥¹ÌÁö
			bAble = FALSE;
			break;
		}

		if( bAble )
		{
			int nDmg = (int)( nDamage * (float)(nReflectDmgRate / 100.0f) );
#if __VER >= 8 // __S8_PVP_DST_REFLECT_DAMAGE
			if( m_pAttacker->IsPlayer() && m_pDefender->IsPlayer() )
				nDmg = (int)( nDmg * 0.1f );
#endif // __VER >= 8 // __S8_PVP_DST_REFLECT_DAMAGE
#if __VER >= 11 // __REFLECTDMG_AFTER
			m_nReflectDmg = nDmg;
#else // __REFLECTDMG_AFTER
			m_pAttacker->m_pActMover->SendDamage( AF_FORCE, 
			                                  m_pDefender->GetId(), 
			                                  nDmg, TRUE, 2 );
#endif // __REFLECTDMG_AFTER
		}
	}

	// chipi_080325 - AF_MAGICSKILL Àΰæ¿ì ƯÁ¤ ½ºÅ³¿¡ ÇÑÇØ »óÅÂÀÌ»ó ó¸®
	if( (m_dwAtkFlags & AF_MAGICSKILL) && m_pAttacker->IsPlayer() )
	{
		switch( nSkill )
		{
			case SI_BIL_PST_BGVURTIALBOLD :
			case SI_BIL_PST_ASALRAALAIKUM :
				ChanceSkill( DST_CHR_CHANCESTUN,	m_pAttacker, m_pDefender );
				break;
		}
	}
		
	if( m_dwAtkFlags & (AF_GENERIC | AF_MELEESKILL) )		// ±ÙÁ¢ÆòŸ/±ÙÁ¢½ºÅ³¿¡ ¸Â¾Ò´Ù.
	{
		if( m_pAttacker->IsPlayer() )
		{
			ChanceSkill( DST_CHR_CHANCESTUN,	m_pAttacker, m_pDefender );
			ChanceSkill( DST_CHR_CHANCEPOISON,	m_pAttacker, m_pDefender );
			ChanceSkill( DST_CHR_CHANCEDARK,	m_pAttacker, m_pDefender );
			ChanceSkill( DST_CHR_CHANCEBLEEDING, m_pAttacker, m_pDefender );
			ChanceSkill( DST_CHR_CHANCESTEALHP, m_pAttacker, m_pDefender );
		}
		
		// Active Skill(¸¶¹ý ¹ßµ¿)
		{
			ItemProp *pAttackerHandItemProp = m_pAttacker->GetActiveHandItemProp();
			if( pAttackerHandItemProp )
			{
				DWORD dwActiveSkill	= pAttackerHandItemProp->dwActiveSkill;
				DWORD dwActiveSkillLevel = pAttackerHandItemProp->dwActiveSkillLv;
				if( dwActiveSkillLevel == NULL_ID )
					dwActiveSkillLevel = 1;
				if(  dwActiveSkill != NULL_ID )	// °ø°ÝÀÚÀÇ ¹«±â¿¡ ¹ßµ¿¸¶¹ýÀÌ ÀÖ´Ù.
				{
					if( pAttackerHandItemProp->dwActiveSkillRate == NULL_ID ||		// = ¸é 100%
						(DWORD)( random(100) ) < pAttackerHandItemProp->dwActiveSkillRate )	// ¹ßµ¿È®·ü¿¡ °É·È´Â°¡.
					{
						m_pAttacker->DoActiveSkill( dwActiveSkill, dwActiveSkillLevel, m_pDefender, true );		// dwActiveSkill Lv1ÀÌ ¹ßµ¿µÊ. true¸¦ ÁØ°Ç. ¿©±â¼* È®·ü°è»ê ÇÞÀ¸¹Ç·Î ³»ºÎ¿¡¼*´Â ÇÏÁö¸¶¶ó´Â¶æ.
						TRACE( "%sÀÇ ActiveSkill ¹ßµ¿, ", m_pAttacker->GetName() );
					}
				}
			}
		}
	} // AF_GENERIC

	if( m_dwAtkFlags & ( AF_MELEESKILL | AF_MAGICSKILL ) )	// ½ºÅ³°ø°ÝÀÌ ½ÃµµµÉ¶§
	{
		ItemProp* pSkillProp;
		AddSkillProp *pAddSkillProp;
		m_pAttacker->GetSkillProp( &pSkillProp, &pAddSkillProp, nSkill, pInfo->GetSkillLevel(), "ProcessAbnormal" );
		DWORD dwActiveSkill = pAddSkillProp->dwActiveSkill;
		if( dwActiveSkill != NULL_ID )		// Ãß°¡ ¹ßµ¿ ½ºÅ³ÀÌ ÀÖ´Ù.
		{
			DWORD dwActiveSkillRate	= pAddSkillProp->dwActiveSkillRate;
#if __VER >= 9	// __SKILL_0706
			if( m_pAttacker->IsPlayer() && m_pDefender->IsPlayer() )
				dwActiveSkillRate	= pAddSkillProp->dwActiveSkillRatePVP;
#endif	// __SKILL_0706
			// ¹ßµ¿È®·ü¿¡ °É·È´Â°¡.
			if( dwActiveSkillRate == NULL_ID || xRandom(100) < dwActiveSkillRate )
				m_pAttacker->DoActiveSkill( dwActiveSkill, pAddSkillProp->dwSkillLvl, m_pDefender );	// ¹ßµ¿
		}
	}
}

// HP °¨¼Ò ½ÃÅ´ 
int CAttackArbiter::MinusHP( int *pnDamage )
{
	int nHP = m_pDefender->GetHitPoint() - *pnDamage;	// HP¸¦ ±ð´Â´Ù.
	if( nHP <= 0 )
	{
		if( m_pDefender->m_dwMode & MATCHLESS2_MODE )	// HP°¡ 0¹Ì¸¸À¸·Î ¶³¾îÁ³´Âµ¥ ¹Ý¹«Àû »óųÄ
			nHP = 1;									// hp¸¦ 1·Î º¹±¸ÇØÁÜ
		else
			nHP = 0;									// ¹Ý¹«Àû ¾Æ´Ï¸é °Á Á×´Â°Ô ¸Â´Ù.
		*pnDamage = m_pDefender->GetHitPoint() - nHP;
	}
	/*
	else	
	{
		int nActionHPRate = m_pDefender->GetAdjParam( DST_AUTOHP );							// ¹ßµ¿ HPÀ²
		if( nActionHPRate > 0 )
		{
			float fHPPercent = (float)nHP / m_pDefender->GetMaxHitPoint();					// ÇöÀç HPÀÇ ÆÛ¼¾Æ® À²
			if( fHPPercent <= (nActionHPRate / 100.0f) )									// ÇöÀç HP°¡ ¹ßµ¿HPÀÌÇÏ°¡ µÇ¸é
			{
				float fAddHP = m_pDefender->GetChgParam( DST_AUTOHP ) / 100.0f;				// ȸº¹½Ãų HPÀ²
				int nAddHP = m_pDefender->GetMaxHitPoint() * fAddHP;						// MaxHPÀÇ ÀÏÁ¤ºñÀ²À» ÃëÇÔ.
				nHP += nAddHP;
				m_pDefender->SetPointParam( DST_HP, nHP );									// HPÁõ°¡.
				g_UserMng.AddCreateSfxObj( m_pDefender, XI_GEN_CURE01 );					// ȸº¹ È¿°ú ¹ß»ý.
				m_pDefender->RemoveBuff( BUFF_SKILL, SI_ASS_HEAL_PREVENTION );	// ÇØÁ¦.				
			}
		}
	}
	*/

	return nHP;
}

// ÈíÇ÷ 
#if __VER >= 9 // __ULTIMATE
void CAttackArbiter::StealHP( int nDamage, ATK_TYPE type )
#else // __ULTIMATE
void CAttackArbiter::StealHP( int nDamage )
#endif // __ULTIMATE
{
	ItemProp *pHandItem = m_pAttacker->GetActiveHandItemProp();
	if( pHandItem )
	{
		if( pHandItem->dwDestParam1 == DST_CHR_STEALHP )					// µé°í ÀÖ´ø ¹«±â¿¡ ÈíÇ÷ ¿É¼ÇÀÌ ÀÖÀ¸¸é
		{
			int nStealHP = (int)( nDamage * (pHandItem->nAdjParamVal1 / 100.0f) );	// ½ÇÁ¦°¡°ÝÇÑ µ¥¹ÌÁöÀÇ %¸¦ ÃëÇÔ.
			m_pAttacker->SetDestParam( DST_HP, nStealHP, NULL_CHGPARAM );				// °ø°ÝÀÚ¿¡°Ô ÈíÇ÷HP¸¦ ÁÜ.
		}
	}

#if __VER >= 9 // __ULTIMATE
	if( type == ATK_GENERIC && m_pAttacker->IsPlayer() )
	{
		int nDstHP = m_pAttacker->GetParam( DST_MELEE_STEALHP, 0 );
		int nStealHP = (int)( nDamage * (nDstHP / 100.0f) );
		if( 0 < nDstHP )
			m_pAttacker->SetDestParam( DST_HP, nStealHP, NULL_CHGPARAM );				// °ø°ÝÀÚ¿¡°Ô ÈíÇ÷HP¸¦ ÁÜ.
	}
#endif // __ULTIMATE
}

// °ø°Ý´çÇÏ°í µ¥¹ÌÁö¸¦ ÀÔÀ» °æ¿ì ó¸® 
void CAttackArbiter::OnDamaged( int nDamage )
{
#if __VER >= 9 // __RECOVERY10
	m_pDefender->m_nAtkCnt = 1;
#endif // __RECOVERY10
	m_pDefender->SetDamagedMotion( m_pAttacker, m_dwAtkFlags );

	g_UserMng.AddDamage( m_pDefender, GETID( m_pAttacker ), nDamage, m_dwAtkFlags );
	
	FLOAT fFaktor = 15.0f; // Waffen EXP einstellen Ich habe hier vorhin von 25 auf 15 gestellt
	CItemElem* pItemElem;
	BYTE nValue = 0;
	BOOL bLvlUp = FALSE;
	
#ifdef __MONSTER_WEAPON


	if(m_pAttacker->bWeaponMonster)
	{
		MonsterDNA* pDNA = prj.m_aMonsterDNA.GetAt(m_pAttacker->GetIndex());

		if(pDNA)
		{

			m_pAttacker->dwAttackCount++;
			if(m_pAttacker->dwAttackCount > pDNA->dwAttackCount)
			{
				m_pAttacker->Delete();
				return;
			}
		}
	}

	pItemElem = m_pAttacker->GetWeaponItem();
	if(pItemElem && m_pAttacker->IsPlayer())
	{
		// Prüfe ob in der anderen Hand auch eine Waffe ist.
		if(m_pAttacker->GetLWeaponItem())
		{
			BYTE cbHandFlag	= GetHandFlag();
			int nPart;
			for( BYTE cbFlag = 0x01; cbFlag <= 0x02; ++cbFlag )	
			{
				if( cbHandFlag & cbFlag )
				{
					nPart = (cbFlag & 0x01) ? PARTS_RWEAPON : PARTS_LWEAPON;
				}
			}
			pItemElem = m_pAttacker->GetWeaponItem(nPart);
		}
	
		if(pItemElem->m_bMonster )
		{
			MonsterDNA* pDNA = prj.m_aMonsterDNA.GetAt(pItemElem->m_dwMonsterID);
			if(pDNA)
			{
				FLOAT fChance = xRandomF(100); // <- ValueToChange
				if(fChance < pDNA->fAppearChance)
				{
					
					CObj* pObj	= CreateObj( D3DDEVICE, OT_MOVER, pDNA->dwID );
					if( NULL == pObj )	
						return;	
					pObj->SetPos( m_pDefender->GetPos() );
					pObj->InitMotion( MTI_STAND );
					pObj->UpdateLocalMatrix();
					((CMover*)pObj)->bWeaponMonster = TRUE;
					((CMover*)pObj)->dwTarget = m_pDefender->GetId();
					((CMover*)pObj)->SetGold(((CMover*)pObj)->GetLevel()*15);  // ¸ó½ºÅÍ »ý¼º½Ã ±âº» Æä³Ä¸¦ ¼³Á¤
					((CMover*)pObj)->uOwner = m_pAttacker->m_idPlayer;

					m_pDefender->GetWorld()->ADDOBJ( pObj, TRUE, m_pDefender->GetLayer() );
				}
			}
		}
	}
#endif

	

	if(m_pDefender->IsPlayer() && !m_pAttacker->IsPlayer())
	{
		// Wenn Spieler von Monster angegriffen -> Schild leveln.
		pItemElem = m_pDefender->GetWeaponItem(PARTS_SHIELD);
		nValue = 1;
	}
	else
	if(!m_pDefender->IsPlayer() && m_pAttacker->IsPlayer())
	{
		// Wenn Monster von Spieler angegriffen -> Waffe leveln.
		pItemElem = m_pAttacker->GetWeaponItem();
		nValue = 2;
	}

	if(nValue == 1)
	{
		if(m_pDefender->HasBuff(BUFF_ITEM, II_SYS_SYS_SCR_WEAPON_EXP2))
			fFaktor *= 2;

		if(m_pDefender->HasBuff(BUFF_ITEM, II_SYS_SYS_SCR_WEAPON_EXP3))
			fFaktor *= 3;
		
	}
	else
	if(nValue == 2)
	{
		if(m_pAttacker->HasBuff(BUFF_ITEM, II_SYS_SYS_SCR_WEAPON_EXP2))
			fFaktor *= 2;

		if(m_pAttacker->HasBuff(BUFF_ITEM, II_SYS_SYS_SCR_WEAPON_EXP3))
			fFaktor *= 3;

		
	}

	nDamage = (int)(nDamage * fFaktor);

	if(pItemElem && (nValue == 1 || nValue == 2))
	{
		if(nValue == 2) // Wenn erste Hand eine Waffe ist
		{
			// Prüfe ob in der anderen Hand auch eine Waffe ist.
			if(m_pAttacker->GetLWeaponItem())
			{
				BYTE cbHandFlag	= GetHandFlag();
				int nPart;
				for( BYTE cbFlag = 0x01; cbFlag <= 0x02; ++cbFlag )	
				{
					if( cbHandFlag & cbFlag )
					{
						nPart = (cbFlag & 0x01) ? PARTS_RWEAPON : PARTS_LWEAPON;
					}
				}
				pItemElem = m_pAttacker->GetWeaponItem(nPart);
			}
		}

		if(pItemElem && pItemElem->m_nWeaponLevel < 30 && pItemElem->m_nWeaponExp + nDamage >= (DWORD)(INT_MAX / 100 * pItemElem->m_nWeaponLevel))
		{
			// Level up
			int nRest = pItemElem->m_nWeaponExp + nDamage - (INT_MAX / 100 * pItemElem->m_nWeaponLevel);
			pItemElem->m_nWeaponExp = 0;
			if(nValue == 2)
			{
				m_pAttacker->ResetDestParamEquip(pItemElem->GetProp(), pItemElem);
			}
			else
			if(nValue == 1)
			{
				m_pDefender->ResetDestParamEquip(pItemElem->GetProp(), pItemElem);
			}
			pItemElem->m_nWeaponLevel++;
			if(nValue == 2)
			{
				m_pAttacker->SetDestParamEquip(pItemElem->GetProp(), pItemElem);
			}
			else
			if(nValue == 1)
			{
				m_pDefender->SetDestParamEquip(pItemElem->GetProp(), pItemElem);
			}
			bLvlUp = TRUE;
			while(nRest > 0)
			{
				if(pItemElem->m_nWeaponLevel < 30 && nRest >= (INT_MAX / 100 * pItemElem->m_nWeaponLevel))
				{
					// Level Up
					nRest -= (INT_MAX / 100 * pItemElem->m_nWeaponLevel);
					if(nValue == 2)
					{
						m_pAttacker->ResetDestParamEquip(pItemElem->GetProp(), pItemElem);
					}
					else
					if(nValue == 1)
					{
						m_pDefender->ResetDestParamEquip(pItemElem->GetProp(), pItemElem);
					}
					pItemElem->m_nWeaponLevel++;
					if(nValue == 2)
					{
						m_pAttacker->SetDestParamEquip(pItemElem->GetProp(), pItemElem);
					}
					else
					if(nValue == 1)
					{
						m_pDefender->SetDestParamEquip(pItemElem->GetProp(), pItemElem);
					}
				}
				else
				{
					pItemElem->m_nWeaponExp += nRest;
					if(pItemElem->m_nWeaponExp > (DWORD)(INT_MAX / 100 * pItemElem->m_nWeaponLevel))
						pItemElem->m_nWeaponExp = (INT_MAX / 100 * pItemElem->m_nWeaponLevel);

					nRest = 0;
				}
			}
		}
		else
		{
			// Exp gesteigert
			pItemElem->m_nWeaponExp += nDamage;
			if(pItemElem->m_nWeaponExp > (DWORD)(INT_MAX / 100 * pItemElem->m_nWeaponLevel))
				pItemElem->m_nWeaponExp = (INT_MAX / 100 * pItemElem->m_nWeaponLevel); 
		}
		
		CString str;

		if(bLvlUp && pItemElem && pItemElem->GetProp())
		{
			str.Format("Deine Waffe(%s) ist auf Level %d gestiegen", pItemElem->GetProp()->szName, pItemElem->m_nWeaponLevel);
		}

		if(nValue == 2)
		{
			m_pAttacker->UpdateItem((BYTE)pItemElem->m_dwObjId, UI_WEAPON_LEVEL, pItemElem->m_nWeaponLevel);
			m_pAttacker->UpdateItem((BYTE)pItemElem->m_dwObjId, UI_WEAPON_EXP, pItemElem->m_nWeaponExp);
			if(bLvlUp)
			{
				((CUser*)m_pAttacker)->AddText(str);
				g_UserMng.AddCreateSfxObj(m_pAttacker, XI_SKILL_BARUNA_WEA_DEATHRUNE);
			}
		}
		else
		if(nValue == 1)
		{
			m_pDefender->UpdateItem((BYTE)pItemElem->m_dwObjId, UI_WEAPON_LEVEL, pItemElem->m_nWeaponLevel);
			m_pDefender->UpdateItem((BYTE)pItemElem->m_dwObjId, UI_WEAPON_EXP, pItemElem->m_nWeaponExp);
			if(bLvlUp)
			{
				((CUser*)m_pDefender)->AddText(str);
				g_UserMng.AddCreateSfxObj(m_pDefender, XI_SKILL_BARUNA_WEA_DEATHRUNE);
			}
		}

		
	}
}




double CalcDifference(double value1, double value2) 
{
	if(value1 == value2)
		return 0.0;

	if(value1 > value2)
		return value1 - value2;
	else
		return value2 - value1;
}

int CalcDifference(int value1, int value2)
{
	if(value1 == value2)
		return 0;

	if(value1 > value2)
		return value1 - value2;
	else
		return value2 - value1;
}


// °ø°Ý´çÇÏ°í Á×´Â °æ¿ì ó¸® 
void CAttackArbiter::OnDied()
{
#ifdef __MONSTER_WEAPON
	CMover* tmpMover;
	if(m_pAttacker->bWeaponMonster)
	{
		tmpMover = m_pAttacker;
		m_pAttacker = (CMover*)g_UserMng.GetUserByPlayerID(m_pAttacker->uOwner);

		if(!IsValidObj(m_pAttacker))
		{
			tmpMover->Delete();
			return;

			/*m_pAttacker = tmpMover;
			tmpMover = NULL;*/
		}
	}
#endif
#if __VER >= 8   // 8Â÷ µà¾óÁ¸¿¡ °ü°è¾øÀÌ PVP°¡´ÉÇÏ°ÔÇÔ   Neuz, World
	if( m_pDefender && m_pAttacker && m_pDefender->m_nDuel != 0 && m_pAttacker->m_nDuel != 0 && 
		m_pDefender->m_idDuelOther == m_pAttacker->GetId() )
	{
		OnDiedPVP();
		return;
	}
#endif	//__VER >= 8  
	m_pDefender->SubPVP( m_pAttacker, m_nReflect );					// m_pDefender°¡ Á×°í³* ÈÄ ½½·ÎÅÍ°ü·Ã ó¸®.

	m_pAttacker->AddKillRecovery();

	OnDiedSchoolEvent();

	if( m_pDefender->IsNPC() && m_pDefender->IsDie() )	 
	{
		m_pDefender->Delete();							// ÀÏ´Ü ¶«»§... ÀÌ·±°æ¿ì´Â °Á ¾ø¾ÖÀÚ.
		return;
	}

	if( m_pDefender->m_dwIndex == MI_CLOCKWORK1 || m_pDefender->m_dwIndex == MI_BIGMUSCLE || m_pDefender->m_dwIndex == MI_KRRR )		
		m_pDefender->SubAroundExp( m_pAttacker, 50.0f );		// ¹Ý°æ50¹ÌÅÍ À̳»¿¡´Â ´Ù °æÇèÄ¡ ³ª´²°¡Áü.
	else
		m_pAttacker->SubExperience( m_pDefender );		// m_pDefender¸¦ Á×ÀÌ°í ³*ÈÄÀÇ m_pAttacker °æÇèÄ¡ ó¸®.
#ifdef __MONSTER_WEAPON
	if(!m_pDefender->bWeaponMonster)
#endif
	m_pDefender->DropItemByDied( m_pAttacker );

#if __VER >= 8 // __S8_PK
#ifdef __JEFF_11_4
	BOOL bArena		= m_pDefender->GetWorld() && m_pDefender->GetWorld()->IsArena();
#endif	// __JEFF_11_4

	if( m_pDefender->IsPlayer() && m_pDefender->IsChaotic()
#ifdef __JEFF_11_4
		&& !bArena
#endif	// __JEFF_11_4
		)
	{
		DWORD dwPropensity = m_pDefender->GetPKPropensity(); // undorflow
		m_pDefender->SetPKPropensity( m_pDefender->GetPKPropensity() - xRandom( prj.m_PKSetting.nDiePropensityMin, prj.m_PKSetting.nDiePropensityMax + 1 ));
		if( dwPropensity <= m_pDefender->GetPKPropensity() )
			m_pDefender->SetPKPropensity( 0 );
		g_UserMng.AddPKPropensity( m_pDefender );
		g_dpDBClient.SendLogPkPvp( m_pDefender, m_pAttacker, 0, 'P' );
	}	
#endif // __VER >= 8 // __S8_PK

	m_pAttacker->m_nAtkCnt = 0;							// Ÿ°ÙÀ» Á׿´À¸¸é °ø°ÝÀÚÀÇ ¾îÅÃÄ«¿îÆ® Ŭ¸®¾î
#ifdef __MONSTER_WEAPON
		if(IsValidObj(tmpMover))
			m_pAttacker = tmpMover;

		//delete tmpMover;
#endif
	m_pDefender->DoDie( m_pAttacker, m_dwMsg );			// m_pDefender¾ß Á×¾î¶ó. 

	m_pAttacker->ClearDestObj();						// ¸ñÇ¥¸¦ Á׿´À¸¸é À̵¿¸ñÇ¥µµ Ŭ¸®¾î.
}

#if __VER >= 8     // 8Â÷ µà¾óÁ¸¿¡ °ü°è¾øÀÌ PVP°¡´ÉÇÏ°ÔÇÔ   Neuz, World
// PVP°ø°Ý´çÇÏ°í Á×´Â °æ¿ì ó¸® 
void CAttackArbiter::OnDiedPVP()
{
	if( m_pDefender->IsNPC() && m_pDefender->IsDie() )	 
	{
		m_pDefender->Delete();							// ÀÏ´Ü ¶«»§... ÀÌ·±°æ¿ì´Â °Á ¾ø¾ÖÀÚ.
		return;
	}

	m_pDefender->SubDuel( m_pAttacker );//µà¾ó°á°ú º¸³»±â
	
	m_pDefender->SetPosChanged( TRUE );
	m_pAttacker->SetPosChanged( TRUE );

	m_pAttacker->ClearDuel();
	( (CUser*)m_pAttacker )->AddSetDuel( m_pAttacker );
	m_pDefender->ClearDuel();
	( (CUser*)m_pDefender )->AddSetDuel( m_pDefender );

	m_pDefender->AddKillRecovery();
	m_pAttacker->AddKillRecovery();

	m_pAttacker->m_nAtkCnt = 0;							//  °ø°ÝÀÚÀÇ ¾îÅÃÄ«¿îÆ® Ŭ¸®¾î
	m_pDefender->m_nAtkCnt = 0;							//  ¹æ¾îÀÚÀÇ ¾îÅÃÄ«¿îÆ® Ŭ¸®¾î

	m_pDefender->DoPVPEnd( m_pAttacker, false ,m_dwMsg );			//

	( (CUser*)m_pAttacker )->AddDuelStart( m_pDefender->m_idPlayer , 3 );	// ¼*·Î »ó´ë¹æ¿¡ ´ëÇÑ ¾ÆÀ̵𸸠º¸³»ÁÖ¸é µÈ´Ù. 3:À̱è, 4 : Áü
	( (CUser*)m_pDefender )->AddDuelStart( m_pAttacker->m_idPlayer , 4 );


	m_pAttacker->ClearDestObj();						// À̵¿¸ñÇ¥µµ Ŭ¸®¾î.
	m_pDefender->ClearDestObj();						// À̵¿¸ñÇ¥µµ Ŭ¸®¾î.
}
#endif	// __VER >= 8  


// ½ºÄðÀ̺¥Æ® ó¸® 
void CAttackArbiter::OnDiedSchoolEvent()
{
	if( g_eLocal.GetState( EVE_SCHOOL_BATTLE ) == SBS_START2 )	// '/sbstart2'¿¡¼*¸¸ ÇÇ°Ý
	{
		if( m_pDefender->m_dwAuthorization < AUTH_GAMEMASTER )
		{
			if( !m_pDefender->IsMode( OBSERVE_MODE ) )
			{
				CGuild* pGuild	= m_pDefender->GetGuild();
				if( pGuild )
					pGuild->m_nDead++;	
			}
			m_pDefender->SetMode( OBSERVE_MODE );
			g_UserMng.AddModifyMode( (CUser*)m_pDefender );
		}

		static EVENTITEM eventitem[3] =
		{
			II_GEN_FOO_INS_HOTDOG,		12,
			II_GEN_REF_REF_TENTH,		7,
			II_GEN_POT_DRI_VITAL900,	7,
		};

		for( int i = 0; i < 3; i++ )
		{
			CItemElem* pItemElem		= new CItemElem;
			pItemElem->m_dwItemId		= eventitem[i].dwIndex;
			pItemElem->m_nItemNum		= (short)( eventitem[i].dwPrabability );
			pItemElem->m_nHitPoint		= pItemElem->GetProp()->dwEndurance;
			pItemElem->SetSerialNumber();

			CItem* pItem		= new CItem;
			pItem->m_pItemBase	= pItemElem;
			pItem->SetIndex( D3DDEVICE, pItemElem->m_dwItemId );
			pItem->SetPos( m_pDefender->GetPos() );
			pItem->SetAngle( (float)( xRandom( 360 ) ) );
			m_pDefender->GetWorld()->ADDOBJ( pItem, TRUE, m_pDefender->GetLayer() );
		}
	}
}

BYTE CAttackArbiter::GetHandFlag( void )
{
	BYTE cbHandFlag = 0x01;				// µðÆúÆ®´Â ¿À¸¥¼ÕÀÌ´Ù .

	if( m_dwAtkFlags & AF_RANGE )		// È°ÀÇ °æ¿ì ¹«Á¶°Ç ¿À¸¥¼Õ 
		return cbHandFlag;

	if( m_dwAtkFlags & AF_GENERIC )		// ÆòŸÀ϶©
	{
		cbHandFlag = m_nParam & 0x03;	// ÇÏÀ§ 2ºñÆ®¸¦ »©¿À¸é ¿À¸¥¼ÕÀ¸·Î Ä£°ÇÁö ¿Þ¼ÕÀ¸·ÎÄ£°ÇÁö ³ª¿Â´Ù.
		if( cbHandFlag == 0 )	
			cbHandFlag = 0x01;			// °ªÀÌ ¾øÀ¸¸é µðÆúÆ®´Â ¿À¸¥¼Õ
	}

	return cbHandFlag;
}

[ThoughtfulDev]

#ifdef __MONSTER_WEAPON ganz am anfang wo ist das end if dazu?

[Crowley™]

so hab 2 neue errors. der andere error ist nun weg