attackcalc.cpp

墨香最新私服

// AttackCalc.cpp: implementation of the CAttackCalc class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AttackCalc.h"
#include "..\[CC]Header\CommonCalcFunc.h"
#include <time.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAttackCalc::CAttackCalc()
{
	srand((unsigned)time(NULL));
}

CAttackCalc::~CAttackCalc()
{
	
}
DWORD CAttackCalc::GetPlayerPoint(LEVELTYPE level1, int leve_gab)
{
	//////////////////////////////////////////////////////////////////////////
	// Àӽà ¶«»§ 
	if(level1 == 99)
		return 0;
	//////////////////////////////////////////////////////////////////////////
	
	ASSERT(level1 >= 1);
	if(leve_gab < -MONSTERLEVELRESTRICT_LOWSTARTNUM)
		leve_gab = -MONSTERLEVELRESTRICT_LOWSTARTNUM;
	else if(leve_gab >= MAX_MONSTERLEVELPOINTRESTRICT_NUM)
		leve_gab  = MAX_MONSTERLEVELPOINTRESTRICT_NUM;

	return GAMERESRCMNGR->GetPLAYERxMONSTER_POINT(level1,leve_gab);
}

BOOL	CAttackCalc::getCritical(CObject* pAttacker,CObject* pTarget,float fCriticalRate)
{
	//( [Å©¸®Æ¼ÄÃ]+20 ) / ( [¹æ¾îÀÚ ·¹º§] * 20 + 300 )
	DWORD attackercritical = pAttacker->GetCritical();

	LEVELTYPE targetlevel = pTarget->GetLevel();
	float fCriticalrate = (attackercritical + 20.f) / (targetlevel * 20.f + 300.f);
	if(fCriticalrate > 0.2f)
		fCriticalrate = 0.2f;
	
	WORD wCriticalPercent = (WORD)(fCriticalrate * 100);

	// ¹«°ø Å©¸®Æ¼ÄÃ
	if(fCriticalRate)
		wCriticalPercent += GetPercent(fCriticalRate,pAttacker->GetLevel(),pTarget->GetLevel());

	return (rand()%100 < wCriticalPercent);
}


double CAttackCalc::getPlayerPhysicalAttackPower(CPlayer * pPlayer,float PhyAttackRate, BOOL bCritical)
{
	double physicalAttackPower = 0;		
	DWORD minVal,maxVal;
	minVal = pPlayer->GetPhyAttackPowerMin();
	maxVal = pPlayer->GetPhyAttackPowerMax();	
	
	if(maxVal<=minVal)
	{
		physicalAttackPower = minVal;
	}
	else
	{		
		DWORD gap = maxVal - minVal + 1;
		physicalAttackPower = minVal+rand()%gap;
	}
	

	physicalAttackPower = physicalAttackPower*PhyAttackRate;
	
	if(bCritical)
	{
		physicalAttackPower = physicalAttackPower*1.5;			// critical attack
	}
	
	return physicalAttackPower;
}

double CAttackCalc::getPlayerAttributeAttackPower(CPlayer * pPlayer, 
							WORD Attrib, DWORD AttAttackMin,DWORD AttAttackMax,float AttAttackRate)
{
	DWORD MinV=0,MaxV=0;
	ASSERT(AttAttackMax >= AttAttackMin);
	if(AttAttackRate > 0)
	{
		// ¼Ó¼º Percent °ø°Ý·Â
		//[¼Ó¼ºRate°ø°Ý·Â] * ( ([½É¸Æ]+200) /100 ) + [½É¸Æ]/5
		WORD SimMek = pPlayer->GetSimMek();
		double midtermVal = (double)(SimMek + 200)/(double)100;
		DWORD MinLVV = (pPlayer->GetLevel()+5) - 5;		// RateMin = (Level + 5) - 5
		DWORD MaxLVV = (pPlayer->GetLevel()+5) + 5;		// RateMax = (Level + 5) + 5
		MinV = DWORD((MinLVV * AttAttackRate * midtermVal) + SimMek/5 + min(SimMek-12,25));
		MaxV = DWORD((MaxLVV * AttAttackRate * midtermVal) + SimMek/5 + min(SimMek-12,25));
		
//		double dS = SimMek;
		//³»°ø °ø°Ý·Â = [ ³»°ø °ø°Ý·Â * {(½É¸Æ +200)/200}*{(½É¸Æ+1000)/500}+½É¸Æ]*0.6
//		MinV = (MinLVV * ((dS+200)/200)*((dS+1000)/500)+dS)*0.6;
//		MaxV = (MaxLVV * ((dS+200)/200)*((dS+1000)/500)+dS)*0.6;
	}

	// ¼Ó¼º Àý´ë °ø°Ý·Â
	MinV += AttAttackMin;
	MaxV += AttAttackMax;

	// ¼Ó¼º °ø°Ý·Â »ó½Â ´õÇØÁÜ(¾ÆÀÌÅÛ,Ư±â)
	float AttUp = 1 + pPlayer->GetAttribPlusPercent(Attrib);
	MinV = (DWORD)(AttUp * MinV);
	MaxV = (DWORD)(AttUp * MaxV);
	
	DWORD AttackPower = random(MinV,MaxV);
	return AttackPower;
}

// monster

double	CAttackCalc::getMonsterPhysicalAttackPower(CMonster * pMonster, float PhyAttackRate, BOOL bCritical)
{
	BYTE bAttackType = MONSTER_ATTACKTYPE1;


	const monster_stats * mon_stats = pMonster->GetMonsterStats();
	double physicalAttackPower= 0;

	if(bAttackType == MONSTER_ATTACKTYPE1)
	{
		physicalAttackPower = mon_stats->PhysicalAttackMin1;
		int tmp = mon_stats->PhysicalAttackMax1-mon_stats->PhysicalAttackMin1;
		if(tmp) physicalAttackPower += rand()%tmp;
	}
	else if(bAttackType == MONSTER_ATTACKTYPE2)
	{
		physicalAttackPower = mon_stats->PhysicalAttackMin2;
		int tmp = mon_stats->PhysicalAttackMax2-mon_stats->PhysicalAttackMin2;
		if(tmp) physicalAttackPower += rand()%tmp;
	}

	return physicalAttackPower;
}

double	CAttackCalc::getMonsterAttributeAttackPower(CMonster * pMonster, WORD Attrib, DWORD AttAttackMin,DWORD AttAttackMax)
{
	monster_stats * mon_stats = pMonster->GetMonsterStats();
	
	ASSERT(AttAttackMax >= AttAttackMin);

	DWORD gap = AttAttackMax - AttAttackMin + 1;
	return AttAttackMin+rand()%gap;
}

double	CAttackCalc::getPhysicalAttackPower(CObject * pObject,float PhyAttackRate, BOOL bCritical)
{
	if(pObject->GetObjectKind() == eObjectKind_Player)
		return getPlayerPhysicalAttackPower((CPlayer*)pObject,PhyAttackRate,bCritical);
	else if(pObject->GetObjectKind() & eObjectKind_Monster)
		return getMonsterPhysicalAttackPower((CMonster*)pObject,PhyAttackRate,bCritical);
	else
	{
		ASSERT(0);
		return 0;
	}
}
double	CAttackCalc::getAttributeAttackPower(CObject * pObject, WORD Attrib, DWORD AttAttackMin,DWORD AttAttackMax,float AttAttackRate)
{
	if(pObject->GetObjectKind() == eObjectKind_Player)
		return getPlayerAttributeAttackPower((CPlayer*)pObject,Attrib,AttAttackMin,AttAttackMax,AttAttackRate);
	else if(pObject->GetObjectKind() & eObjectKind_Monster)
		return getMonsterAttributeAttackPower((CMonster*)pObject,Attrib,AttAttackMin,AttAttackMax);
	else
	{
		ASSERT(0);
		return 0;
	}
}

double	CAttackCalc::getPhyDefenceLevel(CObject* pObject, CObject* pAttacker)
{
	double phyDefence = pObject->GetPhyDefense();
	LEVELTYPE AttackerLevel = pAttacker->GetLevel();

	//( [¹æ¾î·Â] * 2 + 50 ) /  ( [°ø°ÝÀÚ ·¹º§] * 20 + 150 )
	double phyDefenceLevel = (phyDefence*2 + 50) / ( AttackerLevel*20 + 150 );
	if(phyDefenceLevel < 0)
	{
		ASSERT(0);
		phyDefenceLevel = 0;
	}
	if(phyDefenceLevel > 0.9)
		phyDefenceLevel = 0.9;

	return phyDefenceLevel;
}