U2Pawns.U2DrakkBossUpperController

//=============================================================================
// U2DrakkBossUpperController
//=============================================================================

class U2DrakkBossUpperController extends U2NPCControllerBase;

#exec OBJ LOAD File=..\Sounds\U2DrakkNew.uax

/*
-----------------------------------------------------------------------------
	ASSETS
-----------------------------------------------------------------------------
*/
//#exec OBJ LOAD File=..\System\ParticleRes\drakkboss.u
#exec OBJ LOAD File=..\System\ParticleRes\drakkboss.u
#exec OBJ LOAD File=..\System\ParticleRes\DrakkFX.u
#exec OBJ LOAD File=..\System\ParticleRes\LaserFX.u
#exec OBJ LOAD File=..\Sounds\U2Drakk.uax
#exec OBJ LOAD File=..\Sounds\U2JamesA.uax
#exec OBJ LOAD File=..\Sounds\U2WeaponsA.uax
#exec OBJ LOAD File=..\Sounds\U2A.uax
#exec OBJ LOAD FILE=..\Textures\ScottT.utx
#exec OBJ LOAD FILE=..\StaticMeshes\MalekythM.usx
#exec OBJ LOAD File=..\System\ParticleRes\DispersionFX.u
#exec OBJ LOAD File=..\System\ParticleRes\GL_cluster_fx.u
#exec OBJ LOAD File=..\System\ParticleRes\concussion_grenade_FX.u

/*
-----------------------------------------------------------------------------
	DEFINITIONS
-----------------------------------------------------------------------------
*/
const AttachedToBaseState		= 'AttachedToBase';

const MoveHoverActiveLabel		= 'MoveHoverActiveLabel';

const SimpleWaitState			= 'SimpleWait';
const ConstructionState			= 'Construction';
const PrimaryAttackState		= 'PrimaryAttack';
const AlternateAttackState		= 'AlternateAttack';
const KamikazeState				= 'Kamikaze';

const WaitActivateLabel			= 'WaitActivate';
const LaserWaitLabel			= 'LaserWait';
const LaserTargetContactLabel	= 'LaserTargetContact';
const LaserDoneLabel			= 'LaserDone';
const RiseLabel					= 'Rise';
const MovePickDestMidLabel		= 'MovePickDestMid';

enum ECycleType
{
	CT_Random,
	CT_Ordered,
	CT_RandomVisible,
	//CT_Furthest,
};

/*
-----------------------------------------------------------------------------
	VARIABLES
-----------------------------------------------------------------------------
*/
var name ActiveAttackState;

var array<Actor> AttackDestinations;
var float AttackDestinationZ;
var int CurrentAttackDestination;

var vector HoverLocation;
var U2DrakkBossUpper UpperPawn;
var U2DrakkBossController LowerController;
//var float MaxMoveTime;

var ParticleGenerator FireEffects[4];
var LookTarget TracerStartDummy, TracerEndDummy;
var PulseLineGenerator TracerBeamEffect;
var ParticleGenerator ChargeUpEffect;
var ParticleGenerator AltFireEffect;
var ParticleGenerator AltFireEffectTemplate;

var LookTarget WingTakkra[8];

var float IdleSpeed;
var int RiseYawRate;
var float PreAttackDelayTime;
var float AttackDurationTime;
var float PostAttackDelayTime;
var float TimeBetweenShots;
var float AltFireBoltSpeed;
var ECycleType CycleType;

var name AttackDestinationClassName;

var float FireTimer;
var float WingGlowTimer, WingGlowTimerStart;

var string WingBoneNames[8];
var int WingBoneDisabled;

var int PrimaryStageHealth;

var bool bAttached, bKamikaze, bRetaliateOnDamage, bRetaliating, bSimpleWaitNoDelay;
var vector RetaliateLocation;

var Actor RiseTarget;

var() Sound FireLaserSound;
var() Sound TakeHitSound;
var() Sound WingExplodeSound;
var() Sound TracerTurnOnSound;
var() Sound TracerAmbientSound;
var() Sound LaserChargeUpSound;
var() Sound SecondaryLaserChargeUpSound;
var() Sound SecondaryLaserChargeDownSound;
var() Sound SecondaryLaserAmbientSound;
var() Sound SelfDestructSound;
var() Sound SecondaryAttackAmbientSound;

/*
-----------------------------------------------------------------------------
	IMPLEMENTATION FUNCTIONS
-----------------------------------------------------------------------------
*/

/*
	TEST
*/
simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
{
	Super.Trigger(Other, Instigator, EventName);
	
	if (EventName == 'NextStage')
		DrkbucSetAttackState(AlternateAttackState);
	else if (EventName == 'FirstStage')
		DrkbucSetAttackState(PrimaryAttackState);
	else if (EventName == 'Kamikaze')
	{
		DrkbucSetAttackState(AlternateAttackState);
		bKamikaze = true;
	}
}

function DrkbucAttach(U2DrakkBoss InLowerPawn, bool InAttached)
{
	if (bAttached == InAttached)
		return;

	bAttached = InAttached;

	if (bAttached)
	{
		SetFrozen(true);
		UpperPawn.SetCollision(false, false, false);
		UpperPawn.SetPhysics(PHYS_MovingBrush);
		UpperPawn.MountParentNode = "ROOTLow";
		UpperPawn.SetLocation(InLowerPawn.Location);
		UpperPawn.SetRotation(InLowerPawn.Rotation);
		UpperPawn.MountSetParent(InLowerPawn);
		UpperPawn.MountOrgLocation = vect(0,0,0);
		UpperPawn.MountOrgRotation = rot(0,16384,0);
		UpperPawn.SetRotation(InLowerPawn.Rotation);
		SetRotation(InLowerPawn.Rotation);
		UpperPawn.UpdateMountPhysics();
		UpperPawn.MovementPhysics=PHYS_None;//PHYS_MovingBrush
		UpperPawn.SetMovementPhysics(false);

		// OWNERTEST
		//UpperPawn.SetOwner(None);
	}
	else
	{
		SetFrozen(false);
		UpperPawn.SetCollision(true, false, false);
		UpperPawn.MountParentNode = "";
		UpperPawn.MountSetParent(None);
		UpperPawn.MovementPhysics=PHYS_Flying;
		UpperPawn.SetMovementPhysics(false);
		if (ControllerEnemy?)
			EnemyAcquired();

		// OWNERTEST
		//UpperPawn.SetOwner(self);
	}
}

/*
	Firing Effects
*/
private final simulated function bool LaserTraceEx(actor Src, out CheckResult Hit, bool TracePawns, vector StartTrace, vector EndTrace)
{
	local int TraceFlags;

	TraceFlags = TRACE_Level|TRACE_LevelGeometry;
	if (TracePawns)
		TraceFlags = TraceFlags | TRACE_Pawns;
	Src.SingleLineCheck( Hit, Src, EndTrace, StartTrace, TraceFlags);
	
	if (Hit.Actor!=None)
	{
		if ((!TracePawns) || (Pawn(Hit.Actor)==None))
			return(true);
		if ((Pawn(Hit.Actor).Health > 0) && (Pawn(Hit.Actor).TeamNumber != Pawn.TeamNumber))
			return(true);
	}

	//if( U2Pawn(Hit.Actor) != None && U2Pawn(Hit.Actor).GetNotifiedWeapon() != None )
	//	U2Pawn(Hit.Actor).GetNotifiedWeapon().AdjustTraceFireHit( Hit );

	Hit.Location = EndTrace;
	Hit.Actor = None;
	return(false);
}
private final simulated function bool LaserTrace(actor Src, out CheckResult Hit, bool TracePawns)
{
	local vector StartTrace;
	local vector EndTrace;

	StartTrace = Src.Location;
	EndTrace = StartTrace + vector(Src.Rotation)*vect(10000,10000,10000);

	return(LaserTraceEx(Src, Hit, TracePawns, StartTrace, EndTrace));
}
private final simulated function MountToLaser(actor A, bool InUseAlternate)
{
	local vector vX, vY, vZ;

	if (InUseAlternate)
		A.MountParentNode = "laserend";
	else
		A.MountParentNode = "BDLamp02End";

	A.SetPhysics(PHYS_MovingBrush);
	A.MountSetParent(Pawn);

	if (InUseAlternate)
	{
		GetAxes(A.Rotation, vX, vY, vZ);
		A.SetRotation(rotator(-vX));
	}

	A.UpdateMountPhysics();
}
private final simulated function ParticleGenerator ConstructEffect(ParticleGenerator EffectTemplate, optional bool bNoMount)
{
	local ParticleGenerator P;

	//P = class'ParticleGenerator'.static.CreateNew(self, EffectClass, EffectParticles);
	P = class'ParticleGenerator'.static.CreateNew(Pawn, EffectTemplate);
	if (P == None)
		return(None);
	P.Instigator = Pawn;
	//P.bHidden = true;
	//P.bManualTick = true;
	if (!bNoMount)
		MountToLaser(P, false);
	return(P);
}
private final simulated function InitWingTakkra(int i, string BoneName)
{
	WingTakkra[i] = Pawn.Spawn(class'LookTarget', Pawn);
	WingTakkra[i].SetPhysics(PHYS_MovingBrush);
	WingTakkra[i].MountParentNode = BoneName;
	WingTakkra[i].MountSetParent(Pawn);
	WingTakkra[i].UpdateMountPhysics();
	WingTakkra[i].StaticMesh = StaticMesh'MalekythM.Weapons.T_Gun';
	WingTakkra[i].SetDrawType(DT_StaticMesh);
	WingTakkra[i].bNoStaticMeshCollide = true;
	WingTakkra[i].SetDrawScale(1.0);
	WingTakkra[i].bHidden = false;
}
private final simulated function InitEffects()
{
	local int i;
	
	//FireEffects[0] = ConstructEffect(class'ParticleSalamander', "LaserFX.ParticleSalamander12");
	FireEffects[0] = ConstructEffect(ParticleSalamander'LaserFX.ParticleSalamander12');
	FireEffects[1] = ConstructEffect(ParticleSalamander'LaserFX.ParticleSalamander13');
	FireEffects[2] = ConstructEffect(ParticleSalamander'LaserFX.ParticleSalamander14');
	FireEffects[3] = ConstructEffect(ParticleSalamander'LaserFX.ParticleSalamander15');
	
	TracerBeamEffect = PulseLineGenerator(ConstructEffect(PulseLineGenerator'DrakkFX.PulseLineGenerator0'));
	TracerBeamEffect.Trigger(Pawn, Instigator);
	TracerBeamEffect.bMustFace = false;
	TracerBeamEffect.bHidden = true;
	//TracerBeamEffect.bShowBoundingBox = true;
	
	ChargeUpEffect = ConstructEffect(ParticleSalamander'DrakkFX.ParticleSalamander1');
	
	TracerStartDummy = Pawn.spawn(class'LookTarget', Pawn);
	TracerStartDummy.SoundRadius = 255;
	TracerStartDummy.SoundVolume = 255;
	TracerStartDummy.SoundPitch = 64;
	MountToLaser(TracerStartDummy, false);

	TracerEndDummy = Pawn.spawn(class'LookTarget', Pawn);
	TracerEndDummy.SoundRadius = 255;
	TracerEndDummy.SoundVolume = 128;
	TracerEndDummy.SoundPitch = 64;

	TracerBeamEffect.Connections[0].StartActor = TracerStartDummy;
	TracerBeamEffect.Connections[0].EndActor = TracerEndDummy;
	
	AltFireEffect = class'ParticleGenerator'.static.CreateNew( Pawn, AltFireEffectTemplate );
	//AltFireEffect.SetBase( Pawn );
	//AltFireEffect.SetRotation(rot(0,0,0));
	AltFireEffect.SetPhysics(PHYS_MovingBrush);
	AltFireEffect.MountParentNode = "ROOTHigh"; // "Laser13";
	AltFireEffect.MountSetParent(Pawn);
	AltFireEffect.Instigator = Pawn;
	assert( AltFireEffect != None );

	for (i=0;i<8;i++)
		InitWingTakkra(i, WingBoneNames[i]);
}
private final simulated function ShutdownEffects()
{
	local int i;
	local ParticleGenerator P;

	if (TracerStartDummy!=None) { TracerStartDummy.Destroy(); TracerStartDummy=None; }
	if (TracerEndDummy!=None) { TracerEndDummy.Destroy(); TracerEndDummy=None; }
	if (TracerBeamEffect!=None) { TracerBeamEffect.Destroy(); TracerBeamEffect=None; }
	if (ChargeUpEffect!=None) { ChargeUpEffect.Destroy(); ChargeUpEffect=None; }

	for (i=0;i<4;i++)
	{
		P = FireEffects[i];
		if (P!=None)
		{
			//P.bManualTick = false;
			P.Destroy(); // P.ParticleDestroy();
		}
		FireEffects[i] = None;
	}
	if( AltFireEffect != None )
	{
		AltFireEffect.ParticleDestroy();
		AltFireEffect = None;
	}
	for (i=0;i<8;i++)
	{
		if (WingTakkra[i]!=None)
		{
			WingTakkra[i].Destroy();
			WingTakkra[i] = None;
		}
	}
}

/*
-----------------------------------------------------------------------------
	INTERFACE FUNCTIONS
-----------------------------------------------------------------------------
*/

/*
	Common
*/
event PreBeginPlay()
{
	local Actor A;
	local int NumAttackDestinations;
	local float TotalZ;
	
	Super.PreBeginPlay();

	// Initialize attack destinations
	foreach AllActors(class'Actor', A)
	{
		if (A.IsA(AttackDestinationClassName))
		{
			//DM("Added AttackDestination "$A);
			AttackDestinations[NumAttackDestinations++] = A;
			TotalZ += A.Location.Z;
		}
	}
	
	if (AttackDestinations.Length >= 1)
		AttackDestinationZ = TotalZ / AttackDestinations.Length;
}
function Possess( Pawn P )
{
	UpperPawn = U2DrakkBossUpper(P);
	
	Super.Possess( P );

	HoverLocation = Pawn.Location;
	HoverLocation.Z = AttackDestinationZ;
	
	InitEffects();
}
event Destroyed()
{
	RemoveAllTimers();

	ShutdownEffects();

	Super.Destroyed();
}

// can't use regular Tick for this since Controller.Tick happens before Pawn.Tick, and we need the Pawn for mounting purposes
function DrkbucTick(float DeltaTime); // overridden in states

function bool ValidateLowerController()
{
	if (LowerController==None)
		LowerController = UpperPawn.LowerPawn.LowerController;
	return(LowerController!=None);
}

function bool DrkbucPreventDeath( int Damage, Pawn Instigator, class<DamageType> DamageType, vector HitLocation )
{
	return false;
}

/*
	AI Common
*/
function eventBumpFriend( Pawn Other )
{
	// makes me go wandering... evil!
}
function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if ((Instigator==None) || (Instigator==Self) || (U2DrakkBossUpper(Instigator)==None)) // don't let another upper body hurt me
		Super.eventTakeDamage(Damage, Instigator, HitLocation, Momentum, DamageType);
}
function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	Super.eventTookDamage(Damage, Instigator, HitLocation, Momentum, DamageType);

	//if( (Pawn.default.Health - Pawn.Health) > UpperPawn.MinRechargeDamage )
	//	LowerController.NotifyUpperNeedsRecharge();
}
function EnemyAcquired()
{
	DrkbucSetAttackState();
}
/*
	DrakkBossUpperController interface
*/
function DrkbucSetAttackState(optional name InAttackState)
{
	if (InAttackState!='')
		ActiveAttackState = InAttackState;
	
	if (IsInState(ActiveAttackState))
		return;
	
	GotoState(ActiveAttackState);

	ValidateLowerController();
	if (ActiveAttackState==PrimaryAttackState)
	{
		LowerController.DrkbcAttach(UpperPawn, true);
	}
	else if (ActiveAttackState==AlternateAttackState)
	{
		LowerController.DrkbcAttach(UpperPawn, false);
	}
}

//-----------------------------------------------------------------------------

function FireShot(optional bool bUpdateOnly)
{
	local rotator FireRotation;
	
	//if( AltFireEffect != None && ControllerEnemy != None && Pawn.FastTrace( Pawn.Location, ControllerEnemy.Location ) )
	if( AltFireEffect != None && ControllerEnemy != None )
	{
		//FireRotation = AdjustAim( None, AltFireBoltSpeed, Pawn.Location, 0.0, true, false, false, false );
		FireRotation = rotator(ControllerEnemy.Location - AltFireEffect.Location);
		AltFireEffect.SetRotation( FireRotation );
		AltFireEffect.UpdateMountPhysics();
		if (!bUpdateOnly)
			AltFireEffect.Trigger( Pawn, Instigator );
	}
}

function FireShotTimer()
{
	FireShot();
}

function KamikazeTimer()
{
	bKamikaze = true;
}

function StartFiring()
{
	FireShot();
	//AddTimer( 'FireShotTimer', TimeBetweenShots, true );
}

#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
{
	RemoveTimer( 'FireShotTimer' );
}

function PickHoverDestination()
{
	if( AttackDestinations.Length >= 2 )
	{
		ClearMoveAttempts();
		Destination = HoverLocation;
	}
	else
	{
		DM( "WARNING: not enough " $ AttackDestinationClassName $ "s in level for drakk boss (upper) to use!" );
		SpecialGoal = Pawn;
	}
}

function PickAttackDestination()
{
	local int i, Selection, NumPossibleDestinations;
	local array<Actor> PossibleDestinations;
	local vector AttackTargetLocation;
	local ECycleType UseCycleType;
	local actor A, AttackTarget;
	local CheckResult Hit;

	UseCycleType = CycleType;
	if ((UseCycleType == CT_RandomVisible) && (ControllerEnemy==None))
	{
		UseCycleType = CT_Random;
	}
	else
	{
		AttackTarget = ControllerEnemy;
		AttackTargetLocation = AttackTarget.Location;
	}

	if( AttackDestinations.Length >= 2 )
	{
		switch(UseCycleType)
		{
		case CT_Random:
			// just pick a random destination not equal to the current location
			do
			{
				Selection = RandRange( 0, AttackDestinations.Length );
			}
			until ( AttackDestinations[ Selection ] != MoveTarget );
			
			SpecialGoal	= AttackDestinations[ Selection ];
			break;
		
		case CT_Ordered:
			Selection = CurrentAttackDestination;
			CurrentAttackDestination++;
			if( CurrentAttackDestination >= AttackDestinations.Length )
				CurrentAttackDestination = 0;
			
			SpecialGoal	= AttackDestinations[ Selection ];
			break;

		case CT_RandomVisible:
			for (i=0;i<AttackDestinations.Length;i++)
			{
				A = AttackDestinations[i];
				LaserTraceEx(TracerStartDummy, Hit, true, A.Location, A.Location + Normal(AttackTargetLocation-A.Location)*vect(4096,4096,4096));
				if (Hit.Actor==AttackTarget)
					PossibleDestinations[NumPossibleDestinations++] = A;
			}

			if ((PossibleDestinations.Length==0)
			 || ((PossibleDestinations.Length==1) && (PossibleDestinations[0]==MoveTarget)))
			{
				do
				{
					Selection = RandRange( 0, AttackDestinations.Length );
				}
				until ( AttackDestinations[ Selection ] != MoveTarget );
				
				SpecialGoal	= AttackDestinations[ Selection ];
			}
			else
			{
				do
				{
					Selection = RandRange( 0, PossibleDestinations.Length );
				}
				until ( PossibleDestinations[ Selection ] != MoveTarget );
			
				SpecialGoal	= PossibleDestinations[ Selection ];
			}

			break;
		}
	}
	else
	{
		DM( "WARNING: not enough " $ AttackDestinationClassName $ "s in level for drakk boss to use!" );
		SpecialGoal = Pawn;
	}
	
	//MoveTarget = SpecialGoal; //!!mdf-tbd: assume reachable?
	MoveTarget = None;

	ClearMoveAttempts();
}

function float GetMoveSpeed( vector TargetLocation )
{
	local float DistanceToTargetLocation;
	
	DistanceToTargetLocation = VSize( Pawn.Location - TargetLocation );
	
	if( DistanceToTargetLocation > 512 )
		return 1.00;
	else 
		return class'Util'.static.ScaleLinear( DistanceToTargetLocation, 0.0, 512.0, 0.125, 1.00 );
}

state @ SimpleWaitState
{
	ignores EnemyNotVisible;//, HearNoise;
/*
	function DrkbucTick(float DeltaTime)
	{
		Global.DrkbucTick( DeltaTime );
		UpperPawn.UpdateMountPhysics();
	}
*/

	function Trigger( Actor Other, Pawn Instigator, optional name EventName )				
	{
		local Actor A;
		
		if( EventName == UpperPawn.LowerPawn.RiseTargetTag )
		{
			foreach AllActors( class'Actor', A )
			{
				if( A.Tag == UpperPawn.LowerPawn.RiseTargetTag )
				{
					RiseTarget = A;
					break;
				}
			}
			
			if( RiseTarget != None )
			{
				class'MusicScriptEvent'.static.CallRoutine(self, "dm001_fightstart");
				GotoLabel( RiseLabel );
			}
			else
				DMTNS( "WARNING: no rise target (Tag=" $ UpperPawn.LowerPawn.RiseTargetTag $ ")" );
		}
		else
		{
			Super.Trigger( Other, Instigator, EventName );
		}
	}
	
	function EnemyAcquired()
	{
		DrkbucSetAttackState(PrimaryAttackState);
	}

@ BeginLabel:
	
	if (!bSimpleWaitNoDelay)
	{
		// give a few seconds of prep time
		ValidateLowerController();
		DisableSenses();
		LowerController.DisableSenses();
		Sleep(10);
	}

@ WaitActivateLabel:

	ValidateLowerController();
	EnableSenses();
	LowerController.EnableSenses();
	
	#debug   SetControllerEnemy( None, GetContext() ); // so it will be reacquired
	#release SetControllerEnemy( None ); // so it will be reacquired
	if (LowerController.ControllerEnemy?)
		MaybeSetEnemy(LowerController.ControllerEnemy, false);

	Stop;
	
@ RiseLabel:
	ValidateLowerController();
	DisableSenses();
	LowerController.DisableSenses();
	
	EnableRotation( false );
	MoveToActor( RiseTarget, TMT_None, , , , UpperPawn.LowerPawn.RiseSpeed );
	if( MoveResult != MR_DestinationReached )
		Goto( RiseLabel );
	
	EnableRotation( true );
	Focus = None;
	FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
	Pawn.StopMovement( true, false );
	Sleep( UpperPawn.LowerPawn.RiseSpeed );
	Goto( WaitActivateLabel );
}

state @ ConstructionState
{
	ignores EnemyNotVisible, HearNoise, EnemyAcquired, SeeEnemy, NotifyBump;

	event BeginState()
	{
		local int i;

		Super.BeginState();

		for (i=0;i<8;i++)
		{
			if (WingTakkra[i]!=None)
				WingTakkra[i].bHidden = true;
		}
	}
	event EndState()
	{
		local int i;

		for (i=0;i<8;i++)
		{
			if (WingTakkra[i]!=None)
				WingTakkra[i].bHidden = false;
		}

		// due to the wacky destroy() chain between upper and lower, bPendingDelete has to be checked here or
		// we'll get collision hash crashes when trying to change collision during the attach parent reversal below
		if ((UpperPawn?) && !UpperPawn.bDeleteMe && !UpperPawn.bPendingDelete
		 && (UpperPawn.LowerPawn?) && !UpperPawn.LowerPawn.bDeleteMe && !UpperPawn.LowerPawn.bPendingDelete)
		{
			ValidateLowerController();
			LowerController.DrkbcAttach(UpperPawn, true);

			bSimpleWaitNoDelay = true;
			DrkbucAttach(UpperPawn.LowerPawn, false);
		}

		Super.EndState();
	}

@ BeginLabel:

	Pawn.MeshAgentCallAction('Event_Construct');
	Sleep(90);
	
	//GotoState(SimpleWaitState, WaitActivateLabel);
	ValidateLowerController();
	LowerController.GotoState('ReturnToBase');

	Sleep(9999);//Stop;
}

state @ PrimaryAttackState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible, SeeFriend, SeeOther, SeeAlertFriend;
	
	//-------------------------------------------------------------------------

	function DrkbucTick(float DeltaTime)
	{
		local int i;
		local CheckResult Hit;
		local vector SatPos;

		Global.DrkbucTick(DeltaTime);
		
		if (ControllerEnemy!=None)
		{
			SatPos = ControllerEnemy.Location;
			//SatPos.Z += ControllerEnemy.EyeHeight;
			//SatPos.Z += ControllerEnemy.EyeHeight * 0.75;
			//SatPos.Z += ControllerEnemy.EyeHeight * 0.5;
			if (FireTimer > 0.0)
				SatPos += ControllerEnemy.Velocity * UpperPawn.ChargeUpTime * UpperPawn.ChargeLead;
		}
		else
		{
			SatPos = Pawn.Location + vector(Pawn.Rotation)*10000.0;
		}

		if ((FireTimer <= 0.0) || (FireTimer > UpperPawn.ChargeUpTime*UpperPawn.ChargeLead))
			Pawn.MeshSetSatellite('Sat_LaserAim', None, SatPos);

		if (FireTimer < 0.0)
		{
			LaserTrace(TracerStartDummy, Hit, true);
			if (Pawn(Hit.Actor)!=None)
				GotoState(PrimaryAttackState, LaserTargetContactLabel);
		}
		else if (FireTimer > 0.0)
		{
			FireTimer -= DeltaTime;
			if (FireTimer < 0.0)
				FireTimer = 0.0;
		}

		for (i=0;i<4;i++)
			FireEffects[i].UpdateMountPhysics();
		TracerBeamEffect.UpdateMountPhysics();
		ChargeUpEffect.UpdateMountPhysics();
		TracerStartDummy.UpdateMountPhysics();
		LaserTrace(TracerStartDummy, Hit, false);
		TracerEndDummy.SetLocation(Hit.Location);
		for (i=0;i<8;i++)
		{
			WingTakkra[i].UpdateMountPhysics();
			
			if ((WingGlowTimer > 0.0) && (!WingTakkra[i].bHidden))
			{
				WingTakkra[i].bUnlit = true;
				WingTakkra[i].ScaleGlow = (1.0 - (WingGlowTimer / WingGlowTimerStart)) * 10.0;
			}
			else
			{
				WingTakkra[i].bUnlit = false;
				WingTakkra[i].ScaleGlow = 1.0;
			}
		}
		if (WingGlowTimer > 0.0)
		{
			WingGlowTimer -= DeltaTime;
			if (WingGlowTimer < 0.0)
				WingGlowTimer = 0.0;
		}
	}
	/*
	function FirePrimaryShot() // old primary fire effect
	{
		local int i;
		local CheckResult Hit;

		for (i=0;i<4;i++)
		{
			if (FireEffects[i]!=None)
				FireEffects[i].Trigger(self, Instigator);
		}
		
		Pawn.PlaySound(sound'U2Drakk.FireLaser', SLOT_Misc);
		LaserTrace(TracerStartDummy, Hit, true);
		
		if (Pawn(Hit.Actor)!=None)
			Hit.Actor.TakeDamage(UpperPawn.LaserDamage, Pawn, Hit.Location, vect(0,0,0), class'DamageTypeLaserRifle');
	}
	*/
	function bool FirePrimaryShot(int InIndex) // new primary fire effect
	{
		local CheckResult Hit;
		local projectileLaserBeam P;
		local int NodeHandle;
		local vector StartTrace;

		if ((WingBoneDisabled & (1<<InIndex)) != 0)
			return(false);

		if (WingBoneNames[InIndex]!="")
			NodeHandle = Pawn.MeshGetNodeNamed(WingBoneNames[InIndex]);
		if (NodeHandle!=0)
			StartTrace = Pawn.MeshNodeGetTranslation(NodeHandle, MESHNODEREL_World);
		else
			StartTrace = TracerStartDummy.Location;

		Pawn.PlaySound(FireLaserSound, SLOT_Weapon);
		LaserTrace(TracerStartDummy, Hit, true);
		if (bRetaliating && Pawn(Hit.Actor)==None)
			LaserTraceEx(TracerStartDummy, Hit, true, StartTrace, StartTrace + Normal(RetaliateLocation-StartTrace)*vect(10000,10000,10000));

		Pawn.MeshAgentCallAction(StringToName("Event_LegKick"$InIndex, true));
		P = spawn(class'projectileLaserBeam', Pawn, , StartTrace);
		P.SetEndPoint(Hit.Location);
		
		if (Pawn(Hit.Actor)!=None)
			Hit.Actor.TakeDamage(UpperPawn.LaserDamage, Pawn, Hit.Location, vect(0,0,0), class'DamageTypeLaserRifle');

		return(true);
	}

	//-------------------------------------------------------------------------

	event BeginState()
	{
		Super.BeginState();
		
		Pawn.MeshAgentSetInputCurValue('LaserAiming', 'True');

		class'MusicScriptEvent'.static.CallRoutine(self, "dm002_mainfight");
	}
	event EndState()
	{
		TracerBeamEffect.bHidden = true;
		TracerEndDummy.AmbientSound = None;
		FireTimer = 0.0;
		WingGlowTimer = 0.0;
		WingGlowTimerStart = 0.0;
		bRetaliateOnDamage = false;
		bRetaliating = false;

		if ((UpperPawn?) && !UpperPawn.bDeleteMe && !UpperPawn.bPendingDelete)
		{
			Pawn.MeshAgentSetInputCurValue('LaserAiming', 'False');
			Pawn.MeshAgentSetInputCurValue('LegsPulled', 'False');
			Pawn.MeshAgentSetInputCurValue('LegsOut', 'False');
			Pawn.GroundSpeed = Pawn.default.GroundSpeed;
			EnableRotation( true );

			Pawn.bCollideWorld=true;
			if (UpperPawn.LowerPawn?)
				UpperPawn.LowerPawn.bCollideWorld=true;
		}

		Super.EndState();
	}

	function bool DrkbucPreventDeath( int Damage, Pawn Instigator, class<DamageType> DamageType, vector HitLocation )
	{
		Pawn.Health = 1;
		
		return true;
	}

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		local int i;
		local bool wasDisabled;
		local int HealthThreshold;
		local ParticleGenerator P;
		
		Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
		
		for (i=0;i<8;i++)
		{
			wasDisabled = ((WingBoneDisabled & (1<<i)) != 0);
			HealthThreshold = (Pawn.default.Health - PrimaryStageHealth) + i*(PrimaryStageHealth/8);
			if ((Pawn.Health < HealthThreshold) && (!wasDisabled))
			{
				Pawn.MeshAgentCallAction('Event_BodyShake');
				Pawn.PlaySound(TakeHitSound, SLOT_Interact);
				
				P = class'ParticleGenerator'.static.CreateNew(Pawn, ParticleGenerator'DispersionFX.ParticleSalamander3', WingTakkra[i].Location);
				P.SetRotation(rotator(Normal(Instigator.Location - WingTakkra[i].Location)));
				P.Trigger(Pawn, Pawn);
				P.ParticleLifeSpan = P.GetMaxLifeSpan() + 1.0;
				WingTakkra[i].PlaySound(WingExplodeSound, SLOT_Weapon);
				WingTakkra[i].bHidden = true;

				WingBoneDisabled = WingBoneDisabled | (1<<i);

				Pawn.PlaySound(sound'U2DrakkNew.DrakkBossDeathChattr2', SLOT_Weapon, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
			}
		}

		if ((bRetaliateOnDamage) && (Instigator!=None) && (Instigator == ControllerEnemy))
		{
			bRetaliating = true;
			RetaliateLocation = ControllerEnemy.Location;
			GotoState(PrimaryAttackState, LaserTargetContactLabel);
		}
	}
	
	//-------------------------------------------------------------------------
	
@ BeginLabel:
	//Goto( MovePickDestLabel );

	// float up to height of flynodes before starting to cycle between these
	//Pawn.AmbientRotationRate.Yaw = RiseYawRate;
	PickHoverDestination();

@ MoveHoverActiveLabel:
	EnableRotation( false );
	//MoveToPoint( Destination, , , IdleSpeed, MaxMoveTime );
	MoveToPoint( Destination, , , IdleSpeed );
		
	if( MoveResult != MR_DestinationReached )
	{
	 	if( MoveAgain() )
			Goto( MoveHoverActiveLabel );
		else
			Goto(MovePickDestLabel); //Goto( GiveUpLabel ); // don't give up, just abort the hover and go right to an attack dest
	}
	
	//Pawn.AmbientRotationRate.Yaw = 0;
	
@ MovePickDestLabel:
	EnableRotation( true );
	Focus = None;
	FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
	PickAttackDestination();

@ MovePickDestMidLabel:
	FindPathToActor( SpecialGoal, MoveTarget, true );
	if (MoveTarget==None)
		MoveTarget = SpecialGoal;

@ MoveActiveLabel:
	//MoveToActor( MoveTarget, TMT_None, SpecialGoal, , ControllerEnemy, GetMoveSpeed( MoveTarget.Location ), MaxMoveTime );
	Pawn.bCollideWorld=false;
	UpperPawn.LowerPawn.bCollideWorld=false;
	MoveToActor( MoveTarget, TMT_None, SpecialGoal, , ControllerEnemy, GetMoveSpeed( MoveTarget.Location ) );
	Pawn.bCollideWorld=true;
	UpperPawn.LowerPawn.bCollideWorld=true;

	if( MoveResult == MR_DestinationReachedFinal )
		Goto( ReachedDestinationLabel );
	else if( MoveResult == MR_DestinationReached )
		Goto( MovePickDestMidLabel );
	else if( MoveAgain() )
		Goto( MoveActiveLabel );
	else
	{
		//Goto( GiveUpLabel ); // don't give up; this should only happen if someone got in the way (via jumping etc), just wait and try again
		Sleep(3);
		Goto(MovePickDestLabel);
	}
	
@ ReachedDestinationLabel:
	StopMovement( true, true );
	FinishRotation();

	Pawn.MeshAgentSetInputCurValue('LegsOut', 'True');

	// turn on laser tracer
	Pawn.PlaySound(TracerTurnOnSound, SLOT_Misc);
	TracerBeamEffect.bHidden = false;
	TracerEndDummy.AmbientSound = TracerAmbientSound;
	TracerBeamEffect.BeamTexture = Texture'ScottT.Effects.GlowBeam_005red';
	TracerBeamEffect.SpriteJointTexture = Texture'ParticleSystems.Sparks.Sparks11';
	TracerEndDummy.SoundVolume = 192;
	TracerEndDummy.SoundPitch = 64;
	FireTimer = -1.0;

@ LaserWaitLabel:
	//Stop;
	bRetaliateOnDamage = true;
	bRetaliating = false;
	Sleep(5.0 + FRand()*5.0); // timeout after a little while if nobody crosses the beam and we don't retaliate against an attack
	GotoState(PrimaryAttackState, LaserDoneLabel);

@ LaserTargetContactLabel:

	bRetaliateOnDamage = false;

	ChargeUpEffect.Trigger(Pawn, Instigator);
	//ChargeUpEffect.PlaySound(LaserChargeUpSound, SLOT_Interact);
	ChargeUpEffect.PlaySound(LaserChargeUpSound, SLOT_Interact, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
	//ChargeUpEffect.SoundPitch = 24;
	ChargeUpEffect.SoundPitch = 96;
	
	Pawn.GroundSpeed = 0;
	EnableRotation( false );

	Pawn.MeshAgentSetInputCurValue('LegsPulled', 'True');

	FireTimer = UpperPawn.ChargeUpTime;
	WingGlowTimerStart = UpperPawn.ChargeUpTime + 1.0;
	WingGlowTimer = WingGlowTimerStart;
	
	Sleep(UpperPawn.ChargeUpTime);

	TracerBeamEffect.bHidden = true;
	TracerEndDummy.AmbientSound = None;
	
	if (FirePrimaryShot(0))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(1))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(2))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(3))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(4))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(5))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(6))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}
	if (FirePrimaryShot(7))
	{
		FireTimer = 0.125;
		Sleep(0.125);
	}

@ LaserDoneLabel:

	bRetaliateOnDamage = false;
	bRetaliating = false;

	FireTimer = 0.0;
	WingGlowTimer = 0.0;
	WingGlowTimerStart = 0.0;
	TracerBeamEffect.bHidden = true;
	TracerEndDummy.AmbientSound = None;

	Pawn.GroundSpeed = Pawn.default.GroundSpeed;
	EnableRotation( true );

	Pawn.MeshAgentSetInputCurValue('LegsPulled', 'False');
	
	Sleep(UpperPawn.RechargeTime);

	Pawn.MeshAgentSetInputCurValue('LegsOut', 'False');

	if (Pawn.Health < (Pawn.default.Health - PrimaryStageHealth))
	{
		Pawn.PlaySound(sound'U2DrakkNew.Drakk_Boss_Separate_2', SLOT_Weapon, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
		DrkbucSetAttackState(AlternateAttackState);
	}
	else
		Goto( MovePickDestLabel );
} // PrimaryAttackState


state @ AlternateAttackState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible, SeeFriend, SeeOther, SeeAlertFriend;
	
	//-------------------------------------------------------------------------

	function DrkbucTick(float DeltaTime)
	{
		local rotator FireRotation;

		Global.DrkbucTick(DeltaTime);
		//Global.Tick(DeltaTime);
		if (AltFireEffect?)
		{
			//FireRotation = AltFireEffect.Rotation;
			AltFireEffect.UpdateMountPhysics();
			//AltFireEffect.SetRotation( FireRotation );
		}
	}

	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		Super.BeginState();
		Pawn.MeshAgentSetInputCurValue('LaserOut', 'True');
		Pawn.SoundPitch = 128;
		Pawn.SoundRadius = 512;
		FireShot(true);

		// TEST
		AddTimer('KamikazeTimer', 60.0, true);

		class'MusicScriptEvent'.static.CallRoutine(self, "dm003_interlude");
	}
	event EndState()
	{
		if ((UpperPawn?) && !UpperPawn.bDeleteMe && !UpperPawn.bPendingDelete)
		{
			Pawn.SoundRadius = Pawn.default.SoundRadius;
			Pawn.SoundPitch = 64;
			Pawn.MeshAgentSetInputCurValue('LaserOut', 'False');
			Pawn.MeshAgentSetInputCurValue('BodyWaving', 'False');
			Pawn.AmbientSound=None;
		
			Pawn.bCollideWorld=true;
		}
		
		#debug   StopFiring( 0.0, SFI_Behavior, "" );
		#release StopFiring( 0.0, SFI_Behavior );
		AltFireEffect.AmbientSound=None;
		
		Super.EndState();
	}
	
	//-------------------------------------------------------------------------
	
@ BeginLabel:
//	Goto( MovePickDestLabel );

	// float up to height of flynodes before starting to cycle between these
	//Pawn.AmbientRotationRate.Yaw = RiseYawRate;
	PickHoverDestination();

@ MoveHoverActiveLabel:
	//MoveToPoint( Destination, , , IdleSpeed, MaxMoveTime );
	MoveToPoint( Destination, , , IdleSpeed );
		
	if( MoveResult != MR_DestinationReached )
	{
	 	if( MoveAgain() )
			Goto( MoveHoverActiveLabel );
		else
			Goto(MovePickDestLabel); //Goto( GiveUpLabel ); // don't give up, just abort the hover and go right to an attack dest
	}
	
	//Pawn.AmbientRotationRate.Yaw = 0;
	
@ MovePickDestLabel:
	PickAttackDestination();

@ MovePickDestMidLabel:
	FindPathToActor( SpecialGoal, MoveTarget, true );
	if (MoveTarget==None)
		MoveTarget = SpecialGoal;

@ MoveActiveLabel:
	//MoveToActor( MoveTarget, TMT_None, SpecialGoal, , ControllerEnemy, GetMoveSpeed( MoveTarget.Location ), MaxMoveTime );
	Pawn.bCollideWorld=false;
	MoveToActor( MoveTarget, TMT_None, SpecialGoal, , ControllerEnemy, GetMoveSpeed( MoveTarget.Location ) );
	Pawn.bCollideWorld=true;

	if( MoveResult == MR_DestinationReachedFinal )
		Goto( ReachedDestinationLabel );
	else if( MoveResult == MR_DestinationReached )
		Goto( MovePickDestMidLabel );
	else if( MoveAgain() )
		Goto( MoveActiveLabel );
	else
	{
		//Goto( GiveUpLabel ); // don't give up; this should only happen if someone got in the way (via jumping etc), just wait and try again
		Sleep(3);
		Goto(MovePickDestLabel);
	}
	
@ ReachedDestinationLabel:
	StopMovement( true, true );

	AltFireEffect.SoundRadius = 512;

	Pawn.PlaySound(SecondaryLaserChargeUpSound, SLOT_Interact);
	Sleep(GetSoundDuration(SecondaryLaserChargeUpSound)*0.5);

	Pawn.MeshAgentSetInputCurValue('BodyWaving', 'True');
	StartFiring();
	
	AltFireEffect.SoundVolume = 254;
	AltFireEffect.SoundPitch = 64;
	AltFireEffect.AmbientSound=SecondaryLaserAmbientSound;
	Pawn.AmbientSound=SecondaryAttackAmbientSound;
	Sleep( AttackDurationTime );
	Pawn.AmbientSound=None;
	AltFireEffect.AmbientSound=None;

	#debug   StopFiring( 0.0, SFI_Behavior, "" );
	#release StopFiring( 0.0, SFI_Behavior );
	Pawn.MeshAgentSetInputCurValue('BodyWaving', 'False');

	Pawn.PlaySound(SecondaryLaserChargeDownSound, SLOT_Interact);
	Sleep(GetSoundDuration(SecondaryLaserChargeDownSound)*0.5);

	if (bKamikaze)
		GotoState(KamikazeState);
	else
		Goto(MovePickDestLabel);
} // AlternateAttackState

state @ KamikazeState
{
	event bool NotifyHitWall(vector HitNormal, actor Wall)
	{
		UpperPawn.DrkbuDetonate(true, true);
		return true;
	}
	event BeginState()
	{
		Super.BeginState();
		
		ValidateLowerController();
		if (!LowerController || !LowerController.IsInState('SpinningDeath'))
			class'MusicScriptEvent'.static.CallRoutine(self, "dm004_duckandcover");
	}
	event EndState()
	{
		if (Pawn?)
			Pawn.MeshAgentSetInputCurValue('PermaShake', 'False');
		
		Super.EndState();
	}

@ BeginLabel:

	Pawn.PlaySound(SelfDestructSound, SLOT_Interact);
	
	//Sleep(GetSoundDuration(SelfDestructSound));
	Pawn.MeshAgentCallAction('Event_BodyShake');
	Sleep(4);
	Pawn.MeshAgentCallAction('Event_BodyShake');
	Sleep(3);
	Pawn.MeshAgentCallAction('Event_BodyShake');
	Sleep(2);
	Pawn.MeshAgentSetInputCurValue('PermaShake', 'True');
	Sleep(7);
	Pawn.MeshAgentSetInputCurValue('PermaShake', 'False');
	//Sleep(1.75);
	Enable( Event_NotifyHitWall );
	MinHitWall = 0.0;
	Pawn.SetCollisionSize(Pawn.CollisionRadius*0.25, Pawn.CollisionHeight*0.25);
	Pawn.AirSpeed = Pawn.default.AirSpeed*2.0;
	MoveToPoint( Pawn.Location + vector(Pawn.Rotation)*8000.0);
	//Pawn.Velocity = Pawn.Location + vector(Pawn.Rotation)*Pawn.AirSpeed;
	//Pawn.SetPhysics(PHYS_Projectile);
	//UpperPawn.DrkbuDetonate(true, true);

	Stop;
} // KamikazeState

defaultproperties
{
	ActiveAttackState='PrimaryAttack'
	AltFireEffectTemplate=ParticleSalamander'drakkboss.ParticleSalamander0'
	IdleSpeed=0.500000
	RiseYawRate=32767
	PreAttackDelayTime=1.000000
	AttackDurationTime=2.000000
	PostAttackDelayTime=1.000000
	TimeBetweenShots=1.000000
	AltFireBoltSpeed=3000.000000
	CycleType=CT_RandomVisible
	AttackDestinationClassName='FlyNode'
	WingBoneNames(0)="LeftLeg12"
	WingBoneNames(1)="RightLeg12"
	WingBoneNames(2)="LeftLeg22"
	WingBoneNames(3)="RightLeg22"
	WingBoneNames(4)="LeftLeg32"
	WingBoneNames(5)="RightLeg32"
	WingBoneNames(6)="LeftLeg42"
	WingBoneNames(7)="RightLeg42"
	PrimaryStageHealth=3000
	FireLaserSound=Sound'U2Drakk.FireLaser'
	TakeHitSound=Sound'U2JamesA.ASF-Cockpit.Close_02'
	WingExplodeSound=Sound'U2WeaponsA.Dispersion.DP_PoweredUpExplode'
	TracerTurnOnSound=Sound'U2A.Pickups.fshlite1'
	TracerAmbientSound=Sound'U2Drakk.TracerAmbient'
	LaserChargeUpSound=Sound'U2DrakkNew.Laser_Charge_1'
	SecondaryLaserChargeUpSound=Sound'U2JamesA.ASF-PowerDown.HiPowerUp_01'
	SecondaryLaserChargeDownSound=Sound'U2JamesA.ASF-PowerDown.HiPowerDown_01'
	SecondaryLaserAmbientSound=Sound'U2WeaponsA.LaserRifle.LR_LaserBeam'
	SelfDestructSound=Sound'U2Drakk.DrakkBossTry1'
	SecondaryAttackAmbientSound=Sound'U2JamesA.ASF-EngineLoops.HiPowEngLp_01'
	DefaultState='SimpleWait'
	RotationRate=(Pitch=0,Yaw=8192,Roll=0)
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}