Unrealscript & GeSHi

It sure would be nice to have pretty syntax highlighted UnrealScript on your website without any hassle, wouldn't it?

GeSHi is a set of PHP classes that lets you do just this. I've created an unrealScript wordfile for it and it's all very easy to use - provided you have a webserver with PHP installed, of course.

Installation is easy! Just do this:

Download, extract and install GeSHi (tested with 1.0.7.19)
Paste the contents of this text field into a file called 'uscript.php' in the /geshi subdirectory

<?php
/*************************************************************************************
 * uscript.php
 * ---------------------------------
 * Author: pospi (pospi at spadgos dot com)
 * Copyright: (c) 2007 pospi (http://pospi.spadgos.com)
 * Release Version: 1.0.0
 * CVS Revision Version: $Revision: 000 $
 * Date Started: 2007/05/21
 * Last Modified: $Date: 2007-05-21 23:51:03 +1000 (Mon, 21 May 2007) $
 *
 * unrealScript language file for GeSHi.
 *
 * Comments:
 * * Main purpose at this time is for Unreal Engine 2 / 2.5
 * * Mostly taken from UltraEdit unrealScript wordfile.
 *
 * CHANGES
 * -------
 * 2007/05/21 (1.0.0)
 *  -  First Release
 *
 * TODO (updated 2007/05/21)
 * -------------------------
 * * Update to feature any UE3 classes / keywords when UT3 comes out
 *
 *************************************************************************************
 *
 *     This file is part of GeSHi.
 *
 *   GeSHi is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   GeSHi is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with GeSHi; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 ************************************************************************************/
 
$language_data = array (
	'LANG_NAME' => 'Unreal Script',
	'COMMENT_SINGLE' => array(1 => '//', 2 => '#'),
	'COMMENT_MULTI' => array('/*' => '*/'),
	'CASE_KEYWORDS' => GESHI_CAPS_NO_CHANGE,
	'QUOTEMARKS' => array("'", '"'),
	'ESCAPE_CHAR' => '\\',
	'KEYWORDS' => array(
		1 => array(		//declaration keywords
			'simulated', 'state', 'class', 'function', 'event', 'var', 'local',
			'ignores', 'globalconfig', 'config', 'abstract', 'nativereplication', 'native',
			'auto', 'coerce', 'const', 'default',
			'defaultproperties',
			'enum', 'event', 'extends', 'expands', 'final', 'guid', 'latent', 'localized',
			'new', 'noexport', 'operator', 'preoperator', 'optional', 'out',
			'private', 'public', 'protected', 'reliable', 'replication',
			'simulated', 'singular', 'static', 'struct', 'transient', 'unreliable',
			'hidedropdown', 'cacheexempt', 'exec', 'delegate', 'import', 'placeable', 'exportstructs'
			),
		2 => array(		//control flow keywords
			'for', 'while', 'do', 'if', 'else', 'switch', 'case', 'return', 'break', 'continue',
			'begin', 'loop', 'assert',
			'foreach', 'AllActors', 'DynamicActors', 'ChildActors', 'BasedActors', 'TouchingActors', 
			'TraceActors', 'RadiusActors', 'VisibleActors', 'CollidingActors', 'VisibleCollidingActors'
			),
		3 => array(		//global (object) functions
			'log', 'warn', 'rot', 'vect', 'Rand', 'Min', 'Max', 'Clamp', 'Abs', 'Sin', 'ASin', 
			'Cos', 'ACos', 'Tan', 'ATan', 'Exp', 'Loge', 'Sqrt', 'Square', 'FRand', 'FMin', 'FMax', 'FClamp',
			'Lerp', 'Smerp', 'Ceil', 'Round', 'VSize', 'Normal', 'Invert', 'VRand', 'MirrorVectorByNormal',
			'GetAxes', 'GetUnAxes', 'RotRand', 'OrthoRotation', 'Normalize', 'ClockwiseFrom',
			'Len', 'InStr', 'Mid', 'Left', 'Right', 'Caps', 'Chr', 'Asc', 'Locs', 
			'Divide', 'Split', 'StrCmp', 'Repl', 'Eval',
			'InterpCurveEval', 'InterpCurveGetOutputRange', 'InterpCurveGetInputDomain',
			'QuatProduct', 'QuatInvert', 'QuatRotateVector', 'QuatFindBetween', 'QuatFromAxisAndAngle',
			'QuatFromRotator', 'QuatToRotator', 'QuatSlerp',
			'Localize', 'GotoState', 'IsInState', 'GetStateName', 
			'ClassIsChildOf', 'IsA', 'Enable', 'Disable',
			'GetPropertyText', 'SetPropertyText', 'GetEnum', 'DynamicLoadObject', 'FindObject',
			'SaveConfig', 'ClearConfig', 'StaticSaveConfig', 'ResetConfig', 'StaticClearConfig',
			'GetPerObjectNames', 'RandRange', 'StopWatch', 'IsOnConsole', 'IsSoaking',
			'PlatformIsMacOS', 'PlatformIsUnix', 'PlatformIsWindows', 'PlatformIs64Bit',
			'BeginState', 'EndState', 'Created', 'AllObjects', 'GetReferencers', 'GetItemName', 
			'ReplaceText', 'EatStr'
			),
		4 => array(		//common almost-global (actor) functions
			'ClientMessage', 'ConsoleCommand', 'CopyObjectToClipboard', 'TextToSpeech',
			'Error', 'Sleep', 'SetCollision', 'SetCollisionSize', 'SetDrawScale', 'SetDrawScale3D', 
			'SetStaticMesh', 'SetDrawType', 'Move', 'SetLocation', 'SetRotation', 
			'SetRelativeLocation', 'SetRelativeRotation', 'MoveSmooth', 'AutonomousPhysics', 
			'SetBase', 'SetOwner', 'IsJoinedTo', 'GetMeshName', 'PlayAnim', 'LoopAnim', 'TweenAnim', 
			'IsAnimating', 'FinishAnim', 'HasAnim', 'StopAnimating', 'FreezeFrameAt', 'SetAnimFrame', 
			'IsTweening', 'AnimStopLooping', 'AnimEnd', 'LinkSkelAnim', 'LinkMesh', 'BoneRefresh', 
			'GetBoneCoords', 'GetBoneRotation', 'GetRootLocation', 'GetRootRotation', 'AttachToBone', 
			'DetachFromBone', 'SetBoneScale', 'UpdateURL', 'GetURLOption', 'SetPhysics', 'KAddImpulse', 
			'KImpact', 'KApplyForce', 'Clock', 'UnClock', 'Destroyed', 'GainedChild', 'LostChild', 
			'Tick', 'PostNetReceive', 'ClientTrigger', 'Trigger', 'UnTrigger', 'BeginEvent', 'EndEvent',
			'Timer', 'HitWall', 'Falling', 'Landed', 'ZoneChange', 'PhysicsVolumeChange', 'Touch',
			'PostTouch', 'UnTouch', 'Bump', 'BaseChange', 'Attach', 'Detach', 'SpecialHandling', 
			'EncroachingOn', 'EncroachedBy', 'RanInto', 'FinishedInterpolation', 'EndedRotation', 
			'UsedBy', 'FellOutOfWorld', 'KilledBy', 'TakeDamage', 'HealDamage', 'Trace', 'FastTrace',
			'TraceThisActor', 'spawn', 'Destroy', 'TornOff', 'SetTimer', 'PlaySound', 'PlayOwnedSound',
			'GetSoundDuration', 'MakeNoise', 'BeginPlay', 'GetAllInt', 'RenderOverlays', 'RenderTexture',
			'PreBeginPlay', 'PostBeginPlay', 'PostNetBeginPlay', 'HurtRadius', 'Reset', 'Crash'
			),
		5 => array(		//data types
			'none', 'null',
			'float', 'int', 'bool', 'byte', 'char', 'double', 'iterator', 'name', 'string',	//primitive
			'plane', 'rotator', 'vector', 'spline',	'coords', 'Quat', 'Range', 'RangeVector', //structs
			'Scale', 'Color', 'Box', 'IntBox', 'FloatBox', 'BoundingVolume', 'Matrix', 'InterpCurvePoint',
			'InterpCurve', 'CompressedPosition', 'TMultiMap', 'PointRegion', 
			'KRigidBodyState', 'KSimParams', 'AnimRep', 'FireProperties',
			'lodmesh', 'skeletalmesh', 'mesh', 'StaticMesh', 'MeshInstance',	//3d resources
			'sound',	//sound resources
			'material', 'texture', 'combiner', 'modifier', 'ColorModifier', 'FinalBlend',	//2d resources
			'MaterialSequence', 'MaterialSwitch', 'OpacityModifier', 'TexModifier', 'TexEnvMap',
			'TexCoordSource', 'TexMatrix', 'TexOscillator', 'TexPanner', 'TexRotator', 'TexScaler',
			'RenderedMaterial', 'BitmapMaterial', 'ScriptedTexture', 'ShadowBitmapMaterial', 'Cubemap',
			'FractalTexture', 'FireTexture', 'IceTexture', 'WaterTexture', 'FluidTexture', 'WaveTexture',
			'WetTexture', 'ConstantMaterial', 'ConstantColor', 'FadeColor', 'ParticleMaterial',
			'ProjectorMaterial', 'Shader', 'TerrainMaterial', 'VertexColor'
			),
		6 => array(		//misc keywords
			'false', 'true', 'self', 'super', 'MaxInt', 'Pi'
			),
		7 => array(		//common actor enums & variables
			'DT_None', 'DT_Sprite', 'DT_Mesh', 'DT_Brush', 'DT_RopeSprite', 
			'DT_VerticalSprite', 'DT_TerraForm', 'DT_SpriteAnimOnce', 'DT_StaticMesh', 'DT_DrawType', 
			'DT_Particle', 'DT_AntiPortal', 'DT_FluidSurface', 
			'PHYS_None', 'PHYS_Walking', 'PHYS_Falling', 'PHYS_Swimming', 'PHYS_Flying', 
			'PHYS_Rotating', 'PHYS_Projectile', 'PHYS_Interpolating', 'PHYS_MovingBrush', 'PHYS_Spider', 
			'PHYS_Trailer', 'PHYS_Ladder', 'PHYS_RootMotion', 'PHYS_Karma', 'PHYS_KarmaRagDoll', 
			'PHYS_Hovering', 'PHYS_CinMotion',
			'ROLE_None', 'ROLE_DumbProxy', 'ROLE_SimulatedProxy', 
			'ROLE_AutonomousProxy', 'ROLE_Authority',
			'STY_None', 'STY_Normal', 'STY_Masked', 'STY_Translucent', 'STY_Modulated', 'STY_Alpha',
			'STY_Additive', 'STY_Subtractive', 'STY_Particle', 'STY_AlphaZ',
			'OCCLUSION_None', 'OCCLUSION_BSP', 'OCCLUSION_Default', 'OCCLUSION_StaticMeshes',
			'SLOT_None', 'SLOT_Misc', 'SLOT_Pain', 'SLOT_Interact', 'SLOT_Ambient', 'SLOT_Talk', 
			'SLOT_Interface', 'MTRAN_None', 'MTRAN_Instant', 'MTRAN_Segue', 'MTRAN_Fade',
			'MTRAN_FastFade', 'MTRAN_SlowFade',
			
			'DrawType', 'Physics', 'Owner', 'Base', 'Level', 'Game', 'Instigator', 'RemoteRole', 'Role',
			'LifeSpan', 'Tag', 'Event', 'Location', 'Rotation', 'Velocity', 'Acceleration',
			'RelativeLocation', 'RelativeRotation', 'DrawScale', 'DrawScale3D', 'Skins', 'Style',
			'SoundVolume', 'SoundPitch', 'SoundRadius', 'TransientSoundVolume', 'TransientSoundRadius',
			'CollisionRadius', 'CollisionHeight', 'Mass', 'Buoyancy', 'RotationRate', 'DesiredRotation'
			),
		8 => array(		//common non-actor uscript classes
			'Object',
			'CacheManager', 'CameraEffect', 'Canvas', 'CheatManager', 'Commandlet', 'DecoText', 'GUI',
			'InteractionMaster', 'Interactions', 'Interaction', 'KarmaParamsCollision', 'KarmaParamsRBFull',
			'KarmaParamsSkel', 'KarmaParams', 'LevelSummary', 'Locale', 'Manifest', 'MaterialFactory',
			'MeshObject', 'ObjectPool', 'Pallete', 
			'ParticleEmitter', 'MeshEmitter', 'BeamEmitter', 'SpriteEmitter', 'SparkEmitter', 'TrailEmitter',
			'Player', 'PlayerInput', 'PlayInfo', 'ReachSpec', 'Resource', 'LatentScriptedAction', 'ScriptedAction',
			'speciesType', 'StreamBase', 'Stream', 'EditorEngine', 'Engine', 'Time', 'WeaponFire',
			'WebApplication', 'WebRequest', 'WebResponse', 'WebSkin', 'xPawnGibGroup', 'xPawnSoundGroup',
			'xUtil'
			),
		9 => array(		//common actor-based uscript classes
			'Actor',
			'Controller', 'AIController', 'ScriptedController', 'Bot', 'xBot',
			'PlayerController', 'UnrealPlayer', 'xPlayer',
			'DamageType', 'WeaponDamageType', 'Effects', 'Emitter', 'NetworkEmitter',
			'Gib', 'HUD', 'HudBase', 'Info', 'FluidSurfaceInfo', 'Combo', 
			'GameInfo', 'UnrealMPGameInfo', 'DeathMatch', 'TeamGame', 'CTFGame',
			'xCTFGame', 'xBombingRun', 'xDoubleDom', 'xTeamGame',
			'ASGameInfo', 'Invasion', 'ONSOnslaughtGame', 'xDeathmatch',
			'Mutator', 'Inventory', 'Ammunition', 'KeyInventory', 'Powerups', 'Armor', 'Weapon',
			'InventoryAttachment', 'WeaponAttachment',
			'KActor', 'KConstraint', 'KBSJoint', 'KCarWheelJoint', 'KConeLimit', 'KHinge', 'KTire',
			'KVehicleFactory', 'Keypoint', 'AIScript', 'ScriptedSequence', 'ScriptedTrigger', 
			'AmbientSound', 'Light', 'SpotLight', 'SunLight', 'TriggerLight',
			'MeshEffect', 'NavigationPoint', 'GameObjective', 'DestroyableObjective',
			'PathNode', 'FlyingPathNode', 'RoadPathNode', 'InventorySpot', 'PlayerStart',
			'Pawn', 'Vehicle', 'UnrealPawn', 'xPawn', 'Monster', 'ASVehicle', 'KVehicle', 'KCar',
			'ONSWeaponPawn', 'SVehicle', 'ONSVehicle', 'ONSChopperCraft', 'ONSHoverCraft', 
			'ONSPlaneCraft', 'ONSTreadCraft', 'ONSWheeledCraft',
			'Pickup', 'Ammo', 'UTAmmoPickup', 'ArmorPickup', 'KeyPickup', 'TournamentPickup',
			'Projectile', 'Projector', 'DynamicProjector', 'ShadowProjector', 'xScorch',
			'xEmitter', 'xPickupBase', 'xProcMesh', 'xWeatherEffect', 'PhysicsVolume', 'Volume'
			)
		),
	'SYMBOLS' => array(
		'+','-','=','/','*','-','%','>','<','&','^','!','|','`','(',')','[',']','{','}',
		'dot','cross','<<','>>','$','@'
		),
	'CASE_SENSITIVE' => array(
		GESHI_COMMENTS => false,
		1 => false,
		2 => false,
		3 => false,
		),
	'STYLES' => array(
		'KEYWORDS' => array(
			1 => 'color: #0000FF;',
			2 => 'color: #0000FF;',
			3 => 'color: #0066AA;',
			4 => 'color: #0088FF;',
			5 => 'color: #E000E0;',
			6 => 'color: #900000;',
			7 => 'color: #888800;',
			8 => 'color: #AA6600;',
			9 => 'color: #FF8800;'
			),
		'COMMENTS' => array(
			1 => 'color: #008080; font-style: italic;',
			2 => 'color: #000000; font-weight: bold;',
			'MULTI' => 'color: #008080; font-style: italic;'
			),
		'ESCAPE_CHAR' => array(
			0 => ''
			),
		'BRACKETS' => array(
			0 => 'color: #000000;'
			),
		'STRINGS' => array(
			0 => 'color: #999999;'
			),
		'NUMBERS' => array(
			0 => 'color: #FF0000;'
			),
		'METHODS' => array(
			0 => 'color: #006600;'
			),
		'SYMBOLS' => array(
			0 => 'color: #669966;'
			),
		'REGEXPS' => array(
			0 => 'color: #E000E0;',
			1 => 'color: #E000E0;'
			),
		'SCRIPT' => array(
			0 => ''
			)
		),
	'URLS' => array(
		1 => '',
		2 => '',
		3 => '',
		4 => '',
		5 => '',
		6 => '',
		7 => '',
		8 => 'http://wiki.beyondunreal.com/wiki?search={FNAME}',
		9 => 'http://wiki.beyondunreal.com/wiki?search={FNAME}'
		),
	'OOLANG' => false,
	'OBJECT_SPLITTER' => '',
	'REGEXPS' => array(			//handle template-style variable definitions
		0 => array(
			GESHI_SEARCH => '(class\s*)<(\s*(\w+)\s*)>',
			GESHI_REPLACE => "\${1}",
			GESHI_MODIFIERS => 'i',
			GESHI_BEFORE => '',
			GESHI_AFTER => "< \${3} >"
			),
		1 => array(
			GESHI_SEARCH => '(array\s*)<(\s*(\w+)\s*)>',
			GESHI_REPLACE => "\${1}",
			GESHI_MODIFIERS => 'i',
			GESHI_BEFORE => '',
			GESHI_AFTER => "< \${3} >"
			)
		),
	'STRICT_MODE_APPLIES' => GESHI_NEVER,
	'SCRIPT_DELIMITERS' => array(
		),
	'HIGHLIGHT_STRICT_BLOCK' => array(
		)
);
 
?>

Use as follows:

$geshi = &new GeSHi($some_uscript_text, 'uscript');

If you're still confused, read over the documentation on the GeSHi website.

Scroll down a bit and click to see an example, and scroll a bit further to try it yourself.

See an example

class UnrealPawn extends Pawn
	abstract
	config(User);
 
var	() bool		bNoDefaultInventory;	// don't spawn default inventory for this guy
var bool		bAcceptAllInventory;	// can pick up anything
var(AI) bool	bIsSquadLeader;			// only used as startup property
var bool		bSoakDebug;				// use less verbose version of debug display
var bool		bKeepTaunting;
var config bool bPlayOwnFootsteps;
var byte		LoadOut;
 
var config byte SelectedEquipment[16];	// what player has selected (replicate using function)
var()	string	RequiredEquipment[16];	// allow L.D. to modify for single player
var		string	OptionalEquipment[16];	// player can optionally incorporate into loadout
 
var		float	AttackSuitability;		// range 0 to 1, 0 = pure defender, 1 = pure attacker
var		float	LastFootStepTime;
 
var eDoubleClickDir CurrentDir;
var vector			GameObjOffset;
var rotator			GameObjRot;
var(AI) name		SquadName;			// only used as startup property
 
// allowed voices
var string VoiceType;
 
var globalconfig bool bPlayerShadows;
var globalconfig bool bBlobShadow;
 
var int spree;
 
function DropFlag()
{
	if (PlayerReplicationInfo==None || PlayerReplicationInfo.HasFlag==None)
    	return;
 
    PlayerReplicationInfo.HasFlag.Drop(Velocity * 0.5);
}
 
simulated function bool FindValidTaunt( out name Sequence )
{
	local int i;
 
	for( i=0; i<TauntAnims.Length; i++ )
	{
		if( Sequence == TauntAnims[i] )
			return true;
	}
 
	return false;
}
 
function gibbedBy(actor Other)
{
	if ( Role < ROLE_Authority )
		return;
	if ( Pawn(Other) != None )
	{
		if ( (Pawn(Other).Weapon != None) && Pawn(Other).Weapon.IsA('Translauncher') )
			Died(Pawn(Other).Controller, Pawn(Other).Weapon.GetDamageType(), Location);
		else
			Died(Pawn(Other).Controller, class'DamTypeTelefragged', Location);
	}
	else
		Died(None, class'Gibbed', Location);
}
 
/* DisplayDebug()
list important actor variable on canvas.  Also show the pawn's controller and weapon info
*/
simulated function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
{
	local string T;
	local float XL;
 
	if ( !bSoakDebug )
	{
		Super.DisplayDebug(Canvas, YL, YPos);
		return;
	}
 
	Canvas.Style = ERenderStyle.STY_Normal;
	Canvas.StrLen("TEST", XL, YL);
	YPos = YPos + 8*YL;
	Canvas.SetPos(4,YPos);
	Canvas.SetDrawColor(255,255,0);
	T = GetDebugName();
	if ( bDeleteMe )
		T = T$" DELETED (bDeleteMe == true)";
	Canvas.DrawText(T, false);
	YPos += 3 * YL;
	Canvas.SetPos(4,YPos);
 
	if ( Controller == None )
	{
		Canvas.SetDrawColor(255,0,0);
		Canvas.DrawText("NO CONTROLLER");
		YPos += YL;
		Canvas.SetPos(4,YPos);
	}
	else
		Controller.DisplayDebug(Canvas,YL,YPos);
 
	YPos += 2*YL;
	Canvas.SetPos(4,YPos);
	Canvas.SetDrawColor(0,255,255);
	Canvas.DrawText("Anchor "$Anchor$" Serpentine Dist "$SerpentineDist$" Time "$SerpentineTime);
	YPos += YL;
	Canvas.SetPos(4,YPos);
 
	T = "Floor "$Floor$" DesiredSpeed "$DesiredSpeed$" Crouched "$bIsCrouched$" Try to uncrouch "$UncrouchTime;
	if ( (OnLadder != None) || (Physics == PHYS_Ladder) )
		T=T$" on ladder "$OnLadder;
	Canvas.DrawText(T);
	YPos += YL;
	Canvas.SetPos(4,YPos);
}
 
/* BotDodge()
returns appropriate vector for dodge in direction Dir (which should be normalized)
*/
function vector BotDodge(Vector Dir)
{
	local vector Vel;
 
	Vel = GroundSpeed*Dir;
	Vel.Z = JumpZ;
	return Vel;
}
 
function HoldFlag(Actor FlagActor)
{
	if ( GameObject(FlagActor) != None )
		HoldGameObject(GameObject(FlagActor),GameObject(FlagActor).GameObjBone);
}
 
function HoldGameObject(GameObject gameObj, name GameObjBone)
{
	if ( GameObjBone == 'None' )
	{
		GameObj.SetPhysics(PHYS_Rotating);
		GameObj.SetLocation(Location);
		GameObj.SetBase(self);
		GameObj.SetRelativeLocation(vect(0,0,0));
	}
	else
	{
		AttachToBone(gameObj,GameObjBone);
		gameObj.SetRelativeRotation(GameObjRot + gameObj.GameObjRot);
		gameObj.SetRelativeLocation(GameObjOffset + gameObj.GameObjOffset );
	}
}
 
function EndJump();	// Called when stop jumping
 
simulated function ShouldUnCrouch();
 
simulated event SetAnimAction(name NewAction)
{
	AnimAction = NewAction;
	PlayAnim(AnimAction);
}
 
function String GetDebugName()
{
	if ( (Bot(Controller) != None) && Bot(Controller).bSoaking && (Level.Pauser != None) )
		return GetHumanReadableName()@Bot(Controller).SoakString;
	if ( PlayerReplicationInfo != None )
		return PlayerReplicationInfo.PlayerName;
	return GetItemName(string(self));
}
 
function FootStepping(int side);
 
function name GetWeaponBoneFor(Inventory I)
{
	return 'weapon_bone';
}
 
function CheckBob(float DeltaTime, vector Y)
{
	local float OldBobTime;
	local int m,n;
 
	OldBobTime = BobTime;
	Super.CheckBob(DeltaTime,Y);
 
	if ( (Physics != PHYS_Walking) || (VSize(Velocity) < 10)
		|| ((PlayerController(Controller) != None) && PlayerController(Controller).bBehindView) )
		return;
 
	m = int(0.5 * Pi + 9.0 * OldBobTime/Pi);
	n = int(0.5 * Pi + 9.0 * BobTime/Pi);
 
	if ( (m != n) && !bIsWalking && !bIsCrouched )
		FootStepping(0);
	else if ( !bWeaponBob && bPlayOwnFootSteps && !bIsWalking && !bIsCrouched && (Level.TimeSeconds - LastFootStepTime > 0.35) )
	{
		LastFootStepTime = Level.TimeSeconds;
		FootStepping(0);
	}
}
 
/* IsInLoadout()
return true if InventoryClass is part of required or optional equipment
*/
function bool IsInLoadout(class< Inventory > InventoryClass)
{
	local int i;
	local string invstring;
 
	if ( bAcceptAllInventory )
		return true;
 
	invstring = string(InventoryClass);
 
	for ( i=0; i<16; i++ )
	{
		if ( RequiredEquipment[i] ~= invstring )
			return true;
		else if ( RequiredEquipment[i] == "" )
			break;
	}
 
	for ( i=0; i<16; i++ )
	{
		if ( OptionalEquipment[i] ~= invstring )
			return true;
		else if ( OptionalEquipment[i] == "" )
			break;
	}
	return false;
}
 
function AddDefaultInventory()
{
	local int i;
 
	if ( IsLocallyControlled() )
	{
		for ( i=0; i<16; i++ )
			if ( RequiredEquipment[i] != "" )
				CreateInventory(RequiredEquipment[i]);
 
		for ( i=0; i<16; i++ )
			if ( (SelectedEquipment[i] == 1) && (OptionalEquipment[i] != "") )
				CreateInventory(OptionalEquipment[i]);
 
	    Level.Game.AddGameSpecificInventory(self);
	}
	else
	{
	    Level.Game.AddGameSpecificInventory(self);
 
		for ( i=15; i>=0; i-- )
			if ( (SelectedEquipment[i] == 1) && (OptionalEquipment[i] != "") )
				CreateInventory(OptionalEquipment[i]);
 
		for ( i=15; i>=0; i-- )
			if ( RequiredEquipment[i] != "" )
				CreateInventory(RequiredEquipment[i]);
	}
 
	// HACK FIXME
	if ( inventory != None )
		inventory.OwnerEvent('LoadOut');
 
	Controller.ClientSwitchToBestWeapon();
}
 
function CreateInventory(string InventoryClassName)
{
	local Inventory Inv;
	local class< Inventory > InventoryClass;
 
	InventoryClass = Level.Game.BaseMutator.GetInventoryClass(InventoryClassName);
	if( (InventoryClass!=None) && (FindInventoryType(InventoryClass)==None) )
	{
		Inv = Spawn(InventoryClass);
		if( Inv != None )
		{
			Inv.GiveTo(self);
			if ( Inv != None )
				Inv.PickupFunction(self);
		}
	}
}
 
function bool PerformDodge(eDoubleClickDir DoubleClickMove, vector Dir, vector Cross);
 
function bool Dodge(eDoubleClickDir DoubleClickMove)
{
	local vector X,Y,Z;
 
	if ( bIsCrouched || bWantsToCrouch || (Physics != PHYS_Walking) )
		return false;
 
    GetAxes(Rotation,X,Y,Z);
	if (DoubleClickMove == DCLICK_Forward)
		Velocity = 1.5*GroundSpeed*X + (Velocity Dot Y)*Y;
	else if (DoubleClickMove == DCLICK_Back)
		Velocity = -1.5*GroundSpeed*X + (Velocity Dot Y)*Y;
	else if (DoubleClickMove == DCLICK_Left)
		Velocity = 1.5*GroundSpeed*Y + (Velocity Dot X)*X;
	else if (DoubleClickMove == DCLICK_Right)
		Velocity = -1.5*GroundSpeed*Y + (Velocity Dot X)*X;
 
	Velocity.Z = 210;
	CurrentDir = DoubleClickMove;
	SetPhysics(PHYS_Falling);
	return true;
}
 
simulated function PostBeginPlay()
{
	Super.PostBeginPlay();
 
	if ( Level.bStartup && !bNoDefaultInventory )
		AddDefaultInventory();
}
 
simulated function PostNetBeginPlay()
{
	local SquadAI S;
	local RosterEntry R;
 
	Super.PostNetBeginPlay();
	if ( (Role == ROLE_Authority) && Level.bStartup )
	{
		if ( UnrealMPGameInfo(Level.Game) == None )
		{
			if ( Bot(Controller) != None )
			{
				ForEach DynamicActors(class'SquadAI',S,SquadName)
					break;
				if ( S == None )
					S = spawn(class'SquadAI');
				S.Tag = SquadName;
				if ( bIsSquadLeader || (S.SquadLeader == None) )
					S.SetLeader(Controller);
				S.AddBot(Bot(Controller));
			}
		}
		else
		{
			R = GetPlacedRoster();
			UnrealMPGameInfo(Level.Game).InitPlacedBot(Controller,R);
		}
	}
}
 
function RosterEntry GetPlacedRoster()
{
	return None;
}
 
function SetMovementPhysics()
{
	if (Physics == PHYS_Falling)
		return;
	if ( PhysicsVolume.bWaterVolume )
		SetPhysics(PHYS_Swimming);
	else
		SetPhysics(PHYS_Walking);
}
 
function TakeDrowningDamage()
{
	TakeDamage(5, None, Location + CollisionHeight * vect(0,0,0.5)+ 0.7 * CollisionRadius * vector(Controller.Rotation), vect(0,0,0), class'Drowned');
}
 
function int GetSpree()
{
	return spree;
}
 
function IncrementSpree()
{
	spree++;
}
 
simulated function PlayFootStep(int Side)
{
	if ( (Role==ROLE_SimulatedProxy) || (PlayerController(Controller) == None) || PlayerController(Controller).bBehindView )
	{
		FootStepping(Side);
		return;
	}
}
 
//-----------------------------------------------------------------------------
 
/*
Pawn was killed - detach any controller, and die
*/
simulated function ChunkUp( Rotator HitRotation, float ChunkPerterbation )
{
	if ( (Level.NetMode != NM_Client) && (Controller != None) )
	{
		if ( Controller.bIsPlayer )
			Controller.PawnDied(self);
		else
			Controller.Destroy();
	}
 
	bTearOff = true;
	HitDamageType = class'Gibbed'; // make sure clients gib also
	if ( (Level.NetMode == NM_DedicatedServer) || (Level.NetMode == NM_ListenServer) )
		GotoState('TimingOut');
	if ( Level.NetMode == NM_DedicatedServer )
		return;
	if ( class'GameInfo'.static.UseLowGore() )
	{
		Destroy();
		return;
	}
	SpawnGibs(HitRotation,ChunkPerterbation);
 
	if ( Level.NetMode != NM_ListenServer )
		Destroy();
}
 
// spawn gibs (local, not replicated)
simulated function SpawnGibs(Rotator HitRotation, float ChunkPerterbation);
 
/* TimingOut - where gibbed pawns go to die (delay so they can get replicated)
*/
State TimingOut
{
ignores BaseChange, Landed, AnimEnd, Trigger, Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, Falling, BreathTimer;
 
	function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation,
							Vector momentum, class< DamageType > damageType)
	{
	}
 
	function BeginState()
	{
		SetPhysics(PHYS_None);
		SetCollision(false,false,false);
		LifeSpan = 1.0;
		if ( Controller != None )
		{
			if ( Controller.bIsPlayer )
				Controller.PawnDied(self);
			else
				Controller.Destroy();
		}
	}
}
 
State Dying
{
ignores AnimEnd, Trigger, Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, Falling, BreathTimer;
 
	function Landed(vector HitNormal)
	{
		if ( Level.NetMode == NM_DedicatedServer )
			return;
		if ( Shadow != None )
			Shadow.Destroy();
	}
 
	singular function BaseChange()
	{
		Super.BaseChange();
		// fixme - wake up karma
	}
 
	function BeginState()
	{
		local int i;
 
		SetCollision(true,false,false);
        if ( bTearOff && (Level.NetMode == NM_DedicatedServer) )
			LifeSpan = 1.0;
		else
			SetTimer(2.0, false);
        SetPhysics(PHYS_Falling);
		bInvulnerableBody = true;
		if ( Controller != None )
		{
			if ( Controller.bIsPlayer )
				Controller.PawnDied(self);
			else
				Controller.Destroy();
		}
 
		for (i = 0; i < Attached.length; i++)
			if (Attached[i] != None)
				Attached[i].PawnBaseDied();
	}
}
 
defaultproperties
{
     bAcceptAllInventory=True
     bPlayOwnFootsteps=True
     LoadOut=255
     AttackSuitability=0.500000
     SquadName="Squad"
     bPlayerShadows=True
     bCanCrouch=True
     bCanSwim=True
     bCanClimbLadders=True
     bCanStrafe=True
     bCanPickupInventory=True
     bMuffledHearing=True
     SightRadius=12000.000000
     MeleeRange=20.000000
     GroundSpeed=600.000000
     AirSpeed=600.000000
     AirControl=0.350000
     WalkingPct=0.300000
     CrouchedPct=0.300000
     BaseEyeHeight=60.000000
     EyeHeight=60.000000
     CrouchHeight=39.000000
     UnderWaterTime=20.000000
     ControllerClass=Class'UnrealGame.Bot'
     LightHue=40
     LightSaturation=128
     LightBrightness=70.000000
     LightRadius=6.000000
     bStasis=False
     AmbientGlow=40
     bUseCylinderCollision=True
     Buoyancy=99.000000
     RotationRate=(Pitch=0,Roll=2048)
     ForceType=FT_DragAlong
     ForceRadius=100.000000
     ForceScale=2.500000
}