combatsys.cpp

网络游戏龙族 完整的登陆器 C++ 源代码

// CombatSys.cpp: implementation of the CCombatSys class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CombatSys.h"

#include "Char.h"
#include "Map.h"
#include "Menu.h"
#include "Effect.h"
#include "gameproc.h"
using namespace battle;

extern int g_CurrCharStatus;
extern char tool_ID_EFFECT_TEST;
extern bool IsAttackAble(LPCHARACTER pTarget);
extern void DoLButtonDown();

static bool g_aDirection[8] =
{
	false, true,  true,  true,
		true,  false, false, false
};

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CCombatSys::CCombatSys()
{
	
}

CCombatSys::~CCombatSys()
{
	
}

///////////////////////////////////////////////////////////////////////////////
// Public Method
///////////////////////////////////////////////////////////////////////////////

int CCombatSys::Action(LPCHARACTER pCaster)
{ 
	const int nCombat = pCaster->nActiveCombat;
	
	switch (nCombat)
	{
    case LIGHTNING_BOOM:    return ACTION_ATTACK_BONG_DOWN;
    case THUNDER_BLOW:      return ACTION_ATTACK_ONESWORD2;
    case LIGHTNING_SHOCK:   return ACTION_ATTACK_BONG_JJIRKI;
    case THUNDER_STRIKE:    return ACTION_ATTACK_ONESWORD1;
    case GROUND_ATTACK:     return ACTION_ATTACK_BONG_DOWN;
    case BLOOD_WILL:        return ACTION_ATTACK_ONESWORD1; 
    case SWORD_N_ROSES:     return ACTION_ATTACK_ONESWORD2;
    case HORN_OF_ICEBERG:   return ACTION_ATTACK_BONG_JJIRKI;
    case CHARGING:          return ACTION_ATTACK_BONG_DOWN;
    case DOUBLE_ATTACK:     return ACTION_ATTACK_ONESWORD2;
    case DARK_BLADE:        return ACTION_ATTACK_ONESWORD1;
    case LIGHTNING_EXTREME: return ACTION_ATTACK_BONG_ROUND;	// 030513 kyo
    case EARTH_EXTREME:     return ACTION_ATTACK_BONG_DOWN;
    case DARK_EXTREME:      return ACTION_ATTACK_BONG_ROUND;
    case WIND_EXTREME:      return ACTION_ATTACK_BONG_ROUND;
	}
	
	return ACTION_NONE;
} 

void CCombatSys::Effect(MAGICLIST* pEffect)
{
	LPCHARACTER pCaster = pEffect->lpChar_Own;
	LPCHARACTER pTarget = pEffect->lpChar_Target;
	if (pCaster == NULL || pTarget == NULL)  return;
	
	const int nCombat = pEffect->magicSerial;
	
	if (pEffect->magicSubNum == 8)
	{
		switch (nCombat)
		{
		case BLOOD_EARTH:
			{
				break;
			}
		default:
			{
				::InsertMagic(pCaster, pTarget, 
					pEffect->next_Effect, 9,
					pEffect->x, pEffect->y,
					pEffect->tarx, pEffect->tary);
				break;
			}
		}
	}
	else
	{
		switch (nCombat)
		{
		case MULTIPLE_FIRE:
			{
				switch (pCaster->nActiveLevel)
				{
				case 1:
				case 2: EffectShoot(pEffect, 3); break;
				case 3: EffectShoot(pEffect, 5); break;
				}
				
				break;
			}
		case ICING_BLAST:
			{
				switch (pCaster->nActiveLevel)
				{
				case 1:
				case 2: EffectMulti(pEffect, 3); break;
				case 3: EffectMulti(pEffect, 5); break;
				}
				
				break;
			}
		case LIGHTNING_EXTREME:
			{
				//EffectSpread(pEffect);
				EffectSpreadIrregular(pEffect, g_ClientTime, 5, 7, 2 );	//5鸥老埃拜 2锅 // 030328 kyo
				break;
			}
		case EARTH_EXTREME:
			{
				const int nMax = pCaster->nActiveLevel + 1; 
				EffectQuake(pEffect, nMax, g_ClientTime);
				break;
			}
		case FIRE_EXTREME:
		case ICE_EXTREME:
			{
				EffectSpread(pEffect);
				break;
			}
		case DARK_EXTREME:
			{
				const int nMax = pCaster->nActiveLevel + 1; 
				EffectQuake(pEffect, nMax, g_ClientTime);
				break;
			}
		default:
			{
				::InsertMagic(pCaster, pTarget,
					pEffect->next_Effect,
					pEffect->magicSubNum,
					pEffect->x, pEffect->y,
					pEffect->tarx, pEffect->tary, 
					false, 0, false, 
					pEffect->magic_Runtime);
				break;
			}
		}
	}
}

bool CCombatSys::Ready(LPCHARACTER pCaster, int nCombat, int nReady)
{
	switch (pCaster->nCurrentAction)
	{	//< CSD-030423
	case ACTION_ATTACK_BOW:
	case ACTION_THROW:
	case ACTION_SITDOWN:
		{
			return false;
		}
	}	//> CSD-030423
	// 焊咯瘤绰 付过捞 绝绊 付过 某胶泼捞 啊瓷茄 版快
	if (g_lpML == NULL || pCaster->ready_Magic == 0 || pCaster->ready_Magic == 2)
	{
		if (Hero == pCaster)
		{
			const int nNumber = nCombat - 100;
			
			if (nNumber >= 114 && nNumber <= 150)
			{
				OUTPUT(MK_NORMAL, lan->OutputMessage(1, 60), CombatSkillExplain[nNumber].LocalName);
			}
		}
		
		pCaster->excute_MagicNum = nCombat;  		      // 霖厚吝牢 付过狼 绊蜡锅龋甫 悸泼
		pCaster->ready_Magic = 1;					            // 某胶泼 吝牢 惑怕 悸泼
		pCaster->start_Casting  = g_ClientTime + 3000;
		pCaster->end_Casting = g_ClientTime + nReady;	// 某胶泼 肯丰矫埃 悸泼
		// 傈捧胶懦 霖厚 悼累
		const int nType = g_lpMT[nCombat].order_Type;
		const int nCast = 500 + (nType/10) + (nType%10);
		::InsertMagic(pCaster, pCaster, nCast, 0, 0, 0, 0, 0); 
		return true;
	}	
	
	if (Hero == pCaster)
	{
		OUTPUT(MK_WARNING, lan->OutputMessage(1, 59));
	}
	
	return false;
}

bool CCombatSys::Apply(LPCHARACTER pCaster, LPCHARACTER pTarget, int nCombat, int nX, int nY, bool bFail)
{
	if (!IsAttackAble(pTarget))	// 磷绢 乐芭唱 扁磊 葛靛老 版快 
	{		
		goto COMBAT_FIAL;			// 付过 角菩
	}
	
	if (pTarget == NULL)  pTarget = pCaster;

	if (Hero == pCaster || Hero == pTarget) // 030516 kyo 困摹捞悼 刚历 付过狼 己傍咯何甫 汞绰促. 
	{
		const int nNumber = nCombat - 100;
		
		if (nNumber >= 114 && nNumber <= 150)
		{
			if (bFail) 
			{ // 付过捞 角菩茄 版快扼搁
				OUTPUT(MK_NORMAL, lan->OutputMessage(1, 62), CombatSkillExplain[nNumber].LocalName);
				goto COMBAT_FIAL;
			}
			
			if (pCaster == pTarget)
			{
				OUTPUT(MK_NORMAL, lan->OutputMessage(1, 63), pCaster->name, 
					CombatSkillExplain[nNumber].LocalName);
			}
			else
			{
				OUTPUT(MK_NORMAL, lan->OutputMessage(1, 64), pCaster->name, 
					pTarget->name, 
					CombatSkillExplain[nNumber].LocalName);
			}
		}
	}

	// 矫傈磊啊 某胶泼捞 场唱绊 付过 惯荤 霖厚登绢 乐阑矫 肚绰 甘 抛胶飘甫 困茄 皋春急琶矫		
	if ((g_lpMT[nCombat].excute_Type == 0 && pCaster->ready_Magic == 3) ||
		pCaster->ready_Magic == 2 || tool_ID_EFFECT_TEST == 1)
	{
		DIRECTION	dir = pCaster->direction;
		
		if ((g_lpMT[nCombat].appoint_Type == 1 && pCaster == pTarget) || g_lpMT[nCombat].appoint_Type == 0)
		{
			dir = pCaster->direction;
		}
		else
		{
			::ChangeDirection(&dir, pCaster->x, pCaster->y, nX, nY); // 秦寸 努腐瘤痢栏肺 规氢 傈券
		}
		
		switch (nCombat)
		{ 
		case LIGHTNING_SHIELD:
		case BURNING_BLOODY:	// 030415 kyo
		case ICE_SHIELD:
		case LIGHTNING_BOOM:
		case GROUND_ATTACK:
		case THUNDER_BLOW:
		case LIGHTNING_SHOCK:
		case THUNDER_STRIKE:
		case STONE_ARMOR:
		case CRITICAL_HIDING:
		case HORN_OF_ICEBERG:
		case CHARGING:
		case TWISTER:
		case TYBERN_GIFT:
		case ACUQUIRE_DARK:	// 030415 kyo
		case DARK_BLADE:
		case MULTIPLE_FIRE:
		case ICING_BLAST:
		case SIMUNIAN_BOSOM:
		case LIGHTNING_EXTREME: //030513 kyo 
		case EARTH_EXTREME:
		case FIRE_EXTREME:
		case DARK_EXTREME:
		case ICE_EXTREME:
		case WIND_EXTREME:
			{
				::CharDoAni(pCaster, dir, ACTION_BATTLE_NONE);
				break;
			}
		case WHILWIND:
			{	//< CSD-TW-030701
				::CharDoAni(pCaster, dir, ACTION_MAGIC_CASTING);
				break;
			}	//> CSD-TW-030701
		case BLOOD_EARTH:
		case POISONING_NOVA:
			{
				ClearCrash();
				::CharDoAni(pCaster, dir, ACTION_MAGIC_BEFORE);
				break;
			}
		} 
		
		if (!AddEffect(pCaster, pTarget, nCombat, nX, nY, bFail))
		{
			OUTPUT(MK_WARNING, lan->OutputMessage(1, 61));	
			goto COMBAT_FIAL;
		}
	}
	
	// 付过 霖厚惑怕俊辑 付过角力备泅 窜拌肺 傈捞 悸泼
	if (pCaster->ready_Magic == 2)
	{
		// 蜡瘤矫埃捞 粮犁窍绰 付过牢 版快
		if (g_lpMT[nCombat].continue_Time != 0)	
		{
			pCaster->ready_Magic = 3;	// 付过备泅 矫累
		}
		// 茄锅 矫傈俊 茄锅 荤侩 啊瓷茄 付过牢 版快
		if (g_lpMT[nCombat].excute_Type == 1)	
		{
			::EndCastMagic(pCaster);	// 矫傈磊狼 付过 霖厚惑怕甫 檬扁拳
		}
		
		return true;
	}
	
	if (Hero == pCaster)
	{
		OUTPUT(MK_NORMAL, lan->OutputMessage(1, 65));
	}
	
COMBAT_FIAL:
	::EndCastMagic(pCaster);	// 矫傈磊狼 付过 霖厚惑怕甫 檬扁拳
	return false;
}

void CCombatSys::Effect(LPCHARACTER pCaster, LPCHARACTER pTarget)
{
	static int nTemp;
	
	if (pCaster != NULL)
	{
		const int nCaster = pCaster->nActiveCombat;
		
		switch (nCaster)
		{
		case LIGHTNING_BOOM:
			{
				::InsertMagic(pCaster, pTarget, 569, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case THUNDER_BLOW:
			{
				::InsertMagic(pCaster, pTarget, 577, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case LIGHTNING_SHOCK:
			{
				::InsertMagic(pCaster, pTarget, 553, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case THUNDER_STRIKE:
			{
				::InsertMagic(pCaster, pTarget, 552, 4, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case GROUND_ATTACK:
			{
				::InsertMagic(pCaster, pTarget, 574, 4, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case BLOOD_WILL:
			{
				::InsertMagic(pCaster, pTarget, 555, 4, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case SWORD_N_ROSES:
			{
				if (++nTemp%3 == 1)
				{
					::InsertMagic(pCaster, pTarget, 572, 9, 0, 0, pTarget->x, pTarget->y);
				}
				
				break;
			}
		case FLEET_MISSILE:
			{
				InsertMagic(pCaster, pTarget, 575, 0, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case CONVERTING_ARMOR:
			{
				::InsertMagic(pCaster, pTarget, 29, 0, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case HORN_OF_ICEBERG:
			{
				::InsertMagic(pCaster, pTarget, 565, 4, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case CHARGING:
		case DOUBLE_ATTACK:
			{
				::InsertMagic(pCaster, pTarget, 567, 4, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case CHERROY_SHADE:
			{
				::InsertMagic(pCaster, pTarget, 570, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case DARK_BLADE:
			{
				::InsertMagic(pCaster, pTarget, 576, 4, 0, 0, pTarget->x, pTarget->y);
				::InsertMagic(pCaster, pTarget, 560, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case CRITICAL_HIDING:
			{
				::InsertMagic(pCaster, pTarget, 179, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case MULTIPLE_FIRE:
		case FIRE_EXTREME:
			{
				::InsertMagic(pCaster, pTarget, 513, 0, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case ICING_BLAST:
		case ICE_EXTREME:
			{
				::InsertMagic(pCaster, pTarget, 514, 0, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case SHARK_MISSILE:
			{
				switch (pCaster->nCurrentAction)
				{
				case ACTION_ATTACK_BOW:
					{
						::InsertMagic(pCaster, pTarget, 38, 0, 0, 0, pTarget->x, pTarget->y);
						break;
					}
				case ACTION_THROW:
					{
						::InsertMagic(pCaster, pTarget, 189, 0, 0, 0, pTarget->x, pTarget->y);
						break;
					}
				}
				
				break;
			}
		case LIGHTNING_EXTREME: 
			{
				::InsertMagic(pCaster, pTarget, 587, 9, 0, 0, pTarget->x, pTarget->y); // 030513 kyo
				break;
			}
		case EARTH_EXTREME:
			{
				::InsertMagic(pCaster, pTarget, 586, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case DARK_EXTREME: 
			{
				::InsertMagic(pCaster, pTarget, 596, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
		case WIND_EXTREME:
			{
				::InsertMagic(pCaster, pCaster, 591, 0, 0, 0, pCaster->x, pCaster->y);
				::InsertMagic(pCaster, pTarget, 590, 9, 0, 0, pTarget->x, pTarget->y);
				break;
			}
    }
  }
  
  if (pTarget != NULL)
  {
	  const int nActive = pTarget->nActiveCombat;
	  
	  switch (nActive)
	  {
      case STONE_ARMOR:
		  {
			  ::InsertMagic(pTarget, pTarget, 573, 9, 0, 0, pTarget->x, pTarget->y);
			  break;
		  }
	  }
	  
	  const int nPassive = pTarget->nPassiveCombat;
	  
	  switch (nPassive)
	  {
      case LIGHTNING_SHIELD:
		  {
			  ::InsertMagic(pTarget, pTarget, 580, 9, 0, 0, pTarget->x, pTarget->y);
			  break;
		  }
      case ICE_SHIELD:
		  {
			  ::InsertMagic(pTarget, pTarget, 584, 9, 0, 0, pTarget->x, pTarget->y);
			  break;
		  }
	  }
  }
}

int CCombatSys::GetCastContinue(int nCombat) const
{
	return g_lpMT[nCombat].cast_Continue;
}

bool CCombatSys::IsEnable(int nCombat) const
{
	// 乞拳葛靛 惑怕俊辑绰 傈捧胶懦 荤侩 阂啊
	if (main_interface.data[IF_BATTLE_PEACE] == 0)  
	{ 
		OUTPUT(MK_NORMAL, lan->OutputMessage(1, 55));
		return false;
	}
	// 某腐磐啊 磷绢 乐绰 版快
	if (SCharacterData.nCharacterHP <= 0)	
	{
		OUTPUT(MK_WARNING, lan->OutputMessage(1, 66));
		return false;
	}
	// 某腐磐啊 咯包俊辑 磊绊 乐绰 版快
	if (SCharacterData.sleep != CSC_AWAKE)
	{
		OUTPUT(MK_WARNING, lan->OutputMessage(1, 67));
		return false;
	}
	// 旧酒 乐绰 惑怕俊绰 付过矫傈 阂啊
	if (Hero->nCurrentAction == 17)
	{
		return false;
	}
	// 扒拱 救俊 乐绰 版快
	const int nX = Hero->x>>5;
	const int nY = Hero->y>>5;
	
	if (TileMap[nX][nY].attr_inside == 1)
	{
		OUTPUT(MK_WARNING, lan->OutputMessage(1, 4));
		return false;
	}
	
	return true;
}

///////////////////////////////////////////////////////////////////////////////
// Protected Method
///////////////////////////////////////////////////////////////////////////////

bool CCombatSys::AddEffect(LPCHARACTER pCaster, LPCHARACTER pTarget, int nCombat, int nX, int nY, bool bFail)
{
	const int nEffect = nCombat + 300;
	const bool bPattern = false;
	
	switch (nCombat)
	{
	case LIGHTNING_SHIELD:
    case BURNING_BLOODY: 	// 030415 kyo
    case ICE_SHIELD:
    case THUNDER_BLOW:
    case LIGHTNING_SHOCK:
    case THUNDER_STRIKE:
    case BLOOD_WILL:
    case STONE_ARMOR:
    case SWORD_N_ROSES:
    case MULTIPLE_FIRE:
    case FLEET_MISSILE:
    case CONVERTING_ARMOR:
    case HORN_OF_ICEBERG:
    case ICING_BLAST:
    case CRITICAL_HIDING:
    case DOUBLE_ATTACK:
    case GUST:
    case TYBERN_GIFT:
	case ACUQUIRE_DARK:	// 030415 kyo
    case CHERROY_SHADE:
    case SHARK_MISSILE:
    case DARK_BLADE:
    case SIMUNIAN_BOSOM:
    case LIGHTNING_EXTREME:
    case EARTH_EXTREME:
    case FIRE_EXTREME:
    case DARK_EXTREME:
    case ICE_EXTREME:
    case WIND_EXTREME:
		{
			::InsertMagic(pCaster, pTarget, nEffect, 0, 0, 0, nX, nY, bPattern, 0, bFail);
			break;
		}
    case LIGHTNING_BOOM:
    case BLOOD_EARTH:
    case GROUND_ATTACK:
    case POISONING_NOVA:
    case WHILWIND:
    case TWISTER:
		{ 
			::InsertMagic(pCaster, pTarget, nEffect, 8, 0, 0, nX, nY, bPattern, 0, bFail);
			break;
		}
    case CHARGING:
		{ 
			::InsertMagic(pCaster, pTarget, nEffect, 2, 0, 0, nX, nY, bPattern, 0, bFail);
			break;
		}
    default:
		{
			return false;				
		}
	}												
	
	return true;
}