U2Pawns.U2DrakkBossController

//=============================================================================
// U2DrakkBossController
//=============================================================================

class U2DrakkBossController extends U2NPCControllerBasic;

#exec OBJ LOAD FILE=..\Sounds\U2AmbientA.uax
#exec OBJ LOAD File=..\Sounds\U2DrakkNew.uax
#exec OBJ LOAD File=..\System\ParticleRes\DrakkFX.u

const ReturnToBaseState			= 'ReturnToBase';
const SpinningDeathState		= 'SpinningDeath';

var bool bAttached, bElectricActive;
var Actor HomeActor;
var U2DrakkBoss LowerPawn;
//var bool bReactToEnemy;
//var float RechargeRate;

var ElectricGenerator UpperLeftElectric, UpperRightElectric;
var ParticleRadiator DamageEffect;
var float ElectricDistance;
var float LiteBriteTimer;
var float SpinningTimer;
var int WingBoneDisabled;
var bool bPreventDamage;

var() Sound WingExplodeSound;


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

function Possess( Pawn P )
{
	local Actor A;

	LowerPawn = U2DrakkBoss(P);
	Super.Possess( P );

	foreach AllActors(class'Actor', A)
	{
		if (A.Tag == LowerPawn.HomeActorTag)
		{
			HomeActor = A;
			break;
		}
	}
	if (HomeActor==None)
	{
		// allocate a holdspot at the start up location (move it to the floor if needed)
		HomeActor = Spawn( class'HoldSpot', , , P.Location );
		#debug DMAssert( HomeActor != None, GetContext() );
		class'UtilGame'.static.PlaceActorOnFloorUnderLocation( HomeActor, HomeActor.Location );
	}

	InitEffects();
}

event Destroyed()
{
	ShutdownEffects();

	Super.Destroyed();
}

function DrkbcTick(float DeltaTime)
{
	// can't use regular Tick for this since Controller.Tick happens before Pawn.Tick, and we need the Pawn for mounting purposes

	UpperLeftElectric.UpdateMountPhysics();
	UpperRightElectric.UpdateMountPhysics();

	UpdateElectric(UpperLeftElectric, ((WingBoneDisabled & 1) != 0) );
	UpdateElectric(UpperRightElectric, ((WingBoneDisabled & 2) != 0) );
}

simulated function UpdateElectric(ElectricGenerator E, bool bWingDisabled)
{
	local vector V;
	local bool bEnemyInRange;

	bEnemyInRange = false;
	if (bElectricActive && (ControllerEnemy?) && (!bWingDisabled))
	{
		V = ControllerEnemy.Location - E.Location;
		if (VSize(V) < ElectricDistance)
			bEnemyInRange = true;
	}

	if (bEnemyInRange)
	{
		E.SetRotation(rotator(Normal(V)));
		E.AmbientSound = sound'U2AmbientA.Electric.Electricharge03'; //sound'U2AmbientA.Electric.Electricharge02';
		E.SoundVolume = 192;
		E.bOn = true;
	}
	else
	{
		E.AmbientSound = None;
		E.bOn = false;
	}
}

private final simulated function ElectricGenerator ConstructElectric(string BoneName, bool bChargeEffect)
{
	local ElectricGenerator A;

	A = spawn(class'ElectricGenerator', Pawn);
	A.bHidden = true;
	//A.bResetArcOnReuse = true;
	//A.Trigger(Pawn, Pawn.Instigator);
	A.MountParentNode = BoneName;
	A.SetPhysics(PHYS_MovingBrush);
	A.MountSetParent(Pawn);

	if (bChargeEffect)
	{
		A.LatchRate = rng(0.1, 0.3);
		A.ArcLifeSpan = rng(0.1, 1.0);
		A.AffectedRadius = ElectricDistance * 4.0;
		A.BeamWidth = rng(2.0, 4.0);
		A.BeamTextureWidth = rng(4.0, 8.0);
	}
	else
	{
		A.BeamSegLength = rng(20.0, 40.0);
		A.MetaBeamSegLength = rng(80.0, 100.0);
		A.LatchRate = rng(0.5, 1.0);
		A.ArcLifeSpan = rng(0.2, 0.4);
		A.AffectedRadius = ElectricDistance;
		A.SpreadDegrees = 15.0;
		//A.DamageAmount = 5;
		//A.DamageTime = 0.15;
		A.DamageStart = rng(4.0, 8.0);
		A.DamageType = class'DamageTypeElectrical';
		A.bLatchAtOrigin = true;
	}

	return(A);
}
private final simulated function InitEffects()
{
	UpperLeftElectric = ConstructElectric("TopLeftWing13", false);
	UpperRightElectric = ConstructElectric("TopRightWing13", false);
	
	DamageEffect = ParticleRadiator(class'ParticleGenerator'.static.CreateNew(self, ParticleRadiator'DrakkFX.ParticleRadiator0'));
	DamageEffect.Instigator = Pawn;
	DamageEffect.MeshOwner = Pawn;
}
private final simulated function ShutdownEffects()
{
	if (UpperLeftElectric?) { UpperLeftElectric.Destroy(); UpperLeftElectric = None; }
	if (UpperRightElectric?) { UpperRightElectric.Destroy(); UpperRightElectric = None; }
	if (DamageEffect!=None) { DamageEffect.Destroy(); DamageEffect=None; }
}

/*
	DrakkBoss interface
*/
function DrkbcAttach(U2DrakkBossUpper InUpperPawn, bool InAttached)
{
	if (bAttached == InAttached)
		return;

	bAttached = InAttached;

	if (bAttached)
	{
		SetFrozen(true);
		LowerPawn.SetCollision(false, false, false);
		LowerPawn.SetPhysics(PHYS_MovingBrush);
		LowerPawn.MountParentNode = "ROOTHigh"; //"HighMover";
		LowerPawn.SetLocation(InUpperPawn.Location);
		LowerPawn.SetRotation(InUpperPawn.Rotation);
		LowerPawn.MountSetParent(InUpperPawn);
		LowerPawn.MountOrgLocation = vect(0,0,0);
		LowerPawn.MountOrgRotation = rot(0,16384,0);
		LowerPawn.SetRotation(InUpperPawn.Rotation);
		SetRotation(InUpperPawn.Rotation);
		LowerPawn.UpdateMountPhysics();
		LowerPawn.MovementPhysics=PHYS_None;//PHYS_MovingBrush
		LowerPawn.SetMovementPhysics(false);
		bElectricActive = false;
		LowerPawn.MeshAgentSetInputCurValue('WhipsOut', 'False');
	}
	else
	{
		SetFrozen(false);
		LowerPawn.SetCollision(true, false, false);
		LowerPawn.MountParentNode = "";
		LowerPawn.MountSetParent(None);
		LowerPawn.MovementPhysics=PHYS_Walking;
		LowerPawn.SetMovementPhysics(true);
		DrkbcEnableEnemyDetection(true);
		if (ControllerEnemy?)
			EnemyAcquired();
		bElectricActive = true;
		LowerPawn.MeshAgentSetInputCurValue('WhipsOut', 'True');
		
		LowerPawn.DrkbSpawnUpperPawn(true);
	}
}

function DrkbcEnableEnemyDetection(bool bEnable)
{
	Shutdown(!bEnable);
	EnableSenses(bEnable);
}


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


function EnemyAcquired()
{
	DrkbcEnableEnemyDetection(true);
	if (!bAttached)
		Super.EnemyAcquired();
}

function CheckWingDamage(int Index, name InputName, string BoneName, Pawn Instigator)
{
	local bool wasDisabled;
	local int HealthThreshold;
	local ParticleGenerator P;
	local vector WingLoc;
	local int NodeHandle;

	WingLoc = Pawn.Location;
	NodeHandle = Pawn.MeshGetNodeNamed(BoneName);
	if (NodeHandle!=0)
		WingLoc = Pawn.MeshNodeGetTranslation(NodeHandle, MESHNODEREL_World);

	wasDisabled = ((WingBoneDisabled & (1<<Index)) != 0);
	HealthThreshold = (Index+1)*(Pawn.default.Health/5);
	if ((Pawn.Health < HealthThreshold) && (!wasDisabled))
	{
		P = class'ParticleGenerator'.static.CreateNew(Pawn, ParticleGenerator'DispersionFX.ParticleSalamander3', WingLoc);
		P.SetRotation(rotator(Normal(Instigator.Location - WingLoc)));
		P.Trigger(Pawn, Pawn);
		P.ParticleLifeSpan = P.GetMaxLifeSpan() + 1.0;
		Pawn.PlaySound(WingExplodeSound, SLOT_Interact, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
		Pawn.MeshAgentSetInputCurValue(InputName, 'False');

		WingBoneDisabled = WingBoneDisabled | (1<<Index);
	
		Pawn.PlaySound(sound'U2DrakkNew.Explosion_4', SLOT_Misc, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
		Pawn.PlaySound(sound'U2DrakkNew.DrakkBossDeathChattr3', SLOT_Weapon, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.0);
	}
}

function eventBumpFriend( Pawn Other )
{
	// makes me go wandering... evil!
}
function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local int OldHealth;
	
	if (bPreventDamage || (U2DrakkBossUpper(Instigator)!=None)) // don't let my upper body hurt me
		return;
	
	OldHealth = Pawn.Health;
	Pawn.Health += Pawn.default.Health*5.0; // just to make sure we don't die without a spinning death
	Super.eventTakeDamage(Damage, Instigator, HitLocation, Momentum, DamageType);
	if (Pawn.Health <= 0)
		return; // overkill; no spinning death
	Pawn.Health -= Pawn.default.Health*5.0;

	if ( (DamageType!=None) && (!ClassIsChildOf(DamageType, class'DamageTypeThermal')) )
	{
		if ((OldHealth - Pawn.Health) > Pawn.default.Health*0.0225)
			Pawn.PlaySound(sound'U2DrakkNew.Hit_Impact_10', SLOT_Pain);
		else
			Pawn.PlaySound(sound'U2DrakkNew.Hit_Impact_7', SLOT_Pain);
	}
	if (Pawn.Health > 0)
	{
		DamageEffect.Trigger(Pawn, Instigator);	
	}
	else
	{
		Pawn.Health = 10000;
		bPreventDamage = true;
		GotoState(SpinningDeathState);
	}


	CheckWingDamage(0, 'UpperLeftWingOut', "TopLeftWing10", Instigator);
	CheckWingDamage(1, 'UpperRightWingOut', "TopRightWing10", Instigator);
	CheckWingDamage(2, 'LowerLeftWingOut', "LowerLeftWing10", Instigator);
	CheckWingDamage(3, 'LowerRightWingOut', "LowerRightWing10", Instigator);
}

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

state @ FrozenState
{
	ignores EnemyNotVisible, SeeFriend, SeeOther, SeeAlertFriend;

	event EnemyRangeTransition( float Distance )
	{
		#debug   SetControllerEnemy( None, GetContext() ); // so enemy will be reacquired
		#release SetControllerEnemy( None ); // so enemy will be reacquired
		Global.EnemyRangeTransition( Distance );
	}
	
	function eventBumpEnemy( Pawn Other )
	{
		#debug   SetControllerEnemy( None, GetContext() ); // so enemy will be reacquired
		#release SetControllerEnemy( None ); // so enemy will be reacquired
		Global.eventBumpEnemy( Other );
	}
	
	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		#debug   SetControllerEnemy( None, GetContext() ); // so enemy will be reacquired
		#release SetControllerEnemy( None ); // so enemy will be reacquired
		if( Pawn.Health > 0 )
			Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
	}

	function bool IsMobile()
	{ 
		return true;
	}
	
	event BeginState()
	{
		Super.BeginState();

		DrkbcAttach(LowerPawn.UpperPawn, true);

		DrkbcEnableEnemyDetection(false);
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		Ranges[0] = 1024.0;//LowerPawn.ReactToEnemyRange;

		RotationRate = rot(0,0,0);
		EnableRotation( false );
		Focus = None;

		DefaultState = WanderingState; // make it so we don't re-enter the frozenstate undesirably when the player dies (causes infinite mounting recursion)
	}
	
	event EndState()
	{
		Focus = ControllerEnemy;
		RotationRate = default.RotationRate;
		if ((Pawn?) && !Pawn.bDeleteMe && !Pawn.bPendingDelete)
			EnableRotation( true );

		Super.EndState();
	}
} // FrozenState

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

state @ ReturnToBaseState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend;
	
	function EnemyAcquired();
	function NotifyUpperNeedsRecharge();
	
	//-------------------------------------------------------------------------

	function PickDestination()
	{
		GetPathToActor( HomeActor, MoveTarget, true );
		ClearMoveAttempts();
	}

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

	event BeginState()
	{
		Super.BeginState();
		BehaviorController.SetBCEnabled( false );
		#debug   SetControllerEnemy(None, GetContext()); // this might not be needed any more
		#release SetControllerEnemy(None); // this might not be needed any more
	}

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

	event EndState()
	{
		BehaviorController.SetBCEnabled( true );
		Super.EndState();
	}

	//-------------------------------------------------------------------------
	
@ BeginLabel:

@ MovePickDestLabel:
	PickDestination();

@ MoveActiveLabel:
	MoveToActor( MoveTarget, TMT_None, HomeActor );
	
	if( MoveResult == MR_DestinationReachedFinal )
		Goto( ReachedDestinationLabel );
	else if( MoveResult == MR_DestinationReached )
		Goto( MovePickDestLabel );
	else if( MoveAgain() )
		Goto( MoveActiveLabel );
	else
		Goto( /*GiveUpLabel*/ReachedDestinationLabel ); // if we can't make it, don't bother in this case, just go from here
	
@ ReachedDestinationLabel:
	StopMovement( true, true );
	
	/* can't use this... uppercontroller changes when new upperpawns are made, even if old upperpawn is still alive.  Don't assume anything.
	ValidateUpperController();
	UpperController.GotoState('SimpleWait', 'WaitActivate');
	*/
	// We don't so much care here about getting into Simplewait, but rather just getting out of Construction.
	// Construction's EndState will handle the real transition into Simplewait correctly, as the upperbody becomes unfrozen during detachment.
	LowerPawn.UpperPawn.UpperController.GotoState('SimpleWait');
		
	Stop;

} // ReturnToBaseState

state @ SpinningDeathState
{
	ignores EnemyNotVisible, EnemyAcquired, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend;

	event BeginState()
	{
		local U2DrakkBossUpper A;

		Super.BeginState();

		MoveTarget = None;
		ClearMoveAttempts();
		StopMovement(true, true);

		BehaviorController.SetBCEnabled( false );
		LowerPawn.bStationary=true;
		#debug   SetControllerEnemy(None, GetContext());
		#release SetControllerEnemy(None);
		Focus = None;
		LowerPawn.AmbientRotationRate=rot(0,0,0);

		LowerPawn.DrkbDestroyUpperPawn();

		Pawn.PlaySound(sound'U2DrakkNew.Self_Destruct_7', SLOT_Weapon, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.5);

		foreach AllActors(class'U2DrakkBossUpper', A)
		{
			if (ValidPawn(A) && A.UpperController?)
				A.UpperController.bKamikaze = true;
		}

		class'MusicScriptEvent'.static.CallRoutine(self, "dm005_winning");
	}
	event EndState()
	{
		class'MusicScriptEvent'.static.CallRoutine(self, "dm006_victory");
		
		Super.EndState();
	}

	event Tick(float DeltaTime)
	{
		Global.Tick(DeltaTime);

		LowerPawn.AmbientRotationRate.Yaw += 10000.0*DeltaTime;

		if (SpinningTimer > 0.0)
			SpinningTimer = FMax(SpinningTimer - DeltaTime, 0.0);
		if (LiteBriteTimer > 0.0)
		{
			LiteBriteTimer = FMax(LiteBriteTimer - DeltaTime, 0.0);
			if (LiteBriteTimer <= 0.0)
			{
				if (!Pawn.bUnlit)
				{
					Pawn.bUnlit = true;
					Pawn.ScaleGlow = 20.0;
				}
				else
				{
					Pawn.bUnlit = false;
					Pawn.ScaleGlow = 1.0;
				}
				LiteBriteTimer = FRand()*SpinningTimer*0.05;
			}
		}
	}

@ BeginLabel:
	/*
	BehaviorController.SetBCEnabled( false );
	LowerPawn.bStationary=true;
	#debug   SetControllerEnemy(None, GetContext());
	#release SetControllerEnemy(None);
	Focus = None;
	LowerPawn.AmbientRotationRate=rot(0,0,0);

	LowerPawn.DrkbDestroyUpperPawn();

	Pawn.PlaySound(sound'U2DrakkNew.Self_Destruct_7', SLOT_Weapon, Pawn.TransientSoundVolume*2.0, , Pawn.TransientSoundRadius*2.5);
	*/

	Enable(Event_Tick);
	SpinningTimer = 18.0;
	LiteBriteTimer = 0.01;
	Sleep(SpinningTimer);
	LowerPawn.KillSelf();
}

defaultproperties
{
	ElectricDistance=512.000000
	WingExplodeSound=Sound'U2WeaponsA.Dispersion.DP_PoweredUpExplode'
	DefaultState='Frozen'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}