simplemeleeskill.cpp

天之炼狱1服务器端源文件游戏服务端不完整

//////////////////////////////////////////////////////////////////////////////
// Filename    : SimpleMeleeSkill.cpp
// Written by  : excel96
// Description : 
//////////////////////////////////////////////////////////////////////////////

#include "SimpleMeleeSkill.h"
#include "CrossCounter.h"

#include "Gpackets/GCSkillToObjectOK1.h"
#include "Gpackets/GCSkillToObjectOK2.h"
#include "Gpackets/GCSkillToObjectOK5.h"

SimpleMeleeSkill g_SimpleMeleeSkill;

//////////////////////////////////////////////////////////////////////////////
// class SimpleMeleeSkill member methods
//////////////////////////////////////////////////////////////////////////////

void SimpleMeleeSkill::execute(
	Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, 
	const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result,
	CEffectID_t CEffectID)
	throw(Error)
{
	__BEGIN_TRY

	Assert(pSlayer != NULL);
	Assert(pSkillSlot != NULL);

	try 
	{
		Player* pPlayer = pSlayer->getPlayer();
		Zone* pZone = pSlayer->getZone();
		Assert(pPlayer != NULL);
		Assert(pZone != NULL);

		Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
		//Assert(pTargetCreature != NULL);

		// NPC绰 傍拜且 荐啊 绝促.
		// NoSuch力芭. by sigi. 2002.5.2
		if (pTargetCreature==NULL
			|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_NO_DAMAGE) // by sigi. 2002.10.30
			|| pTargetCreature->isNPC())
		{
			executeSkillFailException(pSlayer, param.SkillType);
			return;
		}

		result.pTargetCreature = pTargetCreature;

		// 父老 捞 扁贱捞 漂喊茄 公扁啊 乐绢具父 矫傈且 荐 乐绰 扁贱捞扼搁...
		// 弊 霸凯狼 公扁甫 甸绊 乐绰瘤甫 眉农秦辑 酒聪扼搁 角菩促.
		bool bIncreaseDomainExp = true;
		if (param.ItemClass != Item::ITEM_CLASS_MAX)
		{
			Item* pItem = pSlayer->getWearItem(Slayer::WEAR_RIGHTHAND);
			if (pItem == NULL || pItem->getItemClass() != param.ItemClass)
			{
				executeSkillFailException(pSlayer, param.SkillType);
				return;
			}

			bIncreaseDomainExp = pSlayer->isRealWearingEx(Slayer::WEAR_RIGHTHAND);
		}

		GCSkillToObjectOK1 _GCSkillToObjectOK1;
		GCSkillToObjectOK2 _GCSkillToObjectOK2;
		GCSkillToObjectOK5 _GCSkillToObjectOK5;

		SkillInfo*        pSkillInfo   = g_pSkillInfoManager->getSkillInfo(param.SkillType);
		SkillDomainType_t DomainType   = pSkillInfo->getDomainType();
		SkillLevel_t      SkillLevel   = pSkillSlot->getExpLevel();
		bool              bCriticalHit = false;
		Damage_t          Damage       = 0;

		if (param.bAdd)
		{
			// 颇扼固磐肺 傈崔等 单固瘤 蔼捞 歹秦瘤绰 单固瘤扼搁, 
			// 老馆 单固瘤甫 拌魂 饶, 单固瘤甫 歹秦具 茄促.
			// 颇扼固磐肺 傈崔等 单固瘤 蔼捞 流立利栏肺 静捞绰 单固瘤扼搁,
			// 捞 何盒鳖瘤 甸绢坷瘤 臼栏骨肺, 关狼 何盒鳖瘤 0栏肺 傈崔等促.
			Damage += computeDamage(pSlayer, pTargetCreature, SkillLevel/5, bCriticalHit);
		}

		if (param.bMagicDamage)
		{
			// 父老 胶懦 单固瘤啊 付过 单固瘤扼搁, 付过 单固瘤 拌魂 窃荐甫 捞侩秦 拌魂阑 秦霖促.
			Damage += computeMagicDamage(pTargetCreature, param.SkillDamage, param.SkillType);
		}
		else
		{
			Damage += param.SkillDamage;
		}

		int  RequiredMP  = (int)pSkillInfo->getConsumeMP();
		bool bManaCheck  = hasEnoughMana(pSlayer, RequiredMP);
		bool bTimeCheck  = verifyRunTime(pSkillSlot);
		bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
		bool bHitRoll    = false;
		bool bCanHit     = canHit(pSlayer, pTargetCreature, param.SkillType);
		bool bPK         = verifyPK(pSlayer, pTargetCreature);

		if (param.bMagicHitRoll)
		{
			bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
		}
		else 
		{
			bHitRoll = HitRoll::isSuccess(pSlayer, pTargetCreature, SkillLevel/2);
		}

		// 档 拌凯狼 扁贱篮 嘎瘤 臼歹扼档 7%狼 单固瘤甫 啊柳促 - by bezz
		if ( param.ItemClass == Item::ITEM_CLASS_BLADE && !bHitRoll )
		{
			Damage = getPercentValue( Damage, 7 );
			bHitRoll = true;
		}

		// 付唱啊 乐绢具 窍绊, 矫埃苞 芭府 眉农俊 己傍窍绊,
		// hitroll俊 己傍窍绊, 农肺胶 墨款磐啊 吧妨乐瘤 臼促搁, 己傍捞促.
		if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK)
		{
			CheckCrossCounter(pSlayer, pTargetCreature, Damage, pSkillInfo->getRange());

			decreaseMana(pSlayer, RequiredMP, _GCSkillToObjectOK1);

			// 单固瘤甫 林绊, 郴备档甫 冻绢哆赴促.
			setDamage(pTargetCreature, Damage, pSlayer, param.SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
			computeAlignmentChange(pTargetCreature, Damage, pSlayer, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
			decreaseDurability(pSlayer, pTargetCreature, pSkillInfo->getPoint(), &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);

			// 农府萍拿 洒飘扼搁 惑措规阑 第肺 拱矾唱霸 茄促.
			if (bCriticalHit)
			{
				knockbackCreature(pZone, pTargetCreature, pSlayer->getX(), pSlayer->getY());
			}

			// 浇饭捞绢啊 酒囱 版快俊父 版氰摹啊 棵扼埃促.
			if (!pTargetCreature->isSlayer())
			{
				if (bIncreaseDomainExp)
				{
					shareAttrExp(pSlayer, Damage, param.STRMultiplier, param.DEXMultiplier, param.INTMultiplier, _GCSkillToObjectOK1);
					increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToObjectOK1);
					increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToObjectOK1);
				}

				increaseAlignment(pSlayer, pTargetCreature, _GCSkillToObjectOK1);
			}

			// 菩哦阑 霖厚窍绊, 焊辰促. 
			_GCSkillToObjectOK1.setSkillType(param.SkillType);
			_GCSkillToObjectOK1.setCEffectID(CEffectID);
			_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
			_GCSkillToObjectOK1.setDuration(0);
		
			_GCSkillToObjectOK2.setObjectID(pSlayer->getObjectID());
			_GCSkillToObjectOK2.setSkillType(param.SkillType);
			_GCSkillToObjectOK2.setDuration(0);
		
			_GCSkillToObjectOK5.setObjectID(pSlayer->getObjectID());
			_GCSkillToObjectOK5.setSkillType(param.SkillType);
			_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
			_GCSkillToObjectOK5.setDuration(0);

			if ( param.SkillType == SKILL_TYPHOON )
			{
				if ( !pTargetCreature->isMonster() )
				{
					int TargetLevel = 0;

					if ( pTargetCreature->isSlayer() )
					{
						Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
						Assert( pTargetSlayer != NULL );

						TargetLevel = pTargetSlayer->getHighestSkillDomainLevel();
					}
					else if ( pTargetCreature->isVampire() )
					{
						Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
						Assert( pTargetVampire != NULL );

						TargetLevel = pTargetVampire->getLevel();
					}
					else if ( pTargetCreature->isOusters() )
					{
						Ousters* pTargetOusters = dynamic_cast<Ousters*>(pTargetCreature);
						Assert( pTargetOusters != NULL );

						TargetLevel = pTargetOusters->getLevel();
					}
					
					int LevelDiff = pSlayer->getSkillDomainLevel( SKILL_DOMAIN_BLADE ) - TargetLevel;
					int Ratio = 0;

					if ( LevelDiff >= 10 )
					{
						Ratio = 100;
					}
					else if ( LevelDiff > 0 )
					{
						Ratio = 80;
					}
					else if ( LevelDiff == 0 )
					{
						Ratio = 60;
					}
					else if ( LevelDiff > -10 )
					{
						Ratio = 40;
					}
					else
					{
						Ratio = 20;
					}

					if ( (rand()%100)<Ratio )
					{
						// 胶畔 寸秦谎蝶!
						_GCSkillToObjectOK1.setGrade(1);
						_GCSkillToObjectOK2.setGrade(1);
						_GCSkillToObjectOK5.setGrade(1);
					}
				}
				else //阁胶磐老 版快
				{
					_GCSkillToObjectOK1.setGrade(1);
					_GCSkillToObjectOK2.setGrade(1);
					_GCSkillToObjectOK5.setGrade(1);
				}
			}
		
			pPlayer->sendPacket(&_GCSkillToObjectOK1);
		
			if (pTargetCreature->isPC()) 
			{
				Player* pTargetPlayer = pTargetCreature->getPlayer();
				Assert(pTargetPlayer != NULL);
				pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
			} 
			else 
			{
				Monster * pMonster = dynamic_cast<Monster*>(pTargetCreature);
				pMonster->addEnemy(pSlayer);
			}

			list<Creature*> cList;
			cList.push_back(pSlayer);
			cList.push_back(pTargetCreature);

			pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &_GCSkillToObjectOK5, cList);

			pSkillSlot->setRunTime(param.Delay);

			result.bSuccess = true;
		} 
		else 
		{
			executeSkillFailNormal(pSlayer, param.SkillType, pTargetCreature );
		}
	} 
	catch (Throwable & t) 
	{
		executeSkillFailException(pSlayer, param.SkillType);
	}

	__END_CATCH
}

void SimpleMeleeSkill::execute(
	Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot,
	const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result, 
	CEffectID_t CEffectID, int HitBonus) 
	throw (Error)
{
	__BEGIN_TRY

	Assert(pVampire != NULL);
	Assert(pVampireSkillSlot != NULL);

	try 
	{
		Player* pPlayer = pVampire->getPlayer();
		Zone* pZone = pVampire->getZone();
		Assert(pPlayer != NULL);
		Assert(pZone != NULL);

		Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
		//Assert(pTargetCreature != NULL);

		// NPC绰 傍拜且 荐啊 绝促.
		// NoSuch力芭. by sigi. 2002.5.2
		if (pTargetCreature==NULL
			|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_NO_DAMAGE) // by sigi. 2002.10.30
			|| pTargetCreature->isNPC())
		{
			executeSkillFailException(pVampire, param.SkillType);
			return;
		}

		result.pTargetCreature = pTargetCreature;

		GCSkillToObjectOK1 _GCSkillToObjectOK1;
		GCSkillToObjectOK2 _GCSkillToObjectOK2;
		GCSkillToObjectOK5 _GCSkillToObjectOK5;

		SkillInfo* pSkillInfo   = g_pSkillInfoManager->getSkillInfo(param.SkillType);
		bool       bCriticalHit = false;
		Damage_t   Damage       = 0;

		if (param.bAdd)
		{
			// 颇扼固磐肺 傈崔等 单固瘤 蔼捞 歹秦瘤绰 单固瘤扼搁, 
			// 老馆 单固瘤甫 拌魂 饶, 单固瘤甫 歹秦具 茄促.
			// 颇扼固磐肺 傈崔等 单固瘤 蔼捞 流立利栏肺 静捞绰 单固瘤扼搁,
			// 捞 何盒鳖瘤 甸绢坷瘤 臼栏骨肺, 关狼 何盒鳖瘤 0栏肺 傈崔等促.
			Damage += computeDamage(pVampire, pTargetCreature, 0, bCriticalHit);
		}

		if (param.bMagicDamage)
		{
			// 父老 胶懦 单固瘤啊 付过 单固瘤扼搁, 付过 单固瘤 拌魂 窃荐甫 捞侩秦 拌魂阑 秦霖促.
			Damage += computeMagicDamage(pTargetCreature, param.SkillDamage, param.SkillType, true);
		}
		else
		{
			Damage += param.SkillDamage;
		}

		int  RequiredMP         = decreaseConsumeMP(pVampire, pSkillInfo);
		bool bManaCheck         = hasEnoughMana(pVampire, RequiredMP);
		bool bTimeCheck         = verifyRunTime(pVampireSkillSlot);
		bool bRangeCheck        = verifyDistance(pVampire, pTargetCreature, pSkillInfo->getRange());
		bool bHitRoll           = false;
		bool bCanHit            = canHit(pVampire, pTargetCreature, param.SkillType);
		bool bPK                = verifyPK(pVampire, pTargetCreature);

		if (param.bMagicHitRoll)
		{
			bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
		}
		else 
		{
			bHitRoll = HitRoll::isSuccess(pVampire, pTargetCreature);
		}

		if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK)
		{
			CheckCrossCounter(pVampire, pTargetCreature, Damage);

			// 付唱甫 憋绰促.
			decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
		
			// 单固瘤甫 啊窍绊, 酒捞袍 郴备档甫 冻绢哆赴促.
			setDamage(pTargetCreature, Damage, pVampire, param.SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
			computeAlignmentChange(pTargetCreature, Damage, pVampire, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
			decreaseDurability(pVampire, pTargetCreature, pSkillInfo->getPoint(), &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);

			// 农府萍拿 洒飘扼搁 惑措规阑 第肺 拱矾唱霸 茄促.
			if (bCriticalHit)
			{
				knockbackCreature(pZone, pTargetCreature, pVampire->getX(), pVampire->getY());