U2.U2PlayerTestController

//=============================================================================
// U2PlayerTestController.uc
//=============================================================================

class U2PlayerTestController extends U2PlayerController
	config(User);

/*-----------------------------------------------------------------------------
Mainly exec functions for testing/debugging.

!!mdf-tbd: can/should some of this go into a CheatManager-derived class? The main
problem with this is that the CheatManager approach is limited to singleplayer
only, and many of these cheat functions are useful in networked games...
-----------------------------------------------------------------------------*/

const TeleportFixedState						= 'TeleportFixed';								// ok

const MaxFixCollisionHeight = 100; // don't adjust anything more than this amount?
const MaxCheatSpeed			= 16.0;

struct CreatureInfoT
{
	var string CatStr;
	var string NameStr;
	var string StatusStr;
};

struct ActorInfoT
{
	var class ActorClass;
	var int Count;
	var bool bStatic;
};

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

var() private globalconfig string SummonPackageStrings[ 16 ];	// packages iterated in Summon to find actors
var() private globalconfig string GoodiesList[ 32 ];			// list of goodies to spawn with Goodies
var() private globalconfig CreatureInfoT CreatureList[ 96 ];	// list of creatures summoned with AddCreature (entry 0 not used)
//var() private globalconfig string PlayerClassStrings[ 16 ];	// available classes which can be used with SetPlayerModel
var() globalconfig int ShowViewTraceLen;						// for use with ShowViewTrace debug exec function

// anims
var private Actor	LockedActor;								// Actor used as target of many functions if set

// setspeed
var	bool			bSetSpeedCheatOn;
var float			CurrentSpeed;

// trace debug facility
var private class<HitActorDebugInfoManager> DebugInfoManagerClass;
var private bool bTraceDebugEnabled;		// set when trace debug enabled
var HitActorDebugInfoManager DebugInfoManager;

//!!mdf-tbr: debug scoreboard
var private class<ScoreboardInfoManager> ScoreboardInfoManagerClass;
var ScoreboardInfoManager DebugScoreboard;

var private int	PlayerClassStringIndex;

var	private bool	bBehindViewEnabled;
var	private bool	bNPCsFrozen;
var	private bool	bNPCsLocked;

//!!mdf-tbr: use bHidden?var	private bool	bInvisible;
var	private bool	bServosEnabled;
var	private bool	bTimeDemoEnabled;
var private int		CurrentRMode;
var EPhysics		SavedPhysics;
var int				CreatureIndex;

var() config float NPCShowTime;				// (1.0): how long messages stay on-screen (if bBroadcast)
var() config Font NPCShowFont;				// (font'engine.debugfont')
var() config Color NPCShowColor;			// (0,255,0,255): note that the alpha channel needs to be in 1.255 to have any effect

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

replication
{
	// replicated client to server
	reliable if( Role < ROLE_Authority )
		// NOTE (mdf): you can't currently have any arguments in an exec function's arg list after a float
		/* MJL: there's no console on a ded. server, so this just causes crashes
		// trace info
		TraceLock,
		TraceToggle,
		TraceToggleLevel,
		TraceToggleConsole,
		TraceToggleLog,
		ToggleScoreboard,
		*/

		// location
		GotoActor,
		JumpTo,
		Teleport,
		UnTeleport,
		Where,

		// anims
		DumpAnims,
		DumpAnimsBase,
		DumpSounds,
		ToggleDebugAI,
		ToggleDebugAIAttacks,
		ToggleDebugAIEvents,

		// info
		DumpAll,
		DumpInv,
		EdActor,
		EdHitActor,

		// display
		ToggleShowClass,
		ToggleShowAll,
		ToggleShowKPs,
		ToggleShowNPs,

		// AI
		AIFlags,
		Anywhere,
		ClearOrders,
		DebugFlags,
		DumpAIEvents,
		DumpEvents,
		DumpTags,
		DumpNPs,
		FearMe,
		FindPath,
		FindPathFrom,
		FreezeNPC,
		Here, 
		Here1, 
		Here2,
		LockNPC,
		NPCNext,
		NPCPrev,
		NPCSet,
		NPCShow,
		NPCSum,
		ReloadScripts,
		SetOrders,
		SetScript,
		SetScripts,
		SetWeapon,
		SetWeaponFor,
		ShowCover,
		TestNPList,
		There, 
		There1, 
		There2,
		ToggleFreezeNPCs,
		ToggleLockNPCs,
		TriggerPawns,
		TriggerTarget,

		// misc
		Actors,
		AddActors,
		Damage,
		DamageNPCs,
		Difficulty,
		Distance,
		Dummy,
		FixCollision,
		GetFloorInfo,
		GodEx,
		Goodies,
		HurtMe,
		InvertMouse,
		KillActor,
		KillActiveNPCs,
		KillDormantNPCs,
		KillHitActor,
		KillHitNPC,
		KillNPCs,
		KillNPCsExcept,
		KillPawnsEx,
		KillTimers,
		LockTargetActor,
		Phoenix,
		PO,
		SetCol,
		SetEnemy,
		SetEyeHeight,
		SetFOV,
		SetHealth,
		SetMyEnemy,
		SetMyHealth,
		SetPlayerModel,
		SetSkill,
		SetTeam,
		ShowTeams,
		ShowViewLine,
		ShowViewTrace,
		SizeActor,
		SizePawns,
		StopScenes,
		Sum,
		SumTeam,
		SumVR,
		TestHit,
		TestFall,
		TestNavErrors,
		TestLOS,
		ToggleBehindView,
		ToggleDebugDialog,
		ToggleSubtitles,
		ToggleFOV,
		ToggleFreezeView,
		ToggleHUD,
		ToggleInfiniteAmmo,
		ToggleReloads,
		ToggleInvisibility,
		ToggleRMode,
		ToggleCC,
		HideCCs,
		ShowCCs,
		ToggleSpeed,

		// performance tuning
		SetNPCSprites,
		SetParticleDensity,
		SetStaticMeshBNZE,
		SetStaticMeshCW,
		SetStaticMeshCA,
		SetStaticMeshBA,
		SetStaticMeshBP,
		SetWeaponFire,
		SetWeaponTick,
		ToggleImpacts,
		ToggleServos,
		ToggleTicks;
		
	// replicated server to client
	reliable if( bNetOwner && Role==ROLE_Authority )
		ToggleTimeDemo;
}

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

event PostBeginPlay()
{
	Super.PostBeginPlay();

	if( bCheatsEnabled )
		DM( "cheats enabled on startup" );
}

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

simulated event Destroyed()
{
	if( DebugInfoManager != None )
	{
		DebugInfoManager.Cleanup();
		DebugInfoManager.Delete();
		DebugInfoManager = None;
	}
	bTraceDebugEnabled = false;

	if( DebugScoreboard != None )
	{
		DebugScoreboard.Cleanup();
		DebugScoreboard.Delete();
		DebugScoreboard = None;
	}

	Super.Destroyed();
}

//=============================================================================
// START OF DEBUG/CHEAT EXEC FUNCTIONS
//=============================================================================

function exec TestAssert()
{
	assert(false);
}

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

function bool OKToCheat( optional bool bQuiet )
{
	//return Level.NetMode == NM_Standalone;
	return bCheatsEnabled;
}

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

exec function BeMyMonkey()
{
	bCheatsEnabled = !bCheatsEnabled;
	
	if( bCheatsEnabled )
		DMT( "cheats enabled" );
	else
		DMT( "cheats disabled" );
		
	SaveConfig();
}

function ShowVal( string Str, float Val )
{
	class'UIConsole'.static.BroadcastStatusMessage( 
		Self, 
		Str $ ": " $ class'Util'.static.GetFloatString( Val, 1 ),
		0.5,
		, //font
		, //color
		, //sound
		, //volume
		, //pitch,
		"ConsoleTimedLabelHolder",
		true );
}

exec function BumpGamma() 
{ 
	ConsoleCommand( "gamma + silent" ); 
	ShowVal( "Gamma", GetClient().Gamma );
}
exec function BumpBrightness() 
{ 
	ConsoleCommand( "brightness + silent" ); 
	ShowVal( "Brightness", GetClient().Brightness );
}
exec function BumpContrast() 
{ 
	ConsoleCommand( "contrast + silent" ); 
	ShowVal( "Contrast", GetClient().Contrast );
}

//-----------------------------------------------------------------------------
//!!ARL (mdf) this is only here because I couldn't figure out how to set up
// the debug menu commands to not need a 2nd (dummy) command.

function exec Dummy()
{
}

//------------------------------------------------------------------------------
// Note: should only be used for summoning stuff through exec functions (i.e. 
// with summon etc.) -- we don't want anything else that is summoned to be
// dependent on the SummonPackageStrings in particular .ini files..

static function class<Object> LoadPackageClass( string ClassName )
{
	local string GivenClassName;
	local class<Object> NewClass;
	local int i;

	GivenClassName = ClassName;
	if( instr( ClassName, "." ) >= 0 )
	{
		NewClass = class<Object>( DynamicLoadObject( ClassName, class'Class' ) );
	}
	else
	{
		// no package given -- try various packages
		for( i=0; i<ArrayCount(default.SummonPackageStrings); i++ )
		{
			if( default.SummonPackageStrings[ i ] != "" )
			{
				ClassName = default.SummonPackageStrings[ i ] $ "." $ GivenClassName;

				NewClass = class<Object>( DynamicLoadObject( ClassName, class'Class', true ) );
				if( NewClass != None )
				{
					break;
				}
			}
		}
	}

	return NewClass;
}

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

function Object SummonPackageClass( string ClassName, optional bool bUseViewRotation )
{
	local class<Object> NewClass;
	local bool bStaticOld;
	local Object Obj;
	local bool bOldColActors, bOldBlockActors, bOldBlockPlayers, bOldbOldCollideWorld;
	local Rotator SummonRotation;
	local vector SpawnLocation;
	
	Obj = None;
	if( ClassName == "" )
	{
		DM( "SummonPackageClass: no class given!" );
	}
	else
	{
		NewClass = LoadPackageClass( ClassName );
	
		if( class<Actor>(NewClass) != None )
		{
			// ghost the player first
			if( Pawn != None )
			{
				bOldColActors		= Pawn.bCollideActors;
				bOldBlockActors		= Pawn.bBlockActors;
				bOldBlockPlayers	= Pawn.bBlockPlayers;
				bOldbOldCollideWorld= Pawn.bCollideWorld;
						
				Pawn.SetCollision( false, false, false );
				Pawn.bCollideWorld = false;
			}
			
			if( bUseViewRotation )
			{
				SummonRotation = GetViewRotation();
			}
			else
			{
				// only take Yaw from summoner
				SummonRotation = Rotation;
				SummonRotation.Roll = 0;
				SummonRotation.Pitch = 0;
			}
			// summon some distance away from and above summoner
			if( class<Actor>(NewClass) != None )
			{
				// make sure static things (e.g. decorations) can be summoned
				bStaticOld = class<Actor>(NewClass).default.bStatic;
				SetClassStatic( class<Actor>(NewClass), false );
			}
			if( Pawn != None )
				SpawnLocation = Pawn.Location;
			else
				SpawnLocation = Location;
				
			Obj = Spawn( class<Actor>(NewClass),,,SpawnLocation + 72 * vector(Rotation) + vect(0,0,1) * 15, SummonRotation );

			if( class<Actor>(NewClass) != None )
			{
				SetClassStatic( class<Actor>(NewClass), bStaticOld );
			}

			// restore previous collision
			if( Pawn != None )
			{
				Pawn.SetCollision( bOldColActors, bOldBlockActors, bOldBlockPlayers );
				Pawn.bCollideWorld = bOldbOldCollideWorld; 
			}
		}
		else if( NewClass != None )
		{
			// object
			Obj = new NewClass;
		}
		else
		{
			DM( "SummonPackageClass: class " $ ClassName $ " not found!" );
		}
	}

	if( Obj == None )
	{
		DM( "SummonPackageClass: error spawning " $ ClassName $ "!" );
	}
	else
	{
		// shove into inventory if an inventory item (no other possible use)?
		if( Inventory(Obj) != None && class'UtilGame'.static.GiveInventory( LPawn, Inventory(Obj) ) )
			DM( "SummonPackageClass: added " $ Obj $ " to inventory" );
		else
			DM( "SummonPackageClass: spawned " $ Obj );
	}

	return Obj;
}

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

function bool CheckNamedOrHitActor( string SourceFunctionName, Actor NamedOrHitActor, name TargetName )
{
	local bool bRetVal;

	bRetVal = true;
	if( NamedOrHitActor == None )
	{
		if( TargetName == '' )
		{
			DM( "CheckNamedOrHitActor (" $ SourceFunctionName $ ") -- no Actor under crosshair or no source Pawn!" );
		}
		else
		{
			DM( "CheckNamedOrHitActor (" $ SourceFunctionName $ ") -- named Actor not found or no source Pawn!" );
		}

		bRetVal = false;
	}

	return bRetVal;
}

//-----------------------------------------------------------------------------
// Return first Actor in level which has the given class type or summon one if
// none found.

function Actor FindOrSummonActor( string ActorClass )
{
	local class<Actor> TargetClass;
	local Actor TargetActor;

	TargetClass = class<Actor>(LoadPackageClass( ActorClass ));
	if( TargetClass != None )
	{
		foreach AllActors( TargetClass, TargetActor )
			break;

		if( TargetActor == None )
		{
			// summon one
			TargetActor = Actor(SummonPackageClass( ActorClass ));
		}
	}

	return TargetActor;
}

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

function Actor GetHitActor()
{
	return class'Util'.static.GetHitActor( Self, true );
}

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

function Actor GetNamedActor( name N )
{
	return class'UtilGame'.static.GetNamedActor( Self, N, true, true );
}

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

function Actor GetNamedOrHitActor( optional name N )
{
	return class'UtilGame'.static.GetNamedOrHitActor( Self, N, true, true );
}

//-----------------------------------------------------------------------------
// Return LockedActor if set or Actor under crosshair if any.

function Actor GetLockedOrHitActor( bool bNeedsMesh, optional bool bVerbose )
{
	local Actor A;
	
	if( LockedActor == None )
	{
		A = GetNamedOrHitActor( '' );
		if( A != None && bNeedsMesh ) 
		{
			if( A.Mesh == None )
			{
				A = None;
			}
		}
	}
	else
	{
		A = LockedActor;
	}

	if( bVerbose && A == None )
		DM( "GetLockedOrHitActor: no target animation Actor!" );

	return A;
}

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

function Actor GetNamedLockedOrHitActor( optional name N, optional bool bNeedsMesh, optional bool bVerbose )
{
	if( N != '' )
		return GetNamedActor( N );
	else
		return GetLockedOrHitActor( bNeedsMesh, bVerbose );
}

//-----------------------------------------------------------------------------
// Return named Actor (tries to match name 1st, class 2nd) if given, locked
// Actor otherwise (which might not be set).

function Actor GetNamedOrLockedActor( optional name N )
{
	if( N != '' )
		return class'UtilGame'.static.GetNamedActor( Self, N, true, true );
	else 
		return LockedActor;
}

//-----------------------------------------------------------------------------
// Teleports player to where he is looking. 
//
// Generally used with a binding like:
//
//	bind x Teleport | OnRelease UnTeleport
//
// so holding down 'x' teleports player to the given location and will stay
// "stuck" there until 'x' key is released.
//
// However if UnTeleport isn't called (e.g. used with separate
//
//  bind x Teleport
//  bind y UnTeleport
//
// keys), player can use one key to teleport to given location (and stay
// stuck there) and another key to unteleport (or can re-teleport to
// a new location (using the fly/ghost cheat when teleporting is another
// way to teleport without falling when the teleport key is released).
//
// When reteleported, if the move fails, will remain teleported at current
// location (see state TeleportFixed).
//
// While teleported, should be able to turn, fire and Actor CC is correctly 
// rotated.

simulated function DoTeleport()
{
	local vector HitLocation, HitNormal, TargetLocation;
	local Actor HitActor;
	local vector StartLocation;
	local float SavedRadius, SavedHeight;
	local vector Direction;
	local vector Extents;
	local bool bSuccess;

	if( Pawn == None )
	{
		DM( "Can't teleport -- no Pawn!" );
		return;
	}

	StartLocation = Pawn.Location; 
	StartLocation.Z += Pawn.BaseEyeHeight;
	Direction = vector(GetViewRotation());
	//StartLocation += Direction*LPawn.CrouchRadius;
	HitActor = class'Util'.static.TraceRecursive( Pawn, HitLocation, HitNormal, StartLocation, true, 0.0, Direction );

	if( HitActor != None )
	{	
		// shrink CC to crouch size for teleporting
		SavedRadius = Pawn.CollisionRadius;
		SavedHeight = Pawn.CollisionHeight;

		if( class'Util'.static.AdjustCollisionSize( Pawn, LPawn.CrouchRadius, LPawn.CrouchHeight ) )
		{
			// static mesh and terrain hack -- these don't currently "pop" actors out of geometry correctly
			if( StaticMeshActor(HitActor) != None || TerrainInfo(HitActor) != None )
				HitLocation = HitLocation + HitNormal*FMax( LPawn.default.CollisionRadius, LPawn.default.CollisionHeight );

			TargetLocation = HitLocation;

			// try zero extent result location offset by Pawn's radius along HitNormal
			bSuccess = Pawn.SetLocation( TargetLocation + LPawn.CrouchRadius*HitNormal );
	
			if( !bSuccess )
			{
				// try extent trace back from hit location
				Extents.X = Pawn.CrouchRadius;
				Extents.Y = Pawn.CrouchRadius;
				Extents.Z = Pawn.CrouchHeight;

				if( StartLocation != TargetLocation )
				{
					HitActor = class'Util'.static.TraceRecursive( Pawn, HitLocation, HitNormal, TargetLocation, true, 0.0, -Direction, , Extents );
					bSuccess = Pawn.SetLocation( HitLocation );
				}

				if( !bSuccess )
				{
					// try extent trace forward towards hit location
					HitActor = class'Util'.static.TraceRecursive( Pawn, HitLocation, HitNormal, StartLocation, true, 0.0, Direction, , Extents );
					bSuccess = Pawn.SetLocation( HitLocation );
				}
			}

			if( bSuccess )
			{
				// stick to hit location
				Pawn.ForceStance( ST_Crouching );
				Pawn.AdjustEyeHeight( LPawn.CrouchEyeHeight );
				GotoState( TeleportFixedState );
			}
			else
			{
				// try to restore saved CC (should always work if didn't move)
				Pawn.SetCollisionSize( SavedRadius, SavedHeight );
				DM( "DoTeleport -- teleport failed!" );
			}
		}
		else
		{
			DM( "DoTeleport -- couldn't set crouching size!" );
		}
	}
	else
	{
		DM( "DoTeleport -- failed to hit anything!" );
	}
}

//-----------------------------------------------------------------------------
// Modify the collision height, radius and drawscale for the named, locked or
// hit Actor.

function SizeNamedLockedOrHitTarget( name TargetName, int NewRadius, int NewHeight, float NewDrawScale, bool bQuiet )
{
	local Actor A;

	A = GetNamedLockedOrHitActor( TargetName );
	if( CheckNamedOrHitActor( "SizeNamedLockedOrHitTarget", A, TargetName ) )
	{
		if( NewDrawScale ~= 0.0 )
		{
			NewDrawScale = A.default.DrawScale*NewHeight/A.default.CollisionHeight;
		}

		if( !bQuiet )
		{
			DM( "Setting size for " $ A $" to R=" $ NewRadius $ " H=" $ NewHeight $ " DrawScale=" $ NewDrawScale );
		}

		A.SetCollisionSize( NewRadius, NewHeight );
		A.SetDrawScale( NewDrawScale );
	}
}

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

exec function InvertMouse()
{
	PlayerInput.bInvertMouse = !PlayerInput.bInvertMouse;
	
	DM( "InvertMouse: " $ PlayerInput.bInvertMouse );
}

//-----------------------------------------------------------------------------
// Trace straight down and report slope of geometry under player (or Actor with
// given name) and distance from center of CC to hit location.

exec function GetFloorInfo( optional name TargetName )
{
	local Actor TargetActor;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local float costheta;
	local float sintheta;
	local float tantheta;
	local float theta;
	local float HeightAboveFloor;
	local string strInfo;
	local int ii;
	local vector GFVector;

	if( !OKToCheat() )
		return;

	if( TargetName != '' )
		TargetActor = GetNamedActor( TargetName );
	else
		TargetActor = Self;

	GFVector.X = 0; // TargetActor.CollisionRadius;
	GFVector.Y = 0; // TargetActor.CollisionRadius;
	GFVector.Z = 0;

	HitActor = class'Util'.static.TraceRecursive( TargetActor, HitLocation, HitNormal, TargetActor.Location, false, 500,,,GFVector );

	DM( "  HitActor:    " $ HitActor );
	DM( "  HitNormal:   " $ class'util'.static.GetVectorString(HitNormal) );
	DM( "  HitLocation: " $ class'util'.static.GetVectorString(HitLocation) );

	strInfo = "GetFloorInfo (" $ TargetActor.Name $ "): ";
	if( HitActor != None && (HitActor == Level || Mover(HitActor) != None) )
	{
		HeightAboveFloor = VSize(TargetActor.Location - HitLocation );

		costheta = vect(0,0,1) dot HitNormal;
		if( HitNormal.Z < 0 )
		{
			DM( "GetFloorInfo: got flipped HitNormal below " $ TargetActor.Name $ "!" );
			HitNormal.Z = abs(HitNormal.Z);
		}

		if( costheta ~= 0.0 )
		{
			strInfo = strInfo $ "Slope= ~90 degrees";
		}
		else
		{
			// !!mdf-tbd: acos isn't exposed?
			// theta		= appAcos( costheta );
			strInfo = strInfo $ "Slope=" $ ACos( costheta )*RadiansToDegrees $ " degrees";
			/* its exposed now?
			sintheta = sqrt( 1.0 - (costheta*costheta) );
			tantheta = sintheta/costheta;

			strInfo = strInfo $ "Slope=" $ ATan( tantheta )*RadiansToDegrees $ " degrees";
			*/
		}

		strInfo = strInfo $ "  Height=" $ HeightAboveFloor $ " units";
		DM( strInfo );

		// put decals at hit location 

		// !!mdf-tbd: using 4 of these for now since I can't figure out flags so these 
		// aren't transparent/modulated and 4 of 'em makes spot much more visible
		for( ii=0; ii<4; ii++ )
			Spawn( Class'Legend.SpotMarker', Pawn, , HitLocation, rotator(HitNormal) );
	}
	else
	{
		DM( strInfo $ "error tracing down (HitActor=" $ HitActor $ ")!" );
	}
}

//-----------------------------------------------------------------------------
// Exec functions.
//-----------------------------------------------------------------------------

exec function Goodies( int First, int Last )
{
	local int ii;

	if( !OKToCheat() )
		return;

	if( First < 0 )
		First = 0;
	if( Last >= ArrayCount(GoodiesList) )
		Last = ArrayCount(GoodiesList)-1;

	if( LPawn != None )
	{
		for( ii=First; ii<=Last; ii++ )
		{
			if( GoodiesList[ii] != "" )
			{
				// try shove it into player's inventory
				if( class'UtilGame'.static.GiveInventoryString( LPawn, GoodiesList[ii] ) != None )
				{
					DM( "Added " $ GoodiesList[ii] $ " to inventory" );
				}
				else
				{
					// spawn it on the ground
					SummonPackageClass( GoodiesList[ii] );
				}
			}
		}
	}
	else
	{
		DM( "Invalid Pawn: " $ LPawn );
	}
}

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

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

	DefaultFOV = FClamp(F, 1, 170);
	DesiredFOV = DefaultFOV;
}

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

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

	if( DesiredFOV ~= F )
		F = default.DefaultFOV;
	
	SetFOV( F );	
}

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

exec function Sum( string ClassName )
{
	if( !OKToCheat() )
		return;

	SummonPackageClass( ClassName );
}

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

exec function SumVR( string ClassName )
{
	if( !OKToCheat() )
		return;

	SummonPackageClass( ClassName, true );
}

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

exec function SumTeam( byte ATeam, string ClassName )
{
	local Object O;

	if( !OKToCheat() )
		return;

	O = SummonPackageClass( ClassName );
		
	if( O != None )
	{
		if( Pawn(O) != None && Pawn(O).PlayerReplicationInfo != None )
		{
			Pawn(O).PlayerReplicationInfo.Team = U2GameInfo(Level.Game).GetTeam( ATeam );
		}
		else
		{
			ClientMessage( "SumTeam: " $ ClassName $ " has no PlayerReplicationInfo!" );
		}
	}
	else
	{
		ClientMessage( "SumTeam: error spawning " $ ClassName $ "!" );
	}
}

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

function DoSetWeapon( string WeaponClassString, name TargetName, bool bKeepInv )
{
	local LicenseePawn TargetPawn;

	if( !OKToCheat() )
		return;

	TargetPawn = LicenseePawn(GetNamedLockedOrHitActor( TargetName, true, true ));
	
	if( TargetPawn != None )
	{
		if( !bKeepInv )
			class'UtilGame'.static.RemoveInventoryString( TargetPawn, "" );
			
		if( !class'UtilGame'.static.SetCurrentWeaponString( TargetPawn, WeaponClassString ) )
			DMT( "couldn't assign weapon" );
	}
	else
	{
		DMT( "can't find target: " $ TargetName );
	}
}

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

exec function SetWeaponFor( string WeaponClassString, name TargetName, optional bool bKeepInv )
{
	DoSetWeapon( WeaponClassString, TargetName, bKeepInv );
}

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

exec function SetWeapon( string WeaponClassString, optional bool bKeepInv )
{
	DoSetWeapon( WeaponClassString, '', bKeepInv );
}

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

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

	DoTeleport();
}

//-----------------------------------------------------------------------------
// Only implemented in teleported state.

exec function UnTeleport();

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

exec function GotoActor( name ObjectName )
{
	local Actor A;

	if( !OKToCheat() )
		return;

	A = GetNamedActor( ObjectName );
	if( A != None )
	{
		if( !Pawn.SetLocation( A.Location ) )
		{
			ClientMessage( "GotoActor: couldn't set location (try ghosting first?)" );
		}
	}
	else
	{
		ClientMessage( GetContext() $ ObjectName $ " not found!" );
	}
}

//-----------------------------------------------------------------------------
// Note: multiple float params don't seem to work...

exec function JumpTo( int x, int y, int z )
{
	local vector NewLocation;

	if( !OKToCheat() )
		return;

	NewLocation.x = x;
	NewLocation.y = y;
	NewLocation.z = z;

	if( !Pawn.SetLocation( NewLocation ) )
	{
		ClientMessage( "Couldn't set location" );
	}
}

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

exec function Where( optional name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	if( TargetName != '' )
		TargetActor = GetNamedLockedOrHitActor( TargetName );
	else
		TargetActor = Pawn;
		
	if( TargetActor != None )
	{
		DM( TargetActor $ ": Location: " $ class'Util'.static.GetVectorString(TargetActor.Location) );
	}
	else
	{
		DM( "Where: can't find Actor with name: " $ TargetName );
	}
}

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

function DumpActorList( array<ActorInfoT> ActorList, bool bShowStatic )
{
	local int ii, jj, FoundIndex, MaxCount, MaxIndex, TotalCount;

	for( ii=0; ii<ActorList.Length; ii++ )
	{
		MaxCount = -1;
		for( jj=0; jj<ActorList.Length; jj++ )
		{
			if( ActorList[ jj ].bStatic == bShowStatic && ActorList[ jj ].Count > MaxCount )
			{
				MaxCount = ActorList[ jj ].Count;
				MaxIndex = jj;
			}
		}
		
		if( MaxCount != -1 )
		{
			DM( "  " $ class'Util'.static.PadString( ActorList[ MaxIndex ].ActorClass, 64 ) $ " " $ ActorList[ MaxIndex ].Count );
			TotalCount += ActorList[ MaxIndex ].Count;
			ActorList[ MaxIndex ].Count = -99;
		}
		else
		{
			break;
		}
	}
	
	DM( "  " $ class'Util'.static.PadString( "Total", 64 ) $ " " $ TotalCount );
}

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

exec function Actors( optional bool bVerbose )
{
	local Actor A1, A2;
	local int ActorCount, StaticActorCount, DynamicActorCount1, DynamicActorCount2;
	local bool bFound;
	local array<ActorInfoT> ActorList;
	local int ii, FoundIndex;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A1 )
	{
		ActorCount++;
		if( A1.bStatic )
			StaticActorCount++;
		else
			DynamicActorCount1++;
		
		FoundIndex = -1;
		for( ii=0; ii<ActorList.Length; ii++ )
		{
			if( ActorList[ ii ].ActorClass == A1.Class && ActorList[ ii ].bStatic == A1.bStatic )
			{
				FoundIndex = ii;
				break;
			}
		}
		
		if( FoundIndex == -1 )
		{
			FoundIndex = ActorList.Length;
			ActorList.Length = ActorList.Length + 1;
			ActorList[ FoundIndex ].ActorClass = A1.Class;
			ActorList[ FoundIndex ].bStatic = A1.bStatic;
		}
		
		ActorList[ FoundIndex ].Count++;
						
		if( bVerbose )
			DM( class'Util'.static.PadString( A1, 64) $ " " $ byte(A1.bStatic) );
	}
	
	DM( " " );
	DM( "  Static classes:" );
	DumpActorList( ActorList, true );	
	DM( " " );
	DM( "  Dynamic classes:" );
	DumpActorList( ActorList, false );	

	DM( " " );
	DM( "Actors: " $ ActorCount $ " Static: " $ StaticActorCount $ " Dynamic: " $ DynamicActorCount1 );
	
	// sanity checks
	foreach DynamicActors( class'Actor', A1 )
	{
		if( A1.bStatic )
			DM( "WARNING: actor in DynamicActor list is static: " $ A1 );
		DynamicActorCount2++;
	}
	
	/*
	if( DynamicActorCount1 != DynamicActorCount2 )
	{
		DM( "WARNING: DynamicActorCount1 (" $ DynamicActorCount1 $ ") != DynamicActorCount2 (" $ DynamicActorCount2 $ ")" );

		// find non static actors which are in actor list but not in dynamic actor list?
		foreach AllActors( class'Actor', A1 )
		{
			if( !A1.bStatic )
			{
				bFound = false;
				foreach DynamicActors( class'Actor', A2 )
				{
					if( A1 == A2 )
					{
						bFound = true;
						break;
					}
				}
				
				if( !bFound )
					DM( "  " $ A1 $ " is !bStatic and is in AllActors list but not in DynamicActors list?!" );
			}
		}
	}
	*/	
}

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

exec function SetStaticMeshBNZE( bool bVal )
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
			A.bBlockNonZeroExtentTraces = bVal;
	}
}

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

exec function SetStaticMeshCW( bool bVal )
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
			A.bCollideWorld = bVal;
	}
}

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

exec function SetStaticMeshCA( bool bVal )
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
			A.SetCollision( bVal, A.bBlockActors, A.bBlockPlayers );
	}
}

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

exec function SetStaticMeshBA( bool bVal )
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
			A.SetCollision( A.bCollideActors, bVal, A.bBlockActors );
	}
}

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

exec function SetStaticMeshBP( bool bVal )
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
			A.SetCollision( A.bCollideActors, A.bBlockActors, bVal );
	}
}

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

exec function DumpStaticMeshCollision()
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( StaticMeshActor( A ) != None )
		{
			DM( A $ " bCollideWorld=" $  A.bCollideWorld $ 
			        " bCollideActors=" $ A.bCollideActors $ 
			        " bBlockActors=" $   A.bBlockActors $ 
			        " bBlockPlayers=" $  A.bBlockPlayers $
			        " bBlockNonZeroExtentTraces=" $ A.bBlockNonZeroExtentTraces );
		}
	}
}

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

exec function Damage( int DamageAmount, optional name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedLockedOrHitActor( TargetName );
	if( Controller(TargetActor) != None )
		TargetActor = Controller(TargetActor).Pawn;

	if( Pawn(TargetActor) != None )
		Pawn(TargetActor).TakeDamage( DamageAmount, Pawn, TargetActor.Location, vect(0,0,0), class'DamageType' );
	else
		DM( "Damage: no valid target" );
}

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

exec function DamageNPCs( int DamageAmount )
{
	local Controller C;
	local Pawn P;

	if( !OKToCheat() )
		return;

	DM( "DamageNPCs: Damaging all NPCs" );
	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		P = C.Pawn;
		if( P != None && !P.bIsRealPlayer )
			P.TakeDamage( DamageAmount, Pawn, P.Location, vect(0,0,0), class'Suicided' );
	}
}

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

exec function SetHealth( int NewHealth, optional name TargetName )
{
	local Actor TargetActor;
	local Controller C;

	if( !OKToCheat() )
		return;

	if( TargetName == 'all' )
	{
		DM( "SetHealth - setting health for all PCs/NPCs to " $ NewHealth );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( C.Pawn != None )
				C.Pawn.Health = NewHealth;
	}
	else
	{
		TargetActor = GetNamedLockedOrHitActor( TargetName );
		if( Controller(TargetActor) != None )
			TargetActor = Controller(TargetActor).Pawn;

		if( Pawn(TargetActor) != None )
		{
			DM( "SetHealth - setting health for " $ Pawn(TargetActor).Name $ " to " $ NewHealth );
			Pawn(TargetActor).Health = NewHealth;
		}
		else
			DM( "SetHealth: no valid target" );
	}
}

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

exec function SetMyHealth( int NewHealth )
{
	if( !OKToCheat() )
		return;

	SetHealth( NewHealth, Pawn.Name );
}

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

exec function HurtMe( int Damage )
{
	if( !OKToCheat() )
		return;

	Pawn.TakeDamage( Damage, Pawn, Location, vect(0,0,0), class'Suicided' );
}

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

exec function ManCannon( int Momentum )
{
	local Pawn P;

	if( !OKToCheat() )
		return;

	foreach VisibleActors(class'Pawn', P, 2048.0, Pawn.Location)
	{
		if (P != Pawn)
			P.TakeDamage( 5000, Pawn, P.Location, Normal(P.Location - Pawn.Location)*Momentum, class'DamageTypePhysical' );
	}
}

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

exec function ToggleServos()
{
	local Controller C;

	if( !OKToCheat() )
		return;

	bServosEnabled = !bServosEnabled;

	if( bServosEnabled )
		DM( "ToggleServos - animation servos enabled" );
	else
		DM( "ToggleServos - animation servos disabled" );

	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( U2Pawn(C.Pawn) != None )
			U2Pawn(C.Pawn).bServoEnabled = bServosEnabled;
	}
}

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

function DoDumpAnims( name TargetName, bool bBaseOnly )
{
	local Actor TargetActor;
	local int ii, jj;
	local name BaseName;
	local name BaseNames[ 256 ];
	local int NumBaseNames;
	local bool bFound;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedLockedOrHitActor( TargetName );
	NumBaseNames = 0;
	if( TargetActor != None )
	{
		DM( "DumpAnims: " $ TargetActor.Class.Name $ " -- begin " );

		for( ii=0; ii<TargetActor.GetAnimCount(); ii++ )
		{
			if( bBaseOnly )
			{
				BaseName = TargetActor.GetAnimSlot( TargetActor.GetAnim( ii ) );

				// see if in list yet
				bFound = false;
				for( jj=0; jj<NumBaseNames; jj++ )
				{
					if( BaseNames[ jj ] == BaseName )
					{
						bFound = true;
						break;
					}
				}

				if( !bFound )
				{
					// add it
					BaseNames[ NumBaseNames ] = BaseName;
					NumBaseNames++;
					DM( BaseName );
				}
			}
			else
			{
				DM( class'Util'.static.PadString( ii, 3 ) $ ": " $ TargetActor.GetAnim( ii ) $ " (" $ TargetActor.GetAnimFrames( TargetActor.GetAnim( ii ) ) $ ")" );
			}
		}

		DM( "# Animations: " $ TargetActor.GetAnimCount() );
		if( bBaseOnly )
			DM( "# Base Animations: " $ NumBaseNames );
		DM( "DumpAnims: " $ TargetActor.Class.Name $ " -- end " );
	}
	else
	{
		DM( "DumpAnims -- target not found!" );
	}
}

//-----------------------------------------------------------------------------
// Dump animations in mesh for given or target actor.

exec function DumpAnims( optional name TargetName )
{
	DoDumpAnims( TargetName, false );
}

//-----------------------------------------------------------------------------
// Dump animations in mesh for given or target actor.

exec function DumpAnimsBase( optional name TargetName )
{
	DoDumpAnims( TargetName, true );
}

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

exec function DumpSounds( name TargetName )
{
	local U2Pawn TargetPawn;
	
	TargetPawn = U2Pawn(GetNamedOrHitActor( TargetName ));
	if( TargetPawn != None )
	{
		DMT( "Dumping SoundTable for " $ TargetPawn $ " VoicePackage: " $ TargetPawn.VoicePackage );
		TargetPawn.SoundTable.Dump( TargetPawn );
	}
	else
	{
		DMT( "DumpSounds -- can't find target" @ TargetName );
	}
}

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

exec function LockTargetActor( optional name TargetName )
{
	if( !OKToCheat() )
		return;

	LockedActor = GetNamedOrHitActor( TargetName );
		
	if( CheckNamedOrHitActor( "LockTargetActor", LockedActor, TargetName ) ) 
	{
		if( LockedActor.Mesh == None )
		{
			DM( "LockTargetActor -- Actor has no mesh: " $ LockedActor );
			LockedActor = None;
		}
		else
		{
			DM( "LockTargetActor: locked " $ LockedActor );
		}
	}
}

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

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

	ObjListMemStats(true);
	NPCSum();
	ObjListMemStats(false);
	NPCNext();
}

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

function DoToggleDebugFlag( name TargetName, int DebugFlag )
{
	local LicenseeController LC;

	LC = LicenseeController(GetNamedLockedOrHitActor( TargetName ));
	if( LC != None )
	{
		LC.ToggleDebugFlag( DebugFlag );
		DM( "ToggleDebugFlag -- DebugFlags: " $ LC.GetDebugFlags() );
	}
	else
	{
		DM( "ToggleDebugFlag: can't toggle flags for " $ LC );
	}
}

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

exec function ToggleDebugAI( optional name TargetName )
{
	if( !OKToCheat() )
		return;

	DoToggleDebugFlag( TargetName, LicenseeController.Debug_AI );
}

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

exec function ToggleDebugAIEvents( optional name TargetName )
{
	if( !OKToCheat() )
		return;

	DoToggleDebugFlag( TargetName, LicenseeController.Debug_AIEvents );
}

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

exec function ToggleDebugAIAttacks( optional name TargetName )
{
	if( !OKToCheat() )
		return;

	DoToggleDebugFlag( TargetName, LicenseeController.Debug_AIAttacks );
}

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

exec function DebugFlags( int DebugFlags, optional name TargetName )
{
	local Actor A;
	local LicenseeController LC;

	if( !OKToCheat() )
		return;

	A = GetNamedLockedOrHitActor( TargetName );
	if( LicenseeController(A) != None )
		LC = LicenseeController(A);
	else if( LicenseePawn(A) != None )
		LC = LicenseeController(LicenseePawn(A).Controller);
	if( LC != None )
	{
		DM( "DebugFlags: setting DebugFlags for " $ LC $ " to " $ DebugFlags );
		LC.SetDebugFlags( DebugFlags );
	}
	else
	{
		DM( "DebugFlags: can't toggle flags for " $ TargetName );
	}
}

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

exec function AIFlags( int DebugFlags )
{
	local Pawn P;

	if( !OKToCheat() )
		return;

	DM( "AIFlags: setting DebugFlags for all AI controllers to " $ DebugFlags );
	for( P=Level.PawnList; P!=None; P=P.NextPawn )
	{
		if( !P.bIsRealPlayer && LicenseeController(P.Controller) != None )
			LicenseeController(P.Controller).SetDebugFlags( DebugFlags );
	}
}

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

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

	class'DialogEngine'.static.ToggleDebug(Self);
}

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

exec function ToggleSubtitles()
{
	ShowSubtitles = !ShowSubtitles;
}

//-----------------------------------------------------------------------------
// testing

exec function ShowTeams()
{
	local Pawn P;
	
	if( !OKToCheat() )
		return;

	ClientMessage( " " );	// spacer
	for( P=Level.PawnList; P!=None; P=P.NextPawn )
	{
		ClientMessage( P.Name $ " Health: " $ P.Health $ ")" );

		if( P.PlayerReplicationInfo != None )
		{								   
			ClientMessage( "  Team: " $ P.PlayerReplicationInfo.Team.TeamIndex );
			ClientMessage( "  TeamName: " $ P.PlayerReplicationInfo.Team.TeamName );
		}
		else
		{
			ClientMessage( "  Team: no PlayerReplicationInfo!" );
			ClientMessage( "  TeamName: no PlayerReplicationInfo!" );
		}
	}
}

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

exec function ToggleTimeDemo()
{
	// not a cheat
	bTimeDemoEnabled = !bTimeDemoEnabled;

	if( bTimeDemoEnabled )
	{
		ConsoleCommand( "timedemo 1" );
	}
	else
	{
		ConsoleCommand( "timedemo 0" );
	}
}

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

exec function FOV( float F )
{
	if( OKToCheat() )
		Super.FOV( F );
}
	
//-----------------------------------------------------------------------------

exec function BehindView( Bool B )
{
	if( !OKToCheat() )
		return;
		
	if( B )
		DM( "behindview enabled" );
	else
		DM( "behindview disabled" );

	ClientSetBehindView( B );
}

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

exec function ToggleBehindView()
{
	// is a cheat now?
	if( !OKToCheat() )
		return;

	bBehindViewEnabled = !bBehindViewEnabled;
	BehindView( bBehindViewEnabled );
}

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

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

	if( Pawn != None )
	{
		if( !Pawn.bHidden )
		{
			DM( "invisibility enabled" );
			ConsoleCommand( "invisible 1" );
			Pawn.ClearReferencesTo();
		}
		else
		{
			DM( "invisibility disabled" );
			ConsoleCommand( "invisible 0" );
		}
	}
	else
	{
		DM( "Can't toggleinvisibility -- Pawn not set!" );
	}
}

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

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

	if( DebugScoreboard == None )
	{
		DebugScoreboard = new ScoreboardInfoManagerClass;
		DebugScoreboard.Initialize( Self );
	}

	DebugScoreboard.CycleEnabled();
}

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

function HitActorDebugInfoManager GetTracerInstance()
{
	if( DebugInfoManager == None )
	{
		DebugInfoManager = new DebugInfoManagerClass;
		DebugInfoManager.Initialize( Self );
	}

	return DebugInfoManager;
}

//-----------------------------------------------------------------------------
// Enables on-screen information for Actor that the player is looking at.
// !!mdf-tbd: won't work in MP (myHUD not set)?

exec function TraceToggle( optional name TargetName )
{
	local string DMString;
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	if( TargetName != '' )
	{
		TargetActor = GetNamedActor( TargetName );
		if( TargetActor != None )
		{
			// make sure we compare apples with apples
			if( Pawn(TargetActor) != None && Pawn(TargetActor).Controller != None )
				TargetActor = Pawn(TargetActor).Controller;

			if( GetTracerInstance().GetActorToShow() == TargetActor )
			{
				// unlock it
				DM( "TraceToggle: unlocked " $ TargetActor.Name );
				GetTracerInstance().SetActorToShow( None );
				bTraceDebugEnabled = false;
			}
			else
			{
				// lock it
				DM( "TraceToggle: locked " $ TargetActor.Name );
				GetTracerInstance().SetActorToShow( TargetActor );
				ForceTraceEnable();
				bTraceDebugEnabled = true;
			}	
		}
		else
		{
			DM( "TraceToggle: can't find " $ TargetName );
		}
	}
	else
	{
		bTraceDebugEnabled = !bTraceDebugEnabled;
	
		if( bTraceDebugEnabled )
		{
			// make sure allocated
			GetTracerInstance();
	
			DMString = "TraceToggle: Enabled (";
	
			DMString = DMString $ "Console: " $ GetTracerInstance().GetEchoToConsole();
			DMString = DMString $ ", Log: " $ GetTracerInstance().GetEchoToLog();
	
			DMString = DMString $ ")";
		}
		else
		{
			GetTracerInstance().SetActorToShow( None );
			DMString = "TraceToggle: Disabled";
		}
	
		GetTracerInstance().SetEnabled( byte(bTraceDebugEnabled) );
		DM( DMString );
	}
}

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

function ForceTraceEnable()
{
	// if not tracing, enable it
	if( !bTraceDebugEnabled )
		TraceToggle();
}

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

exec function TraceLock( optional name TargetName )
{
	local Actor TargetActor;
	local bool bWasLocked;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedOrHitActor( TargetName );
	if( TargetActor != None )
	{
		bWasLocked = (GetTracerInstance().GetActorToShow() != None);
		if( !bWasLocked || LevelInfo(TargetActor) == None || GetTracerInstance().GetShowLevel() )
		{
			DM( "TraceLock: locked " $ TargetActor.Name );
			GetTracerInstance().SetActorToShow( TargetActor );
			ForceTraceEnable();
		}
		else
		{
			if( bWasLocked )
				DM( "TraceLock: cleared locked Actor");
	
			GetTracerInstance().SetActorToShow( None );
		}
	}
	else
	{
		DM( "TraceLock: no target Actor!");
	}
}

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

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

	GetTracerInstance().SetShowLevel( !GetTracerInstance().GetShowLevel() );
		
	DM( "TraceToggleLevel: " $ GetTracerInstance().GetShowLevel() );
}

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

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

	GetTracerInstance().SetEchoToConsole( !GetTracerInstance().GetEchoToConsole() );
		
	DM( "TraceToggleConsole: " $ GetTracerInstance().GetEchoToConsole() );
}

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

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

	GetTracerInstance().SetEchoToLog( !GetTracerInstance().GetEchoToLog() );
	
	DM( "TraceToggleLog: " $ GetTracerInstance().GetEchoToLog() );
}

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

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

	GetTracerInstance().SetShowAgentInfo( !GetTracerInstance().GetShowAgentInfo() );
	
	DM( "TraceToggleAgentInfo: " $ GetTracerInstance().GetShowAgentInfo() );
}

//-----------------------------------------------------------------------------
// +expose complete interface?
// +alternatively -- could put anything useful (like this function) into engine?

function ShowViewTraceExtents( bool bUseExtents, vector Extents )
{
	local vector TraceStart, TraceEnd;
	local CheckResult Hit;

	if( !OKToCheat() )
		return;

	TraceStart		= Pawn.Location; 
	TraceStart.Z   += Pawn.BaseEyeHeight;
	TraceEnd = TraceStart + ShowViewTraceLen * vector(Pawn.GetViewRotation());

	if( bUseExtents )
	{
		// Note (mdf): traces with extents are somewhat flaky. This makes sense when tracing over
		// complex geometry, but even tracing with extents over flat bsp often seems to fail or
		// hits the source actor.
		Pawn.SingleLineCheck( Hit, None, TraceEnd, TraceStart, TRACE_ProjTargets, Extents );
	}
	else 
	{
		// but traces without extents won't hit static meshes?
		Pawn.SingleLineCheck( Hit, None, TraceEnd, TraceStart, TRACE_ProjTargets );
	}

	if( Hit.Actor == None )
	{
		DM( "ShowViewTrace (bUseExtents=" $ bUseExtents $ ", TraceLen=" $ ShowViewTraceLen $ ") -- SingleLineCheck didn't hit anything!" );
		AddArrow( TraceStart, TraceEnd );
	}
	else
	{
		TraceEnd = Hit.Location;
		DM( "ShowViewTrace (bUseExtents=" $ bUseExtents $ ", TraceLen=" $ ShowViewTraceLen $ ") -- length = " $ VSize( TraceStart - TraceEnd ) $ " Hit.Actor = " $ Hit.Actor $ " Hit.Time = " $ Hit.Time );
		AddArrow( TraceStart, TraceEnd );
	}
}

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

exec function ShowViewLine()
{
	local vector TraceStart, TraceEnd;

	if( !OKToCheat() )
		return;

	TraceStart		= Pawn.Location; 
	TraceStart.Z   += Pawn.BaseEyeHeight;
	TraceEnd = TraceStart + 65535 * vector(Pawn.GetViewRotation());

	AddArrow( TraceStart, TraceEnd );
}

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

exec function ShowViewTrace( optional bool bUseExtents )
{
	local vector Extents;

	if( !OKToCheat() )
		return;

	if( bUseExtents )
	{
		Extents.X = Pawn.CollisionRadius;
		Extents.Y = Pawn.CollisionRadius;
		Extents.Z = Pawn.CollisionHeight;

		ShowViewTraceExtents( true, Extents );
	}
	else
	{
		ShowViewTraceExtents( false, vect(0,0,0) );
	}
}

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

exec function SizeActor( name TargetName, int NewRadius, int NewHeight, optional float NewDrawScale )
{
	if( !OKToCheat() )
		return;

	// !!mdf-tbd: how to pass in '' for name?
	if( TargetName == 'none' )
		TargetName = '';

	SizeNamedLockedOrHitTarget( TargetName, NewRadius, NewHeight, NewDrawScale, false );
}

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

exec function SizePawns( name ClassName, int NewRadius, int NewHeight, optional float NewDrawScale )
{
	local Controller C;

	if( !OKToCheat() )
		return;

	// !!mdf-tbd: how to pass in '' for name?
	if( ClassName == 'none' || ClassName == '' )
		ClassName = 'Controller';

	DM( "SizePawns -- setting size for all pawns in level to R=" $ NewRadius $ " H=" $ NewHeight $ " DrawScale=" $ NewDrawScale );
	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( C.IsA( ClassName ) )
			SizeNamedLockedOrHitTarget( C.Name, NewRadius, NewHeight, NewDrawScale, true );
	}	
}

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

exec function StopScenes()
{
	local SceneManager SM;
	local bool bFoundScenes;

	if( !OKToCheat() )
		return;

	foreach AllActors( class'SceneManager', SM )
	{
		if( SM.bIsRunning )
		{
			SM.StopScene();
			bFoundScenes = true;
		}
	}

	if( bFoundScenes )
		DM( "WARNING: stopscenes will likely break this level's gameplay!" );
}

//-----------------------------------------------------------------------------
// Forces windowed mode then executes editactor command. Will try given string
// as name 1st, class 2nd (unless bIsName set)

function DoEdActor( coerce string S )
{
	// !!mdf-tbd: ideally engine would end full screen for us
	ConsoleCommand( "endfullscreen" );
	ConsoleCommand( "editactor " $ S );
}

//-----------------------------------------------------------------------------
// Forces windowed mode then executes editactor command. Will try given name as
// as name 1st, class 2nd (unless bIsName set). If no name given, will use 
// locked Actor, if any.

exec function EdActor( name N )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedOrLockedActor( N );

	if( TargetActor != None )
		DoEdActor( "name=" $ TargetActor.Name );
	else
		DM( GetContext() $ " Actor not found" );
}

//-----------------------------------------------------------------------------
// Do an "editactor class" for the object in view.

exec function EdHitActor()
{
	local Actor HitActor;

	if( !OKToCheat() )
		return;

	HitActor = GetHitActor();
	if( HitActor != None )
	{
		DoEdActor( "name=" $ HitActor.Name );
	}
}

//-----------------------------------------------------------------------------
// testing

exec function DumpAll( class<Actor> DumpClass )
{
	local Actor A;
	local int CountMatchingActors;
	local string Message;

	if( !OKToCheat() )
		return;

	if( DumpClass != None )
	{
		foreach AllActors( DumpClass, A )
		{
			Message = A.Name $ " tag: " $ A.Tag $ " event: " $ A.Event $ " state: " $ A.GetStateName() $ " inventory: "$ A.Inventory;
			ClientMessage( Message );
			Log( Message );
			CountMatchingActors++;
		}

		ClientMessage( "Matching Actors: " $ CountMatchingActors );
	}
	else
	{
		ClientMessage( "DumpAll: class is None!" );
	}
}

//-----------------------------------------------------------------------------
// Dump the inventory for the given Actor.

function DumpActorInv( Actor A )
{
	local Inventory Inv;

	DM( A.Name $ ":" );
	for( Inv=A.Inventory; Inv!=None; Inv=Inv.Inventory )   
	{
		DM( "  " $ Inv.Name  );
	}
}

//-----------------------------------------------------------------------------
// Dump the inventory for the named Actor (or nearest Actor that matches by
// class). If no name given, dumps inventory for all actors in the level 
// which are Pawns or which have Inv!=None.

exec function DumpInv( name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	DM( "DumpInv -- begin" );
	if( TargetName == '' )
	{
		foreach AllActors( class'Actor', TargetActor )
		{
			if( (TargetActor.Inventory != None) || (Pawn(TargetActor) != None) )
				DumpActorInv( TargetActor );
		}
	}
	else
	{
		TargetActor = GetNamedActor( TargetName );
		if( TargetActor != None )
			DumpActorInv( TargetActor );
		else
			DM( "DumpInv -- no Actor matches " $ TargetName );
	}
	DM( "DumpInv -- end" );
}

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

exec function Distance( name A1Name, optional name A2Name )
{
	local Actor A1;
	local Actor A2;
	local vector A1ToA2Vect;

	if( !OKToCheat() )
		return;

	A1 = GetNamedActor( A1Name );
	if( A2Name == '' )
		A2 = Pawn;
	else
		A2 = GetNamedActor( A2Name );

	if( A1 == None )
	{
		DM( "Distance: can't find Actor with name: " $ A1Name );
	}
	if( A2 == None )
	{
		DM( "Distance: can't find Actor with name: " $ A2Name );
	}

	if( A1 != None && A2 != None )
	{
		A1ToA2Vect = A2.Location - A1.Location;

		DM( "Distance from " $ A1 $ " to " $ A2 $ "(" $ class'Util'.static.GetVectorString(A1ToA2Vect) $ ")" $ " " $ VSize( A1ToA2Vect ) );
	}
}

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

function DoFixCollision( Actor A )
{
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local float HeightAboveFloor;

	// figure out how high Actor is above the ground

	// make sure collision height puts center of Actor on ground
	HitActor = class'Util'.static.TraceRecursive( A, HitLocation, HitNormal, A.Location, false, MaxFixCollisionHeight );

	if( HitActor != None && (HitActor == Level || Mover(HitActor) != None) )
	{
		HeightAboveFloor = VSize(A.Location - HitLocation );

		// don't reduce CC, but make it bigger if necessary
		if( A.CollisionHeight < HeightAboveFloor )
		{
			DM( "  DoFixCollision: collision height for " $ A.Name $ " changed from " $ A.CollisionHeight $ " to " $ HeightAboveFloor );
			A.SetCollisionSize( A.CollisionRadius, HeightAboveFloor );

			HitActor = class'Util'.static.TraceRecursive( A, HitLocation, HitNormal, A.Location, false, MaxFixCollisionHeight );

			if( HitActor == None || (HitActor != Level && Mover(HitActor) == None) || A.CollisionHeight != HeightAboveFloor )
				DM( "  WARNING (DoFixCollision): Actor moved?" );
		}
	}
}

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

exec function FixCollision( optional name TargetName )
{
	local Actor A;
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

		if( TargetName != '' )
			TargetActor = GetNamedActor( TargetName );
		else
			TargetActor = None;
	
	if( TargetActor != None )
	{
		DM( "FixCollision: fixing collision for " $ TargetActor );
		DoFixCollision( TargetActor );
	}
	else
	{
		DM( "FixCollision: fixing collision for all applicable actors in level" );

		foreach AllActors( class'Actor', A )
		{
			// this won't handle weapons
			if( Inventory(A) != None || Teleporter(A) != None )
			{
				DoFixCollision( A );
			} 
		}
	}
}

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

exec function SetParticleDensity( int D )		
{ 
	if( !OKToCheat() )
		return;

	class'UIConsole'.static.GetClient().ParticleDensity = D; 

	ClientMessage( "ParticleDensity set to " $ D );
}

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

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

	if( (Level.Game.GameFlags & U2GameInfo.GF_NOIMPACTS) == 0 )
	{
		Level.Game.GameFlags = Level.Game.GameFlags | U2GameInfo.GF_NOIMPACTS;
		ClientMessage( "impacts disabled" );
	}
	else
	{
		Level.Game.GameFlags = Level.Game.GameFlags & ~U2GameInfo.GF_NOIMPACTS;
		ClientMessage( "impacts enabled" );	
	}
}

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

exec function SetWeaponTick( bool bTick )
{
	local Weapon W;

	if( !OKToCheat() )
		return;

	foreach AllActors( class'Weapon', W )
		if( U2Weapon(W) != None )
			U2Weapon(W).bDisableTick = !bTick;

	if( bTick )
		ClientMessage( "enabling tick code for all weapons" );
	else
		ClientMessage( "disabling tick code for all weapons" );
}

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

exec function SetWeaponFire( bool bFire )
{
	local Weapon W;

	if( !OKToCheat() )
		return;

	foreach AllActors( class'Weapon', W )
		if( U2Weapon(W) != None )
			U2Weapon(W).bDisableFiring = !bFire;

	if( bFire )
		ClientMessage( "enabling firing for all weapons" );
	else
		ClientMessage( "disabling firing for all weapons" );
}

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

exec function SetNPCSprites( bool bSprite )
{
	local Pawn P;

	if( !OKToCheat() )
		return;

	for( P=Level.PawnList; P!=None; P=P.NextPawn )
	{
		if( AIController(P.Controller) != None )
		{
			if( bSprite )
				P.SetDrawType( DT_Sprite );
			else if( P.DrawType == DT_Sprite )
				P.SetDrawType( P.default.DrawType );
		}
	}

	if( bSprite )
	{
		ClientMessage( "Setting NPC DrawTypes to DT_Sprite" );
	}
	else
	{
		ClientMessage( "Setting NPC DrawTypes to default" );
	}
}

//-----------------------------------------------------------------------------
// Toggle bHidden flag for all actors which match the given class name that are
// bHidden by default (so actors which are normally visible won't be affected).
// If bForce is true, *all* actors will be toggled regardless of whether they
// are normally hidden.

exec function ToggleShowClass( name ClassToShow, optional bool bForce )
{
	local Actor A;
	local bool bHideActors;

	if( !OKToCheat() )
		return;

	// make a first pass through actors to see if any applicable actors
	// aren't hidden and if any found assume that we should hide these
	// otherwise assume that we should make these visible
	bHideActors = false;
	foreach AllActors( class'Actor', A )
	{
		if( A.IsA( ClassToShow ) )
		{
			if( !A.bHidden && (bForce || A.default.bHidden) )
			{
				bHideActors = true;
				break;
			}
		}
	}

	// now apply flag
	foreach AllActors( class'Actor', A )
	{
		if( A.IsA( ClassToShow ) )
		{
			if( !bHideActors && A.bHidden )
			{
				// make any hidden objects visible
				A.bHidden = false;
			}
			else if( bHideActors && !A.bHidden && (bForce || A.default.bHidden) )
			{
				// only hide classes which are hidden by default
				A.bHidden = true;
			}
			
			A.StaticFilterState = FS_Maybe;
		}
	}

	if( bHideActors )
	{
		DM( "Hiding " $ ClassToShow $ "s" );
	}
	else
	{
		DM( "Showing " $ ClassToShow $ "s" );
	}
}

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

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

	ToggleShowClass( 'Actor' );
}

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

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

	ToggleShowClass( 'KeyPoint' );
}

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

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

	ToggleShowClass( 'NavigationPoint' );
}

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

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

	CurrentRMode++;
	if( CurrentRMode > 8 )
		CurrentRMode = 1;

	ConsoleCommand( "rmode " $ CurrentRMode );
	DM( "rmode=" $ CurrentRMode );
}

//-----------------------------------------------------------------------------
// Traces to the Actor the crosshair is pointing at, and toggles their
// collision cylinder drawing on/off.

exec function ToggleCC( optional name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedLockedOrHitActor( TargetName );

	if( LevelInfo(TargetActor) == None && Mover(TargetActor) == None )
	{
		if( CheckNamedOrHitActor( "ToggleCC", TargetActor, TargetName ) )
		{
			if( (TargetActor.SpecialDisplayFlags & DF_Collision) == 0 )
			{
				DM( "ToggleCC: Showing CC for " $ TargetActor );
				TargetActor.SpecialDisplayFlags = TargetActor.SpecialDisplayFlags | DF_Collision;
			}
			else
			{
				DM( "ToggleCC: Hiding CC for " $ TargetActor );
				TargetActor.SpecialDisplayFlags = TargetActor.SpecialDisplayFlags & ~DF_Collision;
			}
		}
	}
	else
	{
		DM( "ToggleCC: can't show cc for " $ TargetActor );
	}
}

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

function SetCCs( class<Actor> TargetClass, bool bShow )
{
	local Actor A;
	
	foreach AllActors( TargetClass, A )
	{
		if( bShow )
		{
			if( A.bHidden )
				A.bHidden = false;
			A.SpecialDisplayFlags = A.SpecialDisplayFlags | DF_Collision;
		}
		else
		{
			if( !A.bHidden && A.default.bHidden )
				A.bHidden = true;
			A.SpecialDisplayFlags = A.SpecialDisplayFlags & ~DF_Collision;
		}
	}				
}

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

exec function ShowCCs( string TargetClassStr )
{
	local class<Actor> TargetClass;

	if( !OKToCheat() )
		return;

	TargetClass = class<Actor>(LoadPackageClass( TargetClassStr ) );
	if( TargetClass != None )
	{
		DM( "ShowCCs: " $ TargetClass );
		SetCCs( TargetClass, true );
	}
	else
	{
		DM( "ShowCCs: can't find class " $ TargetClassStr );
	}
}

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

exec function HideCCs( string TargetClassStr )
{
	local class<Actor> TargetClass;

	if( !OKToCheat() )
		return;

	TargetClass = class<Actor>(LoadPackageClass( TargetClassStr ) );
	if( TargetClass != None )
	{
		DM( "HideCCs: " $ TargetClass );
		SetCCs( TargetClass, false );
	}
	else
	{
		DM( "HideCCs: can't find class " $ TargetClassStr );
	}
}

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

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

	// apply new speed to default values
	Pawn.GroundSpeed = Pawn.default.GroundSpeed * F;
	Pawn.WaterSpeed  = Pawn.default.WaterSpeed * F;
	
	bSetSpeedCheatOn = ( F != 1.0 );
}

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

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

	CurrentSpeed *= 2.0;
	
	if( CurrentSpeed > MaxCheatSpeed )
		CurrentSpeed = 1.0;
	
	SetSpeed( CurrentSpeed );
}

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

exec function DestroyLines()
{
	local Actor A;

	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{	
		if( A.IsA( 'TracerSeg' ) )
		{
			A.Destroy();
		}
	}
}

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

exec function SetCol( name TargetClass, bool bNewColActors, bool bNewBlockActors, bool bNewBlockPlayers )
{
	local Actor A;
	local int Count;

	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
	{
		if( A.IsA( TargetClass ) )
		{
			A.SetCollision( bNewColActors, bNewBlockActors, bNewBlockPlayers );
			Count++;
		}
	}

	DM( "SetCol: " $ bNewColActors $ ", " $ bNewBlockActors $ ", " $ bNewBlockPlayers $ " Count: " $ Count );
}

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

exec function SetEyeHeight( float NewEyeHeight )
{
	if( !OKToCheat() )
		return;

	Pawn.BaseEyeHeight = NewEyeHeight;			// eyeheight will quickly become this (over a few frames)
	Pawn.default.BaseEyeHeight = NewEyeHeight;	// so new eye height not overridden
}

//-----------------------------------------------------------------------------
// Allows player to "change" teams (or change the team of any Pawn)

exec function SetTeam( int InTeamNumber, optional name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedLockedOrHitActor( TargetName, true, true );
	if( TargetActor == None && TargetName == '' )
		TargetActor = Pawn;

	if( Pawn(TargetActor) != None )
	{
		Pawn(TargetActor).PlayerReplicationInfo.Team.RemoveFromTeam( Pawn(TargetActor).Controller );
		U2GameInfo(Level.Game).GetTeam( InTeamNumber ).AddToTeam( Pawn(TargetActor).Controller );
	}
}

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

exec function DumpAIEvents()
{
	local Controller C;

	if( !OKToCheat() )
		return;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		if( U2NPCController(C) != None )
			U2NPCController(C).DumpAIEvents();
}

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

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

	DumpAll( Class'NavigationPoint' );
}

//-----------------------------------------------------------------------------
// Checks whether all NavigationPoints in the level are in the navigation point list

exec function TestNPList()
{
	local NavigationPoint IterP, LastValid;
	local int TotalNodes, NodeCount;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'NavigationPoint', IterP )
	{
		TotalNodes++;
	}

	for( IterP = Level.NavigationPointList; IterP != None; IterP = IterP.NextNavigationPoint )
	{
		LastValid = IterP;
		NodeCount++;
	}

	if( NodeCount == TotalNodes )
	{
		BM( "PathNodeNetwork("$NodeCount$"/"$TotalNodes$") is correct." );
	}
	else
	{
		BM( "PathNodeNetwork("$NodeCount$"/"$TotalNodes$") is broken at: " $ LastValid );
	}
}

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

function ShowReachSpecInfo( ReachSpec RS )
{
	DM( "StartNode: " $ RS.Start );
	DM( "EndNode:   " $ RS.End );
	DM( "Distance:  " $ RS.Distance );
	DM( "Radius:    " $ RS.CollisionRadius );
	DM( "Height:    " $ RS.CollisionHeight );
	DM( "Flags:     " $ RS.reachFlags );
	DM( "bPruned:   " $ RS.bPruned );
}

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

function DoReachSpecInfo( name NPName1, name NPName2 )
{
	local NavigationPoint NP1, NP2;
	local int ii, MaxPaths, DrawnPaths;
	local ReachSpec RS;

	NP1 = NavigationPoint( GetNamedActor( NPName1 ) );
	NP2 = NavigationPoint( GetNamedActor( NPName2 ) );

	if( NP1 == None )
	{
		DM( "ReachSpecInfo: couldn't find NavigationPoint " $ NPName1 );
	}
	if( NP2 == None )
	{
		DM( "ReachSpecInfo: couldn't find NavigationPoint " $ NPName2 );
	}

	if( NP1 != None && NP2 != None )
	{
		// look for Paths[] list entry in NP1 that refers to NP2
		for( ii=0; ii<NP1.PathList.Length; ii++ )
		{
			RS = NP1.PathList[ii];

			assert( RS.Start == NP1 && !RS.bPruned );
			
			if( RS.End == NP2 )
			{
				ShowReachSpecInfo( RS );
				break;
			}
		}

		if( RS.End != NP2 )
		{
			DM( "ReachSpecInfo: no path between " $ NP1 $ " and " $ NP2 );
		}
	}
}

//-----------------------------------------------------------------------------
// Show the reachspec (path) info for the path between NP1 and NP2 (must be
// connected).

exec function ReachSpecInfo( name NPName1, name NPName2 )
{
	if( !OKToCheat() )
		return;

	DoReachSpecInfo( NPName1, NPName2 );
}

//-----------------------------------------------------------------------------
// Only handles walking pawns for now.
// tbd: how to handle paths in water etc.
// tbd: some parts of the pathnode network might be cut off from each other 
//      and this currently will result in tons of error messages about
//      NPs that can't be reached other NPs.
//			+do we want to allow this (separate networks in the same level)?
//			+if so how do we handle this?
//				+make separation explicit (NP with high cost)?
//

function DoVerifyPaths2()
{
	local NavigationPoint NP1, NP2;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local vector NewLocation;
	local vector OriginalLocation;
	local bool bOldCollideActors;
	local bool bOldBlockActors;
	local bool bOldBlockPlayers;
	local int NumPaths;
	local int ErrorCount;

	NumPaths = 0;
	ErrorCount = 0;

	OriginalLocation	= Pawn.Location;
	bOldCollideActors	= Pawn.bCollideActors;
	bOldBlockActors		= Pawn.bBlockActors;
	bOldBlockPlayers	= Pawn.bBlockPlayers;

	// turn of collision so player doesn't telefrag anything or pick up objects
	Pawn.SetCollision( false, false, false );
	Pawn.SetPhysics( Phys_Walking );

	// try to build a path from every NP in the level to every other NP in the level
	// (tbd: don't even try to run this test unless previous tests succeed)
  	for( NP1=Level.NavigationPointList; NP1!=None; NP1=NP1.NextNavigationPoint )
	{
		// move us to that location (with CC on floor so won't fall/intersect with geometry)
		// trace straight down until we hit the level (or exceed 500 units)
		HitActor = class'Util'.static.TraceRecursive( NP1, HitLocation, HitNormal, NP1.Location, false, 500, , 500 );

		if( HitActor != None && (HitActor == Level || Mover(HitActor) != None) )
		{
			if( class'UtilGame'.static.PlaceActorOnFloorUnderLocation( Pawn, NP1.Location ) )
			{
				// try to build a path to every other NP in the level from here
			  	for( NP2=Level.NavigationPointList; NP2!=None; NP2=NP2.NextNavigationPoint )
				{
					if( NP2 != NP1 )
					{
						NumPaths++;
						if( FindPathToActor( NP2 ) == PR_None )
						{
							DM( "VerifyPaths: Can't build a path from " $ NP1 $ " to " $ NP2 );
							ErrorCount++;
						}
					}
				}
			}
			else
			{
				DM( "VerifyPaths: Couldn't use start location at " $ NP1 $ " (SetLocation failed)" );
				ErrorCount++;
			}
		}
	}

	Pawn.SetLocation( OriginalLocation );
	Pawn.SetCollision( bOldCollideActors, bOldBlockActors, bOldBlockPlayers );

	DM( "VerifyPaths: " $ NumPaths $ " paths -- " $ ErrorCount $ " errors." );
}

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

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

	DoVerifyPaths2();
}

/* !!mdf-tbd:
//-----------------------------------------------------------------------------
// Only handles walking pawns for now.
// tbd: how to handle paths in water etc.

function DoVerifyPaths3()
{
	local Pawn P;
	local Controller C;
	local int NumFound;

//	DM( "Verifying all paths -- this could take hours -- use slomo 25-50 or so to speed up!" );
	DM( "Verifying all paths -- this could take a while!" );

	NumFound = 0;
	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( PathWalker(C.Pawn) != None )
		{
			NumFound++;
			class'TriggerHelper'.static.DispatchTrigger( Self, C.Pawn, Self, Pawn, 'WalkPaths' );
		}
	}

	if( NumFound == 0 )
	{
		// create a pathwalker and start it off
		DM( "Spawning a PathWalker" );
		P = Pawn( SummonPackageClass( "PathWalker" ) );
		class'TriggerHelper'.static.DispatchTrigger( Self, P, Self, Pawn, 'WalkPaths' );
	}
	else
	{
		DM( NumFound $ " PathWalkers found." );
	}
}

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

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

	DoVerifyPaths3();
}
*/

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

exec function TestFall( optional name TargetPawnName )
{
	local Controller C;
	local Pawn TargetPawn;
		
	if( !OKToCheat() )
		return;

	DMT( "TestFall" );
	TargetPawn = Pawn(GetNamedOrHitActor(TargetPawnName));
	
	for( C = Level.ControllerList; C != None; C = C.NextController )
	{
		if( !C.bStasis && 
			U2NPCController(C) != None && 
			C.Pawn != None && 
			C.Pawn.Physics != PHYS_Falling &&
			C.Pawn.Base != None &&
			TerrainInfo(C.Pawn.Base) != None &&
			(TargetPawn == None || TargetPawn == C.Pawn) )
		{
			C.Pawn.SetLocation( C.Pawn.Location - 1.5*C.Pawn.CollisionHeight * vect(0,0,1) );
			C.Pawn.SetPhysics( PHYS_Falling );
		}
	}
}

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

exec function TestNavErrors( bool bScriptedStateMoves, bool bMoveTarget, bool bMinZ )
{
	local Controller C;
	
	DMT( "TESTNAVERRORS " $ bScriptedStateMoves $ " " $ bMoveTarget $ " " $ bMinZ );
	for( C = Level.ControllerList; C != None; C = C.NextController )
	{
		if( !C.bStasis && U2NPCController(C) != None )
			U2NPCController(C).ForceNavigationError( bScriptedStateMoves, bMoveTarget, bMinZ );
	}
}

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

exec function FixSkins()
{
	local Pawn P;
	
	if( !OKToCheat() )
		return;
		
	for( P = Level.PawnList; P != None; P = P.NextPawn )
		if( U2Pawn(P) != None )
			U2Pawn(P).FixSkins();
}

//-----------------------------------------------------------------------------
// Destroy the given Actor (if set).

function DoKillActor( Actor TargetActor )
{
 	if( TargetActor != None )
 	{
 		TargetActor.Destroy();
 		DM( "KillActor -- destroyed " $ TargetActor );
 	}
 	else
 	{
 		DM( "KillActor -- Actor not found" );
 	}
}

//-----------------------------------------------------------------------------
// Destroy the named Actor (if found).

exec function KillActor( name TargetName )
{
	if( !OKToCheat() )
		return;

	DoKillActor( GetNamedActor( TargetName ) );
}

//-----------------------------------------------------------------------------
// Destroy the Actor under the crosshair (if any).

exec function KillHitActor()
{
	local Actor HitActor;

	if( !OKToCheat() )
		return;

	HitActor = GetHitActor();
	if( (HitActor != None) && (LevelInfo(HitActor) == None) )
		DoKillActor( HitActor );
}

//-----------------------------------------------------------------------------
// Destroy the NPC under the crosshair (if any).

exec function KillHitNPC()
{
	local Actor HitActor;

	if( !OKToCheat() )
		return;

	HitActor = GetHitActor();
	if( HitActor != None && Pawn(HitActor) != None && StationaryPawn(HitActor) == None )
		DoKillActor( HitActor );
}

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

function DoKillNPCs( bool bKillActive, bool bKillDormant, class<Pawn> PawnClass, Pawn ExceptPawn, bool bCarcasses )
{
	local AIController AIC;
	local Pawn P;

	foreach DynamicActors( class'AIController', AIC )
	{
		if( StationaryPawn(AIC.Pawn) == None &&
			(AIC.Pawn == None || (AIC.Pawn != ExceptPawn && ClassIsChildOf( AIC.Pawn.class, PawnClass ))) &&
			((bKillDormant && AIC.bStasis) ||
			 (bKillActive && !AIC.bStasis)) )
		{
			if( AIC.Pawn != None )
				AIC.Pawn.Destroy(); // note: need to destroy the Pawn or you'll leave behind a "carcass"
			AIC.Destroy();
		}
	}

	if( bCarcasses )
	{
		// now do a pass through the Pawns in case some of these had no controller (carcasses)
		for( P=Level.PawnList; P!=None; P=P.NextPawn )
		{
			if( StationaryPawn(P) == None &&
				ClassIsChildOf( P.Class, PawnClass ) && 
				!P.IsHumanControlled() )
				P.Destroy();
		}
	}
}

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

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

	DM( "killing all active NPCS" );
	DoKillNPCs( true, false, class'Pawn', None, false );
}

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

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

	DM( "killing all dormant NPCS" );
	DoKillNPCs( false, true, class'Pawn', None, false );
}

//-----------------------------------------------------------------------------
// Kill all Pawns of any type except for players and stationary pawns.

exec function KillNPCs( optional string DummyStr )
{
	if( !OKToCheat() )
		return;

	if( DummyStr == "" )
	{
		DM( "killing all NPCS" );
		DoKillNPCs( true, true, class'Pawn', None, false );
	}
	else
	{
		DM( "KillNPCs: invalid parameter given" );
	}
}

//-----------------------------------------------------------------------------
// Kill all Pawns of any type except for players and stationary pawns and the
// named NPC.

exec function KillNPCsExcept( optional name ExceptName )
{
	local Pawn ExceptPawn;

	if( !OKToCheat() )
		return;

	ExceptPawn = Pawn(GetNamedOrHitActor(ExceptName));
	if( ExceptPawn != None )
	{
		DM( "killing all NPCS except: " $ ExceptPawn );
		DoKillNPCs( true, true, class'Pawn', ExceptPawn, false );
	}
	else
	{
		DM( "KillNPCsExcept -- couldn't find " $ ExceptName );
	}
}

//-----------------------------------------------------------------------------
// Kill all Pawns of any type except for players and stationary pawns.

exec function KillPawnsEx( class<Pawn> PawnClass )
{
	if( !OKToCheat() )
		return;

	DM( "killing all " $ PawnClass.Name );
	DoKillNPCs( true, true, PawnClass, None, true );
}

//-----------------------------------------------------------------------------
// Gib all NPCs

exec function GibNPCs()
{
	local Pawn P;

	if( !OKToCheat() )
		return;

	DM( "GibNPCs -- gibbing all npcs" );
	for( P = Level.PawnList; P != None; P = P.nextPawn )
		if( StationaryPawn(P) == None &&
			!P.IsRealPlayer() )
		{
			P.TryToGib( class'Gibbed' );
		}
}

//-----------------------------------------------------------------------------
// Gib the NPC under the crosshair (if any).

exec function GibHitNPC()
{
	local Pawn HitPawn;

	if( !OKToCheat() )
		return;

	HitPawn = Pawn(GetHitActor());
	if( HitPawn != None && StationaryPawn(HitPawn) == None )
	{
 		if( HitPawn.TryToGib( class'Gibbed' ) )
	 		DM( "GibHitNPC -- gibbed " $ HitPawn );
		else
			DM( "GibHitNPC -- unable to gib " $ HitPawn );
 	}
 	else
 	{
 		DM( "GibHitNPC -- NPC not found" );
 	}
}

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

exec function Fall( optional name TargetName )
{
	local Actor A;
	local vector NewLocation;
	
	if( !OKToCheat() )
		return;

	A = GetNamedLockedOrHitActor( TargetName );

	DMT( "FALL: " $ A $ "!" );

	if( A != None )
	{
		NewLocation = A.Location - vect(0,0,1) * (A.CollisionHeight * 2.0);
		if( A.SetLocation( NewLocation ) )
		{
			A.SetPhysics( PHYS_Falling );
			//Velocity += vect(0,0,1) * -100;
			DM( A $ " is falling" );
		}
		else
		{
			if( TargetName == '' )
				DM( "Fall -- unable to move " $ A $ " to " @ NewLocation );
			else
				DM( "Fall -- unable to move " $ A $ " to " @ NewLocation );
		}
	}
	else
	{
		if( TargetName == '' )
			DM( "Fall -- can't make " $ A $ " fall" );
		else
			DM( "Fall -- can't make " $ TargetName $ " fall" );
	}
}

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

exec function KillTimers()
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	foreach AllActors( class'Actor', A )
		A.RemoveAllTimers();
}

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

exec function ToggleTicks( name ClassToShow )
{
	local Actor A;
	local bool bEnable;

	if( !OKToCheat() )
		return;

	bEnable = false;
	foreach AllActors( class'Actor', A )
	{
		if( A.IsA( ClassToShow ) )
		{
			if( !A.IsProbing( Event_Tick ) )
			{
				bEnable = true;
				break;
			}
		}
	}

	foreach AllActors( class'Actor', A )
	{
		if( A.IsA( ClassToShow ) )
		{
			if( bEnable )
				A.Enable( Event_Tick );
			else
				A.Disable( Event_Tick );
		}
	}

	DM( "ToggleTicks class:" $ ClassToShow $ " bEnable:" $ bEnable );
}
	
//-----------------------------------------------------------------------------

exec function FreezeNPC( bool bVal, optional name TargetName )
{
	local Actor A;
	local AIController C;
	
	if( !OKToCheat() )
		return;

	A = GetNamedLockedOrHitActor( TargetName );

	if( Pawn(A) != None )
		C = AIController(Pawn(A).Controller);
	else
		C = AIController(A);

	if( C != None )
	{
		DM( "FreezeNPC: " $ C );
		C.SetFrozen( bVal );
	}
	else
	{
		if( TargetName == '' )
			DM( "FreezeNPC -- can't freeze " $ A );
		else
			DM( "FreezeNPC -- can't freeze " $ TargetName );
	}
}

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

exec function LockNPC( bool bVal, optional name TargetName )
{
	local Actor A;
	local AIController C;
	
	if( !OKToCheat() )
		return;

	A = GetNamedLockedOrHitActor( TargetName );

	if( Pawn(A) != None )
		C = AIController(Pawn(A).Controller);
	else
		C = AIController(A);

	if( C != None )
	{
		DM( "LockNPC: " $ C );
		C.SetStationary( bVal );
	}
	else
	{
		if( TargetName == '' )
			DM( "LockNPC -- can't freeze " $ A );
		else
			DM( "LockNPC -- can't freeze " $ TargetName );
	}
}

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

exec function ToggleFreezeNPCs()
{
	local Controller C;

	if( !OKToCheat() )
		return;

	bNPCsFrozen = !bNPCsFrozen;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		if( AIController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
			AIController(C).SetFrozen( bNPCsFrozen );
	
	DM( "ToggleFreezeNPCs: " $ bNPCsFrozen );
}

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

exec function ToggleLockNPCs()
{
	local Controller C;

	if( !OKToCheat() )
		return;

	bNPCsLocked = !bNPCsLocked;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		if( AIController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
			AIController(C).SetStationary( bNPCsLocked );

	DM( "ToggleLockNPCs: " $ bNPCsLocked );
}

//-----------------------------------------------------------------------------
// creature list
//-----------------------------------------------------------------------------

exec function NPCSum( optional int Index )
{
	if( !OKToCheat() )
		return;

	// spawn current creature
	if( Index != 0 )
	{
		if( CreatureList[ Index ].NameStr != "" )
			SummonPackageClass( CreatureList[ Index ].NameStr );
		else
			DM( "NPCSum -- no creature for given index!" );
	}
	else
		SummonPackageClass( CreatureList[ CreatureIndex ].NameStr );
}

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

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

	class'UIConsole'.static.BroadcastStatusMessage( 
		Self, 
		"#" $ CreatureIndex $
		" (" $ CreatureList[ CreatureIndex ].CatStr $ ") " $
		": " $ 
		CreatureList[ CreatureIndex ].NameStr $
		" (" $ CreatureList[ CreatureIndex ].StatusStr $ ")",
		NPCShowTime,
		NPCShowFont,
		NPCShowColor,
		, //sound
		, //volume
		, //pitch,
		"CenterDebugHolder",
		true );
}

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

exec function NPCNext()
{
	local int OldIndex;

	if( !OKToCheat() )
		return;

	OldIndex = CreatureIndex;

	CreatureIndex++;
	if( CreatureIndex >= ArrayCount(CreatureList) )
		CreatureIndex = 1;

	while( CreatureList[ CreatureIndex ].NameStr == "" && CreatureIndex != OldIndex )
	{
		CreatureIndex++;
		if( CreatureIndex >= ArrayCount(CreatureList) )
			CreatureIndex = 1;
	}

	NPCShow();
}

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

exec function NPCPrev()
{
	local int OldIndex;

	if( !OKToCheat() )
		return;

	OldIndex = CreatureIndex;

	CreatureIndex--;
	if( CreatureIndex < 1 )
		CreatureIndex = ArrayCount(CreatureList)-1;

	while( CreatureList[ CreatureIndex ].NameStr == "" && CreatureIndex != OldIndex )
	{
		CreatureIndex--;
		if( CreatureIndex < 1 )
			CreatureIndex = ArrayCount(CreatureList)-1;
	}

	NPCShow();
}

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

exec function NPCSet( int Index )
{
	local int OldIndex;

	if( !OKToCheat() )
		return;

	OldIndex = CreatureIndex;
	CreatureIndex = Clamp( Index, 0, ArrayCount(CreatureList)-1 );

	while( CreatureList[ CreatureIndex ].NameStr == "" && CreatureIndex != OldIndex )
	{
		CreatureIndex--;
		if( CreatureIndex < 1 )
			CreatureIndex = ArrayCount(CreatureList)-1;
	}

	NPCShow();
}

//-----------------------------------------------------------------------------
// Add X actors of the given class at "random" locations in the current level
// (uses level's NavigationPoints).

exec function AddActors( int NumActors, string ActorClassString )
{
	local int ii, jj;
	local Actor A;
	local class<Actor> ActorClass;
	local NavigationPoint NP;
	local vector SpawnLocation;
	local int NPCount, NPIndex, PlacedActors;
	local bool bKeepTrying;

	if( !OKToCheat() )
		return;

	ActorClass = class<Actor>(LoadPackageClass( ActorClassString ));
	if( ActorClass == None )
	{
		DMT( "AddActors: can't find class for " $ ActorClassString );
		return;
	}
	
	// count navigation points
	NPCount = 0;
	for( NP=Level.NavigationPointList; NP!=None; NP=NP.NextNavigationPoint )
		NPCount++;

	bKeepTrying = true;
	for( ii=0; ii<NumActors && bKeepTrying; ii++ )
	{
		NPIndex = RandRange( 0, NPCount );
		NP = Level.NavigationPointList;
		for( jj=0; jj<NPIndex; jj++ )
			NP = NP.NextNavigationPoint;
		
		// try to spawn the Actor
		while( true )
		{
			SpawnLocation = class'Util'.static.GetLocationAtActor( NP, ActorClass.default.CollisionRadius, ActorClass.default.CollisionHeight );
			
			A = NP.Spawn( ActorClass, /*Owner*/, /*Tag*/, SpawnLocation );
			if( A != None )
			{
				PlacedActors++;
				break;
			}
			else
			{
				// try next NP in list
				jj++;
				if( jj == NPIndex )
				{
					// back to first spot tried
					bKeepTrying = false; // won't be able to spawn any more Actors
					break;
				}
				else if( jj >= NPCount )
				{
					jj = 0;
					NP = Level.NavigationPointList;
				}
				else
				{
					NP = NP.NextNavigationPoint;
				}
			}
		}
	}
	
	DMT( "AddActors placed " $ PlacedActors $ " " $ ActorClass );
}

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

function SetTestMoveTargets( name TargetName, Actor NewMoveTarget, float Speed, ETacticalMoveType TMT )
{
	local Pawn P;
	local Controller C;

	if( !OKToCheat() )
		return;

	P = Pawn(GetNamedOrHitActor( TargetName ));

	if( P != None )
	{
		if( U2NPCController(P.Controller) != None )
		{
			DM( "Calling SetTestMoveTarget( " $ NewMoveTarget $ " ) for " $ P );
			U2NPCController(P.Controller).SetTestMoveTarget( NewMoveTarget, Speed, TMT );
		}
		else
		{
			DM( "SetTestMoveTargets -- target Pawn doesn't have a U2NPCController?" );
		}
	}
	else
	{
		DM( "Calling SetTestMoveTarget( " $ NewMoveTarget $ " ) for all NPCs" );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( U2NPCController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
				U2NPCController(C).SetTestMoveTarget( NewMoveTarget, Speed, TMT );
	}
}

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

exec function Here( optional float Speed )
{
	if( !OKToCheat() )
		return;

	SetTestMoveTargets( '', Self, Speed, TMT_None );
}

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

exec function Here1( optional float Speed )
{
	if( !OKToCheat() )
		return;

	SetTestMoveTargets( '', Self, Speed, TMT_Basic );
}

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

exec function Here2( optional float Speed )
{
	if( !OKToCheat() )
		return;

	SetTestMoveTargets( '', Self, Speed, TMT_Serpentine );
}

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

function HandleThere( name TargetName, float Speed, ETacticalMoveType TMT )
{
	local Actor TargetActor;

	TargetActor = GetNamedOrHitActor( TargetName );

	if( TargetActor != None )
		SetTestMoveTargets( '', TargetActor, Speed, TMT );
	else
		DM( "There -- target not found: " $ TargetName );
}

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

exec function There( name TargetName, optional float Speed )
{
	if( !OKToCheat() )
		return;

	HandleThere( TargetName, Speed, TMT_None );
}

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

exec function There1( name TargetName, optional float Speed )
{
	if( !OKToCheat() )
		return;

	HandleThere( TargetName, Speed, TMT_Basic );
}

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

exec function There2( name TargetName, optional float Speed )
{
	if( !OKToCheat() )
		return;

	HandleThere( TargetName, Speed, TMT_Serpentine );
}

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

exec function Anywhere( optional name TargetName )
{
	if( !OKToCheat() )
		return;
		
	SetTestMoveTargets( TargetName, None, 0.0, TMT_None );
}

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

exec function ClearOrders( optional name TargetName )
{
	local Pawn P;
	local Controller C;

	if( !OKToCheat() )
		return;

	P = Pawn(GetNamedOrHitActor( TargetName ));

	if( P != None )
	{
		if( U2NPCController(P.Controller) != None )
		{
			DM( "ClearOrders -- clearing orders for " $ P );
			U2NPCController(P.Controller).SetOrders();
		}
		else
		{
			DM( "ClearOrders -- target Pawn doesn't have a U2NPCController?" );
		}
	}
	else
	{
		DM( "ClearOrders -- clearing orders for all NPCs" );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( U2NPCController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
				U2NPCController(C).SetOrders();
	}
}

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

exec function SetOrders( name Orders, optional name TargetName, optional float OrdersThreshold )
{
	local Pawn P;
	local Controller C;

	if( !OKToCheat() )
		return;

	P = Pawn(GetNamedOrHitActor( TargetName ));

	if( P != None )
	{
		if( U2NPCController(P.Controller) != None )
		{
			DM( "SetOrders -- setting orders for " $ P $ " to " $ Orders );
			U2NPCController(P.Controller).SetOrders( Orders, None, OrdersThreshold, Self, false );
		}
		else
		{
			DM( "SetOrders -- target Pawn doesn't have a U2NPCController?" );
		}
	}
	else
	{
		DM( "SetOrders -- setting orders for all NPCs to " $ Orders );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( U2NPCController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
				U2NPCController(C).SetOrders( Orders, None, OrdersThreshold, Self, false );
	}
}

//-----------------------------------------------------------------------------
// Affects named Actor (or nearest matching class), or locked Actor or Actor
// under crosshair. If no applicable U2NPCController, will refresh scripts for 
// *all* U2NPCControllers in the level which are under script control.

exec function ReloadScripts( optional name TargetName )
{
	local Controller C;

	if( !OKToCheat() )
		return;

	C = U2NPCController(GetNamedLockedOrHitActor( TargetName ));
	if( C != None )
	{
		DM( "Reloading script for: " $ C );
		U2NPCController(C).ReloadScriptController();
	}
	else
	{
		DM( "Reloading all scripts" );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( U2NPCController(C) != None )
			{
				U2NPCController(C).ReloadScriptController();
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Can't have 2 strings or 1 string, 1 optional string with an exec?

exec function SetScript( name CommandFileName, optional name TargetName, optional name StartLabelName )
{
	local U2Pawn P;
	local string CommandFile;
	local string StartLabel;

	if( !OKToCheat() )
		return;

	P = U2Pawn(GetNamedLockedOrHitActor( TargetName ));
	if( P == None )
	{
		DM( "SetScript -- couldn't find target Pawn " $ TargetName );
	}
	else if( U2NPCController(P.Controller) == None )
	{
		DM( "SetScript -- target doesn't have a U2NPCController" );
	}
	else
	{
		CommandFile = string(CommandFileName);
		if( StartLabelName != '' )
			StartLabel = string(StartLabelName);

		DM( "SetScript -- setting script for: " $ P );
		U2NPCController(P.Controller).SetScript( CommandFile, StartLabel );
	}
}

//-----------------------------------------------------------------------------
// Gives all NPCs in the level the given script, or, if no script name given,
// detaches script controller for all NPCs.

exec function SetScripts( optional string CommandFileString )
{
	local U2NPCController NPC;
	local Controller C;

	if( !OKToCheat() )
		return;

	if( CommandFileString != "" )
	{
		DM( "SetScripts -- setting script for all NCPs to: " $ CommandFileString );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( U2NPCController(C) != None )
				U2NPCController(C).SetScript( CommandFileString );
		}
	}
	else
	{
		DM( "SetScripts -- clearing scripts for all NCPs" );
	}
}

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

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

	Level.bPlayersOnly = !Level.bPlayersOnly;

	if( Level.bPlayersOnly )
	{
		DMT( "PlayersOnly enabled!" );
	}
	else
	{
		DMT( "PlayersOnly disabled!" );
	}
}

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

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

/* !!mdf:
	U2Pawn(Pawn).bFreezeView = !U2Pawn(Pawn).bFreezeView;
*/
}

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

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

	U2GameInfo(Level.Game).bDisplayHUD = !U2GameInfo(Level.Game).bDisplayHUD;
}

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

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

	Level.Game.SetInfiniteAmmo( !Level.Game.GetInfiniteAmmo() );
	
	DM( "ToggleInfiniteAmmo: " $ Level.Game.GetInfiniteAmmo() );
}

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

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

	Level.Game.SetReloadsEnabled( !Level.Game.GetReloadsEnabled() );
	
	DM( "ToggleReloads: " $ Level.Game.GetReloadsEnabled() );
}

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

function TogglePawnInvulnerability( Pawn P )
{
/*
!!mdf-tbd:
	if( P.ReducedDamageType == 'All' )
	{
		P.ReducedDamageType = '';
		DM( P.Name $ " is vulnerable" );
	}
	else
	{
		P.ReducedDamageType = 'All'; 
		DM( P.Name $ " is invulnerable" );
	}
*/
}

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

exec function FearMe()
{
	local Controller C;

	if( !OKToCheat() )
		return;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		if( AIController(C) != None && C.Pawn != None && StationaryPawn(C.Pawn) == None )
			AIController(C).FearThisSpot( Pawn );
}

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

exec function ShowCover( float Distance, optional name EnemyName )
{
	local Actor A;

	if( !OKToCheat() )
		return;

	// testing:
	DMT( "ShowCover Distance = " $ Distance );
	foreach VisibleCollidingActors( class'Actor', A, Distance, Pawn.Location, false )
	{
		if( Mover(A) == None && A.bBlockZeroExtentTraces )
		{
			DMT( "  including " $ A.Name $ "(" $ VSize(A.Location - Pawn.Location) );
			if( A == Pawn )
				AddActor( A, ColorCyan() );
 			else if( StaticMeshActor(A) != None || !A.bNoStaticMeshCollide )
				AddActor( A, ColorBlue() );
			else
				AddActor( A, ColorGreen() );
		}
	}
}

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

function DoFindPath( name SourcePawnName, name TargetActorName, optional bool bClearSpecialColliders )
{
	local Actor Path;
	local Pawn SourcePawn;
	local Actor TargetActor;
	local int ii, LastRouteCacheEntry;

	SourcePawn = Pawn(GetNamedActor( SourcePawnName ));
	if( SourcePawn == None )
	{
		DM( "Can't find source pawn " $ SourcePawnName );
		return;
	}
	if( SourcePawn.Controller == None )
	{
		DM( "source pawn doesn't have a controller " $ SourcePawnName );
		return;
	}
	
	TargetActor = GetNamedActor( TargetActorName );
	if( TargetActor == None )
	{
		DM( "Can't find target actor " $ TargetActorName );
		return;
	}

	AddActor( SourcePawn, ColorCyan() );
	AddActorAt( SourcePawn, TargetActor.Location, ColorCyan() );
		
	if( SourcePawn.Controller.ActorReachable( TargetActor ) )
		DM( TargetActor $ " is directly reachable" );
	else
		DM( TargetActor $ " is NOT directly reachable" );

	SourcePawn.Controller.FindPathToActor( TargetActor, Path, , , bClearSpecialColliders );
	if( Path == None )
	{
		DM( "Can't build a path from " $ SourcePawn $ " to " $ TargetActor );
		return;
	}
	
	DM( "FindPath Path: " $ Path );
	if( SourcePawn.Location != SourcePawn.Controller.RouteCache[ ii ].Location )
		AddArrow( SourcePawn.Location, SourcePawn.Controller.RouteCache[ ii ].Location, ColorRed() );

	for( ii=0; ii<ArrayCount(SourcePawn.Controller.RouteCache); ii++ )
	{
		if( SourcePawn.Controller.RouteCache[ ii ] == None )
			break;
		DM( "RouteCache " $ ii $ ": " $ SourcePawn.Controller.RouteCache[ ii ] );
		LastRouteCacheEntry++;
	}
	
	for( ii=0; ii<LastRouteCacheEntry-1; ii++ )
	{
		AddActorAt( SourcePawn, SourcePawn.Controller.RouteCache[ ii ].Location, ColorBlue() );
		AddArrow( SourcePawn.Controller.RouteCache[ ii ].Location, SourcePawn.Controller.RouteCache[ ii+1 ].Location, ColorBlue() );
	}

	AddActorAt( SourcePawn, SourcePawn.Controller.RouteCache[ LastRouteCacheEntry-1 ].Location, ColorBlue() );
	
	if( SourcePawn.Controller.RouteCache[ LastRouteCacheEntry-1 ] != TargetActor )
		AddArrow( SourcePawn.Controller.RouteCache[ LastRouteCacheEntry-1 ].Location, TargetActor.Location, ColorRed() );
}

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

exec function FindPath( name TargetActorName, optional bool bClearSpecialColliders )
{
	if( OKToCheat() )
		DoFindPath( Pawn.Name, TargetActorName, bClearSpecialColliders );
}

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

exec function FindPathFrom( name SourcePawnName, name TargetActorName, name TargetName, optional bool bClearSpecialColliders )
{
	if( OKToCheat() )
		DoFindPath( SourcePawnName, TargetActorName, bClearSpecialColliders );
}

//-----------------------------------------------------------------------------
// Toggle invulnerability for the named pawn (or nearest pawn that matches by
// class). If no name given, toggles all pawns in the level.

exec function GodEx( optional name TargetName )
{
	local Controller C;
	local Pawn P;

	if( !OKToCheat() )
		return;

	if( TargetName == '' )
	{
		// toggle invincibility for all Pawns
		DM( "GodEx -- toggling all pawns:" );
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			TogglePawnInvulnerability( C.Pawn );
		}
	}
	else
	{
		P = Pawn(GetNamedActor( TargetName ));
		if( P != None && P.Controller != None )
		{
			TogglePawnInvulnerability( P );
		}
		else
		{
			DM( "GodEx -- no Actor matches " $ TargetName );
		}
	}
}

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

exec function Phoenix()
{
	local PowerSuit CurrentPS;

	if( !OKToCheat() )
		return;

	CurrentPS = PowerSuit(class'UtilGame'.static.GetInventoryItem( Pawn, class'PowerSuit' ));
	if( PowerSuitPhoenix(CurrentPS) != None )
	{
		class'UtilGame'.static.RemoveInventoryString( Pawn, "U2.PowerSuitPhoenix" );
		U2Pawn(Pawn).DefaultInventory[0] = U2Pawn(Pawn).default.DefaultInventory[0];
		DMT( "Phoenix disabled" );
	}
	else
	{
		if( CurrentPS != None )
			CurrentPS.Destroy();
			
		class'UtilGame'.static.GiveInventoryClass( Pawn, class'PowerSuitPhoenix' );
		U2Pawn(Pawn).DefaultInventory[0] = "U2.PowerSuitPhoenix";
		DMT( "Phoenix enabled" );
	}
}

//-----------------------------------------------------------------------------
// If no class string specified, cycles through all available classes which are
// ok for players (mainly restricted by animations which class mesh has).

exec function SetPlayerModel( optional string ClassNameStr )
{
/* !!mdf-uw
	local int ii;

	if( !OKToCheat() )
		return;

	if( ClassNameStr != "" )
	{
		U2Pawn(Pawn).StaticSetPlayerModel( U2Pawn(Pawn), ClassNameStr );
	}
	else
	{
		ii = PlayerClassStringIndex;
		do
		{
			if( ii >= ArrayCount(PlayerClassStrings) )
			   ii = 0;
			else
			   ii++;
		}
		until( PlayerClassStrings[ii] != "" || ii == PlayerClassStringIndex );
		PlayerClassStringIndex = ii;
		
		if( PlayerClassStrings[ii] != "" )
			U2Pawn(Pawn).StaticSetPlayerModel( U2Pawn(Pawn), PlayerClassStrings[ii] );
		else
			DM( "SetPlayerModel -- error looking for next class in PlayerClassStrings" );
	}
*/
}

exec function SetEnemy( optional name TargetName )
{
	local Actor TargetActor;
	local Controller C;

	if( !OKToCheat() )
		return;

	if( TargetName == 'all' )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			#debug   C.SetControllerEnemy( Pawn, GetContext() );
			#release C.SetControllerEnemy( Pawn );
		}
	}
	else
	{
		TargetActor = GetNamedOrHitActor( TargetName );
		if( Pawn(TargetActor) != None )
			TargetActor = Pawn(TargetActor).Controller;

		if( Controller(TargetActor) != None )
		{
			#debug   Controller(TargetActor).SetControllerEnemy( Pawn, GetContext() );
			#release Controller(TargetActor).SetControllerEnemy( Pawn );
		}
	}
}

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

exec function SetMyEnemy( optional name TargetName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedOrHitActor( TargetName );

	if( Controller(TargetActor) != None )
		TargetActor = Controller(TargetActor).Pawn;

	if( Pawn(TargetActor) != None )
	{
		#debug   SetControllerEnemy( Pawn(TargetActor), GetContext() );
		#release SetControllerEnemy( Pawn(TargetActor) );
		DM( "SetMyEnemy -- player's Enemy set to " $ TargetActor );
	}
	else 
	{
		DM( "SetMyEnemy -- no valid target found!" );
	}
}

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

exec function Difficulty( byte Difficulty )
{
	if( !OKToCheat() )
		return;
		
	Level.Game.SetDifficulty( Difficulty );
	DMT( "Game Difficulty: " $ Level.Game.GetDifficulty() $ "/" $ Level.Game.GetMaxDifficulty() );
}

//-----------------------------------------------------------------------------
// Can be used to set skill for any controllers, including player(s) for use 
// with tweaking weapon ratings (using tracelock/setcontrollerenemy).

exec function SetSkill( float NewSkill, optional name TargetPawnName )
{
	local Pawn TargetPawn;
	local Controller C;

	if( !OKToCheat() )
		return;

	NewSkill = FClamp( NewSkill, 0.0, 1.0 );
	if( TargetPawnName != '' )
	{
		TargetPawn = Pawn(GetNamedActor( TargetPawnName ));

		if( TargetPawn != None && AIController(TargetPawn.Controller) != None )
		{
			AIController(TargetPawn.Controller).SetSkill( NewSkill );
			DM( "SetSkill -- set skill for " $ TargetPawnName $ " to " $ NewSkill );
		}
		else
		{
			DM( "SetSkill -- couldn't find " $ TargetPawnName $ " or Controller is None" );
		}
	}
	else
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( AIController(C) != None )
				AIController(C).SetSkill( NewSkill );
		}

		DM( "SetSkill -- set skill for all Controllers to " $ NewSkill );
	}
}

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

exec function DumpEvents()
{
	local Actor A;
	local int ii;
	
	if( !OKToCheat() )
		return;

	DM( "DumpEvents" );
	DM( "" );
	foreach AllActors( class'Actor', A )
	{
		if( A.Event != '' )
			DM( class'Util'.static.PadString( A.Name, 32 ) $ " Event: " $ A.Event);

		if( Dispatcher(A) != None )
		{
			for( ii=0; ii<ArrayCount(Dispatcher(A).OutEvents); ii++ )
				if( Dispatcher(A).OutEvents[ ii ] != '' )
					DM( class'Util'.static.PadString( A.Name, 32 ) $ " OutEvent: " $ Dispatcher(A).OutEvents[ ii ] );
		}
		
		if( RoundRobin(A) != None )
		{
			for( ii=0; ii<ArrayCount(RoundRobin(A).OutEvents); ii++ )
				if( RoundRobin(A).OutEvents[ ii ] != '' )
					DM( class'Util'.static.PadString( A.Name, 32 ) $ " OutEvent: " $ RoundRobin(A).OutEvents[ ii ] );
		}
	}
}

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

exec function DumpTags()
{
	local Actor A;
	
	if( !OKToCheat() )
		return;

	DM( "DumpTags" );
	DM( "" );
	foreach AllActors( class'Actor', A )
	{
		if( A.Tag != '' )
			DM( class'Util'.static.PadString( A.Name, 32 ) $ " " $ A.Tag );
	}
}

//-----------------------------------------------------------------------------
// Find all Controllers in level and trigger them with the given event.
// Subclasses of Pawn may or may not respond to the given Event, e.g if this is
// an order. If TriggeringActorName is set and corresponds to an Actor in the 
// level, this Actor will be used as the triggering Actor, otherwise Self is 
// used. e.g. NPCs handling the given event can use the triggering Actor in some 
// way.

exec function TriggerPawns( name TriggerEvent, optional name TriggeringActorName )
{
	local Controller C;
	local Actor TriggeringActor;

	if( !OKToCheat() )
		return;

	TriggeringActor = GetNamedActor( TriggeringActorName );
	if( TriggeringActor == None )
		TriggeringActor	= Self;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
		class'TriggerHelper'.static.DispatchTrigger( Self, C, TriggeringActor, Pawn, TriggerEvent );
		
	DMT( "TriggerPawns: " $ TriggerEvent $ " (" $ TriggeringActorName $ ")" );
}

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

exec function TriggerTarget( name TriggerEvent, optional name TargetActorName )
{
	local Actor TargetActor;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedOrHitActor( TargetActorName );
	if( TargetActor == None )
	{
		DM( "TriggerTarget -- can't find target: " $ TargetActorName );
	}
	else
	{
		TargetActor.Trigger( Self, Pawn, TriggerEvent );
	}
}

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

exec function EnableFreeOrders( bool bEnable )
{
	if( !OKToCheat() )
		return;

	if( bEnable )
		TriggerPawns( 'EnableFreeOrders' );
	else
		TriggerPawns( 'DisableFreeOrders' );
}

//-----------------------------------------------------------------------------
//								  STATE CODE
//-----------------------------------------------------------------------------

state @ TeleportFixedState extends @ PlayerWalkingState
{
	//--------------------------------------------------------------------------

	function ProcessMove( float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot )	
	{
	}

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

	function DoTeleport()
	{
		Global.DoTeleport();
		Pawn.SetPhysics( PHYS_None );
	}

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

	function DoUnTeleport()
	{
		Pawn.SetStance( ST_Standing );
		
		if( SavedPhysics == PHYS_Flying )
		{
			GotoState( PlayerFlyingState );
		}
		else if( Pawn.PhysicsVolume.bWaterVolume )
		{
			Pawn.SetPhysics( PHYS_Swimming );
			GotoState( Pawn.WaterMovementState );
		}
		else
		{
			GotoState( PlayerWalkingState );
		}

		SavedPhysics = PHYS_None;
	}

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

	exec function UnTeleport()
	{
		DoUnTeleport();
	}

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

	event BeginState()
	{
		// save off old physics in case player using fly cheat
		if( SavedPhysics == PHYS_None )
			SavedPhysics = Pawn.Physics;
		Pawn.SetPhysics( PHYS_None );
	}
} // TeleportFixed

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

exec function TestLOS( name TargetName )
{
	local Actor TargetActor;
	local bool bResult;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedActor( TargetName );
	if( TargetActor != None )
	{
		DM( " " );
		DM( "!BEG checking LOS from player to " $ TargetActor );
		bResult = LineOfSightTo( TargetActor );
		DM( "!END checking LOS from player to " $ TargetActor );

		if( bResult )
			DM( "TestLOS - can see " $ TargetActor );
		else
			DM( "TestLOS - can not see " $ TargetActor );
	}
	else
	{
		DM( "TestLOS - couldn't find " $ TargetName );
	}
}

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

exec function TestHit( name TargetName )
{
	local Actor TargetActor;
	local bool bResult;
	local CheckResult Hit;

	if( !OKToCheat() )
		return;

	TargetActor = GetNamedActor( TargetName );
	if( TargetActor != None )
	{
		DM( " " );
		DM( "!BEG checking whether player can hit (shoot) " $ TargetActor );
		bResult = LineOfSightTo( TargetActor, true, TRACE_ProjTargets | TRACE_World | TRACE_StopAtFirstHit );
		//bResult = LineOfSightTo( TargetActor, true, TRACE_OnlyProjActor | TRACE_World | TRACE_StopAtFirstHit );
		DM( "!END checking whether player can hit (shoot) " $ TargetActor );

		if( bResult )
			DM( "TestHit - can hit " $ TargetActor );
		else
			DM( "TestHit - can not hit " $ TargetActor );
	}
	else
	{
		DM( "TestHit - couldn't find " $ TargetName );
	}
}

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

exec function NextLevel()
{
	local LevelChange L;

	if( !OKToCheat() )
		return;

	foreach DynamicActors( class'LevelChange', L )
		L.Trigger( None, None );
}

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

exec function Open( string MapName )
{
	if( !OKToCheat() )
		return;
		
	ConsoleCommand( "OPENMAP " $ MapName );
}

//-----------------------------------------------------------------------------
// Ideally this wouldn't be an exec so it can't be used from the console, but 
// it probably doesn't matter either way

exec function UIOpenMap( string MapName )
{
	ConsoleCommand( "OPENMAP " $ MapName );
}

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

defaultproperties
{
	SummonPackageStrings(0)="Engine"
	SummonPackageStrings(1)="U2"
	SummonPackageStrings(2)="U2Pawns"
	SummonPackageStrings(3)="U2Weapons"
	SummonPackageStrings(4)="U2Decorations"
	SummonPackageStrings(5)="U2XMP"
	SummonPackageStrings(7)="Legend"
	SummonPackageStrings(8)="ParticleSystems"
	SummonPackageStrings(13)="U2Test"
	GoodiesList(0)="U2Weapons.weaponInvAssaultRifle"
	GoodiesList(1)="U2Weapons.weaponInvRocketLauncher"
	GoodiesList(2)="U2Weapons.weaponInvPistol"
	GoodiesList(3)="U2Weapons.weaponInvFlamethrower"
	GoodiesList(4)="U2Weapons.weaponInvGrenadeLauncher"
	GoodiesList(5)="U2Weapons.weaponInvLeechGun"
	GoodiesList(6)="U2Weapons.weaponInvEnergyRifle"
	GoodiesList(7)="U2Weapons.weaponInvShotgun"
	GoodiesList(8)="U2Weapons.weaponInvSingularityCannon"
	GoodiesList(9)="U2Weapons.weaponInvSniperRifle"
	GoodiesList(10)="U2Weapons.weaponInvLaserRifle"
	GoodiesList(11)="U2Weapons.weaponInvTakkra"
	GoodiesList(12)="U2Weapons.ammoInvGrenadeConcussion"
	GoodiesList(13)="U2Weapons.ammoInvGrenadeEMP"
	GoodiesList(14)="U2Weapons.ammoInvGrenadeFragment"
	GoodiesList(15)="U2Weapons.ammoInvGrenadeIncendiary"
	GoodiesList(16)="U2Weapons.ammoInvGrenadeSmoke"
	GoodiesList(17)="U2Weapons.ammoInvGrenadeToxic"
	GoodiesList(20)="U2XMP.FieldGeneratorDeployable"
	GoodiesList(21)="U2XMP.RocketTurretDeployable"
	GoodiesList(22)="U2XMP.AutoTurretDeployable"
	GoodiesList(23)="U2XMP.ProximitySensorDeployable"
	CreatureList(0)=(CatStr="Main-Walk",StatusStr="N/A")
	CreatureList(1)=(CatStr="Main-Walk",NameStr="U2Pawns.U2AraknidLight")
	CreatureList(2)=(CatStr="Main-Walk",NameStr="U2Pawns.U2AraknidMedium")
	CreatureList(3)=(CatStr="Main-Walk",NameStr="U2Pawns.U2AraknidHeavy")
	CreatureList(4)=(CatStr="Main-Walk",NameStr="U2Pawns.U2Izarian")
	CreatureList(6)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MarineLight")
	CreatureList(7)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MarineMedium")
	CreatureList(8)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MarineHeavy")
	CreatureList(9)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercFemLight")
	CreatureList(10)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercFemMedium")
	CreatureList(11)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercFemHeavy")
	CreatureList(12)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercJapLight")
	CreatureList(13)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercJapMedium")
	CreatureList(14)=(CatStr="Main-Walk",NameStr="U2Pawns.U2MercJapHeavy")
	CreatureList(15)=(CatStr="Main-Walk",NameStr="U2Pawns.U2SkaarjLight")
	CreatureList(16)=(CatStr="Main-Walk",NameStr="U2Pawns.U2SkaarjMedium")
	CreatureList(17)=(CatStr="Main-Walk",NameStr="U2Pawns.U2SkaarjHeavy")
	CreatureList(25)=(CatStr="Main-Walk",NameStr="U2Pawns.U2Tosc")
	CreatureList(26)=(CatStr="Main-Hover",NameStr="U2Pawns.U2DrakkDroid")
	CreatureList(27)=(CatStr="Main-Hover",NameStr="U2Pawns.U2DrakkLight")
	CreatureList(28)=(CatStr="Main-Hover",NameStr="U2Pawns.U2DrakkMedium")
	CreatureList(29)=(CatStr="Main-Hover",NameStr="U2Pawns.U2DrakkBoss")
	CreatureList(36)=(CatStr="Misc-Walk",NameStr="U2Pawns.Aida")
	CreatureList(37)=(CatStr="Misc-Walk",NameStr="U2Pawns.Isaak")
	CreatureList(38)=(CatStr="Misc-Walk",NameStr="U2Pawns.Neban")
	CreatureList(39)=(CatStr="Misc-Walk",NameStr="U2Pawns.U2KaiClothed")
	CreatureList(40)=(CatStr="Misc-Walk",NameStr="U2Pawns.U2CivilianScientist")
	CreatureList(41)=(CatStr="Misc-Walk",NameStr="U2Pawns.U2ColonistHumanFemaleA")
	CreatureList(42)=(CatStr="Misc-Walk",NameStr="U2Pawns.U2ColonistHumanMaleA")
	CreatureList(43)=(CatStr="Misc-Walk",NameStr="U2Pawns.U2SpecialCivilian")
	CreatureList(44)=(CatStr="Misc-Walk",NameStr="U2Pawns.RaffTrainingBot")
	CreatureList(51)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Cockroach")
	CreatureList(52)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Cyprid")
	CreatureList(53)=(CatStr="Other-Walk",NameStr="U2Pawns.U2MegaParata")
	CreatureList(54)=(CatStr="Other-Walk",NameStr="U2Pawns.U2MegaSnipe")
	CreatureList(55)=(CatStr="Other-Walk",NameStr="U2Pawns.U2MiniMukhogg")
	CreatureList(56)=(CatStr="Other-Walk",NameStr="U2Pawns.U2MiniRammer")
	CreatureList(57)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Mukhogg")
	CreatureList(58)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Parata")
	CreatureList(59)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Rammer")
	CreatureList(60)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Seagoat")
	CreatureList(61)=(CatStr="Other-Walk",NameStr="U2Pawns.U2Snipe")
	CreatureList(71)=(CatStr="Other-Fly",NameStr="U2Pawns.U2FlyingSnake")
	CreatureList(72)=(CatStr="Other-Fly",NameStr="U2Pawns.U2Hummer")
	CreatureList(73)=(CatStr="Other-Fly",NameStr="U2Pawns.U2Spore")
	CreatureList(80)=(CatStr="Other-Fly",NameStr="U2Pawns.U2Diver")
	CreatureList(81)=(CatStr="Other-Swim",NameStr="U2Pawns.U2Bellowfish")
	CreatureList(82)=(CatStr="Other-Swim",NameStr="U2Pawns.U2KillerSprout")
	CreatureList(83)=(CatStr="Other-Swim",NameStr="U2Pawns.U2KillerTadpole")
	CreatureList(84)=(CatStr="Other-Swim",NameStr="U2Pawns.U2PinwheelFish")
	CreatureList(85)=(CatStr="Other-Swim",NameStr="U2Pawns.U2Schoolfish")
	CreatureList(86)=(CatStr="Other-Swim",NameStr="U2Pawns.U2Uglyfish")
	CreatureList(87)=(CatStr="Other-Swim",NameStr="U2Pawns.U2WaterDipper")
	ShowViewTraceLen=65535
	DebugInfoManagerClass=Class'U2.HitActorDebugInfoManager'
	ScoreboardInfoManagerClass=Class'U2.ScoreboardInfoManager'
	bServosEnabled=true
	CurrentRMode=5
	CreatureIndex=1
	NPCShowTime=1.000000
	NPCShowColor=(B=255,G=255,A=255)
     DeathMusic(0)="DEATH_1.ogg"
     DeathMusic(1)="DEATH_2.ogg"
     DeathMusic(2)="DEATH_3.ogg"
     DeathMusic(3)="DEATH_4.ogg"
     ExecManagerClasses(0)=Class'U2.CheatManager'
     ExecManagerClasses(1)=Class'U2.AdminManager'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}