//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class W3AardProjectile extends W3SignProjectile
{
	protected var staminaDrainPerc : float;

	event OnProjectileCollision( pos, normal : Vector, collidingComponent : CComponent, hitCollisionsGroups : array< name >, actorIndex : int, shapeIndex : int )
	{
		var projectileVictim : CProjectileTrajectory;

		projectileVictim = (CProjectileTrajectory)collidingComponent.GetEntity();

		if( projectileVictim )
		{
			projectileVictim.OnAardHit( this );
		}

		super.OnProjectileCollision( pos, normal, collidingComponent, hitCollisionsGroups, actorIndex, shapeIndex );
	}

	protected function ProcessCollision( collider : CGameplayEntity, pos, normal : Vector )
	{
		// W3EE - Begin
		var dmgVal : float;
		var sp : SAbilityAttributeValue;
		var isFrostAard : bool;
		var effectParams : SCustomEffectParams;
		var victimNPC : CNewNPC;

		//if already hit this entity, skip
		if ( hitEntities.FindFirst( collider ) != -1 )
		{
			return;
		}

		//mark that entity was hit
		hitEntities.PushBack( collider );
		super.ProcessCollision( collider, pos, normal );

		//check if mutation 6 is in effect
			isFrostAard = ( ( W3PlayerWitcher )owner.GetPlayer() && owner.CanUseSkill(S_Magic_s12, GetSignEntity()) );

			if( owner.GetPlayer().IsSwimming() )
				action.AddDamage(theGame.params.DAMAGE_NAME_FORCE, 20000.f);

			if( isFrostAard )
		{
				action.SetBuffSourceName( "Magic_s12" );
		}
			else
		{
				dmgVal = 500.f;
				sp = GetSignEntity().GetTotalSignIntensity();
				if (owner.GetSkillLevel(S_Magic_s20, GetSignEntity()) >= 2)
					dmgVal += 100.f;
				if (owner.GetSkillLevel(S_Magic_s20, GetSignEntity()) >= 4)
					dmgVal += 100.f;

				dmgVal *= sp.valueMultiplicative;
				if( signEntity.IsAlternateCast() )
					dmgVal *= 0.1f * owner.GetSkillLevel(S_Magic_s01, GetSignEntity());
			action.AddDamage( theGame.params.DAMAGE_NAME_FORCE, dmgVal );
		}
			isFrostAard = false;

		action.SetHitAnimationPlayType(EAHA_ForceNo);
		action.SetProcessBuffsIfNoDamage(true);
		if( isFrostAard && victimNPC && victimNPC.IsAlive() )
		{
			ProcessFrostAard( victimNPC );
		}
		if ( !owner.IsPlayer() )
		{
			action.AddEffectInfo( EET_KnockdownTypeApplicator );
		}

		//action.SetHitEffect('aard_hit', false, false);
		//action.SetHitEffect('aard_hit_back', true, false);
		//action.SetHitEffect('aard_hit_parried', false, true);
		//action.SetHitEffect('aard_hit_back_parried', true, true);
		theGame.damageMgr.ProcessAction( action );
		collider.OnAardHit( this );

		if (RandRange(100, 0) < 5 + owner.GetSkillLevel(S_Magic_s06, GetSignEntity()) * 3)
		{
			victimNPC = (CNewNPC) collider;
			if( victimNPC && victimNPC.IsAlive() )
	}
		var noInstaKill : bool;
		noInstaKill = false;

		//freeze or slowdown freeze
			//if slowdown do nothing more
			victimNPC.AddEffectDefault( EET_SlowdownFrost, this, "Mutation 6", true );
			noInstaKill = true;
			//add freeze effect to trigger instant kill
		{
			effectParams.effectType = EET_Confusion;
			effectParams.creator = owner.GetPlayer();
			effectParams.sourceName = 'AardShockwave';
			effectParams.duration = 3.f;
			victimNPC.AddEffectCustom(effectParams);
		}
	}

			//check if both freeze & knockdown was applied to target
			if( EffectInteractionSuccessfull( result ) && ( victimNPC.HasBuff( EET_Knockdown ) || victimNPC.HasBuff( EET_HeavyKnockdown ) || victimNPC.GetIsRecoveringFromKnockdown() ) )
	{
				//if frozen and knocked down -> instakill
		var dmgVal, slowDuration, prc : float;
		var sp : SAbilityAttributeValue;
			else
		dmgVal = 250.f;
		sp = GetSignEntity().GetTotalSignIntensity();
		if (owner.GetSkillLevel(S_Magic_s20, GetSignEntity()) >= 2)
			dmgVal += 50.f;
		if (owner.GetSkillLevel(S_Magic_s20, GetSignEntity()) >= 4)
			dmgVal += 50.f;

		dmgVal *= sp.valueMultiplicative;
		if( noInstaKill && !victimNPC.HasBuff( EET_Frozen ) )
		if( signEntity.IsAlternateCast() )
			dmgVal *= 0.1f * owner.GetSkillLevel(S_Magic_s01, GetSignEntity());

		prc = victimNPC.GetNPCCustomStat(theGame.params.DAMAGE_NAME_FROST);
		action.AddDamage( theGame.params.DAMAGE_NAME_FORCE, dmgVal );
		action.AddDamage( theGame.params.DAMAGE_NAME_FROST, dmgVal );
		slowDuration = (2.f + owner.GetSkillLevel(S_Magic_s12, GetSignEntity() )) * sp.valueMultiplicative * (1 - prc);
		action.AddEffectInfo( EET_SlowdownFrost, slowDuration );
	}
	// W3EE - End

	event OnAttackRangeHit( entity : CGameplayEntity )
	{
		entity.OnAardHit( this );
	}

	public final function GetStaminaDrainPerc() : float
	{
		return staminaDrainPerc;
	}

	public final function SetStaminaDrainPerc(p : float)
	{
		var sp : SAbilityAttributeValue;
		sp = GetSignEntity().GetTotalSignIntensity();
		staminaDrainPerc = p * sp.valueMultiplicative;
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class W3AxiiProjectile extends W3SignProjectile
{
	protected function ProcessCollision( collider : CGameplayEntity, pos, normal : Vector )
	{
		DestroyAfter( 3.f );

		collider.OnAxiiHit( this );
		//Destroy();
	}

	protected function ShouldCheckAttitude() : bool
	{
		return false;
	}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class W3IgniProjectile extends W3SignProjectile
{
	private var channelCollided : bool;
	private var dt : float;
	private var isUsed : bool;

	default channelCollided = false;
	default isUsed = false;

	// W3EE - Begin
	public function GetSignEntity() : W3SignEntity
	{
		return signEntity;
	}
	// W3EE - End

	public function SetDT(d : float)
	{
		dt = d;
	}

	public function IsUsed() : bool
	{
		return isUsed;
	}

	public function SetIsUsed( used : bool )
	{
		isUsed = used;
	}

	event OnProjectileCollision( pos, normal : Vector, collidingComponent : CComponent, hitCollisionsGroups : array< name >, actorIndex : int, shapeIndex : int )
	{
		var rot, rotImp : EulerAngles;
		var v, posF, pos2, n : Vector;
		var igniEntity : W3IgniEntity;
		var ent, colEnt : CEntity;
		var template : CEntityTemplate;
		var f : float;
		var test : bool;
		var postEffect : CGameplayFXSurfacePost;

		channelCollided = true;

		//show collision fx at the place of impact
		igniEntity = (W3IgniEntity)signEntity;

		if(signEntity.IsAlternateCast())
		{
			//igni burn fx left on objects and terrain
			test = (!collidingComponent && hitCollisionsGroups.Contains( 'Terrain' ) ) || (collidingComponent && !((CActor)collidingComponent.GetEntity()));

			colEnt = collidingComponent.GetEntity();
			if( (W3BoltProjectile)colEnt || (W3SignEntity)colEnt || (W3SignProjectile)colEnt )
				test = false;

			if(test)
			{
				f = theGame.GetEngineTimeAsSeconds();

				if(f - igniEntity.lastFxSpawnTime >= 1)
				{
					igniEntity.lastFxSpawnTime = f;

					template = (CEntityTemplate)LoadResource( "igni_object_fx" );

					//set rotation to normal of terrain
					rot.Pitch	= AcosF( VecDot( Vector( 0, 0, 0 ), normal ) );
					rot.Yaw		= this.GetHeading();
					rot.Roll	= 0.0f;

					//trace
					posF = pos + VecNormalize(pos - signEntity.GetWorldPosition());
					if(theGame.GetWorld().StaticTrace(pos, posF, pos2, n, igniEntity.projectileCollision))
					{
						ent = theGame.CreateEntity(template, pos2, rot );
						ent.AddTimer('TimerStopVisualFX', 5, , , , true);

						postEffect = theGame.GetSurfacePostFX();
						postEffect.AddSurfacePostFXGroup( pos2, 0.5f, 8.0f, 10.0f, 0.3f, 1 );
					}
				}
			}

			//collision fx
			if ( !hitCollisionsGroups.Contains( 'Water' ) )
			{
				//show collision fx at the place of impact
				v = GetWorldPosition() - signEntity.GetWorldPosition();
				rot = MatrixGetRotation(MatrixBuildFromDirectionVector(-v));

				igniEntity.ShowChannelingCollisionFx(GetWorldPosition(), rot, -v);
			}
		}

		return super.OnProjectileCollision(pos, normal, collidingComponent, hitCollisionsGroups, actorIndex, shapeIndex);
	}

	protected function ProcessCollision( collider : CGameplayEntity, pos, normal : Vector )
	{
		var signPower, channelDmg : SAbilityAttributeValue;
		var burnChance : float;					// chance to apply burn effect (NPC only)
		var maxArmorReduction : float;			// by how much the armor can be reduced
		var applyNbr : int;						// how many times base armor reduction has to be applied
		var i : int;
		var npc : CNewNPC;
		var armorRedAblName : name;
		var actorVictim : CActor;
		var ownerActor : CActor;
		var dmg : float;
		var performBurningTest : bool;
		var igniEntity : W3IgniEntity;
		var postEffect : CGameplayFXSurfacePost = theGame.GetSurfacePostFX();
		// W3EE - Begin
		var armorRedAttr : SAbilityAttributeValue;
		var currentReduction, perHitReduction, armorRedVal, pts, prc, reductionFactor, maxReductionFactor : float;
		// W3EE - End

		postEffect.AddSurfacePostFXGroup( pos, 0.5f, 8.0f, 10.0f, 2.5f, 1 );

		// this condition prevents from hitting actor twice by the same projectile
		if ( hitEntities.Contains( collider ) )
		{
			return;
		}
		hitEntities.PushBack( collider );

		super.ProcessCollision( collider, pos, normal );

		ownerActor = owner.GetActor();
		actorVictim = ( CActor ) action.victim;
		npc = (CNewNPC)collider;

		signPower = signEntity.GetTotalSignIntensity();
		if(signEntity.IsAlternateCast())
		{
			igniEntity = (W3IgniEntity)signEntity;
			// W3EE - Begin
			performBurningTest = false;
			if(!actorVictim.HasBuff(EET_Burning))
				performBurningTest = igniEntity.UpdateBurningChance(actorVictim, dt);
			// W3EE - End


			// if target was already hit then skip initial damage, also skip the hit particle
			// signPower = signEntity.GetTotalSignIntensity();
			if( igniEntity.hitEntities.Contains( collider ) )
			{
				channelCollided = true;
				action.SetHitEffect('');
				action.SetHitEffect('', true );
				action.SetHitEffect('', false, true);
				action.SetHitEffect('', false, true);
				action.SetHitEffect('', false, true);
				action.SetHitEffect('', true, true);
				action.ClearDamage();

				//add channeling damage
				// W3EE - Begin
				// channelDmg = owner.GetSkillAttributeValue(signSkill, 'channeling_damage', false, true);
				dmg = 800.f + GetSignEntity().GetActualOwner().GetSkillLevel(S_Magic_s09, GetSignEntity()) * 100;
				dmg *= signPower.valueMultiplicative;
				if(actorVictim.HasBuff(EET_Burning))
					dmg *= 0.6f;
				// W3EE - End
				dmg *= dt;
				action.AddDamage(theGame.params.DAMAGE_NAME_FIRE, dmg);
				action.SetIsDoTDamage(dt);

				if(!collider)	//if no target (just showing impact fx) then exit
					return;
			}
			else
			{
				igniEntity.hitEntities.PushBack( collider );
			}

			if(!performBurningTest)
			{
				action.ClearEffects();
			}

			if( !actorVictim.HasBuff(EET_SlowdownFirestream) && !actorVictim.HasBuff(EET_Burning) )
				actorVictim.AddEffectDefault(EET_SlowdownFirestream, ownerActor,,true);

			actorVictim.AddTimer('Runeword1DisableFireFX', 1.f, false,,,, true);
			if( !actorVictim.IsEffectActive('critical_burning') )
			{
				actorVictim.PlayEffect('critical_burning');
				actorVictim.PlayEffect('critical_burning_csx');
			}
		}

		//if npc is shielded do not take any dmg
		if ( npc && npc.IsShielded( ownerActor ) )
		{
			collider.OnIgniHit( this );
			return;
		}

		// Claculate sign spellpower, taking target resistances into consideration
		// signPower = ownerActor.GetTotalSignSpellPower(S_Magic_s02);

		// a piece of custom code for calculating burning effect
		if ( !owner.IsPlayer() )
		{
			signPower = ownerActor.GetTotalSignSpellPower(S_Magic_s02);
			burnChance = signPower.valueMultiplicative;
			if ( RandF() < burnChance )
			{//VIO
				action.AddEffectInfo(EET_Burning);
				action.AddEffectInfo(EET_Burning);
				action.AddEffectInfo(EET_Burning);
			}

			dmg = CalculateAttributeValue(signPower);
			if ( dmg <= 0 )
			{
				dmg = 20;
			}
			action.AddDamage( theGame.params.DAMAGE_NAME_FIRE, dmg);
		}

		if(signEntity.IsAlternateCast())
		{
			action.SetHitAnimationPlayType(EAHA_ForceNo);
		}
		else
		{//VIO
			action.SetHitEffect('igni_cone_hit', false, false);
			action.SetHitEffect('igni_cone_hit', true, false);
			action.SetHitEffect('igni_cone_hit', false, true);
			action.SetHitEffect('igni_cone_hit', true, false);
			action.SetHitReactionType(EHRT_Igni, false);
		}

		theGame.damageMgr.ProcessAction( action );

		// Melt armor
		// W3EE - Begin
		if ( owner.CanUseSkill(S_Magic_s08, GetSignEntity()) && npc )
		{
			prc = npc.GetNPCCustomStat(theGame.params.DAMAGE_NAME_FIRE);

			maxArmorReduction = CalculateAttributeValue(owner.GetSkillAttributeValue(S_Magic_s08, 'max_armor_reduction', false, true)) * GetSignEntity().GetActualOwner().GetSkillLevel(S_Magic_s08, GetSignEntity());
			maxReductionFactor = 0.02f * GetSignEntity().GetActualOwner().GetSkillLevel(S_Magic_s08, GetSignEntity()) * signPower.valueMultiplicative;
			if ( !npc.IsProtectedByArmor() )
			{
				maxArmorReduction *= 0.5f;
				maxReductionFactor *= 0.5f;
			}
			reductionFactor = MinF(1, maxReductionFactor * MaxF(0.25f, 1 - prc));
			if( signEntity.IsAlternateCast() )
			{
				reductionFactor = MinF(1, reductionFactor * dt);
			}

			reductionFactor = ClampF(reductionFactor, 0.f, maxArmorReduction - npc.GetTotalArmorReduction()) * -1.f;
			npc.ModifyArmorValue(reductionFactor);
		}
		// W3EE - End
		collider.OnIgniHit( this );
	}

	event OnAttackRangeHit( entity : CGameplayEntity )
	{
		entity.OnIgniHit( this );
	}

	//range fx
	event OnRangeReached()
	{
		var v : Vector;
		var rot : EulerAngles;

		//projectile keeps flying e.g. through actors so we need to check if it hit something before or not
		if(!channelCollided)
		{
			//collision fx
			v = GetWorldPosition() - signEntity.GetWorldPosition();
			rot = MatrixGetRotation(MatrixBuildFromDirectionVector(-v));
			((W3IgniEntity)signEntity).ShowChannelingRangeFx(GetWorldPosition(), rot);
		}

		isUsed = false;

		super.OnRangeReached();
	}

	public function IsProjectileFromChannelMode() : bool
	{
		return signSkill == S_Magic_s02;
	}
}