graydarkness.cpp

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

//////////////////////////////////////////////////////////////////////////////
// Filename    : GrayDarkness.cpp
// Written by  : 
// Description : 
//////////////////////////////////////////////////////////////////////////////

#include "GrayDarkness.h"
#include "EffectGrayDarkness.h"
#include "RankBonus.h"

#include "MonsterCorpse.h"
#include "ctf/FlagManager.h"

#include "Gpackets/GCSkillToTileOK1.h"
#include "Gpackets/GCSkillToTileOK2.h"
#include "Gpackets/GCSkillToTileOK3.h"
#include "Gpackets/GCSkillToTileOK4.h"
#include "Gpackets/GCSkillToTileOK5.h"
#include "Gpackets/GCSkillToTileOK6.h"
#include "Gpackets/GCAddEffect.h"
#include "Gpackets/GCSkillFailed1.h"

int normalizeCoord_GRAY_DARKNESS( int x, int y, int edge )
{
	return x * (edge * 2 + 1 ) + y;
}

//////////////////////////////////////////////////////////////////////////////
// 轨颇捞绢 坷宏璃飘 勤甸矾
//////////////////////////////////////////////////////////////////////////////
void GrayDarkness::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
	throw(Error)
{
	__BEGIN_TRY

	//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;

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

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

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

		// NoSuch力芭. by sigi. 2002.5.2
		if (pTargetCreature==NULL)
		{
			executeSkillFailException(pVampire, getSkillType());
			return;
		}

		execute(pVampire, pTargetCreature->getX(), pTargetCreature->getY(), pVampireSkillSlot, CEffectID);
	} 
	catch (Throwable & t) 
	{
		executeSkillFailException(pVampire, getSkillType());
	}

	//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;

	__END_CATCH
}

//////////////////////////////////////////////////////////////////////////////
// 轨颇捞绢 鸥老 勤甸矾
//////////////////////////////////////////////////////////////////////////////
void GrayDarkness::execute(Vampire* pVampire, ZoneCoord_t X, ZoneCoord_t Y, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
	throw(Error)
{
	__BEGIN_TRY

	//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;

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

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

		Assert(pPlayer != NULL);
		Assert(pZone != NULL);

		GCSkillToTileOK1 _GCSkillToTileOK1;
		GCSkillToTileOK2 _GCSkillToTileOK2;
		GCSkillToTileOK3 _GCSkillToTileOK3;
		GCSkillToTileOK4 _GCSkillToTileOK4;
		GCSkillToTileOK5 _GCSkillToTileOK5;
		GCSkillToTileOK6 _GCSkillToTileOK6;

		SkillType_t SkillType  = pVampireSkillSlot->getSkillType();
		SkillInfo*  pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);

		ZoneCoord_t myX = pVampire->getX();
		ZoneCoord_t myY = pVampire->getY();

		// Knowledge of Innate 啊 乐促搁 hit bonus 10
		int HitBonus = 0;
		if ( pVampire->hasRankBonus( RankBonus::RANK_BONUS_KNOWLEDGE_OF_INNATE ) )
		{
			RankBonus* pRankBonus = pVampire->getRankBonus( RankBonus::RANK_BONUS_KNOWLEDGE_OF_INNATE );
			Assert( pRankBonus != NULL );

			HitBonus = pRankBonus->getPoint();
		}

		int  RequiredMP  = decreaseConsumeMP(pVampire, pSkillInfo);
		bool bManaCheck  = hasEnoughMana(pVampire, RequiredMP);
		bool bTimeCheck  = verifyRunTime(pVampireSkillSlot);
		bool bRangeCheck = verifyDistance(pVampire, X, Y, pSkillInfo->getRange());
		bool bHitRoll    = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
		bool bSlayerSafeZone = pZone->getZoneLevel( X, Y ) & SLAYER_SAFE_ZONE;
		
		bool bTileCheck = false;
		VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
		if (rect.ptInRect(X, Y)) bTileCheck = true;

		if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && !bSlayerSafeZone)
		{
			decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);

			// 捞棋飘狼 瘤加矫埃阑 拌魂茄促.
			SkillInput input(pVampire);
			SkillOutput output;
			computeOutput(input, output);

/*			// Wisdom of GrayDarkness 捞 乐促搁 瘤加矫埃 30% 刘啊
			if ( pVampire->hasRankBonus( RankBonus::RANK_BONUS_WISDOM_OF_GRAY_DARKNESS ) )
			{
				RankBonus* pRankBonus = pVampire->getRankBonus( RankBonus::RANK_BONUS_WISDOM_OF_GRAY_DARKNESS );
				Assert( pRankBonus != NULL );

				output.Duration += getPercentValue( output.Duration, pRankBonus->getPoint() );
			}*/

			Range_t    Range    = 3;

			int oX, oY;
			
			list<Creature*> cList;	// denier list
			
			int edge = 1;

			// Wide GrayDarkness 捞 乐促搁 裹困啊 5*5 肺 荐沥. skill type 阑 荐沥茄促.
/*			if ( pVampire->hasRankBonus( RankBonus::RANK_BONUS_WIDE_GRAY_DARKNESS ) )
			{
				RankBonus* pRankBonus = pVampire->getRankBonus( RankBonus::RANK_BONUS_WIDE_GRAY_DARKNESS );
				Assert( pRankBonus != NULL );

				Range = pRankBonus->getPoint();
				edge = ( pRankBonus->getPoint() - 1 ) / 2;

				SkillType = SKILL_WIDE_GRAY_DARKNESS;
			}*/

//			map<int, uint> canAddMap;

			for(oY = -edge; oY <= edge; oY++)
			for(oX = -edge; oX <= edge; oX++)
			{
				int tileX = X+oX;
				int tileY = Y+oY;
				if (rect.ptInRect(tileX, tileY))
				{
					Tile& tile = pZone->getTile(tileX, tileY);

//					if ( canAddMap[normalizeCoord_GRAY_DARKNESS( oX, oY, edge )] == 1 ) continue;

					if ( tile.hasItem() )
					{
						Item* pItem = tile.getItem();
						if ( pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_CORPSE && pItem->getItemType() == MONSTER_CORPSE )
						{
							MonsterCorpse* pMonsterCorpse = dynamic_cast<MonsterCorpse*>(pItem);
							if ( g_pFlagManager->isFlagPole( pMonsterCorpse ) )
							{
//								canAddMap[normalizeCoord_GRAY_DARKNESS( oX+1, oY, edge )] = 1;
//								canAddMap[normalizeCoord_GRAY_DARKNESS( oX+1, oY+1, edge )] = 1;
//								canAddMap[normalizeCoord_GRAY_DARKNESS( oX, oY+1, edge )] = 1;
								continue;
							}
						}
					}

					if ( tile.getEffect( Effect::EFFECT_CLASS_TRYING_POSITION ) != NULL ) continue;

					// 泅犁 鸥老俊促 捞棋飘甫 眠啊且 荐 乐促搁...
					if (tile.canAddEffect())
					{
						// 赣矫 弊扼款靛 乐澜 眠啊 给茄寸.
						if ( tile.getEffect(Effect::EFFECT_CLASS_MERCY_GROUND) != NULL ) continue;

						// 鞍篮 effect啊 乐栏搁 瘤款促.
						Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_GRAY_DARKNESS);
						if (pOldEffect != NULL)
						{
							ObjectID_t effectID = pOldEffect->getObjectID();
							pZone->deleteEffect(effectID);// fix me
						}
					
						// 捞棋飘 努贰胶甫 积己茄促.
						EffectGrayDarkness* pEffect = new EffectGrayDarkness(pZone , tileX, tileY);
						pEffect->setDeadline(output.Duration);
						pEffect->setLevel(pVampire->getINT());
						pEffect->setDuration(output.Duration);
//						pEffect->setStartTime();

						// Tile俊 嘿捞绰 Effect绰 ObjectID甫 殿废罐酒具 茄促.
						ObjectRegistry & objectregister = pZone->getObjectRegistry();
						objectregister.registerObject(pEffect);
						pZone->addEffect(pEffect);
						tile.addEffect(pEffect);

						const slist<Object*>& oList = tile.getObjectList();
						for(slist<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++) 
						{
							Object* pTarget = *itr;
							Creature* pTargetCreature = NULL;
							if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE 
								&& ( (pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
							) 
							{
								cList.push_back(pTargetCreature);
								_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
								_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
								_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
							}

//							pEffect->affectObject(pTarget, false);
						}
					}	
				}	
			}

			_GCSkillToTileOK1.setSkillType(SkillType);
			_GCSkillToTileOK1.setCEffectID(CEffectID);
			_GCSkillToTileOK1.setX(X);
			_GCSkillToTileOK1.setY(Y);
			_GCSkillToTileOK1.setDuration(output.Duration);
			_GCSkillToTileOK1.setRange(Range);

			_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
			_GCSkillToTileOK2.setSkillType(SkillType);
			_GCSkillToTileOK2.setX(X);
			_GCSkillToTileOK2.setY(Y);
			_GCSkillToTileOK2.setDuration(output.Duration);
			_GCSkillToTileOK2.setRange(Range);
			//_GCSkillToTileOK2.addShortData(MODIFY_VISION, GRAY_DARKNESS_SIGHT);

			_GCSkillToTileOK3.setObjectID(pVampire->getObjectID());
			_GCSkillToTileOK3.setSkillType(SkillType);
			_GCSkillToTileOK3.setX(X);
			_GCSkillToTileOK3.setY(Y);

			_GCSkillToTileOK4.setSkillType(SkillType);
			_GCSkillToTileOK4.setX(X);
			_GCSkillToTileOK4.setY(Y);
			_GCSkillToTileOK4.setRange(Range);
			_GCSkillToTileOK4.setDuration(output.Duration);

			_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
			_GCSkillToTileOK5.setSkillType(SkillType);
			_GCSkillToTileOK5.setX(X);
			_GCSkillToTileOK5.setY(Y);
			_GCSkillToTileOK5.setRange(Range);
			_GCSkillToTileOK5.setDuration(output.Duration);

			_GCSkillToTileOK6.setOrgXY(myX, myY);
			_GCSkillToTileOK6.setSkillType(SkillType);
			_GCSkillToTileOK6.setX(X);
			_GCSkillToTileOK6.setY(Y);
			_GCSkillToTileOK6.setDuration(output.Duration);
			_GCSkillToTileOK6.setRange(Range);
			//_GCSkillToTileOK6.addShortData(MODIFY_VISION, GRAY_DARKNESS_SIGHT);

			for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
			{
				Creature* pTargetCreature = *itr;
				if (canSee(pTargetCreature, pVampire)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);