skillformula.cpp

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

void GunShotGuidance::computeOutput( const SkillInput& input, SkillOutput& output )
{
	output.Damage	= 50 + input.SkillLevel / 2;
	output.Duration	= 10;
	output.Delay	= 10;
	output.Range	= 8;
}

void AirShield::computeOutput( const SkillInput& input, SkillOutput& output )
{
//	output.Damage	= 50 + ( input.SkillLevel >> 1 ); 			// 50 + SkillLevel / 2
	output.Damage	= 50 + ( input.SkillLevel / 5 ); 			// 50 + SkillLevel / 2
	output.Duration = ( 10 + ( input.SkillLevel >> 1 ) ) * 10;	// 10 + SkillLevel / 2 (檬)
	//output.Delay	= ( 5 - ( input.SkillLevel / 25 ) ) * 10;
	output.Delay	= output.Duration;		// Delay 客 Duration 捞 鞍促. by bezz 2003.3.5
}

void BulletOfLight::computeOutput( const SkillInput& input, SkillOutput& output )
{
/*	switch( input.IClass )
	{
		case Item::ITEM_CLASS_SMG:
			output.Damage = 2 + ( input.SkillLevel / 10 );
			break;
		case Item::ITEM_CLASS_SG:
			output.Damage = 3 + ( input.SkillLevel / 8 );
			break;
		case Item::ITEM_CLASS_AR:
			output.Damage = 4 + ( input.SkillLevel / 6 );
			break;
		case Item::ITEM_CLASS_SR:
			output.Damage = 5 + ( input.SkillLevel / 5 );
			break;
		default:
			output.Damage = 0;
			break;
	}*/
	output.Damage = - 20 + ( input.SkillLevel * 2 / 3 ); // / 1.5 );
	output.ToHit  = - 10 + ( input.SkillLevel / 2 ); // / 1.5 );
	output.Delay  = 2;	// 0.2檬
}

void HandsOfWisdom::computeOutput(const SkillInput& input, SkillOutput& output) 
{
	output.Damage = input.STR / 15 + input.INTE / 8;
	output.Delay  = 6; // 0.6檬
}

void LightBall::computeOutput(const SkillInput& input, SkillOutput& output) 
{
//	output.Damage = 2 + (input.INTE/20) + (input.SkillLevel/10);
	output.Damage = 9 + (input.INTE/20) + (input.SkillLevel/10);
	output.Delay  = 10; // 1檬
	output.Range  = 2 + (input.SkillLevel/25);
}

void HolyArrow::computeOutput(const SkillInput& input, SkillOutput& output) 
{
//	output.Damage = 2 + (input.INTE/20) + (input.SkillLevel/10);
	output.Damage = 8 + (input.INTE/20) + (input.SkillLevel/10);
	output.Delay  = 10; // 1檬
	output.Range  = 2 + (input.SkillLevel/25);
}

void Rebuke::computeOutput(const SkillInput& input, SkillOutput& output)
{
//	output.Duration = ( 2 + (input.SkillLevel/20) ) * 10;
	output.Duration = ( 8 + (input.SkillLevel/20) ) * 10;
//	output.Damage	= ( input.INTE/10 ) + ( input.SkillLevel/5 );
	output.Damage	= 10 + ( input.INTE/10 ) + ( input.SkillLevel/5 );
	output.Delay	= 80;
}

void SpiritGuard::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Duration = ( 10 + (input.SkillLevel/2) ) * 10;
	output.Damage	= ( input.INTE/10 ) + ( input.SkillLevel/4 );
	output.Delay	= 10;
	output.Tick		= 10;
}

void Regeneration::computeOutput(const SkillInput& input, SkillOutput& output)
{
//	output.Duration = ( 5 + (input.SkillLevel/10) ) * 10;
	output.Damage	= 10 + ( input.INTE/40 ) + ( input.SkillLevel/10 );
	output.Duration = ( 15 + (input.SkillLevel/2) ) * 10;
//	output.Delay	= ( 6 + (input.SkillLevel/50) ) * 10;
	output.Delay	= output.Duration;
	output.Tick		= 10;
}

void PowerOfLand::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Delay	= 10;
	output.Damage	= ( input.STR / 8 ) + ( input.SkillLevel / 3 );
	output.Duration = 10;	// 1檬
	output.Tick		= 10;	// 1檬
}

void TurnUndead::computeOutput(const SkillInput& input, SkillOutput& output)
{
//	output.Damage	= 10 + ( input.INTE / 20 ) + ( input.SkillLevel / 2 );
	output.Damage	= 20 + ( input.INTE / 20 ) + ( input.SkillLevel / 3 );
	output.Delay	= 10;
}

void Armageddon::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage	= ( input.STR / 8 ) + ( input.INTE / 6 );
	output.Delay	= 10;
	output.Duration	= ( ( input.DEX / 10 ) + ( input.INTE / 20 ) ) * 10;
	output.Tick		= 10;
}

void BloodyBreaker::computeOutput(const SkillInput& input, SkillOutput& output) 
{
	output.Damage = input.INTE/4 + input.STR/5 + input.DEX/5;
	output.Delay = max(1, 3-input.DEX/50 ) * 10;
	// ToHit 篮 knockback 犬伏
	output.ToHit = 50;
}

void RapidGliding::computeOutput(const SkillInput& input, SkillOutput& output) 
{
	output.Range = min( 6, 2 + ( input.DEX / 50 ) );
	output.Delay = max( 1, 5 - ( input.DEX / 60) ) * 10;// min=1
}

void MagicElusion::computeOutput(const SkillInput& input, SkillOutput& output)
{
	Attr_t SUM = ( input.STR + input.DEX + input.INTE );
	output.Damage =  SUM / 5;
	output.Duration = 50 + ( SUM / 3 );
	output.Delay = 50;
}

void PoisonMesh::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage =  5 + input.SkillLevel/4;
	output.Duration = 50;
	output.Delay = 50;
}

void IllusionOfAvenge::computeOutput(const SkillInput& input, SkillOutput& output)
{
	Attr_t SUM = ( input.STR + input.DEX + input.INTE );
	output.Damage = 15 + (SUM/3);
	output.Delay = 50;
}

void WillOfLife::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage = 5 + input.SkillLevel/7;
	output.Duration = 30 + input.SkillLevel;
	output.Delay = output.Duration * 2;
}

void DenialMagic::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Duration = ( 10 + ( input.SkillLevel / 2 ) ) * 10;
	output.Delay = ( 8 - ( input.SkillLevel / 20 ) ) * 10;
}

void Requital::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Duration = ( 10 + ( input.SkillLevel / 2 ) ) * 10;
	output.Delay = ( 10 + ( input.SkillLevel / 2 ) ) * 10;
	output.Damage = ( input.INTE / 8 ) + ( input.SkillLevel / 4 );
}

void Concealment::computeOutput(const SkillInput& input, SkillOutput& output)
{
//	output.Duration = ( 5 + ( input.SkillLevel / 5 )) * 10;
//	output.Duration = ( 15 + ( input.SkillLevel / 3 )) * 10;
	output.Duration = ( 30 + ( input.SkillLevel / 2 )) * 10;
//	output.Delay = max( 1, 5 - ( input.DEX / 50 ) ) * 10;
	output.Delay = output.Duration;
}

void SwordRay::computeOutput(const SkillInput& input, SkillOutput& output)
{
//	output.Damage = 5 + input.STR/15 + input.SkillLevel/10;
	output.Damage = input.STR/25 + input.SkillLevel/20;
	output.Range =  2 + input.SkillLevel/33;
	output.Delay = ( 5 - input.SkillLevel/25 ) * 10;
	output.Tick=5;
	output.Duration=5;
}

void MultiAmputate::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage = input.STR/20 + input.SkillLevel/10;
	output.Range =  2 + input.SkillLevel/25;
	output.Delay = ( 5 - input.SkillLevel/25 ) * 10;
}

void HitConvert::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Delay = (8 - input.SkillLevel/33) * 10;
	output.Range = 2 + input.SkillLevel/33;
}

void WildTyphoon::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage = (input.STR/12) + (input.SkillLevel/5);
	output.Delay = 50 - input.SkillLevel*10/25;
	output.Range = 1;
}

void UltimateBlow::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Delay = 100 - input.SkillLevel*10/25;
	output.Range = 1 + input.SkillLevel/50;
}

void Illendue::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage = ( input.INTE / 10 ) * ( 1 + ( input.SkillLevel / 33 ) );
	output.Delay = 50 - input.SkillLevel*10/33;
	output.Range = 5;
}

void Lightness::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Duration = ( 15 + ( ( input.SkillLevel / 25 ) * 10 ) ) * 10;
	output.Delay = min ( 300, output.Duration );
}

void Flourish::computeOutput(const SkillInput& input, SkillOutput& output)
{
	// 1 <= SkillLevel <= 15
	if ( input.SkillLevel < 16 )
	{
		output.Damage = 3 + (int)( ( input.STR / 20.0 ) * ( 1.0 + ( input.SkillLevel / 22.5 ) ) );
		output.Damage = min( 30, output.Damage );
	}
	// 16 <= SkillLevel <= 30
	else
	{
		output.Damage = 3 + (int)( ( input.STR / 20.0 ) * ( 4.0 / 3.0 + ( input.SkillLevel / 45.0 ) ) );
		output.Damage = min( 30, output.Damage );
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.1);
	}
}

void Evade::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = (int)( ( input.DEX / 10.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 22.5 ) ) );
		output.Damage = 10 + (int)( input.SkillLevel * 16.0 / 9.0 );
	}
	else
	{
//		output.Damage = (int)( ( input.DEX / 10.0 ) * ( 4.0/3.0 + ( (float)(input.SkillLevel) / 45.0 ) ) );
		output.Damage = 10 + (int)( 40.0 / 3.0 + input.SkillLevel * 8.0 / 9.0 );
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.1);
	}

	output.Damage = min( 50, output.Damage );
//	output.Duration = (int)(( 30.0 + ( (float)(input.SkillLevel) * 3.0 ) ) * 10);
	output.Duration = ( 60 + input.DEX / 10 * ( input.SkillLevel * 2 / 3 ) ) * 10;
	output.Duration = min( 1200, output.Duration );
//	output.Delay = max ( 50 , output.Duration * 2 - ( input.DEX * 2 ) );
	output.Delay = output.Duration - ( input.SkillLevel / 5 );
}

void SharpRound::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = (int)( ( input.STR / 9.0 ) * ( 1.0 + ( input.SkillLevel / 15.0 ) ) );
		output.Damage = (int)(14.0 + ( input.STR / 15.0 ) * ( 1.0 + ( input.SkillLevel / 15.0 )));
		output.Damage = min( 55, output.Damage );
	}
	else
	{
//		output.Damage = (int)( ( input.STR / 9.0 ) * ( 1.5 + ( input.SkillLevel / 30.0 ) ) );
		output.Damage = (int)(14.0 + ( input.STR / 15.0 ) * ( 1.5 + ( input.SkillLevel / 30.0 )));
		output.Damage = min( 55, output.Damage );
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.1);
	}

	output.Delay = 0;
}

void BackStab::computeOutput(const SkillInput& input, SkillOutput& output)
{
}

void Blunting::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
		output.Damage = min(60,(int)(( (input.STR/20.0) + (input.DEX/10.0) ) * ( 1.0 + (input.SkillLevel/15.0) )));
	}
	else
	{
		output.Damage = min(60,(int)(( (input.STR/20.0) + (input.DEX/10.0) ) * ( 1.5 + (input.SkillLevel/30.0) )));
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.1);
	}

	output.Duration = min( 300, (int)((( (input.DEX+input.INTE) / 20.0 ) + ( (input.SkillLevel/2.0) )) * 10) );
	if ( input.SkillLevel == 30 ) output.Duration = (int)(output.Duration * 1.1);

	output.Delay = max(40,(int)(( 8 - (input.DEX/50.0) ) * 10));
	output.Range = 1 + (input.SkillLevel/10);
}

void GammaChop::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
		output.Damage = 10 + (int)( ( input.STR / 10.0 ) * ( 1.0 + ( input.SkillLevel / 11.25 ) ) );
		output.Damage = min( 120, output.Damage );
	}
	else
	{
		output.Damage = 10 + (int)( ( input.STR / 10.0 ) * ( 5.0/3.0 + ( input.SkillLevel / 22.5 ) ) );
		output.Damage = min( 120, output.Damage );
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.1);
	}
	output.Delay = 10;//max(10,(int)(( 4 - ( input.DEX / 60.0 ) ) * 10));
	output.Range = 1 + (input.SkillLevel / 15);
}

void CrossGuard::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = (int)( ( input.STR / 20.0 ) * ( 1.0 + ( input.SkillLevel / 11.25 ) ) );
		output.Damage = 15 + ( input.SkillLevel * 14 / 9 );
	}
	else
	{
//		output.Damage = (int)( ( input.STR / 20.0 ) * ( 5.0/3.0 + ( input.SkillLevel / 22.5 ) ) );
		output.Damage = 15 + ( 35 / 3 + input.SkillLevel * 7 / 9 );
	}

	output.Damage = min( 50, output.Damage );
	output.Duration = (int)(( 60.0 + ( input.DEX / 10.0 ) + ( input.SkillLevel * 2.0 ) ) * 10);
	output.Duration = min( 1800, output.Duration );

	if ( input.SkillLevel == 30 ) output.Duration = (int)(output.Duration * 1.1);

	output.Delay = output.Duration;
}

void KasasArrow::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = 7 + (int)( ( input.INTE / 8.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 22.5 ) ) );
		output.Damage = 15 + (int)( ( input.INTE / 55.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 30.0 ) ) );
	}
	else
	{
//		output.Damage = 7 + (int)( ( input.INTE / 8.0 ) * ( 4.0/3.0 + ( (float)(input.SkillLevel) / 45.0 ) ) );
		output.Damage = 15 + (int)( ( input.INTE / 50.0 ) * ( 1.5 + ( (float)(input.SkillLevel) / 25.0 ) ) );
		if ( input.SkillLevel == 30 ) output.Damage = (int)(output.Damage * 1.2);
	}

	output.Delay = 0;
	output.Range = 3 + (input.SkillLevel / 10);
}

void HandsOfFire::computeOutput(const SkillInput& input, SkillOutput& output)
{
	output.Damage = (int)( 5.0 + input.SkillLevel*15.0/30.0 );
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = (int)( ( 1 + input.INTE / 50.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 22.5 ) ) );
//		output.Damage = (int)( ( 7 + input.INTE / 12.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 11.25 ) ) );
	}
	else
	{
//		output.Damage = (int)( ( 1 + input.INTE / 50.0 ) * ( 4.0/3.0 + ( (float)(input.SkillLevel) / 45.0 ) ) );
//		output.Damage = (int)( ( 7 + input.INTE / 12.0 ) * ( 5.0/3.0 + ( (float)(input.SkillLevel) / 22.5 ) ) );
	}

	output.Duration = (int)(( 60.0 + (input.DEX / 10.0 ) + (input.SkillLevel*1.5) ) * 10);
	if ( input.SkillLevel == 30 ) output.Duration = (int)(output.Duration * 1.1);
	output.Duration = min(1200, output.Duration);
	output.Delay = output.Duration;
}

void Prominence::computeOutput(const SkillInput& input, SkillOutput& output)
{
	if ( input.SkillLevel <= 15 )
	{
//		output.Damage = (int)( ( input.INTE / 30.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 15.0 ) ) );
//		output.Damage = 15 + (int)( ( input.INTE / 20.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 11.25 ) ) );
		output.Damage = 5 + (int)( ( input.INTE / 25.0 ) * ( 1.0 + ( (float)(input.SkillLevel) / 10.0 ) ) );
	}
	else
	{
//		output.Damage = (int)( ( input.INTE / 30.0 ) * ( 1.5 + ( (float)(input.SkillLevel) / 30.0 ) ) );
//		output.Damage = 15 + (int)( ( input.INTE / 20.0 ) * ( 5.0/3.0 + ( (float)(input.SkillLevel) / 22.5 ) ) );
		output.Damage = 5 + (int)( ( input.INTE / 25.0 ) * ( 2.0 + ( (float)(input.SkillLevel) / 25.0 ) ) );
	}

	output.Duration = (int)(( 5.0 + ( input.INTE / 30.0 ) + (input.SkillLevel/5.0) ) * 10);
	output.Delay = output.Duration - ( input.DEX / 20 );
	if ( input.SkillLevel == 30 ) output.Dura