U2.CheatManager

//=============================================================================
// CheatManager
// Object within playercontroller that manages "cheat" commands
// only spawned in single player mode
//=============================================================================

class CheatManager extends Object within PlayerController;

/* Used for correlating game situation with log file
*/
exec function WriteToLog()
{
	if( !OKToCheat() )
		return;

	log("NOW!");
}

exec function FreezeFrame(float delay)
{
	Level.Game.SetPause(true,outer);
	Level.PauseDelay = Level.TimeSeconds + delay;
}

exec function SetFlash(float F)
{
	FlashScale.X = F;
}

exec function SetFogR(float F)
{
	FlashFog.X = F;
}

exec function SetFogG(float F)
{
	FlashFog.Y = F;
}

exec function SetFogB(float F)
{
	FlashFog.Z = F;
}

/* 
Scale the player's size to be F * default size
*/
exec function ChangeSize( float F )
{
	if( !OKToCheat() )
		return;

	if ( Pawn.SetCollisionSize(Pawn.Default.CollisionRadius * F,Pawn.Default.CollisionHeight * F) )
	{
		Pawn.SetDrawScale(F);
		Pawn.SetLocation(Pawn.Location);
	}
}

exec function SetCameraDist( float F )
{
	CameraDist = FMax(F,2);
}

/* Stop interpolation
*/
exec function EndPath()
{
}

/* 
Camera and pawn aren't rotated together in behindview when bFreeCamera is true
*/
exec function FreeCamera( bool B )
{
	bFreeCamera = B;
	bBehindView = B;
}


exec function CauseEvent( name EventName )
{
	if( !OKToCheat() )
		return;

	TriggerEvent( EventName, Pawn, Pawn);
}

exec function NextLevel()
{
	local LevelChange A;

	if( !OKToCheat() )
		return;
	
	foreach AllActors(class'LevelChange',A)
		A.Trigger(Outer,Instigator);
}

exec function Amphibious()
{
	if( !OKToCheat() )
		return;

	Pawn.UnderwaterTime = +999999.0;
}
	
//NEW (mdf) optional speed support
exec function Fly( optional float Speed )
/*OLD
exec function Fly()
*/
{
//NEW (mdf)
	if( !OKToCheat() )
		return;

	if( Pawn == None )
		return;
//OLD
	Pawn.UnderWaterTime = Pawn.Default.UnderWaterTime;	
	ClientMessage("You feel much lighter");
	Pawn.SetCollision(true, true , true);
	Pawn.bCollideWorld = true;
	bCheatFlying = true;
//NEW (mdf)	cleanup, optional speed support
	CheatFlyingSpeed = Speed;
	Outer.GotoState( PlayerController.PlayerFlyingState );
/*OLD
	Outer.GotoState('PlayerFlying');
*/
}

exec function Walk()
{	
	local bool OldBehindView; //NEW MJL
	
	if( !OKToCheat() )
		return;
	
	if ( Pawn != None )
	{
		bCheatFlying = false;
		Pawn.UnderWaterTime = Pawn.Default.UnderWaterTime;	
		Pawn.SetCollision(true, true , true);
		Pawn.SetPhysics(PHYS_Walking);
		Pawn.bCollideWorld = true;
//NEW MJL
		OldBehindView = bBehindView;
		Restart();
		bBehindView = OldBehindView;
/*OLD
		ClientRestart();
*/
	}
}

//NEW (mdf) optional speed support
exec function Ghost( optional float Speed )
/*OLD
exec function Ghost()
*/
{
//NEW (mdf)	mdf-tbd: ghost in spectating mode borks being able to start game (no way out)
	if( !OKToCheat() )
		return;

	if( Pawn == None )
		return;
//OLD
	Pawn.UnderWaterTime = -1.0;	
	ClientMessage("You feel ethereal");
	Pawn.SetCollision(false, false, false);
	Pawn.bCollideWorld = false;
	bCheatFlying = true;
//NEW (mdf)	cleanup, optional speed support
	CheatFlyingSpeed = Speed;
	Outer.GotoState( PlayerController.PlayerFlyingState );
/*OLD
	Outer.GotoState('PlayerFlying');
*/
}

exec function AllAmmo()
{
	local Inventory Inv;

	if( !OKToCheat() )
		return;

	for( Inv=Pawn.Inventory; Inv!=None; Inv=Inv.Inventory ) 
		if (Ammunition(Inv)!=None) 
		{
			Ammunition(Inv).AmmoAmount  = 999;
			Ammunition(Inv).MaxAmmo  = 999;				
		}
}	

exec function Invisible(bool B)
{
	if( !OKToCheat() )
		return;

	Pawn.bHidden = B;

	if (B)
//NEW
	{
		Pawn.Visibility = 0;
		Pawn.ClearReferencesTo();
	}
/*OLD
		Pawn.Visibility = 0;
*/
	else
		Pawn.Visibility = Pawn.Default.Visibility;
}
	
exec function God()
{
	if( !OKToCheat() )
		return;

	if ( bGodMode )
	{
		bGodMode = false;
		ClientMessage("God mode off");
		return;
	}

	bGodMode = true; 
	ClientMessage("God Mode on");
}

exec function SloMo( float T )
{
	if( !OKToCheat() )
		return;

	Level.Game.SetGameSpeed(T);
/*OLD (mdf) don't save new setting so slomo changes will only be in effect for this level?
	Level.Game.SaveConfig(); 
	Level.Game.GameReplicationInfo.SaveConfig();
*/
}

exec function SetJumpZ( float F )
{
	if( !OKToCheat() )
		return;

	Pawn.JumpZ = F;
}

exec function SetSpeed( float F )
{
	if( !OKToCheat() )
		return;

	Pawn.GroundSpeed = Pawn.Default.GroundSpeed * f;
	Pawn.WaterSpeed = Pawn.Default.WaterSpeed * f;
}

exec function KillAll( class<Actor> aClass )
{
	local Actor A;

	if( !OKToCheat() )
		return;

	if ( ClassIsChildOf(aClass, class'Pawn') )
	{
		KillAllPawns(class<Pawn>(aClass));
		return;
	}
	foreach DynamicActors( class 'Actor', A )
		if ( ClassIsChildOf( A.class, aClass ) )
			A.Destroy();
}

// Kill non-player pawns and their controllers
function KillAllPawns( class<Pawn> aClass )
{
//NEW (mdf) fixes for killall somepawnclass not killing all matching pawns
	local AIController AIC;
	local Pawn P;
	
	if( !OKToCheat() )
		return;

	foreach DynamicActors( class'AIController', AIC )
	{
		if( AIC.Pawn != None && ClassIsChildOf( AIC.Pawn.Class, aClass ) )
		{
			AIC.Pawn.Destroy();
			AIC.Destroy();
		}
	}

	// now do a pass through the Pawns in case some of these had no controller (carcasses)
	foreach DynamicActors( class'Pawn', P )
	{
		if( ClassIsChildOf( P.Class, aClass ) && !P.IsHumanControlled() )
			P.Destroy();
	}

/*OLD
	local Pawn P;
	
	foreach DynamicActors( class'Pawn', P )
		if ( ClassIsChildOf( P.Class, aClass )
			&& !P.IsHumanControlled() )
		{
			if ( P.Controller != None )
				P.Controller.Destroy();
			P.Destroy();
		}
*/
}

//NOTE (mdf) - use KillNPCs -- this doesn't work for bots (which can respawn)
exec function KillPawns()
{
	if( !OKToCheat() )
		return;

	KillAllPawns( class'Pawn' );
}

/* Avatar()
Possess a pawn of the requested class
*/
exec function Avatar( string ClassName )
{
	local class<Actor> NewClass;
	local Pawn P;
		
	if( !OKToCheat() )
		return;

	NewClass = class<Actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		foreach DynamicActors(class'Pawn',P)
		{
			if ( (P.Class == NewClass) && (P != Pawn) )
			{
				if ( Pawn.Controller != None )
					Pawn.Controller.PawnDied();
				Possess(P);
				break;
			}
		}
	}
}

exec function Summon( string ClassName )
{
	local class<Actor> NewClass;
	local vector SpawnLoc;

	if( !OKToCheat() )
		return;

	log( "Fabricate " $ ClassName );
	NewClass = class<Actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		if ( Pawn != None )
			SpawnLoc = Pawn.Location;
		else
			SpawnLoc = Location;
		Spawn( NewClass,,,SpawnLoc + 72 * vector(Rotation) + vect(0,0,1) * 15 );
	}
}

exec function PlayersOnly()
{
	if( !OKToCheat() )
		return;

	Level.bPlayersOnly = !Level.bPlayersOnly;
//NEW (mdf) more info please
	DMT( "PlayersOnly: " $ Level.bPlayersOnly );
//OLD
}

//NEW (mdf)
exec function CheatView( class<Actor> aClass, optional bool bIncludeDormant, optional bool bQuiet )
{
	if( !OKToCheat() )
		return;

	ViewClass( aClass, bIncludeDormant, bQuiet );
}
/*OLD
exec function CheatView( class<Actor> aClass, optional bool bQuiet )
{
	ViewClass( aClass, bQuiet, true);
}
*/

// ***********************************************************
// Navigation Aids (for testing)

// remember spot for path testing (display path using ShowDebug)
exec function RememberSpot()
{
	if( !OKToCheat() )
		return;

	if ( Pawn != None )
		Destination = Pawn.Location;
	else
		Destination = Location;
}

// ***********************************************************
// Changing viewtarget

exec function ViewSelf(optional bool bQuiet)
{
	if( !OKToCheat() )
		return;

	bBehindView = false;
	if ( Pawn != None )
		SetViewTarget(Pawn);
	else
		SetViewtarget(outer);
	if (!bQuiet )
		ClientMessage(OwnCamera, 'Event');
	FixFOV();
}

exec function ViewPlayer( string S )
{
	local Controller P;

	if( !OKToCheat() )
		return;

	for ( P=Level.ControllerList; P!=None; P= P.NextController )
		if ( P.bIsPlayer && (P.PlayerReplicationInfo.PlayerName ~= S) )
			break;

	if ( P.Pawn != None )
	{
		ClientMessage(ViewingFrom@P.PlayerReplicationInfo.PlayerName, 'Event');
		SetViewTarget(P.Pawn);
	}

//NEW
	if ( ViewTarget != Pawn )
		ViewTarget.BecomeViewTarget();
/*OLD
	bBehindView = ( ViewTarget != Pawn );
	if ( bBehindView )
		ViewTarget.BecomeViewTarget();
*/
}

//NEW (mdf/mjl) -- multiple cleanup and fixes, some possibly temporary depending on the next code drop

function bool ValidTarget( Actor A, bool bIncludeDormant,  bool bIncludeStationaryPawns )
{
	return( (bIncludeDormant || !A.bStasis) && 
			(bIncludeStationaryPawns || Controller(A) == None || StationaryPawn(Controller(A).Pawn) == None) );
}

exec function ViewClass( class<Actor> aClass, optional bool bIncludeDormant, optional bool bQuiet )
{
	local Actor A, NewTarget;
	local bool bFound;
	local bool bIncludeStationaryPawns;

	if( !OKToCheat() )
		return;

	if ( (Level.Game != None) && !Level.Game.bCanViewOthers )
		return;

	// if Pawn specified, search for Controllers instead (and change code elsewhere to 
	// use Controller's Pawn as the ViewTarget temporarily).
	if( aClass == class'Pawn' )
	{
		aClass = class'Controller';
		bIncludeStationaryPawns	= true;
	}

	// make a first pass to see if we find the current ViewTarget
	NewTarget = None;
	foreach AllActors( aClass, A )
	{
		if( bFound )
		{
			// bFound set on a previous iteration -- take next valid Actor and break out
			if( ValidTarget( A, bIncludeDormant, bIncludeStationaryPawns ) )
			{
				NewTarget = A;
				break;
			}
		}
		else
		{
			if( A == ViewTarget || (Controller(A) != None && Controller(A).Pawn == ViewTarget) )
				bFound = true;
		}
	}
	
	if( NewTarget == None )
	{
		// ViewTarget not found or end of list reached -- try using first matching Actor	
		foreach AllActors( aClass, NewTarget )
			if( ValidTarget( NewTarget, bIncludeDormant, bIncludeStationaryPawns ) )
				break;
	}

	// if first is outer (playercontroller), then just do a ViewSelf below
	if( NewTarget != None && NewTarget != outer )
	{
		if( !bQuiet )
		{
			if( NewTarget.bDeleteMe )
			{
				ClientMessage( ViewingFrom@NewTarget@"(deleted!)", 'Event' );
			}
			else if( Controller(NewTarget) != None )
			{
				if( Controller(NewTarget).Pawn != None && !Controller(NewTarget).Pawn.bDeleteMe )
					ClientMessage( ViewingFrom@Controller(NewTarget).Pawn.GetHumanReadableName(), 'Event' );
				else
					ClientMessage( ViewingFrom@NewTarget, 'Event' );
			}
			else
			{
				ClientMessage( ViewingFrom@NewTarget, 'Event' );
			}
		}
		SetViewTarget( NewTarget );

		if( ViewTarget != outer )
			ViewTarget.BecomeViewTarget();
		FixFOV();
	}
	else
		ViewSelf( bQuiet );
}
/*OLD
exec function ViewClass( class<Actor> aClass, optional bool bQuiet, optional bool bCheat )
{
	local Actor other, first;
	local bool bFound;

	if ( (Level.Game != None) && !Level.Game.bCanViewOthers )
		return;

	first = None;
	foreach AllActors( aClass, other )
	{
		if ( bFound || (first == None) )
		{
			first = other;
			if ( bFound )
				break;
		}
		if ( other == ViewTarget ) 
			bFound = true;
	}  

	if ( first != None )
	{
		if ( !bQuiet )
		{
			if ( Pawn(first) != None )
				ClientMessage(ViewingFrom@First.GetHumanReadableName(), 'Event');
			else
				ClientMessage(ViewingFrom@first, 'Event');
		}
		SetViewTarget(first);
		bBehindView = ( ViewTarget != outer );

		if ( bBehindView )
			ViewTarget.BecomeViewTarget();

		FixFOV();
	}
	else
		ViewSelf(bQuiet);
}
*/

/*OLD: use Goodies, or other commands. this is warfare-specific
exec function Loaded()
{
	local inventory Inv;
	local weapon Weap;

	if( Level.Netmode!=NM_Standalone )
		return;

	Pawn.GiveWeapon("Weapons.WeapCOGAssaultRifle");
	Pawn.GiveWeapon("Weapons.WeapCOGLightPlasma");
	Pawn.GiveWeapon("Weapons.WeapCOGPistol");
	Pawn.GiveWeapon("Weapons.WeapCOGMinigun");
	Pawn.GiveWeapon("Weapons.WeapGeistSniperRifle");
	Pawn.GiveWeapon("Weapons.WeapGeistGrenadeLauncher");
	
	for ( inv=Pawn.inventory; inv!=None; inv=inv.inventory )
	{
		weap = Weapon(inv);
		if ( (weap != None) && (weap.AmmoType != None) )
			weap.AmmoType.AmmoAmount = weap.AmmoType.MaxAmmo;
	}
}
*/

defaultproperties
{
}