U2AI.ScriptControllerBase

//=============================================================================
// ScriptControllerBase.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 2/11/03 5:53p $
// $Revision: 122 $
//=============================================================================

class ScriptControllerBase extends ScriptControllerInterf
	config(User)
	native;

/*=============================================================================
Implements a command interpreter which can be used to script/control NPCs. The
script commands are created in a text file which is associated with an instance
of this class at run-time.

For example, includes support for:
	+controlling the inventory which NPCs have and use
	+specifying the stance for NPCs (standing, crouching, prone)
	+specifying whether the NPC is hurt, alert etc.
	+specifying a patrol route, and movement speed
	+controlling the events which NPCs are allowed to react to (e.g. whether
	 they should break off their patrol when they see an enemy)
	+setting up code which is executed when a specific event occurs
	+reacting to triggers and dynamically changing the way that triggers are 
	 handled
	+testing the state or properties of actors
	+enabling/disabling various debug levels in the controlled NPC
	+playing animations, sounds
	+integer and boolean "scratch" variables (e.g. do this patrol 3 times, then 
	 switch to another patrol; if this is the first time I see the player, play
	 this sound).
	+destroying (NPC completely removed from level) or killing NPCs (carcass spawned)

See U2AIScripting.doc for more info.

Note: the native code parsing command appends any line with a "call", "interrupt", or
"gotolabel" in it with the line number for that label (so we don't have to
scan for it). So commands which include a call, interrupt, or gotolabel section
will have an int at the end of their signature. 

Also, labels aren't stripped out of the code, e.g. to help with debugging --
depending on debugmode setting, a stripped-down version of the script (comments 
removed) is dumped to the log with the labels and patched-in destination lines 
shown to make things easier to interpret.

Timer Overview
--------------

Scripts can use the ontimer command to set up a timer which will cause script
execution to jump to the specified label if/when the specified time limit is
up. By default (RepeatFrequency = 0.0), the timer will uninstall itself when
the timer runs out (and scripts can manually uninstall timers if desired).

Currently timers are implemented using a static array in this class. Possible
alternatives would have been to implement timers as separate objects (with
timer events redirected to the associated script controller), but this was 
decided against for now for possible performance reasons.

Up to 5 timers can be used with ontimer. The first parameter to ontimer (1-5)
specified the target timer.

Trigger Handler Overview
------------------------

Scripts can use the ontrigger command to associate a script label with a 
particular event. If/when the event occurs this will cause script execution to 
jump to the specified label.

Triggers can also have a timer associated with them. This is usually used to
limit how long the script will wait for the event to occur (e.g. when waiting
for a squad leader's signal, the script has to allow for the possibility that
the signal (in the form of an event) will never arrive. Timers which are 
associated with triggers are stored in the 2nd half of the Timers list.

Any time that a trigger handler is uninstalled, the associated timer, if any, 
will also be uninstalled.

If a trigger occurs, and the trigger is set to repeat (default), the timer will
be reset.

If a trigger occurs, and the trigger is set to once-only, the timer will be
removed along with the trigger handler.

If a timer occurs before the associated trigger event, the timer and the trigger
handler will be uninstalled.

If a trigger is reset, the associated timer is also reset.

=============================================================================*/

const MaxCommandInfoEntries			= 128;		// size of commands list
const MaxEvents						= 32;		// max number of events in event info list
const MaxTriggerEvents				= 32;		// max number of tracked triggers
const MaxPushedCommandIndices 		= 32;		// maximum call/interrupt depth
const MaxPatrolSize					= 128;		// max length of patrol that can be used with resumepatrol
												
const MaxTimers						= 10;		// max number of timers (ontimer and ontrigger timers)
const MaxTriggerTimers 				= 5;		// max number of trigger timers (uses bottom of Timers list)
const MaxGeneralTimers 				= 5;		// = MaxTimers - MaxTriggerTimers

//NOTE (mdf): don't add wasted overhead by setting up complex calls to DMSC etc. before checking flags to see if enabled
const Debug_None					= 0x0000;	// don't show any debug info
const Debug_Info					= 0x0001;	// show internal debug info
const Debug_Commands				= 0x0002;	// dump commands and log executed commands
const Debug_Events					= 0x0004;	// dump events as they are received
const Debug_Jumps					= 0x0008;	// log control flow changes (gotos, calls, onevents etc.)

const DefaultExt					= ".u2s";

// supported states
const BroadcastErrorState			= 'BroadcastError';
const ChangingStanceState			= 'ChangingStance';
const DetachingState				= 'Detaching';
const ExecuteCommandsState			= 'ExecuteCommands';
const FiringState					= 'Firing';
const SleepingState					= 'Sleeping';

// wait for event states
const WaitActorInRangeState			= 'WaitActorInRange';
const WaitActorOutOfRangeState		= 'WaitActorOutOfRange';
const WaitAnimEndState				= 'WaitAnimEnd';			// only really needed for waiting for end of scripted animations
const WaitBumpEnemyState			= 'WaitBumpEnemy';
const WaitBumpFriendState			= 'WaitBumpFriend';
const WaitBumpOtherState			= 'WaitBumpOther';
const WaitBumpPlayerState			= 'WaitBumpPlayer';
const WaitDestinationReachedState	= 'WaitDestinationReached';
const WaitDialogBeginState			= 'WaitDialogBegin';
const WaitDialogPausedState			= 'WaitDialogPaused';
const WaitDialogFarPausedState		= 'WaitDialogFarPaused';
const WaitDiedState					= 'WaitDied';
const WaitFinishedRotationState		= 'WaitFinishedRotation';
const WaitHearNoiseFriendlyState	= 'WaitHearNoiseFriendly';
const WaitHearNoiseOtherState		= 'WaitHearNoiseOther';
const WaitHearNoiseThreatState		= 'WaitHearNoiseThreat';
const WaitScriptedLandingState		= 'WaitScriptedLanding';
const WaitSeeEnemyState				= 'WaitSeeEnemy';
const WaitSeeFriendState			= 'WaitSeeFriend';
const WaitSeeOtherState				= 'WaitSeeOther';
const WaitSeePlayerState			= 'WaitSeePlayer';
const WaitTakeDamageState			= 'WaitTakeDamage';
const WaitTookDamageState			= 'WaitTookDamage';
const WaitTookDamageEnemyState		= 'WaitTookDamageEnemy';
const WaitTookDamageFriendState		= 'WaitTookDamageFriend';
const WaitTriggerState				= 'WaitTrigger';

// events
const ActorInRangeEvent				= 'ActorInRange';			// generated when the InRangeActor comes within the InRangeDistance
const ActorOutOfRangeEvent			= 'ActorOutOfRange';		// generated once when the InRangeActor comes goes out of the InRangeDistance
const AnimEndEvent					= 'AnimEnd';				// goes to Controller unless Pawn has no Controller (dying state)
const AutoBeginEvent				= 'AutoBegin';				// goes to Controller, generated by U2NPCControllerScriptable
const AutoEndEvent					= 'AutoEnd';				// goes to Controller, generated by Controller
const BumpEnemyEvent				= 'BumpEnemy';				// NotifyBump --> Controller --> BumpEnemy/Friend/Other
const BumpFriendEvent				= 'BumpFriend';				// NotifyBump --> Controller --> BumpEnemy/Friend/Other
const BumpOtherEvent				= 'BumpOther';				// NotifyBump --> Controller --> BumpEnemy/Friend/Other
const BumpPlayerEvent				= 'BumpPlayer';				// not an actual event: eventwait BumpPlayer --> BumpEnemy/BumpFriend checked for player
const DestinationReachedEvent		= 'DestinationReached';		// goes to Controller
const DialogBeginEvent 				= 'DialogBegin';			// generated by Controller before destroyed
const DialogUnPauseEvent			= 'DialogUnPause';			// generated when dialog unpauses npc's script
const DiedEvent 					= 'Died';					// generated by Controller before destroyed
const EnemyNotVisibleEvent			= 'EnemyNotVisible';		// goes to Controller
const HearNoiseFriendlyEvent		= 'HearNoiseFriendly';		// HearNoise --> Controller --> HearNoiseFriendly
const HearNoiseOtherEvent			= 'HearNoiseOther';			// HearNoise --> Controller --> HearNoiseOther
const HearNoiseThreatEvent			= 'HearNoiseThreat';		// HearNoise --> Controller --> HearNoiseThreat
const InheritEnemyEvent				= 'InheritEnemy';			// generated when NPC could inherit another NPC's Enemy
const ScriptedLandingEvent			= 'ScriptedLanding';		// generated when NPC in scripted state lands (not passed back to NPC)
const SeeAlertFriendEvent			= 'SeeAlertFriend';			// SeeAlertFriend --> Controller
const SeeEnemyEvent					= 'SeeEnemy';				// SeeEnemy --> Controller
const SeeFriendEvent				= 'SeeFriend';				// SeeFriend --> Controller --> SeeFriend
const SeeOtherEvent					= 'SeeOther';				// SeeOther --> Controller --> SeeOther
const SeePlayerEvent				= 'SeePlayer';				// not an actual event: eventwait SeePlayer --> SeeEnemy/SeeFriend checked for player
const TakeDamageEvent				= 'TakeDamage';				// goes to Pawn
const TookDamageEvent				= 'TookDamage';				// eventTakeDamage --> TookDamage generated by U2NPCControllerScriptable
const TookDamageEnemyEvent			= 'TookDamageEnemy';		// generated internall from TookDamage for use by scripts only
const TookDamageFriendEvent			= 'TookDamageFriend';		// generated internall from TookDamage for use by scripts only
const TriggerEvent					= 'Trigger';				// goes to Pawn then Controller

// timers
const BroadcastErrorMessageTimerName	= 'BroadcastErrorMessage';
const ResumeProcessingTimerName			= 'ResumeProcessing';
const StanceChangeDoneTimerName			= 'StanceChangeDone';
const StopFiringTimerName				= 'StopFiring';
const StopFiringBackupTimerName			= 'StopFiringBackup';

//-----------------------------------------------------------------------------
// parser related
													
// arguments										
const MaxArgsByte					= 5;
const MaxArgsFloat					= 5;
const MaxArgsInt					= 5;
const MaxArgsName					= 5;
const MaxArgsString					= 5;
const MaxArgsLabel					= 2;

/*-----------------------------------------------------------------------------
Command signatures.

Note: use SigO_... for any signature with optional args. This should also help
to avoid name clashes (UC isn't case-sensitive).
*/

const BUpperAscii					= 0x42;	// obligatory bool (0/1)
const FUpperAscii					= 0x46;	// obligatory float
const IUpperAscii					= 0x49;	// obligatory int
const MUpperAscii					= 0x4D;	// obligatory name (added to name table if not in game)
const NUpperAscii					= 0x4E;	// obligatory name (must already exist in game / name table)
const SUpperAscii					= 0x53;	// obligatory string
const TUpperAscii					= 0x54;	// obligatory target name (must be found in level?)

const bLowerAscii					= 0x62;	// optional bool (0/1)
const fLowerAscii					= 0x66;	// optional float                                
const iLowerAscii					= 0x69;	// optional int                                    
const mLowerAscii					= 0x6D;	// optional name (added to name table if not in game)
const nLowerAscii					= 0x6E;	// optional name (must already exist in game / name table)
const sLowerAscii					= 0x73;	// optional string                              
const tLowerAscii					= 0x74;	// optional target name (must be found in level if given?)

const Sig_B							= "B";
const Sig_F							= "F";
const Sig_FFF						= "FFF";
const Sig_I							= "I";
const Sig_MB						= "MB";
const Sig_M							= "M";
const Sig_MM						= "MM";
const Sig_N							= "N";
const Sig_NB						= "NB";
const Sig_NF						= "NF";
const Sig_NFb						= "NFb";
const Sig_NM						= "NM";
const Sig_NS						= "NS";
const Sig_S							= "S";
const Sig_SI						= "SI";
const Sig_SM						= "SM";
const Sig_SSN						= "SSN";
const Sig_SSS						= "SSS";
const Sig_T							= "T";
const Sig_TM						= "TM";
const Sig_TNb						= "TNb";
const Sig_TS						= "TS";
const Sig_TSS						= "TSS";
const SigO_bi						= "bi";
const SigO_Bb						= "Bb";
const SigO_f						= "f";
const SigO_Fs						= "Fs";
const SigO_Fss						= "Fss";
const SigO_i						= "i";
const SigO_Iffssi					= "Iffssi";
const SigO_Mb						= "Mb";
const SigO_IMfb						= "IMfb";
const SigO_IMffb					= "IMffb";
const SigO_Mfb						= "Mfb";
const SigO_Mffb						= "Mffb";
const SigO_MSs						= "MSs";
const SigO_Mssbfss					= "Mssbfss";
const SigO_Mt						= "Mt";
const SigO_TMb						= "TMb";
const SigO_ntfn						= "ntfn";
const SigO_Nb						= "Nb";
const SigO_NFss						= "NFss";
const SigO_Nfb						= "Nfb";
const SigO_Nn						= "Nn";
const SigO_Nssb						= "Nssb";
const SigO_s						= "s";
const SigO_sffiiiss					= "sffiiiss";
const SigO_sm						= "sm";
const SigO_Sb						= "Sb";
const SigO_Sbi						= "Sbi";
const SigO_Si						= "Si";
const SigO_SIb						= "SIb";
const SigO_Ss						= "Ss";
const SigO_t						= "t";
const SigO_tib						= "tib";
const SigO_Tfb						= "Tfb";
const SigO_TFFFb					= "TFFFb";
const SigO_TNss						= "TNss";
const SigO_TSbss					= "TSbss";
const SigO_TSf						= "TSf";
const SigO_TSi						= "TSi";
const SigO_TSnfbff					= "TSnfbff";
const SigO_TSSss					= "TSSss";
const Sig_XXX						= "X";					// no args (parser will make sure nothing after command)

const TextGotoLabel					= "gotolabel";			// gotolabel command string literal
const TextCall						= "call";				// call command string literal
const TextInterrupt					= "interrupt";			// interrupt command string literal

const DefaultPropertyString			= "default";
const PlayerSpeakerString			= "player";				// speaker string of the player
const SelfSpeakerString				= "self";				// used to impley npc is talking by himself

const SpecialStateAgentInput		= 'SpecialState';		// agent input that, when bound, locks the agent

const TargetControllerName			= 'controller';			// the controlled NPC's controller
const TargetEventInstigatorName	 	= 'eventinstigator';	// instigator for most recent event (if applicable)
const TargetEventOtherName			= 'eventother';			// other for most recent event (if applicable)
const TargetFoundName				= 'found';				// actor found in previous call to FindActor
const TargetPawnName				= 'pawn';				// the controlled NPC's pawn
const TargetPlayerName				= 'player';				// the player
const TargetSelfName				= 'self';				// the script controller itseld (mainly for accessing scratch variables)

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

const MsgBadOrMissingArgument		= "bad or missing parameter";
const MsgBadOrMissingLabel			= "bad or missing label";
const MsgBadOrMissingLabelIndex		= "bad or missing label index";
const MsgCallInterruptReturnError	= "mismatched call/return or interrupt/return error";	// extra junk after last valid argument
const MsgGotoLabelInterruptError	= "bad or missing gotolabel/interrupt";
const MsgInternalErrorSignature		= "internal errors -- bad function signature";
const MsgInvalidArgument			= "invalid argument";									// extra junk after last valid argument
const MsgInvalidArgumentExtra		= "invalid extra argument";								// extra junk after last valid argument
const MsgInvalidCommand				= "invalid command (u2s commands should be all lower-case)";
const MsgInvalidCommandListIndex	= "invalid command list index";
const MsgInvalidEventName			= "invalid event name";
const MsgInvalidOrders 				= "invalid orders (error setting NPC orders)";
const MsgInvalidOrderGiver			= "invalid order giver";
const MsgInvalidOrdersObject		= "invalid orders object";
const MsgInvalidOrdersNotSupported  = "invalid orders (given orders not currently supported)";
const MsgScriptInitError			= "error initializing commands!";
const MsgScriptLoadError			= "error loading commands!";
const MsgTargetFindError			= "can't find given target";
const MsgTargetVerifyError			= "internal error - CommandTarget not set while executing commnand";

const CommandsListIndex_Error		= -999;
const CommandsListIndex_Label		=  999;
const CommandsListIndex_Stop		=   -1;

const ResumePatrolBest  			= 'best';
const ResumePatrolClosest			= 'closest';
const ResumePatrolRandom			= 'random';
const ResumePatrolSaved  			= 'saved';

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

enum ECommandCode				// operands									action
{																			
CMD_None,						//											error
CMD_Label,						//											label
CMD_AddAmmo,					// ammostring amount [maxclip]				gives N units of specified ammo to NPC, if maxclip=1 makes sure clip is as full as possible
CMD_AgentBind,					// inputname valuename						sets and locks an agent input to a given value, for characters with agent-driven meshes
CMD_AgentCall,					// actionname [wait]						calls an agent action of the given name, for characters with agent-driven meshes
CMD_AgentExecute,				// actiontext [wait]						compiles and executes a GAL string on-the-fly as if were inside an action, and calls it
CMD_AgentUnbind,				// inputname								unlocks an agent input previously locked and set with AgentBind
CMD_AnimLoop,					// name [rate tweentime [wait]]				loops specified anim on channel 0
CMD_AnimLoopEx,					// channel name [rate tweentime [wait]]		loops specified anim on arbitrary channel
CMD_AnimPlay,					// name [rate tweentime	[wait]]				plays specified anim on channel 0
CMD_AnimPlayEx,					// channel name [rate tweentime [wait]]		plays specified anim on arbitrary channel
CMD_AnimRelease,				// 											allow NPC to control anims (currently idle only)
CMD_AnimTween,					// name [tweentime [wait]]					tweens specified anim on channel 0
CMD_AnimTweenEx,				// channel name [tweentime [wait]]			tweens specified anim on arbitrary channel
CMD_Call,						// label									pushes line after current one and jumps to given label
CMD_CallScript,					// scriptname								pushes current script state and switches to specified file
CMD_CallEnd,  					// 											aborts any previously pushed call (can no longer return)
CMD_ClearEvents,  				// 											clears any current onevents 
CMD_ClearTimers,  				// 											clears any current general timers 
CMD_ClearTriggers,				// 											clears any current ontriggers
CMD_ConsoleCommand,  			// command									executes given console command
CMD_DebugAI,					// 0/1										enables/disables debug AI mode in controlled NPC
CMD_DebugAIEvents,				// 0/1										enables/disables debug events mode in controlled NPC
CMD_DebugAIFlags,				// ###										explicitely sets debug AI flags in controlled NPC
CMD_DebugMode,					// flags									enables/disables various debug modes for the script controller
CMD_DecProperty,				// name property value [#]					decrements (integer) property in named actor by 1 or by #
CMD_DeployInventory,			// S [1]									deploy given inventory item [alt deploy it]
CMD_Destroy,					// 											destroy controlled NPC (and controller)
CMD_DialogDisable,				// topicname								disable this dialog node
CMD_DialogEnable,				// topicname								enable this dialog node
CMD_DialogFar,					// topicname speaker1 [speaker2]			starts dialog b/w 2 npcs regardless of distance
CMD_DialogFarWait,				// topicname speaker1 [speaker2]			waits for dialog b/w 2 npcs to finish
CMD_DialogInitiate,				// speaker topicname						tries to initiate given dialog with given target
CMD_DialogTerminate,			// speaker									tries to remove NPC from dialog
CMD_DirectionalPatrol,			// 0/1										whether NPC faces in direction of patrol destination
CMD_Dormant,					// 0/1 [1]									toggle whether NPC (Pawn and Controller) is dormant (bStasis=true and Physics=PHYS_None) [1] means stay dormant even if script removed?
CMD_DropInventory,				// S										drop given inventory item
CMD_EnableProbeEvent,			// probename 0|1							enables/disables NPC probe event (for performance) e.g. enableprobeevent seeplayer 0 -> no more seeplayer events
CMD_EnableXMPHandling,			// 0/1										enables/disables NPC reacting to XMP items (inert 0/1 sets this to 1/0 use enablexmphandling 0/1 to override this).
CMD_Error,						//											used internally
CMD_EventDisable,				// event									disables event
CMD_EventEnable,				// event									enables event
CMD_EventWait,					// event									waits until event occurs 
CMD_FindActor,					// [name Min Max Type Vis Num gotolabel targetlabel] searches for actors in level (all args optional)
CMD_Fire,						// [duration]								fire (weapon / animation-based) for given duration
CMD_FireAlt,					// [duration]								alt fire (weapon / animation-based) for given duration
CMD_Gib,						// [bDestroy] [gorelevel]					gib controlled NPC. If gib fails, bDestroy determines if npc is killed or destroyed. Gore level overrides the gibset's default gore level
CMD_GibAll,						// targetclass [bDestroy] [gorelevel]		gib all actors of the given class. . If gib fails, bDestroy determines if npc is killed or destroyed. Gore level overrides the gibset's default gore level
CMD_GiveInventory,				// inventorystring							gives the specified inventory item to the NPC
CMD_GiveItemToPlayer,			// inventorystring [ammocount]				give item to player, if ammocount treats as ammo and adds this much ammo to player's inventory
CMD_GiveTossedItem,				// inventorystring							add item to tossed items list
CMD_GotoActor,					// targetname [dist [face]]					sends NPC to specifed actor at specified dist (error if target not found), face=1 ==> try to face target (e.g. for initiating dialog)
CMD_GotoActorSafe,				// targetname [dist [face]]					sends NPC to specifed actor at specified dist (not an error if target not found), face=1 ==> try to face target (e.g. for initiating dialog)
CMD_GotoLabel,					// label									jumps to given label
CMD_IncProperty,				// name property value [#]					increments (integer) property in named actor by 1 or by #
CMD_Inert,						// 0/1										toggles NPC reacting to sensory input -- shorthand for toggling bump, hearnoise, seeplayer, tookdamage
CMD_HandlerGroup,				// 											denotes start of a new handler groups (can't be in one currently?)
CMD_HandlerGroupEnd,			// 											denotes end of a new handler groups (must be in one currently)
CMD_HeadTracking,				// 0/1
CMD_Jump,						// X Y Z									launch NPC in given direction
CMD_Kill,						// 											kill controlled NPC (goes into dying state)
CMD_KillAll,					// targetclass								kill all actors of the given class
CMD_LockStep,					// name [f]									maintain given or current distance from named actor (for keeping squads in formation)
CMD_Message,					// string [0|1|2]							displays the given message in-game (surround with "" for multiple words) 0: onscreen 1: log 2: onscreen and log
CMD_OnEvent,					// xxx [gotolabel ### [clear]]				when event xxx occurs, jumps to given label (or disables previous onevent)
CMD_OnTimer,					// index [delay repeat gotolabel ###]		adds a general-purpose timer
CMD_OnTrigger,					// name [gotolabel ###]						when trigger with given event name occurs, jumps to given label (or disables previous ontrigger)
CMD_PlaySound,					// name sound [slot [volume [bNoOverride [Radius [Pitch]]]]]	plays sound through named actor (or self=controlled NPC)
CMD_PlaySoundWait,				// name sound [slot [volume [bNoOverride [Radius [Pitch]]]]]	plays sound through named actor (or self=controlled NPC) and script waits for sound to finish
CMD_PlaySoundTableSlot,			// name slot								play sound belonging to the specified group from named pawn's sound table
CMD_PlaySoundTableSlotWait,		// name slot								play sound belonging to the specified group from named pawn's sound table and script waits for sound to finish
CMD_RemoveInventory,			// [string]									removes all [or the specified] inventory from the NPC
CMD_RemoveInventoryFromPlayer,	// [string]									removes all [or the specified] inventory from the player
CMD_RemoveItemFromPlayer,		// inventorystring							add item to player's inventory
CMD_RemoveTossedItem,			// inventorystring							remove item from tossed items list
CMD_ResumePatrol,				// startlabel endlabel						finds the "best" destination at which the resume patrolling and jumps to that line
CMD_Return,						//      									returns to most recently pushed line or script state (error if no applicable)
CMD_Rotate,						// #.#										rotate #.# degrees clockwise (right) relative to forward
CMD_SaveDestination,			// 											copies GotoActorTarget into SavedDestination for later use with resumepatrol
CMD_SendEvent,  				// EventName [triggerpawns]	triggers all Actors with tag that matches given Event, or all NPCs
CMD_SetActorRangeTest,			// target distance							sets the InRangeActor and InRangeDistance for ActorInRange/ActorOutOfRange events
CMD_SetAimOdds,					// odds										sets odds of hitting target when firing weapon under script control
CMD_SetAlert,					// 0/1										controls whether NPC uses "alert" animations
CMD_SetAmmo,					// ammostring amount [maxclip]				makes sure NPC has exactly specified amount of given type of ammo, if maxclip=1 makes sure clip is as full as possible
CMD_SetFocus,					// [name]									set scripted focus to given actor or clear focus
CMD_SetHealth,					// x.x										sets controlled NPC's health to x.x
CMD_SetInventory,				// targetname inventorystring				sets target's selected inventory to x.x
CMD_SetLocation,				// locationname [allowfail]					move pawn to location of locationame
CMD_SetLocationNamed,			// targetname locationname [allowfail]		move actor matching targetname to location of locationame
CMD_SetLocationVector,			// targetname X Y Z							move targetname to given coordinates
CMD_SetMoveSpeed,				// speed [stance]							0.01 to MaxDesiredSpeed (usually 1.0) -- set speed used for scripted movement
CMD_SetMoveSpeedAuto,			// speed									0.01 to MaxDesiredSpeed (usually 1.0) -- set speed used for autonomous movement
CMD_SetOrders,					// orders [OrdersObject [fparam [ordergiver]]] sets/clears orders
CMD_SetPhysics,					// physics
CMD_SetProperty,				// targetname property value  				sets property in named actor to value
CMD_SetProperties,				// classname property value  				sets given property in all actors which are a classname
CMD_SetSatellite,				// satellitename [targetname]				binds a mesh satellite node of the given name to the given target, for dynamic animations
CMD_SetScript,					// filename [startlabel]					switches over to the given script [at the given label]
CMD_SetSkill,					// skill									set NPC's skill to given value (0.0..1.0)
CMD_SetStance,					// stand / crouch / prone					specifies stance that NPC should use while patrolling
CMD_SetStationary,				// 1/0 [1]									makes NPC immobile/mobile, optionally forever
CMD_SetTacticalMoveType,		// 0/1/2									sets tactical move type to use during scripted movement (0: none 1: basic 2: serpentine)
CMD_SetWeapon,					// weaponstring								set NPC's weapon to specified one, spawning it if necessary
CMD_Shutdown,					// 1/0										makes NPC as inert as possible without actually making it dormant or removing its controller
CMD_Sleep,  					// [x.x]   									puts controller to sleep for x.x seconds (defaults to "forever")
CMD_SleepRand,					// [x.x]									puts controller to sleep for random time in 0..x.x seconds (x.x defaults to 1.0)
CMD_Spawn,						// targetname S	[1 [filename [startlabel]]]	spawn given actor at targetname's location, if 1 is given, failure = error, optionally gives spawned NPCs a script
CMD_Stop,						// 											stops execution, detaches script controller
CMD_StopMovement,				// 											stops NPC movement
CMD_StopSound,					// slot	[bStopNoOverrideSounds]				stops any sounds played through the named actor on the specified sound slot
CMD_TestActorInRange,			// name distance							if given actor is outside given distance of pawn ==> next command skipped
CMD_TestProperty,				// name property value  					property != value ==> next command skipped (string comparison)
CMD_TestPropertyCI,				// name property value  					property != value ==> next command skipped (case-insensitive string comparison)
CMD_TestPropertyE,				// name property value  					property != value ==> next command skipped (numerical comparison)
CMD_TestPropertyG,				// name property value  					property <= value ==> next command skipped (numerical comparison)
CMD_TestPropertyGE,				// name property value  					property <  value ==> next command skipped (numerical comparison)
CMD_TestPropertyL,				// name property value  					property >= value ==> next command skipped (numerical comparison)
CMD_TestPropertyLE,				// name property value  					property >  value ==> next command skipped (numerical comparison)
CMD_TestRandom,					// float									(if random number in 0.0..1.0 > value ==> next command skipped)
CMD_TestState,					// name name								(false ==> next command skipped)
CMD_TurnToActor,				// targetname [LOS [Lock]]					turn NPC to face named actor, LOS=0 ==> LOS not needed, LOS=1 ==> LOS needed, LOS=2 ==> LOS not needed but turn anyway, Lock means target actor won't be cleared
CMD_Unuse,						// name										unuse the named actor
CMD_Use,						// name										use the named actor
CMD_UsePickups,					// 0/1										if 0, won't go after or pickup pickups
CMD_WeaponLoad,					//											load current weapon
CMD_WeaponSetAmmoType,			// ammoname
CMD_WeaponSupportsAltFire,		// weaponname 0/1							disables/enables NPC being able to alt fire weapon
CMD_WeaponSupportsFire,			// weaponname 0/1							disables/enables NPC being able to primary fire weapon
};

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

// for holding parsed arguments:
var byte	ArgsByte[MaxArgsByte];								// UC doesn't support arrays of bools -- bools use bytes
var float	ArgsFloat[MaxArgsFloat];
var int		ArgsInt[MaxArgsInt];   
var name	ArgsName[MaxArgsName];  
var string	ArgsString[MaxArgsString];
var int		ArgsLabel[MaxArgsLabel];

//-----------------------------------------------------------------------------
// scratch variables (used with set/get/inc/dec property for loop control, 
// conditional branching etc.)?

var int		Int1, Int2, Int3, Int4, Int5, Int6, Int7, Int8, Int9;
var bool	Bool1, Bool2, Bool3, Bool4, Bool5, Bool6, Bool7, Bool8, Bool9;

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

var string ScriptErrorMessage;									// last error message

// vars for decoded command
var int		CurrentCommandIndex;								// index of current command
var int		DecodedCount;										// count of total number of commands decoded so far

var() globalconfig int DebugMode;								// script debug mode (use debugmode command or unreal.ini to enable)
var() globalconfig float ErrorMessageFrequency;

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

// used for CommandInfo list (list of available commands)
struct native CommandInfoT	
{
	var string CommandString;
	var ECommandCode CommandCode;
	var string Signature;
};

var() const CommandInfoT CommandInfo[ MaxCommandInfoEntries ];	// list of commands (token string/code pairs, command signatures)

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

struct native CommandT
{			 
	var string CommandString;		// command string
	var int CommandIndex;			// index into Commands list (stored so don't have to extract from command string each time)
	var Object CommandTarget;		// command target (stored if possible so don't have to extract/find each time)
};

var CommandT CurrentCommand;		// current command

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

struct native EventT
{
	var name  EventName;										// event name...
	var name  EventWaitState;									// state to use when waiting for the event
	var bool  bEnabled;		  									// event is enabled (default)
	var bool  bCanToggle;										// event can be enabled/disabled (false ==> always enabled)
	var int   OnCmdIndex;										// index to handler (line # after stripping comments)
	var bool  bClear;											// whether to clear handler when event arrives
	var int	  Group;											// group event handler belongs to
	var bool  bInterrupt;										// whether to execute gotolabel (false) or interrupt (true)
};
var() EventT Events[MaxEvents];									// list of events (string/name/waitstatename)
var int NumEvents;												// number of events
																
struct native TimerT
{																
	var float InitialFrequency;
	var float RepeatFrequency;	
	var int   TriggerIndex;										// index of assosiated trigger event for trigger timers
	var int   OnCmdIndex;									
	var int	  Group;											// group event handler belongs to
	var bool  bInterrupt;										// whether to execute gotolabel (false) or interrupt (true)
};																
var() TimerT Timers[MaxTimers];									// timer list (ontimer and ontrigger timers -- ontrigger timers use bottom of list)

struct native TriggerEventT
{
	var name  EventName;
	var int   OnCmdIndex;
	var bool  bClear;											// whether to clear trigger handler when event arrives
	var int   TimerIndex;										// index of associated timer, -1 if none
	var int	  Group;											// group event handler belongs to
	var bool  bInterrupt;										// whether to execute gotolabel (false) or interrupt (true)
};

var() TriggerEventT TriggerEvents[ MaxTriggerEvents ];			// list of trigger events which are being tracked (for "ontrigger xxx gotolable yyy" or "waitevent trigger xxx")
var int NumTriggerEvents;										// number of events currently in list (which is kept packed but not sorted)

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

var int NumPushedCommandIndices;
var int PushedCommandIndices[ MaxPushedCommandIndices ];

/*-----------------------------------------------------------------------------
Actor references. The CommandTarget in any CommandT structs can also refer
to actors. 
*/

var Actor FoundActors[ UtilGame.MaxFilteredActors ];
var Actor SavedEventInstigator;
var Actor SavedEventOther;
var protected Actor GotoActorTarget;
var protected Actor DialogTarget;
var protected Actor SavedDestination; // copy of GotoActorTarget (used with savedestination command)

var int	NumFoundActors;

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

var() string CommandFileName;									// name of file with commands
var() string StartLabelName;									// optional label to start at instead of top of script

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

var protected name WaitTriggerEvent;

//-----------------------------------------------------------------------------
// event enabling/disabling

// indices into Events table for locating corresponding bEnabled flag
var int ActorInRangeIndex;
var int ActorOutOfRangeIndex;
var int AnimEndIndex;
var int AutoBeginIndex;
var int AutoEndIndex;
var int BumpEnemyIndex;
var int BumpFriendIndex;
var int BumpOtherIndex;
var int BumpPlayerIndex;
var int DialogBeginIndex;
var int DialogUnPauseIndex;
var int DiedIndex;
var int EnemyNotVisibleIndex;
var int HearNoiseFriendlyIndex;
var int HearNoiseOtherIndex;
var int HearNoiseThreatIndex;
var int InheritEnemyIndex;
var int ScriptedLandingIndex;
var int SeeAlertFriendIndex;
var int SeeEnemyIndex;
var int SeeFriendIndex;
var int SeeOtherIndex;
var int SeePlayerIndex;
var int TakeDamageIndex;
var int TookDamageIndex;
var int TookDamageEnemyIndex;
var int TookDamageFriendIndex;
var int TriggerIndex;

// handler groups
var int CurrentHandlerGroup;
var int NextHandlerGroupIndex;
var bool bInHandlerGroup;
var bool bXMPHandlingEnabled;

// set once Initialized
var protected U2NPCControllerScriptable NPCOwner;
var protected U2Pawn U2PawnOwner;

var array<CommandT> Commands;

//-----------------------------------------------------------------------------
// native functions

native function bool LoadCommandsFromFile( string FileName, LevelInfo Level );	// returns false on error (bad labels etc.)

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

function ResumeProcessing();

//=============================================================================
// event handling functions
//=============================================================================

function int FindEvent( name EventName )
{
	local int Index;

	Index = 0;
	while( Index < NumEvents && !(Events[Index].EventName == EventName) )
		Index++;
	
	if( Index >= NumEvents )
		Index = -1;

	return Index;
}

//-----------------------------------------------------------------------------
// debug help

function DumpTriggers()
{
	local int Index;

	NPCOwner.DMTNS( "NumTriggerEvents: " $ NumTriggerEvents );
	for( Index=0; Index<NumTriggerEvents; Index++ )
		NPCOwner.DMTNS( "  TriggerEvents # " $ Index $ ": " $ TriggerEvents[Index].EventName $ " Line: " $ TriggerEvents[Index].OnCmdIndex );
}

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

function int FindTrigger( name EventName )
{
	local int Index;

	//NPCOwner.DMTNS( "FindTrigger:      " $ EventName );
	//DumpTriggers();

	// look for trigger name in table
	Index = 0;
	while( Index < NumTriggerEvents && TriggerEvents[Index].EventName != EventName )
		Index++;

	if( Index >= NumTriggerEvents )
		Index = -1;

	return Index;
}

//-----------------------------------------------------------------------------
// Can be called with TriggerIndex = -1 (e.g. if trigger was already disabled).

function ClearTrigger( int TriggerIndex, bool bClearTimer )
{
	local int Index;

	//NPCOwner.DMTNS( "ClearTrigger -- TriggerIndex: " $ TriggerIndex $ " NumTriggerEvents: " $ NumTriggerEvents );

	if( TriggerIndex != -1 )
	{
		// mdf-tbr:?
		//NPCOwner.DMTNS( "TriggerEvents[ TriggerIndex ].EventName:  " $ TriggerEvents[ TriggerIndex ].EventName );
		//NPCOwner.DMTNS( "TriggerEvents[ TriggerIndex ].OnCmdIndex:	" $ TriggerEvents[ TriggerIndex ].OnCmdIndex );
#debugbegin		
		NPCOwner.DMAssert( NumTriggerEvents >= 1, "ClearTrigger #1" );
		NPCOwner.DMAssert( TriggerEvents[ TriggerIndex ].EventName != '', "ClearTrigger #2" );
		NPCOwner.DMAssert( TriggerEvents[ TriggerIndex ].OnCmdIndex != -1, "ClearTrigger #3" );
#debugend

		TriggerEvents[ TriggerIndex ].EventName = '';
		TriggerEvents[ TriggerIndex ].OnCmdIndex = -1;

		if( bClearTimer && TriggerEvents[ TriggerIndex ].TimerIndex != -1 )
		{
			HandleRemoveTimer( TriggerEvents[ TriggerIndex ].TimerIndex, false );
			TriggerEvents[ TriggerIndex ].TimerIndex = -1;
		}

		// move rest of list up so it remains packed
		for( Index=TriggerIndex; Index<NumTriggerEvents-1; Index++ )
			TriggerEvents[ Index ] = TriggerEvents[ Index+1 ];

		NumTriggerEvents--;
	}
	else
	{
		// mdf-tbr?:
		if( NumTriggerEvents <= 0 )
			NPCOwner.DM( "Warning -- ClearTrigger called with NumTriggerEvents = " $ NumTriggerEvents $ " is this OK?" );
	}
}

//-----------------------------------------------------------------------------
// debug

function DumpTimers()
{
	local int Index;

	for( Index=0; Index<MaxGeneralTimers; Index++ )
		NPCOwner.DMTNS( "  Timer # " $ Index $ ": " $ " Frequency: " $ Timers[Index].InitialFrequency $ " / " $ Timers[Index].RepeatFrequency $ " Line: " $ Timers[Index].OnCmdIndex );

	for( Index=MaxGeneralTimers; Index<MaxTimers; Index++ )
		NPCOwner.DMTNS( "  TriggerTimer # " $ Index $ ": " $ " Frequency: " $ Timers[Index].InitialFrequency $ " Name: " $ Timers[Index].TriggerIndex $ " Line: " $ Timers[Index].OnCmdIndex );
}

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

function bool GetEventIndex( name EventName, out int Index )
{
	Index = FindEvent( EventName );
	if( Index == -1 )
		SetScriptError( "Invalid event name: " $ EventName );

	return (Index != -1);
}

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

function SetEventIndex( name EventName, out int EventIndex )
{
	EventIndex = FindEvent( EventName );

	if( EventIndex == -1 )
		Log( "Warning -- error setting EventIndex for " $ EventName );
}	

//-----------------------------------------------------------------------------
// Note: can't use DestinationReached in scripts -- its used implicitely by
// gotoactor etc.

function InitEventsIndices()
{
	local int EventIndex;

	NumEvents=0;
	for( EventIndex=0; EventIndex<MaxEvents && Events[EventIndex].EventName != ''; EventIndex++ )
		NumEvents++;

	SetEventIndex( ActorInRangeEvent,		ActorInRangeIndex );
	SetEventIndex( ActorOutOfRangeEvent,	ActorOutOfRangeIndex );
	SetEventIndex( AnimEndEvent,			AnimEndIndex );
	SetEventIndex( AutoBeginEvent,			AutoBeginIndex );
	SetEventIndex( AutoEndEvent,			AutoEndIndex );
	SetEventIndex( BumpEnemyEvent,			BumpEnemyIndex );
	SetEventIndex( BumpFriendEvent,			BumpFriendIndex );
	SetEventIndex( BumpOtherEvent,			BumpOtherIndex );
	SetEventIndex( BumpPlayerEvent,			BumpPlayerIndex );
	SetEventIndex( DialogBeginEvent,		DialogBeginIndex );
	SetEventIndex( DialogUnPauseEvent,		DialogUnPauseIndex );
	SetEventIndex( DiedEvent,				DiedIndex );
	SetEventIndex( EnemyNotVisibleEvent,	EnemyNotVisibleIndex );
	SetEventIndex( HearNoiseFriendlyEvent,	HearNoiseFriendlyIndex );
	SetEventIndex( HearNoiseOtherEvent,		HearNoiseOtherIndex );
	SetEventIndex( HearNoiseThreatEvent,	HearNoiseThreatIndex );
	SetEventIndex( InheritEnemyEvent,		InheritEnemyIndex );
	SetEventIndex( ScriptedLandingEvent,	ScriptedLandingIndex );
	SetEventIndex( SeeAlertFriendEvent,		SeeAlertFriendIndex );
	SetEventIndex( SeeEnemyEvent,			SeeEnemyIndex );
	SetEventIndex( SeeFriendEvent,			SeeFriendIndex );
	SetEventIndex( SeeOtherEvent,			SeeOtherIndex );
	SetEventIndex( SeePlayerEvent,			SeePlayerIndex );
	SetEventIndex( TakeDamageEvent,			TakeDamageIndex );
	SetEventIndex( TookDamageEvent,			TookDamageIndex );
	SetEventIndex( TookDamageEnemyEvent,	TookDamageEnemyIndex );
	SetEventIndex( TookDamageFriendEvent,	TookDamageFriendIndex );
	SetEventIndex( TriggerEvent,			TriggerIndex );
}

//-----------------------------------------------------------------------------
// Called when an onevent or ontrigger event comes in which has a label to jump
// to associated with it.

function HandleOnEvent( int NewCommandIndex, optional bool bInterrupt )
{
	//NPCOwner.DMTNS( "HandleOnEvent: " $ NewCommandIndex );

	if( bInterrupt )							// onevent XXX interrupt YYY
		DoInterrupt( NewCommandIndex );
	else
		DoGoto( NewCommandIndex );				// onevent XXX gotolabel YYY

	GotoState( ExecuteCommandsState );
}

//-----------------------------------------------------------------------------
// Disable any onevent/ontimer/ontrigger handlers in same group as the given
// one. We assume that the initiating event/timer/trigger has already been
// handled prior to calling this function (tbd: support keeping the initiating
// event/timer/trigger?).

function ClearHandlers( int Group )
{
	local int ii;

	if( Group != 0 )
	{
		// clear matching triggers
		ii = 0;
		while( ii < NumTriggerEvents )
		{
			if( TriggerEvents[ ii ].Group == Group )
			{
				ClearTrigger( ii, true ); // this will shift list down
			}
			else
			{
				ii++;
			}
		}
	
		for( ii=0; ii<MaxGeneralTimers; ii++ )
		{
			if( Timers[ ii ].Group == Group && Timers[ ii ].OnCmdIndex != -1 )
				HandleRemoveTimer( ii, true );
		}
	
		for( ii=0; ii<NumEvents; ii++ )
		{
			if( Events[ ii ].Group == Group && Events[ ii ].OnCmdIndex != -1 )
			{
				// don't disable the event -- just disconnect the handler
				Events[ ii ].OnCmdIndex = -1;
				Events[ ii ].Group = 0;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// A .u2s can specify "onevent xxx gotolabel yyy" so that when event xxx occurs,
// the script controller will begin processing commands starting at the line after
// the given label yyy.
//
// A .u2s can also specify "onevent xxx interrupt zzz" so that when event xxx occurs
// the script controller will process the commands at label zzz until a return is
// reached.  Processing will then resume by re-executing the line that was executing
// at the time the event occurred, hence the name "interrupt".
//
// Returns true if event is being handled (active onevent xxx).

function bool CheckForOnCmdIndex( int EventIndex )
{
	local bool bResult;

	if( Events[EventIndex].OnCmdIndex >= 0 )
	{
		//DMSC( "IndexOnCmdIndex: " $ Events[EventIndex].OnCmdIndex );
		HandleOnEvent( Events[EventIndex].OnCmdIndex, Events[EventIndex].bInterrupt );

		if( Events[EventIndex].bClear )
		{
			// this was a one-time only event handler -- clear it
			Events[EventIndex].OnCmdIndex = -1;	// disable onevent
			Events[EventIndex].bClear = false;	// and make sure bClear is set back to default
		}

		// make sure that any handlers in the same group are disabled
		ClearHandlers( Events[EventIndex].Group );

		bResult = true;
	}

	return bResult;
}

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

function DoPreEventStuff( U2NPCControllerScriptable NPC, int EventIndex, optional Actor Instigator, optional Actor Other )
{
	if( (DebugMode & Debug_Events) != 0 )
		DMSC( GetCommandFile() $ DefaultExt $ " (EVENT) " $ Events[EventIndex].EventName $ ": EventInstigator=" $ Instigator $ ": EventOther=" $ Other );

	// squirrel these away in case script wants to use them
	SavedEventInstigator = Instigator;
	SavedEventOther = Other;

	if( NPC.DebugAIEvents() ) 
		NPC.DMT( Events[EventIndex].EventName $ ": " $ byte(Events[EventIndex].bEnabled && !NPC.bStasis) $ "," $ Events[EventIndex].OnCmdIndex $ " " $ GetScriptContextStr() );
}

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

function DoPostEventStuff( U2NPCControllerScriptable NPC, int EventIndex )
{
	CheckForOnCmdIndex( EventIndex );
}

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

function eventSCActorInRange( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, ActorInRangeIndex );
	DoPostEventStuff( NPC, ActorInRangeIndex );
}

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

function eventSCActorOutOfRange( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, ActorOutOfRangeIndex );
	DoPostEventStuff( NPC, ActorOutOfRangeIndex );
}

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

function eventSCAnimEnd( U2NPCControllerScriptable NPC, int Channel )
{
	// mdf-tbd: don't show AnimEnd events (too much spam)
	// DoPreEventStuff( NPC, AnimEndIndex );
	DoPostEventStuff( NPC, AnimEndIndex );
}

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

function eventSCAutoBegin( U2NPCControllerScriptable NPC, name DestinationState, name DestinationLabel )
{
	DoPreEventStuff( NPC, AutoBeginIndex );
	if( Events[AutoBeginIndex].bEnabled )
		NPC.eventAutoBegin( DestinationState, DestinationLabel );

	if( Events[AutoBeginIndex].OnCmdIndex >= 0 )
	{
		DoPostEventStuff( NPC, AutoBeginIndex );
	}
	else if( Events[AutoBeginIndex].bEnabled )
	{
		// autobegin isn't disabled and there is no autobegin handler so detach the script controller
		DetachScriptController();
	}
}

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

function eventSCAutoEnd( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, AutoEndIndex );
	// always enabled, never passed back to NPC
	DoPostEventStuff( NPC, AutoEndIndex );
}

//-----------------------------------------------------------------------------
// Not a real event -- generated internally by BumpEnemy/Friend and passed back
// to NPC as BumpEnemy/Friend if not filtered. Returns true if event handled.

function bool eventSCBumpPlayer( U2NPCControllerScriptable NPC, Pawn Other, bool bFriendly )
{
	DoPreEventStuff( NPC, BumpPlayerIndex, Other );
	if( Events[BumpPlayerIndex].bEnabled )
	{
		if( bFriendly )
			NPC.eventBumpFriend( Other );
		else
			NPC.eventBumpEnemy( Other );
	}
	return CheckForOnCmdIndex( BumpPlayerIndex );
}

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

function eventSCBumpEnemy( U2NPCControllerScriptable NPC, Pawn Other )
{
	if( Other.IsRealPlayer() )
	{
		if( !eventSCBumpPlayer( NPC, Other, false ) )
			DoPostEventStuff( NPC, BumpEnemyIndex );
	}
	else
	{
		DoPreEventStuff( NPC, BumpEnemyIndex, Other );
		if( Events[BumpEnemyIndex].bEnabled || (bXMPHandlingEnabled && StationaryPawn(Other) != None))
			NPC.eventBumpEnemy( Other );
		DoPostEventStuff( NPC, BumpEnemyIndex );
	}
}

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

function eventSCBumpFriend( U2NPCControllerScriptable NPC, Pawn Other )
{
	if( Other.IsRealPlayer() )
	{
		if( !eventSCBumpPlayer( NPC, Other, true ) )
			DoPostEventStuff( NPC, BumpEnemyIndex );
	}
	else
	{
		DoPreEventStuff( NPC, BumpFriendIndex, Other );
		if( Events[BumpFriendIndex].bEnabled )
			NPC.eventBumpFriend( Other );
		DoPostEventStuff( NPC, BumpFriendIndex );
	}
}

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

function eventSCBumpOther( U2NPCControllerScriptable NPC, Actor Other )
{
	DoPreEventStuff( NPC, BumpOtherIndex, Other );
	if( Events[BumpOtherIndex].bEnabled )
		NPC.eventBumpOther( Other );
	DoPostEventStuff( NPC, BumpOtherIndex );
}

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

function eventSCDialogBegin( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, DialogBeginIndex );
	DoPostEventStuff( NPC, DialogBeginIndex );
}

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

function eventSCDied( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, DiedIndex );
	DoPostEventStuff( NPC, DiedIndex );
}

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

function eventSCEnemyNotVisible( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, EnemyNotVisibleIndex );
	if( Events[EnemyNotVisibleIndex].bEnabled )
		NPC.eventEnemyNotVisible();
	DoPostEventStuff( NPC, EnemyNotVisibleIndex );
}

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

function eventSCHearNoiseFriendly( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
{
	DoPreEventStuff( NPC, HearNoiseFriendlyIndex, NoiseMaker.Instigator, NoiseMaker );
	if( Events[HearNoiseFriendlyIndex].bEnabled )
		NPC.eventHearNoiseFriendly( Loudness, NoiseMaker );
	DoPostEventStuff( NPC, HearNoiseFriendlyIndex );
}

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

function eventSCHearNoiseOther( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
{
	DoPreEventStuff( NPC, HearNoiseOtherIndex, NoiseMaker.Instigator, NoiseMaker );
	if( Events[HearNoiseOtherIndex].bEnabled )
		NPC.eventHearNoiseOther( Loudness, NoiseMaker );
	DoPostEventStuff( NPC, HearNoiseOtherIndex );
}

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

function eventSCHearNoiseThreat( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
{
	DoPreEventStuff( NPC, HearNoiseThreatIndex, NoiseMaker.Instigator, NoiseMaker );
	if( Events[HearNoiseThreatIndex].bEnabled || (bXMPHandlingEnabled && StationaryPawn(NoiseMaker) != None) )
		NPC.eventHearNoiseThreat( Loudness, NoiseMaker );
	DoPostEventStuff( NPC, HearNoiseThreatIndex );
}

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

function eventSCInheritEnemy( U2NPCControllerScriptable NPC, Pawn NewEnemy )
{
	DoPreEventStuff( NPC, InheritEnemyIndex );
	if( Events[InheritEnemyIndex].bEnabled )
		NPC.eventInheritEnemy( NewEnemy );
	DoPostEventStuff( NPC, InheritEnemyIndex );
}

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

function eventSCScriptedLanding( U2NPCControllerScriptable NPC )
{
	DoPreEventStuff( NPC, ScriptedLandingIndex );
	DoPostEventStuff( NPC, ScriptedLandingIndex );
}

//-----------------------------------------------------------------------------
// Not a real event -- generated internally by SeeEnemy/Friend and passed back
// to NPC as SeeEnemy/Friend if not filtered. Returns true if event handled.

function bool eventSCSeePlayer( U2NPCControllerScriptable NPC, Pawn Seen, bool bFriendly )
{
	DoPreEventStuff( NPC, SeePlayerIndex, Seen );
	if( Events[SeePlayerIndex].bEnabled )
	{
		if( bFriendly )
			NPC.eventSeeFriend( Seen );
		else
			NPC.eventSeeEnemy( Seen );
	}
	return CheckForOnCmdIndex( SeePlayerIndex );
}

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

function eventSCAlertFriend( U2NPCControllerScriptable NPC, Pawn Seen )
{
	DoPreEventStuff( NPC, SeeAlertFriendIndex, Seen );
	if( Events[SeeAlertFriendIndex].bEnabled )
		NPC.eventSeeAlertFriend( Seen );
	DoPostEventStuff( NPC, SeeAlertFriendIndex );
}

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

function eventSCSeeEnemy( U2NPCControllerScriptable NPC, Pawn Seen )
{
	if( Seen.IsRealPlayer() )
	{
		if( !eventSCSeePlayer( NPC, Seen, false ) )
			DoPostEventStuff( NPC, SeeEnemyIndex );
	}
	else
	{
		DoPreEventStuff( NPC, SeeEnemyIndex, Seen );
		if( Events[SeeEnemyIndex].bEnabled || (bXMPHandlingEnabled && StationaryPawn(Seen) != None) )
			NPC.eventSeeEnemy( Seen );
		DoPostEventStuff( NPC, SeeEnemyIndex );
	}
}

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

function eventSCSeeFriend( U2NPCControllerScriptable NPC, Pawn Seen )
{
	if( Seen.IsRealPlayer() )
	{
		if( !eventSCSeePlayer( NPC, Seen, true ) )
			DoPostEventStuff( NPC, SeeFriendIndex );
	}
	else
	{
		DoPreEventStuff( NPC, SeeFriendIndex, Seen );
		if( Events[SeeFriendIndex].bEnabled )
			NPC.eventSeeFriend( Seen );
		DoPostEventStuff( NPC, SeeFriendIndex );
	}
}

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

function eventSCSeeOther( U2NPCControllerScriptable NPC, Actor Seen )
{
	DoPreEventStuff( NPC, SeeOtherIndex, Seen );
	if( Events[SeeOtherIndex].bEnabled )
		NPC.eventSeeOther( Seen );
	DoPostEventStuff( NPC, SeeOtherIndex );
}

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

function eventSCTakeDamage( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	DoPreEventStuff( NPC, TakeDamageIndex, EventInstigator );
	if( !NPCOwner.bStasis && Events[TakeDamageIndex].bEnabled )
		NPC.eventTakeDamage( Damage, EventInstigator, HitLocation, Momentum, DamageType );
	DoPostEventStuff( NPC, TakeDamageIndex );
}

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

function eventSCTookDamage( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	DoPreEventStuff( NPC, TookDamageIndex, EventInstigator );
	if( !NPCOwner.bStasis && Events[TookDamageIndex].bEnabled )
		NPC.eventTookDamage( Damage, EventInstigator, HitLocation, Momentum, DamageType );
	if( NPC.GetAttitudeTo( EventInstigator ) == ATTITUDE_Enemy )
		eventSCTookDamageEnemy( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
	else if( NPC.GetAttitudeTo( EventInstigator ) == ATTITUDE_Friend )
		eventSCTookDamageFriend( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
	DoPostEventStuff( NPC, TookDamageIndex );
}

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

function eventSCTookDamageEnemy( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	DoPreEventStuff( NPC, TookDamageEnemyIndex, EventInstigator );
	DoPostEventStuff( NPC, TookDamageEnemyIndex );
}

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

function eventSCTookDamageFriend( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	DoPreEventStuff( NPC, TookDamageFriendIndex, EventInstigator );
	DoPostEventStuff( NPC, TookDamageFriendIndex );
}

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

function eventSCTrigger( U2NPCControllerScriptable NPC, Actor Other, Pawn Instigator, name EventName )
{
	local int TriggerIndex;
	local int SavedOnCmdIndex;
	local bool SavedbInterrupt;

	//NPCOwner.DMTNS( "eventSCTrigger -- begin" );

	// squirrel these away in case script wants to use them
	SavedEventInstigator = Instigator;
	SavedEventOther = Other;

	if( NPC.DebugAIEvents() ) 
		NPC.DM( "eventSCTrigger -- Other=" $ Other $ " Event=" $ EventName $ " Instigator=" $ Instigator $ " " $ GetScriptContextStr() );

	/*tbd: not used anywhere currently
	if( !NPC.bStasis && Events[TriggerIndex].bEnabled )
		NPC.eventTrigger( Other, Instigator );
	*/

	// ontrigger can be used to associate specific events with a gotolabel
	TriggerIndex = FindTrigger( EventName );
	if( TriggerIndex != -1 )
	{
		SavedOnCmdIndex = TriggerEvents[ TriggerIndex ].OnCmdIndex;
		SavedbInterrupt = TriggerEvents[ TriggerIndex ].bInterrupt;

		if( TriggerEvents[ TriggerIndex ].bClear )
		{
			// trigger is once only -- remove from table
			//NPC.DMTNS( "eventSCTrigger -- calling ClearTrigger for event " $ EventName $ " TriggerIndex= " $ TriggerIndex );

    		ClearTrigger( TriggerIndex, true );

 			// make sure that any handlers in the same group are disabled
			// (we assume that triggers in a group can't be set up to repeat for now?)
			ClearHandlers( TriggerEvents[ TriggerIndex ].Group );
		}
		else
		{
			// trigger will repeat -- reset timer if any
			if( TriggerEvents[ TriggerIndex ].TimerIndex != -1 )
			{
				HandleAddTimer( TriggerEvents[ TriggerIndex ].TimerIndex, 
								Timers[ TriggerEvents[ TriggerIndex ].TimerIndex ].InitialFrequency );
			}
		}

		// mdf-tbd: doing this before calling ClearTrigger can cause
		// problems because HandleOnEvent can cause script commands to be
		// executed and this could result in a cleartriggers command or some
		// other command which will make the current index invalid.
		// I think that moving this here should fix things -- this will just
		// let any "cleaning up" for the trigger be done before allowing
		// further commands to execute. We just need to be sure to save off
		// the OnCmdIndex before calling ClearTrigger (since it won't be 
		// available any more after this).
		HandleOnEvent( SavedOnCmdIndex, SavedbInterrupt );
	}

	//NPCOwner.DMTNS( "eventSCTrigger -- end" );
}

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

function HandleRemoveTimer( int Index, bool bClearTrigger )
{
	Timers[Index].OnCmdIndex = -1;
	if( bClearTrigger && Timers[Index].TriggerIndex != -1 )
	{
		// make sure associated trigger is removed too
		//NPCOwner.DMTNS( "HandleRemoveTimer -- calling ClearTrigger for timer " $ Index );
		ClearTrigger( Timers[Index].TriggerIndex, false );
		Timers[Index].TriggerIndex = -1;
	}
	RemoveTimer( StringToName( "eventSCTimer" $ Index, true ) );
}

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

function HandleAddTimer( int Index, float Frequency )
{
	local name TimerName;
	
	TimerName = StringToName( "eventSCTimer" $ Index, true );

	//DMSC( "HandleAddTimer " $ TimerName $ " " $ Index $ " Frequency: " $ Frequency );
	// Note: have to remove timer first (or will have multiple timers for the same handler
	//mdf-tbd: call to remove timers should be redundent if I fix AddTimer/S
	RemoveTimer( TimerName );
	AddTimer( TimerName, Frequency );
}

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

function float HandleTimeRemaining( int Index )
{
	return TimeRemaining( StringToName( "eventSCTimer" $ Index, true) );
}

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

function HandleTimer( int TimerIndex )
{
	local int SavedOnCmdIndex;
	local bool SavedbInterrupt;

	if( Timers[ TimerIndex ].OnCmdIndex != -1 )
	{
		SavedOnCmdIndex = Timers[ TimerIndex ].OnCmdIndex;
		SavedbInterrupt = Timers[ TimerIndex ].bInterrupt;

		// reset timer?
		if( Timers[ TimerIndex ].RepeatFrequency ~= 0.0 )
		{
			DMSC( "removing timer #" $ TimerIndex );
			HandleRemoveTimer( TimerIndex, true );

 			// make sure that any handlers in the same group are disabled
			// (we assume that timers in a group can't be set up to repeat for now?)
			ClearHandlers( Timers[ TimerIndex ].Group );
		}
		else
		{
			HandleAddTimer( TimerIndex, Timers[ TimerIndex ].RepeatFrequency );
		}

		HandleOnEvent( SavedOnCmdIndex, SavedbInterrupt );
	}
	else
	{
		SetScriptError( "invalid timer handler in HandleTimer: " $ TimerIndex );
	}
}

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

// global timer handlers (only called when active timers are actually associated with these)
function eventSCTimer0() { HandleTimer( 0 ); }
function eventSCTimer1() { HandleTimer( 1 ); }
function eventSCTimer2() { HandleTimer( 2 ); }
function eventSCTimer3() { HandleTimer( 3 ); }
function eventSCTimer4() { HandleTimer( 4 ); }
function eventSCTimer5() { HandleTimer( 5 ); }
function eventSCTimer6() { HandleTimer( 6 ); }
function eventSCTimer7() { HandleTimer( 7 ); }
function eventSCTimer8() { HandleTimer( 8 ); }
function eventSCTimer9() { HandleTimer( 9 ); }

//-----------------------------------------------------------------------------
// mdf-tbi: do we also need to disable the events in the controlled Pawn to
// minimize overhead (e.g. could get spammed with SeeEnemy since engine code 
// will continue to send these if they aren't disabled).
// Current Answer: no -- I don't think this is introducing much overhead at 
// all.

function EnableEvents()
{
	local int Index;

	for( Index=0; Index<NumEvents; Index++ )
	{
		Events[Index].bEnabled = true;
	}
}

//=============================================================================
// ERROR HANDLING
//=============================================================================

function SetScriptError( coerce string Msg )
{
	if( U2PawnOwner != None && !U2PawnOwner.bDisableErrorMessages )
	{
		// don't spam first error?
		if( Msg == "" || ScriptErrorMessage == "" )
			ScriptErrorMessage = Msg;
	}
}

//=============================================================================
// STARTUP/CLEANUP
//=============================================================================

function CleanupScriptController()
{
	//Log( Self $ ": CleanupScriptController" );
	RemoveAllTimers();
	ClearFoundActors();
	GotoActorTarget = None;
	DialogTarget = None;
	SavedDestination = None;
	NPCOwner = None;
	U2PawnOwner = None;
}

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

function ResetScriptController()
{
	Int1 = 0; Int2 = 0; Int3 = 0; Int4 = 0; Int5 = 0; Int6 = 0; Int7 = 0; Int8 = 0; Int9 = 0;
	Bool1 = false; Bool2 = false; Bool3 = false; Bool4 = false; Bool5 = false; Bool6 = false; Bool7 = false; Bool8 = false; Bool9 = false;

	CleanupScriptController();
	InitEventsIndices();
	ExecClearEvents();
	ExecClearTimers();
	ExecClearTriggers();
	ClearPushedCommands();

	SavedEventInstigator = None;
	SavedEventOther = None;

	WaitTriggerEvent = '';

	CurrentHandlerGroup = 0;
	NextHandlerGroupIndex = 1;
	bInHandlerGroup = false;

	// set once Initialized
	NPCOwner = None;
	U2PawnOwner = None;

	CurrentCommandIndex = 0;
	DecodedCount = 0;
	
	SetScriptError( "" );
}

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

function bool IdiotCheckCommandsList()
{
	local int ii;
	
	for( ii=0; ii<MaxCommandInfoEntries; ii++ )
	{
		if( CommandInfo[ii].CommandString == "" )
			break;
		
		if( CommandInfo[ii].CommandCode == CMD_None )
		{
			SetScriptError( "invalid command code at " $ ii );
			break;
		}
		if( CommandInfo[ii].Signature == "" )
		{
			SetScriptError( "invalid signature at " $ ii );
			break;
		}
	}

	if( ScriptErrorMessage == "" )
	{
		ii++;
		while( ii<MaxCommandInfoEntries)
		{
			if( CommandInfo[ii].CommandString != "" )
			{
				SetScriptError( "gap in CommandInfo list prior to " $ ii );
				break;
			}
			ii++;
		}
	}

	return ( ScriptErrorMessage == "" );
}

//-----------------------------------------------------------------------------
// Initialize the script controller if this hasn't been done already or if this
// is a reload request (e.g. if script file changed externally and the 
// RefreshScripts command was used). Normally called from BeginState once the 
// controlled NPC enters the Scripted state.

function InitializeScriptController( U2NPCControllerScriptable Owner )
{
	if( (DebugMode & Debug_Commands) != 0 )
		DMSC( "InitializeScriptController  U2S=" $ GetCommandFile() );

	ResetScriptController();

	// set this asap since used in debugging code
	NPCOwner = Owner;
	U2PawnOwner = U2Pawn(NPCOwner.Pawn);
	//Log( Self $ " InitializeScriptController  NPCOwner: " $ NPCOwner $ " U2PawnOwner: " $ U2PawnOwner );

	if( IdiotCheckCommandsList() )
	{
		//mdf-tbr: debug
		//DMSC( "Initialize -- Outer is: " $ Outer );
		//NPCOwner.ConsoleCommand( "trace class=" $ Class );
		//ConsoleCommand( "trace funcs" );
		//ConsoleCommand( "trace gotos" );

		if( LoadCommands() )
    	{
			if( InitCommands() )
			{
				GotoState( ExecuteCommandsState );
			}
		}
	}

	if( ScriptErrorMessage != "" )
		ScriptError();
}

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

function MakeECErrorObvious()
{
	if( ScriptErrorMessage == MsgScriptInitError || ScriptErrorMessage == MsgScriptLoadError )
		U2PawnOwner.MakeErrorObvious( ET_ScriptLoad );
	else
		U2PawnOwner.MakeErrorObvious( ET_ScriptRun );
}

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

function ShowWarning( string Msg, int CommandIndex )
{
	local string CommandStr;

	NPCOwner.DMT( "U2SWARNING> " $ CommandFileName $ DefaultExt $ ": " $ Msg );

	if( CommandIndex >= 0 && CommandIndex < Commands.Length )
	{
		CommandStr = GetCommandStringFromIndex( CommandIndex );
		if( CommandStr != "" )
			NPCOwner.DMT( "U2SWARNING> " $ "  Command: " $ CommandStr );
	}
}

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

function HandleScriptError()
{
	NPCOwner.DMT( " " );
	ShowWarning( ScriptErrorMessage, CurrentCommandIndex );
	NPCOwner.DMT( "U2SWARNING> " $ 
		"Pawn: " $ U2PawnOwner.Name $ " script controller: " $ Name ); 
	NPCOwner.DMT( "U2SWARNING> " $ "AIController: " $ NPCOwner.Name $ " State: " $ NPCOwner.GetStateName() $ "CurrentCommandIndex: " $ CurrentCommandIndex );

	NPCOwner.DMT( " " );
	MakeECErrorObvious();
}

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

function ScriptError()
{
	HandleScriptError();
	GotoState( BroadcastErrorState );
}

//-----------------------------------------------------------------------------
// Look for the given label in the script commands and return its index.

function int GetLabelIndex( string LabelName )
{
	local string CommandString;
	local int CommandsListIndex;
	local int CommandIndex;
	local string Label;
	local int Index;
	local int ReturnedIndex;
	local CommandT LocalCommand;

	ReturnedIndex = -1;

	// start at given label -- have to scan for it in the commands list (we don't know the command index)
	for( Index=0; Index<Commands.Length; Index++ )
	{
		LocalCommand = Commands[ Index ];
		CommandString = LocalCommand.CommandString;
		CommandsListIndex = LocalCommand.CommandIndex;

		if( CommandsListIndex == CommandsListIndex_Error )
		{
			SetScriptError( MsgInvalidCommandListIndex );
		}
		else if( CommandsListIndex == CommandsListIndex_Label )
		{
			if( Left( CommandString, 1 ) != ":" )
			{
				SetScriptError( "Error parsing label out of " $ CommandString );
			}
			else
			{
				CommandString = Mid( CommandString, 1 );
				if( class'Util'.static.ParseString( CommandString, Label ) != 1 )
				{
					SetScriptError( "Error parsing label out of " $ CommandString );
					break;
				}
				else
				{
					if( Label ~= LabelName )
					{
						ReturnedIndex = Index;
						break;
					}
				}
			}
		}
	}

	return ReturnedIndex;
}

/*-----------------------------------------------------------------------------
Reset commands so that the current command is the first one in the list or the
one at the specified start label.

mdf-tbd: add code to validate gotoactor targets (unless flagged -- add to
signature) to make sure these exist (and, tbd, can be pathed to from the
start location (unless flagged). This would help detect a lot of pathing
issues on startup instead of later in the game. We pbly wouldn't want to do
this for scripts which are loaded after the level starts up though so as to 
not slow things down. What about doing some kind of pathing test on startup?
*/

function bool InitCommands()
{
	DMSC( "InitCommands -- begin -- StartLabelName=" $ StartLabelName );

	DecodedCount = 0;
	CurrentCommandIndex = 0;

	if( StartLabelName != "" )
	{
		// script was given a label to start at
		if( StartLabelName ~= "begin" )
		{
			// support implicit begin label at start of .u2s for StartLabel
			CurrentCommandIndex = 0;
		}
		else
		{
			// look for the given label
			CurrentCommandIndex = GetLabelIndex( StartLabelName );
	
			if( CurrentCommandIndex == -1 )
			{
				SetScriptError( "Error setting start label '" $ StartLabelName $ "'" );
			}
		}
	}

	EnableEvents();

	//DMSC( "InitCommands -- end" );
	return ( ScriptErrorMessage == "" );
}

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

function DumpCommands( coerce string strHeading )
{
	local int CommandIndex;
	local CommandT LocalCommand;
	local string strDump;

	DMSC( " ", true );
	DMSC( " " $ strHeading, true );
	for( CommandIndex=0; CommandIndex<Commands.Length; CommandIndex++ )
	{
		LocalCommand = Commands[ CommandIndex ];
		
		strDump = "  " $ class'Util'.static.PadString(CommandIndex,3,true,"0");
		if( LocalCommand.CommandIndex >= 0 )
			strDump = strDump $ " " $ class'Util'.static.PadString(LocalCommand.CommandIndex,3,true,"0");
		else
			strDump = strDump $ " " $ class'Util'.static.PadString(LocalCommand.CommandIndex,3,true);
		if( LocalCommand.CommandString != "" )
			strDump = strDump $ " " $ LocalCommand.CommandString;
		if( LocalCommand.CommandTarget != None )
			strDump = strDump $ " -> " $ LocalCommand.CommandTarget;

		DMSC( strDump, true );
	}
}

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

function bool LoadCommands()
{
	local bool bSuccess;
	
	bSuccess = LoadCommandsFromFile( CommandFileName, NPCOwner.Level );

 	if( (DebugMode & Debug_Commands) != 0 )
 	{
 		DMSC( " ", true );
  		DMSC( "----------------------------------------", true );
 		DMSC( CommandFileName $ DefaultExt $ " #Commands: " $ Commands.Length, true );
 	}

	// -1 is an error, 0 commands (empty file) is not (so you can disable a script by commenting it out)
 	if( Commands.Length >= 1 )
 	{					
 		if( (DebugMode & Debug_Commands) != 0 )
 			DumpCommands( "Source commands:" );

 		// mdf-tbd: 
 		// Set all bEnable flags to true (once next cmd executed?)
 		// i.e. reinit everything?
 
 		// parse all commands without executing them to test for missing or invalid arguments?
 		for( CurrentCommandIndex = 0; CurrentCommandIndex < Commands.Length; CurrentCommandIndex++ )
 		{
 			if( CompileCommand( CurrentCommandIndex ) )
 				DecodeCommand( true, false );

 			if( ScriptErrorMessage != "" )
 			{
 				// log all warnings at once (first one will appear again at the end)
 				ShowWarning( ScriptErrorMessage, CurrentCommandIndex );
				bSuccess = false;
 			}
 		}

 		if( (DebugMode & Debug_Commands) != 0 )
 			DumpCommands( "Compiled commands:" );
 	}

 	if( (DebugMode & Debug_Commands) != 0 )
 	{
  		DMSC( "----------------------------------------", true );
 		DMSC( " ", true );
 	}

	if( !bSuccess )
	{
		SetScriptError( MsgScriptLoadError );
	}
	
	return ( ScriptErrorMessage == "" );
}

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

function string GetCommandFile()
{ 
	return CommandFileName;
}

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

function SetCommandFile( string NewCommandFileName )
{
	CommandFileName = NewCommandFileName;
}

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

function SetStartLabel( string NewStartLabelName )
{
	StartLabelName = NewStartLabelName;
}

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

function DetachScriptController()
{
	// immediately restore default controller in owner
	if( NPCOwner != None )
		NPCOwner.DetachScriptController();
}

//=============================================================================
// UTILITY
//=============================================================================

function Pawn FindPlayer()
{
	local Pawn P;

	// Scan PawnList instead of ControllerList in case player not possessed 
	// currently (e.g. during matinee).
	for( P=NPCOwner.Level.PawnList; P!=None; P=P.NextPawn )
		if( P.bIsRealPlayer )
			return P;

	return None;
}

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

function Object FindTarget( name TargetName, optional bool bOptional )
{
	local Object ReturnedObject;

	if( TargetName == TargetFoundName )
		ReturnedObject = GetFoundActor();
	else if( TargetName == TargetSelfName )
		ReturnedObject = Self;
	else if( TargetName == TargetControllerName )
		ReturnedObject = NPCOwner;
	else if( TargetName == TargetEventInstigatorName )
		ReturnedObject = SavedEventInstigator;
	else if( TargetName == TargetEventOtherName )
		ReturnedObject = SavedEventOther;
	else if( TargetName == TargetPawnName )
		ReturnedObject = U2PawnOwner;
	else if( TargetName == TargetPlayerName )
		ReturnedObject = FindPlayer();
	else
		ReturnedObject = class'UtilGame'.static.GetNamedActor( NPCOwner, TargetName );
	
	if( ReturnedObject == None && !bOptional )
		SetScriptError( "FindTarget -- Can't find " $ TargetName );

	return ReturnedObject;
}

//-----------------------------------------------------------------------------
// Return true if the target name represents a "special" target that can't be
// determined at load time.

function bool RunTimeTarget( name TargetName )
{
	return ( TargetName == TargetEventInstigatorName || 
			 TargetName == TargetEventOtherName ||
			 TargetName == TargetFoundName );
}

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

function bool UpdateTarget( name TargetName )
{
	local bool bResult;

	// find and store target
	bResult = false;
	if( CurrentCommand.CommandTarget == None )
	{
		CurrentCommand.CommandTarget = FindTarget( TargetName );
		bResult = (CurrentCommand.CommandTarget != None);
	}

	return bResult;
}

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

function Actor.ESoundSlot FindSoundSlot( name SlotName )
{
	local Actor.ESoundSlot Slot;

	switch( SlotName )
	{
	case '':
		Slot = SLOT_Misc;
		break;
	case 'SLOT_Misc':
		Slot = SLOT_Misc;
		break;
	case 'SLOT_Pain':
		Slot = SLOT_Pain;
		break;
	case 'SLOT_Interact':
		Slot = SLOT_Interact;
		break;
	case 'SLOT_Ambient':
		Slot = SLOT_Ambient;
		break;
	case 'SLOT_Talk':
		Slot = SLOT_Talk;
		break;
	case 'SLOT_Interface':
		Slot = SLOT_Interface;
		break;
	case 'SLOT_Dialog':
		Slot = SLOT_Dialog;
		break;
	default:
		SetScriptError( "Invalid slot " $ SlotName );
		Slot = SLOT_Misc;
		break;
	}

	//U2PawnOwner.DM("FindSoundSlot -- " @ SlotName @ "result:" @ Slot );

	return Slot;
}

//=============================================================================
// "PARSING"
//=============================================================================

function RegisterDecodeError( string Error )
{
	SetScriptError( "Warning -- invalid command #" $ class'Util'.static.PadString(CurrentCommandIndex,3,true,"0") $ " (" $ Error $ ")" );
}

//-----------------------------------------------------------------------------
// Use the current command's signature to determine what kind of arguments
// should be present (if any) and shove these into the ArgsXXX arrays for use
// when the commands are actually executed.
//
// Note: T/t args are really names and are stored in ArgsName along with other 
// names.
//
// Note: unused ArgsXXX entries aren't cleared. Optional args will be set to
// the defaults given below if no argument was supplied.

function ParseArgs( bool bStartup )
{
	local int ArgType;
	local int Res;
	// variables for holding results after parsing a single command
	local string CurrentCommandString;
	local string Signature;
	local bool bOptionalFound;
	local int ByteArgs;
	local int FloatArgs;
	local int IntArgs;
	local int NameArgs;
	local int StringArgs;
	local int LabelArgs;
	local bool bReachedLabel;
	local ECommandCode CommandCode;
	local int ii;

//DMSC( "ParseArgs -- begin" );

	CurrentCommandString = CurrentCommand.CommandString;
	Signature = CommandInfo[ CurrentCommand.CommandIndex ].Signature;

	bOptionalFound = false;
	ByteArgs	= 0;
	FloatArgs	= 0;
	IntArgs		= 0;
	NameArgs	= 0;
	StringArgs	= 0;
	LabelArgs	= 0;

	if( Signature == Sig_XXX )
		goto Continue1;

	while( Signature != "" )
	{
//		DMSC( "CurrentCommandString:" $ CurrentCommandString );
		ArgType = Asc( Left( Signature, 1 ) );

		// uppercase = obligatory, lowercase = optional
		if( ArgType <= TUpperAscii )
		{
			// if an optional argument was already processed, all following args have to be optional
			if( bOptionalFound )
				goto SignatureError;

			switch( ArgType )
			{
			case BUpperAscii:
				Res = class'Util'.static.ParseBool( CurrentCommandString, ArgsByte[ByteArgs] );
				ByteArgs++;
				break;
	
			case FUpperAscii:
				Res = class'Util'.static.ParseFloat( CurrentCommandString, ArgsFloat[FloatArgs] );
				FloatArgs++;
				break;
	
			case IUpperAscii:
				Res = class'Util'.static.ParseInt( CurrentCommandString, ArgsInt[IntArgs] );
				IntArgs++;
				break;
	
			case MUpperAscii:
				Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs], true );
				NameArgs++;
				break;
	
			case NUpperAscii:
				Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs] );
				NameArgs++;
				break;
	
			case SUpperAscii:
				Res = class'Util'.static.ParseString( CurrentCommandString, ArgsString[StringArgs] );
				StringArgs++;
				break;

			case TUpperAscii:
				Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs] );
				if( bStartup )
				{
					// compiling commands -- store target
					if( CurrentCommand.CommandTarget != None )
						goto SignatureError; // signature contains multiple targets!

					if( !RunTimeTarget( ArgsName[NameArgs] ) )
					{
						if( !UpdateTarget( ArgsName[NameArgs] ) )
							goto TargetFindError; // can't find target
					}
				}
				else 
				{
					if( CurrentCommand.CommandTarget == None )
						CurrentCommand.CommandTarget = FindTarget( ArgsName[NameArgs] );

					// executing commands -- target must be set at this point
					if( CurrentCommand.CommandTarget == None )
						goto TargetVerifyError; // target not set!
				}

				NameArgs++;
				break;

			default:
				goto SignatureError;
			}

			if( Res != 1 )
				goto ParseError;
		}
		else
		{
			bOptionalFound = true;

			if( !bReachedLabel )
			{
				// check for reaching a label (indicated by a #)
				class'Util'.static.StripSpaces( CurrentCommandString, true, false );

	  			if( Left( CurrentCommandString, 1 ) == "#" )
					bReachedLabel = true;	// finish with signature so missing args cleared
			}

			if( bReachedLabel )
			{
				// just set defaults for rest of args (which must be missing since a label was reached)
				switch( ArgType )
				{
				case bLowerAscii:
					ArgsByte[ByteArgs++] = 0;
					break;
				case fLowerAscii:
					ArgsFloat[FloatArgs++] = 0.0;
					break;
				case iLowerAscii:
					ArgsInt[IntArgs++] = 0;
					break;
				case mLowerAscii:
				case nLowerAscii:
				case tLowerAscii:
					ArgsName[NameArgs++] = '';
					break;
				case sLowerAscii:
					ArgsString[StringArgs++] = "";
					break;
				default:
					goto SignatureError;
				}

			}
			else
			{
				Res = 1;
				switch( ArgType )
				{
				case bLowerAscii:
					Res = class'Util'.static.ParseBool( CurrentCommandString, ArgsByte[ByteArgs], 0 );
					ByteArgs++;
					break;
		
				case fLowerAscii:
					Res = class'Util'.static.ParseFloat( CurrentCommandString, ArgsFloat[FloatArgs], 0.0 );
					FloatArgs++;
					break;
		
				case iLowerAscii:
					Res = class'Util'.static.ParseInt( CurrentCommandString, ArgsInt[IntArgs], 0 );
					IntArgs++;
					break;
		
				case mLowerAscii:
					Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs], true, '' );
					NameArgs++;
					break;
		
				case nLowerAscii:
					Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs], false, '' );
					NameArgs++;
					break;
		
				case sLowerAscii:
					Res = class'Util'.static.ParseString( CurrentCommandString, ArgsString[StringArgs], "" );
					StringArgs++;
					break;
		
				case tLowerAscii:
					Res = class'Util'.static.ParseName( CurrentCommandString, ArgsName[NameArgs], false, '' );
					if( ArgsName[NameArgs] != '' )
					{
						if( bStartup )
						{
							// compiling commands -- store target
							if( CurrentCommand.CommandTarget != None )
								goto SignatureError; // signature contains multiple targets!

							if( !RunTimeTarget( ArgsName[NameArgs] ) )
							{
								if( !UpdateTarget( ArgsName[NameArgs] ) )
									goto TargetFindError; // can't find target
							}
						}
						else 
						{
							if( CurrentCommand.CommandTarget == None )
								CurrentCommand.CommandTarget = FindTarget( ArgsName[NameArgs] );

							// executing commands -- target must be set at this point
							if( CurrentCommand.CommandTarget == None )
								goto TargetVerifyError; // target not set!
						}
					}
					NameArgs++;
					break;
		
				default:
					goto SignatureError;
				}

				if( Res == -1 )
					goto ParseError;
			}
		}

		// throw away current first character
		Signature = Mid(Signature, 1 );
	}

	// mdf-tbd: idiot checks in anticipation of pre-compiling some args?
	if( bStartup )
	{
		if( ByteArgs   >= MaxArgsByte ||
			FloatArgs  >= MaxArgsFloat ||
			IntArgs	   >= MaxArgsInt ||
			NameArgs   >= MaxArgsName ||
			StringArgs >= MaxArgsString ||
			LabelArgs  >= MaxArgsLabel )
		{
			goto SignatureError;
		}

		// bit of a hack to check for invalid gotolabels in onevent/ontimer/ontrigger
		CommandCode = CommandInfo[ CurrentCommand.CommandIndex ].CommandCode;
		if( CommandCode == CMD_OnEvent )
		{
			if( ArgsString[0] != "" && ( ArgsString[0] != TextGotoLabel && ArgsString[0] != TextInterrupt ))
				goto MsgGotoLabelInterruptError;
		}
		else if( CommandCode == CMD_OnTimer )
		{
			if( ArgsString[0] != "" && ( ArgsString[0] != TextGotoLabel && ArgsString[0] != TextInterrupt ))
				goto MsgGotoLabelInterruptError;
		}
		else if( CommandCode == CMD_OnTrigger )
		{
			if( (ArgsString[0] != "" && ( ArgsString[0] != TextGotoLabel && ArgsString[0] != TextInterrupt )) ||
				(ArgsString[2] != "" && ( ArgsString[2] != TextGotoLabel && ArgsString[2] != TextInterrupt )) )
				goto MsgGotoLabelInterruptError;
		}
		else if( CommandCode == CMD_EventEnable || CommandCode == CMD_EventDisable )
		{
			if( FindEvent( ArgsName[ 0 ] ) == -1 )
				goto MsgInvalidEventName;
		}
	}

	goto Continue1;

MsgGotoLabelInterruptError:
	RegisterDecodeError( MsgGotoLabelInterruptError );
	return;

MsgInvalidEventName:
	RegisterDecodeError( MsgInvalidEventName );
	return;

SignatureError:
	RegisterDecodeError( MsgInternalErrorSignature );
	return;

TargetFindError:
	RegisterDecodeError( MsgTargetFindError );
	return;

TargetVerifyError:
	RegisterDecodeError( MsgTargetVerifyError );
	return;

ParseError:
	RegisterDecodeError( MsgBadOrMissingArgument );
	return;

Continue1:
	if( bStartup )
	{
		// update the command in case any targets were set above
		Commands[ CurrentCommandIndex ] = CurrentCommand;
	}

	class'Util'.static.StripSpaces( CurrentCommandString, true, false );

	// clear LabelArgs here since gotolabel is often optional
	for( ii=0; ii<MaxArgsLabel; ii++ )
		ArgsLabel[ ii ] = 0;

	// extract any labels
	while( Left( CurrentCommandString, 1 ) == "#" )
	{
		// hit label indieces patched in during pre-processing
		// skip #
		CurrentCommandString = Mid( CurrentCommandString, 1 );
		if( class'Util'.static.ParseInt( CurrentCommandString, ArgsLabel[LabelArgs] ) != 1 )
			goto LabelError;

//		DMSC( "Added label index #" $ LabelArgs $ ": " $ ArgsLabel[LabelArgs] );
		LabelArgs++;

		class'Util'.static.StripSpaces( CurrentCommandString, true, false );
	}
	goto Continue2;

LabelError:
	RegisterDecodeError( MsgBadOrMissingLabel );
	return;

Continue2:
	// make sure nothing remains
	if( class'Util'.static.ParseString( CurrentCommandString, Signature ) != 0 )
		RegisterDecodeError( MsgInvalidArgumentExtra );
//DMSC( "ParseArgs -- end" );
}

//-----------------------------------------------------------------------------
// Find the index into the CommandInfo list which corresponds to the given command.
// At startup, the entire list of commands in the current script file is 
// "compiled" and these indices are inserted at the front of all script commands 
// for faster in-game decoding and to have access to the "signature" for the 
// command -- the arguments (possibly optional) that the command takes.

function int DetermineCommandsListIndex( string CommandString )
{
	local int Index;

	Index = 1;
	while( (Index < MaxCommandInfoEntries) && !(CommandInfo[Index].CommandString == CommandString) )
		Index++;
	
	if( Index >= MaxCommandInfoEntries )
		Index = CommandsListIndex_Error;

//	DMSC( "DetermineCommandsListIndex -- Index for " $ CommandString $ " is " $ Index );
	return Index;
}

//-----------------------------------------------------------------------------
// "Compile" the command at the given index. Extracts the command name and 
// converts this into an index into the CommandInfo list for fast lookups. This
// is saved into the native commands list along with the shortened command
// string (i.e. sans the command which was extracted).

function bool CompileCommand( int CommandIndex )
{
	local int CommandListIndex;
	local string CommandListString;
	local string CommandStr;
	local CommandT LocalCommand;

	// parse out command
	CommandListIndex = CommandsListIndex_Error;

	LocalCommand = Commands[ CommandIndex ];
	CommandListString = LocalCommand.CommandString;

	// extract the command string
	if( class'Util'.static.ParseString( CommandListString, CommandStr ) == 1 )
	{
		// determine the command index for the command

		if( Left(CommandStr,1) == ":" )
		{
			// label
			CommandListIndex = CommandsListIndex_Label;
		}
	    else
		{
			// other
			CommandListIndex = DetermineCommandsListIndex( CommandStr );

			if( CommandListIndex != CommandsListIndex_Error )
			{
				// replace CommandString with what is left after parsing out command
				LocalCommand.CommandString = CommandListString;
			}
			else
			{
				//!!mdf-tbd: why are invalid command no longer generating a proper warning
				NPCOwner.DM( "#1: " $ LocalCommand.CommandString );
			}
		}

		LocalCommand.CommandIndex = CommandListIndex;

		// write out the changes
		Commands[ CommandIndex ] = LocalCommand;
	}

	if( CommandListIndex == CommandsListIndex_Error )
	{
		SetScriptError( MsgInvalidCommand );
	}

	return( CommandListIndex != CommandsListIndex_Error );
}

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

function string GetCommandStringFromIndex( int CommandIndex )
{
	local int CommandListIndex;
	local string Msg;
	local CommandT LocalCommand;

	LocalCommand = Commands[ CommandIndex ];

	CommandListIndex = LocalCommand.CommandIndex;
	if( CommandListIndex > 0 && CommandListIndex < MaxCommandInfoEntries )
	{
		if( LocalCommand.CommandString == "" )
			Msg = CommandInfo[CommandListIndex].CommandString;
		else
			Msg = CommandInfo[CommandListIndex].CommandString $ " " $ LocalCommand.CommandString;
	}

	return Msg;
}

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

function ShowProgress()
{
	//if( NPCOwner != None )
	//	NPCOwner.BM( "SC: " $ GetCommandFile() $ DefaultExt $ " - Command #" $ class'Util'.static.PadString(CurrentCommandIndex,3,true,"0") $ " (" $ DecodedCount $ "): " $ GetCommandStringFromIndex(CurrentCommandIndex) $ " " $ GetScriptContextStr(false), true );
	DMSC( GetCommandFile() $ DefaultExt $ " " $ GetCommandStringFromIndex(CurrentCommandIndex), true );
}

//-----------------------------------------------------------------------------
// Decode the next command without actually executing it (sets up execution).
// Sets ScriptErrorMessage and returns false if an error occurs.

function bool DecodeCommand( bool bStartup, bool bShowProgress )
{
	//Log( "DecodeCommand -- begin CurrentCommandIndex: " $ CurrentCommandIndex );
	SetScriptError( "" );

	if( CurrentCommandIndex >= 0 && CurrentCommandIndex < Commands.Length )
	{
		DecodedCount++;

		CurrentCommand = Commands[ CurrentCommandIndex ];

		// mdf-tbr: (dev debug)
		if( bShowProgress && (DebugMode & Debug_Commands) != 0 )
			ShowProgress();

		if( CurrentCommand.CommandIndex >= 0 && CurrentCommand.CommandIndex < MaxCommandInfoEntries )
		{
			//DMSC( "calling ParseArgs" );
			ParseArgs( bStartup );
		}
		else if( CurrentCommand.CommandIndex != CommandsListIndex_Label )
		{
			SetScriptError( "invalid command: '" $ CurrentCommand.CommandString $ "'" );
		}
	}
	else if( CurrentCommandIndex >= Commands.Length )
	{
		// mdf-tbd: when end of script reached, treat like a halt was reached?
		CurrentCommand.CommandIndex = CommandsListIndex_Stop;
	}
	else
	{
		SetScriptError( "DecodeCommand -- CurrentCommandIndex isn't in 0.." $ Commands.Length-1 $ " (" $ CurrentCommandIndex $ ")" );
	}

	//!!!Log( "DecodeCommand -- end" );
	return( ScriptErrorMessage == "" );
}

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

function SetCurrentCommandIndex( int DestinationIndex )
{
	if( (DebugMode & Debug_Jumps) != 0 )
		DMSC( GetCommandFile() $ DefaultExt $ " (JUMP) " $ CurrentCommandIndex $ " --> " $ DestinationIndex $ " (" $ Commands[ DestinationIndex ].CommandString $ ")", true );
		
	CurrentCommandIndex = DestinationIndex;
}

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

// NOTE: push the next command which will be executed when the script returns
function DoCall( int DestinationIndex )
{
	PushCommandIndex( CurrentCommandIndex );
	SetCurrentCommandIndex( DestinationIndex );
}

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

function DoGoto( int DestinationIndex )
{
	SetCurrentCommandIndex( DestinationIndex );
}

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

// NOTE: push the current command which will be re-executed when the script returns
function DoInterrupt( int DestinationIndex )
{
	PushCommandIndex( CurrentCommandIndex - 1);
	SetCurrentCommandIndex( DestinationIndex );
}

//=============================================================================
// "EXECUTION"
//=============================================================================

function ClearFoundActors()
{
	local int ii;

	for( ii=0; ii<UtilGame.MaxFilteredActors; ii++ )
		FoundActors[ ii ] = None;
	NumFoundActors = 0;
}

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

function Actor GetFoundActor()
{
	local int SelectionIndex;

	if( NumFoundActors >= 2 )
	{
		// select one of the found actors randomly and make it the only selection
		SelectionIndex = Rand( NumFoundActors );
	
		FoundActors[ 0 ] = FoundActors[ SelectionIndex ];
		NumFoundActors = 1;
	}

	if( NumFoundActors == 1 )
		return FoundActors[ 0 ];
	else
		return None;
}

//-----------------------------------------------------------------------------
// NOTE: CommandTarget is set at load time if possible, otherwise it is set as
// the command is executed (e.g. if the target is 'found'. Either way, the
// target should be set at this point.

function bool ProcessExecGotoActor( Actor TargetActor )
{
	//!!!Log( "ProcessExecGotoActor: " $ TargetActor $ " - begin" );
	
	GotoActorTarget = None;
	if( TargetActor != None )
	{
		NPCOwner.SetSpecialGoal( TargetActor, ArgsFloat[0], (ArgsByte[0] == 1) );
		GotoActorTarget = TargetActor;
		//!!!Log( "  going to WaitDestinationReached state" );
		GotoState( WaitDestinationReachedState );
		//!!!Log( "ProcessExecGotoActor: " $ TargetActor $ " - end #1" );
		return true;
	}

	//!!!Log( "ProcessExecGotoActor: " $ TargetActor $ " - end #2" );
	return false;
}

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

function ClearPushedCommands()
{
	local int i;

	for( i=0; i<MaxPushedCommandIndices; i++ )
		PushedCommandIndices[i] = -1;

	NumPushedCommandIndices = 0;
}

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

function PushCommandIndex( int CommandIndex )
{
	if( NumPushedCommandIndices < MaxPushedCommandIndices )
		PushedCommandIndices[NumPushedCommandIndices++] = CommandIndex;
	else
		SetScriptError( "PushCommandIndex -- maximum call depth exceeded" );
}

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

function int PopCommandIndex()
{
	local int ReturnedIndex;

	if( NumPushedCommandIndices >= 1 )
		ReturnedIndex = PushedCommandIndices[--NumPushedCommandIndices];
	else
		SetScriptError( "PopCommandIndex -- mismatched return" );

	return ReturnedIndex;
}

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

function ExecAddAmmo()
{
	if( !class'U2Weapon'.static.AddAmmo( U2PawnOwner, ArgsString[0], ArgsInt[0], (ArgsByte[0] != 0) ) )
	{
		SetScriptError( "Couldn't add ammo " $ ArgsString[0] $ " to NPC" );
	}
}

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

function ExecAgentBind()
{
	if (U2PawnOwner != None)
	{
		U2PawnOwner.MeshAgentSetInputCurValue(ArgsName[0], ArgsName[1]);
		U2PawnOwner.MeshAgentSetInputLock(ArgsName[0], true);

		// script is shutting down the default animation behavior of the agent
		// turn off damage momentum and knockdowns
		if( ArgsName[0] == SpecialStateAgentInput )
			NPCOwner.AgentSpecialStateBegin();
	}
}

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

function bool ExecAgentCall()
{
	local float Duration;
	
	if (U2PawnOwner == None)
		return false;
	
	Duration = U2PawnOwner.MeshAgentCallAction(ArgsName[0]);

	if (ArgsByte[0] != 0)
	{
		if (Duration > 0.0)
		{
			ArgsFloat[0] = Duration;
		}
		else
		{
			SetScriptError( "Unable to wait on agent action " $ ArgsName[0] );
			ArgsFloat[0] = 1.0; // just to prevent runaway loops when a wait is expected
		}

		class'DialogEngine'.static.SetActorReadyTime( U2PawnOwner, NPCOwner.Level.TimeSeconds + ArgsFloat[0] );

		GotoState( SleepingState );
		return true;
	}
	else
		return false;
}

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

function bool ExecAgentExecute()
{
	local float Duration;
	
	if (U2PawnOwner == None)
		return false;
	
	Duration = U2PawnOwner.MeshAgentImmediateAction(ArgsString[0]);

	if (ArgsByte[0] != 0)
	{
		if (Duration > 0.0)
		{
			ArgsFloat[0] = Duration;
		}
		else
		{
			SetScriptError( "Unable to wait on agent execute " $ ArgsString[0] );
			ArgsFloat[0] = 1.0; // just to prevent runaway loops when a wait is expected
		}

		class'DialogEngine'.static.SetActorReadyTime( U2PawnOwner, NPCOwner.Level.TimeSeconds + ArgsFloat[0] );

		GotoState( SleepingState );
		return true;
	}
	else
		return false;
}

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

function ExecAgentUnbind()
{
	if (U2PawnOwner != None)
	{
		U2PawnOwner.MeshAgentSetInputLock(ArgsName[0], false);

		// restore npc back to original behavior now that the agent is unlocked
		if( ArgsName[0] == SpecialStateAgentInput )
			NPCOwner.AgentSpecialStateEnd();
	}
}

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

function bool ExecAnim( ECommandCode ECType, int Channel )
{
	local bool bRetVal;
	local bool bResult;

	if( ECType == CMD_AnimLoopEx ) ECType = CMD_AnimLoop;
	else if( ECType == CMD_AnimPlayEx ) ECType = CMD_AnimPlay;
	else if( ECType == CMD_AnimTweenEx ) ECType = CMD_AnimTween;

	if( Channel == 0 )
	{
		// cdh: leave channel zero to use existing controller behavior 
		if( ECType == CMD_AnimLoop )
		{
			bResult = NPCOwner.LPawn.LookupLoopAnim( ArgsName[0], ArgsFloat[0], ArgsFloat[1], 2 );
			// tbd: now what -- how long should anim loop for etc.
		}
		else if( ECType == CMD_AnimPlay )
		{
			bResult = NPCOwner.LPawn.LookupPlayAnim( ArgsName[0], ArgsFloat[0], ArgsFloat[1], 0 );
		}
		else if( ECType == CMD_AnimTween )
		{
    		bResult = NPCOwner.LPawn.LookupTweenAnim( ArgsName[0], ArgsFloat[0], 0 );
		}
	}
	else
	{
		// cdh: auxiliary channels are only used for effects right now, and the controller code
		//      is not really set up to handle multiple animations yet anyway, so just bypass all
		//      of that and call the animation functions directly
		if( ECType == CMD_AnimLoop )
		{
			NPCOwner.LPawn.LoopAnim( ArgsName[0], ArgsFloat[0], ArgsFloat[1], Channel );
			// tbd: now what -- how long should anim loop for etc.
		}
		else if( ECType == CMD_AnimPlay )
		{
			NPCOwner.LPawn.PlayAnim( ArgsName[0], ArgsFloat[0], ArgsFloat[1], Channel );
		}
		else if( ECType == CMD_AnimTween )
		{
    		NPCOwner.LPawn.TweenAnim( ArgsName[0], ArgsFloat[0], Channel );
		}
		bResult = (NPCOwner.LPawn.GetAnimFrames(ArgsName[0]) > 0);
	}
	// tbd: check return value -- false means anim not found so don't ever wait?

	if( !bResult )
	{
		SetScriptError( "animloop/play/tween -- invalid animation: " $ ArgsName[0] );
	}
	else
	{
		NPCOwner.SetScriptedIdleAnims( true );
	}

	if( ArgsByte[0] == 1 )
	{
		bRetVal = true;
		GotoState( WaitAnimEndState );
	}

	return bRetVal;
}

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

function ExecAnimRelease()
{
	NPCOwner.SetScriptedIdleAnims( false );
}

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

function ExecCall()
{
	DoCall( ArgsLabel[0] );
}

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

function ExecCallScript()
{
	// mdf-tbi:
	/* to do this in the current controller, we need to save all kinds of stuff:
			current command line
			any pushed commands
			trigger settings
			event settings

		but, if this simply causes a new script controller to be spawned and set up
		with a reference to this script controller so it can return to this, we
		don't have to worry about any of this

		+spawn new script controller
		+set its file name to ArgsString[0] and label to ArgsLabel[0]
		+initialize it?
		+set its ParentScriptController to Self
		+switch over to it
			+hmm, does it inherit anything from this state (and on returning make sure these are updated in the caller?)

				Yes?:
					event states (enabled/disabled)
					DebugMode

				No?:
					event handlers			(can't -- these refer to labels in the calling script)
					trigger handlers		(can't -- these refer to labels in the calling script)
					scratch variables		(called script shouldn't know/care how these were used)
					pushed calls
					current command index
					ArgsXXX
					DecodedCount
					Commands.Length
					GotoActorTarget
					WaitTriggerEvent
	*/
}

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

function ExecCallEnd()
{
	ClearPushedCommands();
}

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

function ExecClearEvents()
{
	local int Index;

	for( Index=0; Index<NumEvents; Index++ )
	{
		Events[Index].OnCmdIndex = -1;
	}
}

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

function ExecClearTimers()
{
	local int Index;

//	NPCOwner.DMTNS( "ExecClearTimers" );
	for( Index=0; Index<MaxGeneralTimers; Index++ )
		HandleRemoveTimer( Index, false );
}

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

function ExecClearTriggers()
{
	local int Index;

//NPCOwner.DMTNS( "ExecClearTriggers" );

	for( Index=0; Index<NumTriggerEvents; Index++ )
	{
		TriggerEvents[Index].EventName = '';
		TriggerEvents[Index].OnCmdIndex = -1;
	}

	for( Index=MaxGeneralTimers; Index<MaxTimers; Index++ )
		HandleRemoveTimer( Index, false );

	NumTriggerEvents = 0;
}

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

function ExecConsoleCommand()
{
	local bool bCheatsEnabledOld;
	
	if( NPCOwner.Level.PlayerControllerList != None )
	{
		bCheatsEnabledOld = NPCOwner.Level.PlayerControllerList.bCheatsEnabled;
		NPCOwner.Level.PlayerControllerList.ConsoleCommand( ArgsString[0] );
		NPCOwner.Level.PlayerControllerList.bCheatsEnabled = bCheatsEnabledOld;
	}
	
	// use Actor ConsoleCommand? Doesn't work?
	//U2PawnOwner.ConsoleCommand( ArgsString[0] );
}

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

function ExecDebugAI()
{
	NPCOwner.SetDebugAI( ArgsByte[0] != 0 );
}

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

function ExecDebugAIEvents()
{
	NPCOwner.SetDebugAIEvents( ArgsByte[0] != 0 );
}

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

function ExecDebugAIFlags()
{
	NPCOwner.SetDebugAIFlags( ArgsInt[0] );
}

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

function ExecDebugMode()
{
	DebugMode = ArgsInt[0];
}

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

function ExecDecProperty()
{
	local int Val;
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanSetProperty( ArgsString[0] ) )
		{
			Val = int(O.GetPropertyText( ArgsString[0] ));
			if( ArgsInt[0] == 0 )
				O.SetPropertyText( ArgsString[0], string(Val-1) );
			else
				O.SetPropertyText( ArgsString[0], string(Val-ArgsInt[0]) );
		}
		else
		{
			SetScriptError( "can't set property " $ ArgsString[0] $ " in " $ O );
		}
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecDeployInventory()
{
	local U2XMPItem DI;

	DI = U2XMPItem(class'UtilGame'.static.GiveInventoryString( U2PawnOwner, ArgsString[0] ));
    if( DI != None )
    {
		if( ArgsByte[ 0 ] == 0 )
		{
			U2PawnOwner.Controller.bFire = 1;
			DI.Fire();
		}
		else
		{
			U2PawnOwner.Controller.bAltFire = 1;
			DI.AltFire();
		}
	}
	else
	{
		SetScriptError( "Couldn't deploy " $ ArgsString[0] );
	}
}

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

function ExecDestroy()
{
	U2PawnOwner.Destroy();
}

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

function ExecDialogDisable()
{
	class'DialogEngine'.static.DisableNode( NPCOwner, ArgsName[0] );
}

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

function ExecDialogEnable()
{
	class'DialogEngine'.static.EnableNode( NPCOwner, ArgsName[0] );
}

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

function bool ExecDialogFar( bool bWait )
{
	local Actor Iter, A, B;
	local bool bOther, bChangedState;

	//NPCOwner.DMT("ExecFarDialog: Speakers" @ ArgsString[0] @ ArgsString[1] @ "Topic:" @ ArgsName[0] @ "Waiting:" @ bWait );

	bOther = ArgsString[1] != "";

	if(			  ArgsString[0] ~= PlayerSpeakerString ) A = FindPlayer();
	if( bOther && ArgsString[1] ~= PlayerSpeakerString ) B = FindPlayer();


	if( A == None || B == None )
	{
		//!!MB (mdf) possible performance issue (if called often enough) use target for first arg so pre-loaded once?
		foreach NPCOwner.DynamicActors( class'Actor', Iter )
		{
			if(			  Iter.Speaker ~= ArgsString[0] )	A = Iter;
			if( bOther && Iter.Speaker ~= ArgsString[1] )	B = Iter;
			if( A != None && B != None )
				break;
		}
	}

	if( A != None && B != None && A != B )
		class'DialogEngine'.static.Initiate( A, B, ArgsName[0], NPCOwner );
	else if( A != None )
		class'DialogEngine'.static.Initiate( A, None, ArgsName[0], NPCOwner );
	else if( B != None )
		class'DialogEngine'.static.Initiate( B, None, ArgsName[0], NPCOwner );
	else
		SetScriptError( "DialogFar -- can't find speakers for '" $ ArgsString[0] $ "' and '" $ ArgsString[1] $ "'" );

	if( bWait )
	{
		GotoState( WaitDialogFarPausedState );
		bChangedState = true;
	}

	return bChangedState;
}

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

function ExecDialogInitiate()
{
	local Actor Iter, A;

	if( U2PawnOwner != None )
	{
		//NPCOwner.DM("ExecDialogInitiate: Other" @ ArgsString[0] @ "Topic:" @ ArgsName[0] );

		if( ArgsString[0] ~= PlayerSpeakerString )
			A = FindPlayer();
		else if( ArgsString[0] != SelfSpeakerString )
		{
			foreach U2PawnOwner.DynamicActors( class'Actor', Iter )
				if( Iter.Speaker ~= ArgsString[0] )
				{
					A = Iter;
					break;
				}
		}

		// pawn is talking solo
		if( A == U2PawnOwner )
		{
			Warn( "DialogInitiate -- other has the same speaker string as this npc -- use '" $ SelfSpeakerString $ "' instead" );
			A = None;
		}

		// either talk to someone, or talk to yourself about a topic
		if( A != None || ArgsName[0] != '' )
		{
			// initiate specified dialog with target
			class'DialogEngine'.static.Initiate( U2PawnOwner, A, ArgsName[0] );
			DialogTarget = A;
		}
		else
			SetScriptError( "DialogInitiate -- can't find speaker '" $ ArgsString[0] $ "' or topic '" $ ArgsName[0] $ "'" );
	}
}

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

function ExecDialogTerminate()
{
	local Actor A;

	if( ArgsString[0] ~= PlayerSpeakerString )
		A = FindPlayer();
	else
	{
		foreach NPCOwner.DynamicActors( class'Actor', A )
			if( A.Speaker ~= ArgsString[0] )
				break;
	}

	if( A != None )
	{
		// initiate specified dialog with target
		A.DialogTerminate();
		DialogTarget = None;
	}
}

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

function ExecDirectionalPatrol()
{
	NPCOwner.SetDirectionalPatrol( bool(ArgsByte[0]) );
}

/*-------------------------------------------------------------------------
NOTE: even with bStasis -- NPCs can still take damage and go PHYS_Falling 
etc. so with bStasis set, script generated events events (TakeDamage, 
Trigger etc.) are implicitely disabled above. Engine events should be 
automatically disabled if the Pawn/Controller has bStasis=true. 
Only way to wake up a dormant NPC is through a handled trigger or event 
(handlers are still called) or through a timer.
*/

function ExecDormant()
{
	NPCOwner.SetDormant( ArgsByte[0] != 0, ArgsByte[1] != 0 );
}

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

function ExecDropInventory()
{
	local Inventory Inv;

	Inv = class'UtilGame'.static.GiveInventoryString( U2PawnOwner, ArgsString[0] );
	if( Inv != None )
		Inv.DropFrom( U2PawnOwner.Location );
	else
		SetScriptError( "Couldn't drop inventory " $ ArgsString[0] );
}

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

function ExecEnableProbeEvent()
{
	NPCOwner.EnableProbeEvent( ArgsName[ 0 ], ArgsByte[ 0 ] == 1 );
}

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

function ExecEventDisable()
{
	local int EventIndex;

	if( GetEventIndex( ArgsName[0], EventIndex ) )
	{
		if( Events[EventIndex].bCanToggle )
			Events[EventIndex].bEnabled = false;
		else
			SetScriptError( "Can't toggle event " $ ArgsName[0] );
	}
}

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

function ExecEventEnable()
{
	local int EventIndex;

	if( GetEventIndex( ArgsName[0], EventIndex ) )
	{
		if( Events[EventIndex].bCanToggle )
			Events[EventIndex].bEnabled = true;
		else
			SetScriptError( "Can't toggle event " $ ArgsName[0] );
	}
}

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

function ExecEventWait()
{
	local int EventIndex;

	if( GetEventIndex( ArgsName[0], EventIndex ) )
	{
		if( Events[EventIndex].EventWaitState != '' )
			GotoState( Events[EventIndex].EventWaitState );
		else
			SetScriptError( "Can't wait for " $ ArgsName[0] );
	}
}

//-----------------------------------------------------------------------------
// All args are optional. None --> clear previous found target (if any). Will
// only do a gotolabel/call if these were specified.

function ExecFindActor()
{
	local float MinDist, MaxDist;
	local UtilGame.EDistanceFilterType DistanceFilterType;
	local UtilGame.EVisibilityFilterType VisibilityFilterType;
	local int FindActorResult;

	//NPCOwner.DMTNS( "String0 " $ ArgsString[ 0 ] );
	//NPCOwner.DMTNS( "String1 " $ ArgsString[ 1 ] );
	//NPCOwner.DMTNS( "String2 " $ ArgsString[ 2 ] );
	//NPCOwner.DMTNS( "Float0  " $ ArgsFloat[ 0 ] );
	//NPCOwner.DMTNS( "Float1  " $ ArgsFloat[ 1 ] );
	//NPCOwner.DMTNS( "Int0    " $ ArgsInt[ 0 ] );
	//NPCOwner.DMTNS( "Int1    " $ ArgsInt[ 1 ] );
	//NPCOwner.DMTNS( "Int2    " $ ArgsInt[ 2 ] );

	if( ArgsString[0] == "" )
	{
		ClearFoundActors();
	}
	else
	{
		MinDist = ArgsFloat[ 0 ];
		MaxDist = ArgsFloat[ 1 ];
		if( MinDist > MaxDist )
		{
			SetScriptError( "Min > Max for FindActor" );
			return;
		}

		// convert ints to enums
		switch( ArgsInt[ 0 ] )
		{
			case 0:
				DistanceFilterType = DFT_First;
				break;
			case 1:
				DistanceFilterType = DFT_Closest;
				break;
			case 2:
				DistanceFilterType = DFT_Furthest;
				break;
			case 3:
				DistanceFilterType = DFT_Any;
				break;
			default:
				SetScriptError( "Invalid distance type for FindActor " $ ArgsInt[0] );
				return;
		}

		switch( ArgsInt[ 1 ] )
		{
			case 0:
				VisibilityFilterType = VFT_None;
				break;
			case 1:
				VisibilityFilterType = VFT_Visible;
				break;
			case 2:
				VisibilityFilterType = VFT_FOV;
				break;
			default:
				SetScriptError( "Invalid visibility type for FindActor " $ ArgsInt[1] );
				return;
		}

		if( ArgsInt[2] == 0 )
			ArgsInt[2] = UtilGame.MaxFilteredActors;

		FindActorResult = class'UtilGame'.static.GetFilteredActors( 
							U2PawnOwner,
							ArgsString[0],
							FoundActors,
							ArgsFloat[0],
							ArgsFloat[1],
							DistanceFilterType,
							VisibilityFilterType,
							ArgsInt[2] );

		//DMSC( "Found Actors: " $ FindActorResult );

		if( FindActorResult >= 0 )
		{
			// call/jump to destination label or continue with next line
			NumFoundActors = FindActorResult;

			//for( FindActorResult=0; FindActorResult<NumFoundActors; FindActorResult++ )
			//	DMSC( FindActorResult $ ": " $ FoundActors[ FindActorResult ] );
			if( ArgsString[1] == TextGotoLabel || ArgsString[1] == TextCall )
				HandleCallOrGotoLabel( NumFoundActors != 0, ArgsString[1] );
			else if( ArgsString[1] != "" )
				SetScriptError( "Invalid FindActor argument (where gotolabel/call should be: " $ ArgsString[1] );
		}
		//note: not an error if no matching actors found - script has to decide this (by branching on success
		// with call/gotolabel and/or by using gotoactor vs gotoactorsafe)
	}
}

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

function ExecGib()
{
	local int SavedGibGoreLevel;

	// use the specified gore level
	if( ArgsInt[0] != 0 && U2PawnOwner.GibSetClass != None )
	{
		SavedGibGoreLevel = U2PawnOwner.GibSetClass.default.GoreLevel;
		U2PawnOwner.GibSetClass.default.GoreLevel = ArgsInt[0];
	}

	if( U2PawnOwner.ShouldGib( class'Gibbed' ) )
		U2PawnOwner.ChunkUp();
	else if( ArgsByte[0] == 0 )
		U2PawnOwner.Died( NPCOwner, None, U2PawnOwner.Location, vect(0,0,0) );
	else
		U2PawnOwner.Destroy();

	// restore the default
	if( ArgsInt[0] != 0 && U2PawnOwner.GibSetClass != None )
		U2PawnOwner.GibSetClass.default.GoreLevel = SavedGibGoreLevel;
}

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

function ExecGibAll()
{
	local class<Pawn> TargetClass;
	local Controller C;
	local U2Pawn U2P;
	local int SavedGibGoreLevel;

	TargetClass = class<Pawn>(DynamicLoadObject( ArgsString[0], Class'Class'));

	if( TargetClass != None )
	{
		for( C=NPCOwner.Level.ControllerList; C!=None; C=C.NextController )
		{
			U2P = U2Pawn(C.Pawn);
			if( U2P != None && ClassIsChildOf( U2P.class, TargetClass ) )
			{
				if( ArgsInt[0] != 0 )
				{
					SavedGibGoreLevel = U2P.GibSetClass.default.GoreLevel;
					U2P.GibSetClass.default.GoreLevel = ArgsInt[0];
				}

				if( U2P.ShouldGib( class'Gibbed' ) )
					U2P.ChunkUp();
				else if( ArgsByte[0] == 0 )
					U2P.Died( NPCOwner, None, U2P.Location, vect(0,0,0) );
				else
					U2PawnOwner.Destroy();

				if( ArgsInt[0] != 0 )
					U2P.GibSetClass.default.GoreLevel = SavedGibGoreLevel;
			}
		}
	}
	else
	{
		SetScriptError( "GibAll: invalid class " $ ArgsString[0] );
	}
}

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

function ExecGiveInventory()
{
	if( class'UtilGame'.static.GiveInventoryString( U2PawnOwner, ArgsString[0] ) == None )
	{
		SetScriptError( "Couldn't give inventory " $ ArgsString[0] $ " to NPC" );
	}
}

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

function ExecGiveItemToPlayer()
{
	if( ArgsInt[0] == 0 )
	{
		if( class'UtilGame'.static.GiveInventoryString( FindPlayer(), ArgsString[0] ) == None )
		{
			SetScriptError( "Couldn't give item " $ ArgsString[0] $ " to player" );
		}
	}
	else
	{
		if( !class'U2Weapon'.static.AddAmmo( FindPlayer(), ArgsString[0], ArgsInt[0] ) )
		{
			SetScriptError( "Couldn't give ammo" $ ArgsString[0] $ " to player" );
		}
	}
}

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

function ExecGiveTossedItem()
{
	if( !U2PawnOwner.GiveTossedItem( ArgsString[0] ) )
		SetScriptError( "Couldn't give tossed item " $ ArgsString[0] $ " to NPC" );
}

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

function ExecGotoActor()
{
	if( !ProcessExecGotoActor( Actor(CurrentCommand.CommandTarget) ) )
		SetScriptError( "Can't gotoactor " $ CurrentCommand.CommandTarget );
	//DMSC( " GotoActor: " $ A );
}

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

function bool ExecGotoActorSafe()
{
	return ProcessExecGotoActor( Actor(FindTarget( ArgsName[0], true )) );
}

//-------------------------------------------------------------------------
// Sets NewCmdIndex to line index stored in ArgsInt[0]

function ExecGotoLabel()
{
	DoGoto( ArgsLabel[0] );
}

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

function ExecIncProperty()
{
	local int Val;
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanSetProperty( ArgsString[0] ) )
		{
			Val = int(O.GetPropertyText( ArgsString[0] ));
			if( ArgsInt[0] == 0 )
				O.SetPropertyText( ArgsString[0], string(Val+1) );
			else
				O.SetPropertyText( ArgsString[0], string(Val+ArgsInt[0]) );
		}
		else
		{
			SetScriptError( "can't set property " $ ArgsString[0] $ " in " $ O );
		}
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecInert()
{
	local bool bVal;

	bVal = !bool(ArgsByte[0]);
	
	Events[ BumpEnemyIndex ].bEnabled = bVal;
	Events[ BumpFriendIndex ].bEnabled = bVal;
	Events[ BumpOtherIndex ].bEnabled = bVal;
	Events[ BumpPlayerIndex ].bEnabled = bVal;
	Events[ HearNoiseFriendlyIndex ].bEnabled = bVal;
	Events[ HearNoiseOtherIndex ].bEnabled = bVal;
	Events[ HearNoiseThreatIndex ].bEnabled = bVal;
	Events[ InheritEnemyIndex ].bEnabled = bVal;
	Events[ SeeAlertFriendIndex ].bEnabled = bVal;
	Events[ SeeEnemyIndex ].bEnabled = bVal;
	Events[ SeeFriendIndex ].bEnabled = bVal;
	Events[ SeeOtherIndex ].bEnabled = bVal;
	Events[ SeePlayerIndex ].bEnabled = bVal;
	Events[ TookDamageIndex ].bEnabled = bVal;
	Events[ TookDamageEnemyIndex ].bEnabled = bVal;
	Events[ TookDamageFriendIndex ].bEnabled = bVal;
	
	// if "inert 1", also clear bXMPHandlingEnabled but don't *set* bXMPHandlingEnabled if "inert 0"
	if( !bVal )
	{
		bXMPHandlingEnabled = bVal;
		NPCOwner.SetXMPHandlingEnabled( bXMPHandlingEnabled );
	}
}

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

function ExecHandlerGroup()
{
	if( !bInHandlerGroup )
	{
		bInHandlerGroup = true;

		// any subsequent onevent/ontimer/ontrigger in this group
		CurrentHandlerGroup = NextHandlerGroupIndex++;
	}
	else
	{
		SetScriptError( "handlergroup -- already in a handler groupe!" );
	}
}

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

function ExecHandlerGroupEnd()
{
	if( bInHandlerGroup )
	{
		bInHandlerGroup = false;

		// any subsequent onevent/ontimer/ontrigger not in a group
		CurrentHandlerGroup = 0;
	}
	else
	{
		SetScriptError( "handlergroupend -- not in a handler groupe!" );
	}
}

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

function ExecHeadTracking()
{
	NPCOwner.SetHeadTrackingEnabled( bool( ArgsByte[ 0 ] ) );
}

//-----------------------------------------------------------------------------
/*
function ShowJumpPos()
{
	U2PawnOwner.AddActor( U2PawnOwner, U2PawnOwner.ColorBlue() );
	if( U2PawnOwner.Physics == PHYS_Falling )
		AddTimer( 'ShowJumpPos', 0.1 );
}
*/

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

function ExecJump()
{
	// mdf-tbi: doesn't work if Pawn *just* landed -- phys_falling getting spammed with phys_walking
	//U2PawnOwner.AddActor( U2PawnOwner, U2PawnOwner.ColorGreen() );
	U2PawnOwner.Velocity.X = ArgsFloat[0];
	U2PawnOwner.Velocity.Y = ArgsFloat[1];
	U2PawnOwner.Velocity.Z = ArgsFloat[2];
	U2PawnOwner.SetPhysics( PHYS_Falling );
	
	//AddTimer( 'ShowJumpPos', 0.1 );
}

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

function ExecKill()
{
	U2PawnOwner.Died( NPCOwner, None, U2PawnOwner.Location, vect(0,0,0) );
}

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

function ExecKillAll()
{
	local class<Actor> TargetClass;
	local Actor A;

	TargetClass = class<Actor>(DynamicLoadObject( ArgsString[0], Class'Class'));

	if( TargetClass != None )
	{
		foreach NPCOwner.DynamicActors( class'Actor', A )
			if ( ClassIsChildOf( A.class, TargetClass ) )
				A.Destroy();
	}
	else
	{
		SetScriptError( "KillAll: invalid class " $ ArgsString[0] );
	}
}

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

function ExecLockStep()
{
	// mdf-tbi:
}

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

function ExecMessage()
{
	if( ArgsInt[0] >= 0 && ArgsInt[0] <= 2 )
		NPCOwner.DMTNS( ArgsString[0], ArgsInt[0] == 1, ArgsInt[0] != 2, 'SM' );
	else
		SetScriptError( "Message - invalid argument: " $ ArgsInt[0] );
}

//-----------------------------------------------------------------------------
// Sets up cmd to jump to specified label when event xxx occurs.

function ExecOnEvent()
{
	local int EventIndex;

	if( GetEventIndex( ArgsName[0], EventIndex ) )
	{
		if( ArgsString[1] == "" )
		{
			Events[EventIndex].OnCmdIndex = -1;						// onevent xxx (disable onevent)
			Events[EventIndex].Group = 0;							// clear 
		}
		else
		{
			if( ArgsString[0] == TextGotoLabel )						// onevent xxx gotolabel lll (label line # ArgsLabel[0] at this point)
			{
				Events[EventIndex].bInterrupt = false;	
			}
			else if( ArgsString[0] == TextInterrupt )
			{
				Events[EventIndex].bInterrupt = true;				// onevent xxx interrupt lll
			}
			// "call" command not allowed

			Events[EventIndex].OnCmdIndex = ArgsLabel[0];
			Events[EventIndex].bClear = bool(ArgsByte[0]);			// if clear=1, event handler will be automatically removed when the event occurs
			Events[EventIndex].Group = CurrentHandlerGroup;
		}
	}
}

//-----------------------------------------------------------------------------
// Sets up cmd to jump to specified label when time is up occurs.

function ExecOnTimer()
{
	local int TimerIndex;
	local int Index;

	TimerIndex = ArgsInt[0]-1;
	if( TimerIndex >= 0 && TimerIndex < MaxGeneralTimers )
	{
		if( ArgsFloat[0] ~= 0.0 )
		{
			HandleRemoveTimer( TimerIndex, false );
			Timers[TimerIndex].Group = 0;
		}
		else
		{
			Timers[TimerIndex].InitialFrequency = ArgsFloat[0];
			Timers[TimerIndex].RepeatFrequency = ArgsFloat[1];
			Timers[TimerIndex].TriggerIndex = -1;				// no trigger event associated with this timer
			Timers[TimerIndex].Group = CurrentHandlerGroup;

			if( ArgsString[0] == TextGotoLabel )				// ontrigger xxx gotolabel lll
			{
				Timers[TimerIndex].bInterrupt = false;
			}
			else if( ArgsString[0] == TextInterrupt )
			{
				Timers[TimerIndex].bInterrupt = true;			// ontrigger xxx interrupt lll
			}
			// "call" command not allowed

			Timers[TimerIndex].OnCmdIndex = ArgsLabel[0];		// (label line # ArgsLabel[0] at this point)

			if( CurrentHandlerGroup != 0 && Timers[TimerIndex].RepeatFrequency > 0.0 )
				SetScriptError( "Can't have a repeating timer in a handler group!" );

			// set/reset with specified initial frequency
			HandleAddTimer( TimerIndex, ArgsFloat[0] );
		}
	}
	else
	{
		SetScriptError( "Invalid timer index: " $ TimerIndex );
	}
}

//-----------------------------------------------------------------------------
// Sets up cmd to jump to specified label when trigger xxx occurs. If a time
// limit was specified, also associates a timer with the trigger handler.
//
// M					s0				s1		b0		f0				  s2			s3			l0 l1
// eventname [ [gotolabel|interrupt] labelname [clear [timelimit [gotolabel|interrupt] labelname]]] #  #

function ExecOnTrigger()
{
	local int TriggerIndex;
	local int TimerIndex;

//NPCOwner.DMTNS( "ExecOnTrigger: " $ ArgsName[0] $ " NumTriggerEvents: " $ NumTriggerEvents );

	// look for trigger name in table
	if( ArgsName[0] != '' )
	{
		TriggerIndex = FindTrigger( ArgsName[0] );
	
//		DMSC( "ExecOnTrigger(): " $ TriggerIndex );

		if( ArgsString[0] == "" )
		{
			// no first gotolabel so disabling OnTrigger -- clear if in table
			//NPCOwner.DMTNS( "ExecOnTrigger -- calling ClearTrigger for event " $ ArgsName[0] $ " TriggerIndex= " $ TriggerIndex );
			if( TriggerIndex != -1 )
			{
				ClearTrigger( TriggerIndex, true );
				TriggerEvents[ TriggerIndex ].Group = 0;
			}
		}
		else
		{
			// update if in table, otherwise add
			if( TriggerIndex == -1 )
			{
				// not already in table -- add
				TriggerIndex = NumTriggerEvents++;

//				DMSC( "  adding to table at " $ TriggerIndex );

				TriggerEvents[ TriggerIndex ].EventName = ArgsName[0];
				TriggerEvents[ TriggerIndex ].TimerIndex = -1;

				if( ArgsFloat[0] > 0.0 )
				{
					// allocate a timer
					for( TimerIndex=MaxGeneralTimers; TimerIndex<MaxTimers; TimerIndex++ )
						if( Timers[ TimerIndex ].OnCmdIndex == -1 )
							break;

					if( TimerIndex == MaxTimers )
					{
						SetScriptError( "Can't associate timer with ontrigger handler (out of timers)");
						TimerIndex = -1;
					}
				}
			}
			else if( ArgsFloat[0] <= 0.0 )
			{
				// trigger handler already present & no timer this time so remove it
				TimerIndex = TriggerEvents[ TriggerIndex ].TimerIndex;
				if( TimerIndex != -1 )
				{
//					DMSC( "  removing timer at " $ TimerIndex );
					Timers[ TimerIndex ].TriggerIndex = -1;
					HandleRemoveTimer( TimerIndex, false );
					TimerIndex = -1;
				}
			}
			else
			{
				// trigger handler already present -- may or may not have a timer
				TimerIndex = TriggerEvents[ TriggerIndex ].TimerIndex;
			}

//			DMSC( "  TimerIndex= " $ TimerIndex );

			// adding or updating timer
			if( (TimerIndex != -1) && (ArgsFloat[0] > 0.0) )
			{
				//DMSC( "  adding timer " $ ArgsName[0] $ " at " $ TimerIndex $ " OnCmdIndex #1: " $ ArgsLabel[0] $ " OnCmdIndex #2: " $ ArgsLabel[1] );

				if( ArgsLabel[1] == 0 )
				{
					//DMSC( "Using same label for timer!" );
					ArgsLabel[1] = ArgsLabel[0];
				}

				// set timer
				Timers[ TimerIndex ].InitialFrequency = ArgsFloat[0];
				Timers[ TimerIndex ].RepeatFrequency = 0.0;
				Timers[ TimerIndex ].TriggerIndex = TriggerIndex;
				Timers[ TimerIndex ].OnCmdIndex = ArgsLabel[1];
				TriggerEvents[ TriggerIndex ].TimerIndex = TimerIndex;
				if( ArgsString[2] == TextInterrupt )
				{
					Timers[ TimerIndex ].bInterrupt = true;
				}
				else if( ArgsString[2] == TextGotoLabel )
				{
					Timers[ TimerIndex ].bInterrupt = false;
				}
				// "call" command not allowed
				
				// set/reset with specified initial frequency
				HandleAddTimer( TimerIndex, ArgsFloat[0] );
			}

			// store trigger event destination label index
			TriggerEvents[ TriggerIndex ].bClear = ( CurrentHandlerGroup != 0 || ArgsByte[0] != 0 ); // triggers can't have bClear=0 in a handler group
			TriggerEvents[ TriggerIndex ].OnCmdIndex = ArgsLabel[0];
			TriggerEvents[ TriggerIndex ].Group = CurrentHandlerGroup;
			if( ArgsString[0] == TextInterrupt )
			{
				TriggerEvents[ TriggerIndex ].bInterrupt = true;
			}
			else if( ArgsString[0] == TextGotoLabel )
			{
				TriggerEvents[ TriggerIndex ].bInterrupt = false;
			}
			// "call" command not allowed

			//DMSC( "  adding to trigger to table at: " $ TriggerIndex $ " CmdIndex: " $ ArgsLabel[0] $ " bClear:" $ ArgsByte[0] );
		}
	}
	else
	{
		SetScriptError( "Invalid trigger name " $ ArgsName[0] );
	}

//	NPCOwner.DMTNS( "ExecOnTrigger -- NumTriggerEvents: " $ NumTriggerEvents );
}

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

function bool ExecPlaySound( bool bWait )
{
	local Actor A;
	local Sound S;
	local Actor.ESoundSlot Slot;
	local bool bChangeState;

	A = Actor(CurrentCommand.CommandTarget);

	if( A != None )
	{
		// set defaults from target actor
		if( ArgsFloat[0] == 0.0 )
			ArgsFloat[0] = A.TransientSoundVolume;
		if( ArgsFloat[1] == 0.0 )
			ArgsFloat[1] = A.TransientSoundRadius;
		if( ArgsFloat[2] == 0.0 )
			ArgsFloat[2] = 1.0;

		Slot = FindSoundSlot( ArgsName[1] );

		S = Sound(DynamicLoadObject( ArgsString[0], Class'Sound' ));
		if( S != None )
		{
			A.PlaySound( S, Slot, ArgsFloat[0], bool(ArgsByte[0]), ArgsFloat[1], ArgsFloat[2] );
			if( bWait )
			{
				ArgsFloat[0] = A.GetSoundDuration( S );
				GotoState( SleepingState );
				bChangeState = true;
			}
		}
		else
			SetScriptError( "Invalid sound " $ ArgsString[0] );
	}

	return bChangeState;
}

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

function bool ExecPlaySoundTableSlot( bool bWait )
{
	local U2Pawn U2P;
	local sound S;
	local bool bChangeState;
	local SoundSlotInterf.ESoundTableSlot SlotIndex;

	U2P = U2Pawn(CurrentCommand.CommandTarget);

	if( U2P != None && U2P.SoundTable != None )
	{
		if( U2P.SoundTable.StringToSlot( ArgsString[0], SlotIndex ) )
		{
			S = U2P.SoundTable.PlaySlotSound( U2P, SlotIndex );

			if( S != None )
			{
				if( bWait )
				{
					ArgsFloat[0] = U2P.GetSoundDuration( S );
					GotoState( SleepingState );
					bChangeState = true;
				}
			}
			else
				SetScriptError( "No sound found for sound table slot: " $ ArgsString[0] );
		}
		else
			SetScriptError( "Invalid sound table slot: " $ ArgsString[0] $ " for target: " $ U2P $ " using voice package:" @ U2P.VoicePackage );
	}
	else
		SetScriptError( "Invalid target or target has no sound table" );

	return bChangeState;
}

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

function ExecRemoveInventory()
{
	// don't care if we couldn't remove it because not found?
	if( !class'UtilGame'.static.RemoveInventoryString( U2PawnOwner, ArgsString[0] ) )
	{
		SetScriptError( "Couldn't remove inventory " $ ArgsString[0] $ " from NPC" );
	}
}

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

function ExecRemoveInventoryFromPlayer()
{
	// don't care if we couldn't remove it because not found?
	if( !class'UtilGame'.static.RemoveInventoryString( FindPlayer(), ArgsString[0] ) )
	{
		SetScriptError( "Couldn't remove inventory " $ ArgsString[0] $ " from player" );
	}
}

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

function ExecRemoveItemFromPlayer()
{
	// don't care if we couldn't remove it because not found?
	if( !class'UtilGame'.static.RemoveInventoryString( FindPlayer(), ArgsString[0] ) )
	{
		SetScriptError( "Couldn't remove item " $ ArgsString[0] $ " from player" );
	}
}

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

function ExecRemoveTossedItem()
{
	if( !U2PawnOwner.RemoveTossedItem( ArgsString[0] ) )
	{
		SetScriptError( "Couldn't remove tossed item " $ ArgsString[0] $ " from NPC" );
	}
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: could use support for finding spot which is unoccupied...

function ExecResumePatrol()
{
	local int ii;
	local int StartIndex;
	local int EndIndex;
	local string CommandString;
	local int CommandsListIndex;
	local Actor PatrolList[MaxPatrolSize];
	local int CommandIndices[MaxPatrolSize];
	local Actor DestinationActor;
	local name DestinationName;
	local int Res;
	local int NumDestinations;
	local float Dist, ClosestDist;
	local int SelectedIndex;
	local Actor NextPath;
	local string FinalLabel;
	local CommandT LocalCommand;

	StartIndex = ArgsLabel[0];
	EndIndex = ArgsLabel[1];

	//DMSC( "StartIndex:" $ StartIndex );
	//DMSC( "EndIndex:" $ EndIndex );

	// scan commands from StartIndex+1 to EndIndex-1 looking for gotoactor commands and making a list of destination actors
	for( ii=StartIndex+1; ii<=EndIndex-1; ii++ )
	{
		LocalCommand = Commands[ ii ];
		CommandString = LocaLCommand.CommandString;

		// DMSC( ii $ ": " $ CommandString );

		CommandsListIndex = LocalCommand.CommandIndex;
		if( CommandsListIndex != CommandsListIndex_Label )
		{
			if( CommandInfo[CommandsListIndex].CommandCode == CMD_GotoActor || CommandInfo[CommandsListIndex].CommandCode == CMD_GotoActorSafe )
			{
				// this is a gotoactor command -- save off the destination if still valid
				Res = class'Util'.static.ParseName( CommandString, DestinationName );
				if( Res == 1 )
				{
					DestinationActor  = Actor(LocalCommand.CommandTarget);

					if( DestinationActor != None )
					{
						PatrolList[ NumDestinations ] = DestinationActor;
						CommandIndices[ NumDestinations ] = ii;
						NumDestinations++;
					}
				}
			}
			else if( (ii==EndIndex-1) && CommandInfo[CommandsListIndex].CommandCode == CMD_GotoLabel )
			{
				// if last command before end label is a gotolabel startlabel ==> circular patrol -- add first actor to end of list
				Res = class'Util'.static.ParseString( CommandString, FinalLabel );
				if( Res == 1 && FinalLabel == ArgsString[0] )
				{
					PatrolList[ NumDestinations ] = PatrolList[ 0 ];
					CommandIndices[ NumDestinations ] = CommandIndices[ 0 ];
					NumDestinations++;
				}
			}
		}
	}

	if( NumDestinations == 0 )
	{
		SetScriptError( "No gotoactors found for resumepatrol?" );
	}
	else
	{
		//DMSC( "ExecResumePatrol Destinations:" );
		//for( ii=0; ii<NumDestinations; ii++ )
		//	DMSC( ii $ ": " $ PatrolList[ ii ] $ " Index=" $ CommandIndices[ ii ] );

		SelectedIndex = -1;
		if( ArgsName[0] == ResumePatrolBest || ArgsName[0] == ResumePatrolClosest )
		{
			// pick the closest one to the NPC's current location
			// mdf-tbd: test reachability + total path distance
			ClosestDist = 9999999;
			for( ii=0; ii<NumDestinations; ii++ )
			{
				Dist = VSize( U2PawnOwner.Location - PatrolList[ii].Location );
				if( Dist < ClosestDist )
				{
					ClosestDist = Dist;
					SelectedIndex = ii;
				}
			}
			//DMSC( "Closest=" $ PatrolList[ SelectedIndex ] $ " (" $ SelectedIndex $ ")" );

			if( ArgsName[0] == ResumePatrolBest && SelectedIndex < (NumDestinations-1) )
			{
				// best: select next one in list if directly reachable
				if( NPCOwner.ActorReachable( PatrolList[SelectedIndex+1] ) )
				{
					SelectedIndex++;
					//DMSC( "next destination is directly reachable: " $ PatrolList[ SelectedIndex ] );
				}
				else
				{
					// or if path to next one in list is directly reachable
					NPCOwner.FindPathToActor( PatrolList[SelectedIndex+1], NextPath, false, true, true );
					//DMSC( "Path to" $ PatrolList[ SelectedIndex+1 ] $ " is " $ NextPath );
					if( (NextPath != None) && NPCOwner.ActorReachable( NextPath ) )
					{
						SelectedIndex++;
						//DMSC( "path to next destination is directly reachable: " $ PatrolList[ SelectedIndex ] );
					}
				}					
			}
		}
		else if( ArgsName[0] == ResumePatrolSaved )
		{
			// look for destination matching saved one
			for( ii=0; ii<NumDestinations; ii++ )
			{
				if( PatrolList[ii] == SavedDestination )
				{
					SelectedIndex = ii;
					break;
				}
			}
		}
		else if( ArgsName[0] == ResumePatrolRandom )
		{
			SelectedIndex = RandRange( 0, NumDestinations );
		}

		if( SelectedIndex == -1 )
		{
			SetScriptError( "No destination actor selected for resumepatrol?" );
		}
		else
		{
			//DMSC( "Want to head to " $ PatrolList[ SelectedIndex ] );
	 		SetCurrentCommandIndex( CommandIndices[ SelectedIndex ] - 1 );
		}
	}
}

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

function ExecReturn()
{
	SetCurrentCommandIndex( PopCommandIndex() );
}

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

function ExecRotate()
{
	// mdf-tbi:
}

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

function ExecSaveDestination()
{
	SavedDestination = GotoActorTarget;
}

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

function ExecSendEvent()
{
	// for now just send given event to all actors with matching tags and to all NPCs
	// mdf-tbd (opt): make argsbyte an int with 1=trigger NPCs, 2=trigger actors with matching tags, 3=both
	// if 1 is given, we can call TriggerNPCsStatic() instead which will be MUCH faster
	// This should pbly also be extended into the triggers themselves
 	class'TriggerHelper'.static.TriggerActors( NPCOwner, class'Actor', NPCOwner, U2PawnOwner, ArgsName[0], bool(ArgsByte[0]) );
}

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

function ExecSetActorRangeTest()
{
	NPCOwner.SetActorRangeTest( Actor( FindTarget( ArgsName[0], true )), ArgsFloat[0], ArgsByte[0] != 0 );
}

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

function ExecSetAimOdds()
{
	NPCOwner.SetAimOdds( ArgsFloat[0] );
}

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

function ExecSetAlert()
{
	NPCOwner.SetAlert( bool(ArgsByte[0]) );
}

//-----------------------------------------------------------------------------
// Turn this into a utility function?

function ExecSetAmmo()
{
	local Ammunition AmmoInv;
	local class<Ammunition> AmmoClass;

	AmmoClass = class<Ammunition>(DynamicLoadObject( ArgsString[0], class'class' ));
	if( AmmoClass != None )
	{
		AmmoInv = Ammunition(U2PawnOwner.FindInventoryType( AmmoClass ));
		if( AmmoInv == None && ArgsInt[0] > 0 )
		{
			// add it
			AmmoInv = U2PawnOwner.Spawn( AmmoClass, U2PawnOwner, , , rot(0,0,0) );
			if( AmmoInv != None )
			{
				AmmoInv.GiveTo( U2PawnOwner );
			}
			else
			{
				SetScriptError( "Invalid ammo type specified for setammo command?" );
			}
		}

		if( AmmoInv != None )
		{
			AmmoInv.AmmoAmount = ArgsInt[0];
			if( ArgsByte[0] != 0 && U2Ammo(AmmoInv) != None )
				U2Ammo(AmmoInv).MaximizeClipAmount();
		}
	}
	else
	{
		SetScriptError( "Invalid ammo type specified for setammo command?" );
	}
}

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

function ExecSetFocus()
{
	local Actor A;

	if( ArgsName[0] != '' )
	{
		A = Actor(CurrentCommand.CommandTarget);

		if( A != None )
			NPCOwner.SetScriptedFocus( A );
	}
	else
	{
		NPCOwner.SetScriptedFocus( None );
	}
}

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

function ExecSetHealth()
{
	NPCOwner.SetHealth( ArgsInt[0] );
}

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

function ExecSetInventory()
{
	local Pawn TargetPawn;
	local Inventory Inv;
	local int OldAutoSwitchPriority;
		
	TargetPawn = Pawn(CurrentCommand.CommandTarget);
	if( TargetPawn != None && TargetPawn.Controller != None )
	{
		Inv = class'UtilGame'.static.GiveInventoryString( TargetPawn, ArgsString[0] );
		if( Inv != None )
		{
			if( Weapon(Inv) != None )
			{
				// bit hack-ish -- no command to make a weapon current afaict
				OldAutoSwitchPriority = Weapon(Inv).AutoSwitchPriority;
				Weapon(Inv).AutoSwitchPriority = 999999;
				TargetPawn.Controller.SwitchToBestWeapon();
				Weapon(Inv).AutoSwitchPriority = OldAutoSwitchPriority;
			}
			else
			{
				SetScriptError( "setinventory: can't switch to a non-weapon: " $ ArgsString[ 0 ] );
			}
		}
		else
		{
			SetScriptError( "setinventory: can't give item: " $ ArgsString[ 0 ] );
		}
	}
	else
	{
		SetScriptError( "setinventory: can't find target pawn or has no controller: " $ ArgsName[ 0 ] );
	}
}

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

function DoSetLocation( Actor LocationActor, Actor TargetActor )
{
	//NPCOwner.DMTNS( "DoSetLocation: " $ LocationActor $ " " $ TargetActor );
	if( LocationActor != None )
	{
		if( !TargetActor.SetLocation( LocationActor.Location ) && ArgsByte[0] == 0 )
			SetScriptError( "Couldn't place " $ TargetActor $ " at " $ LocationActor );
	}
	else
	{
		SetScriptError( "Invalid target actor " $ TargetActor );
	}
}

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

function execSetLocation()
{
	DoSetLocation( Actor(FindTarget( ArgsName[0] )), U2PawnOwner );
}

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

function execSetLocationNamed()
{
	DoSetLocation( Actor(FindTarget( ArgsName[1] )), Actor(CurrentCommand.CommandTarget) );
}

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

function execSetLocationVector()
{
	local vector TargetLocation;

	TargetLocation.X = ArgsFloat[0];
	TargetLocation.Y = ArgsFloat[1];
	TargetLocation.Z = ArgsFloat[2];

	if( !Actor(CurrentCommand.CommandTarget).SetLocation( TargetLocation ) && ArgsByte[0] == 1 )
		SetScriptError( "Couldn't place " $ CurrentCommand.CommandTarget $ " at " $ TargetLocation );
}

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

function ExecSetMoveSpeed()
{
	local bool bResult;

	switch( ArgsString[0] )
	{
	case "":
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], U2PawnOwner.GetStance() );
		break;
	case "standing":
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Standing );
		break;
	case "crouching":
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Crouching );
		break;
	case "prone":
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Prone );
		break;
	case "all":
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Standing );
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Crouching );
		bResult = NPCOwner.SetScriptedMoveSpeedMultiplier( ArgsFloat[0], Actor.ST_Prone );
		break;
	default:
		SetScriptError( "Invalid stance specified " $ ArgsString[0] );
		break;
	}

	if( !bResult )
		SetScriptError( "Invalid movement speed specified " $ ArgsFloat[0] );
}

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

function ExecSetMoveSpeedAuto()
{
	NPCOwner.SetAutoMoveSpeed( ArgsFloat[0] );
}
		
/*-----------------------------------------------------------------------------
NOTE: only 1 target can be pre-computed currently. This is done for the
OrdersObject (if set) since this will generally take longer to find than the 
order giver (which can be found in the Controller list and which won't be used 
that often).

mdf-tbd:
which orders imply leaving scripted state (go autonomous)
	+attack
	+defend
	+follow (?)
	+none (freelance) (why use in scripted state -- just use "stop" command, no?)

+optionally stay scripted?
	+hold		(can remain in effect on autonomous)
*/


function ExecSetOrders()
{
	local name Orders;
	local Object OrderGiver;
	local Actor OrdersObject;

	///NPCOwner.DM( "ExecSetOrders -- Orders:" $ ArgsName[0] $ " OrdersObject: " $ CurrentCommand.CommandTarget $ " fParam:" $ ArgsFloat[0] $ " OrderGiver:" $ ArgsName[2] );

	// verify orders
	Orders = ArgsName[0];
	switch( Orders )
	{
		case U2NPCController.OrdersGoto:
			Orders = U2NPCController.OrdersGoto;
			break;
		case U2NPCController.OrdersNone:
			Orders = U2NPCController.OrdersNone;
			break;
		case U2NPCController.OrdersSquad:
			Orders = U2NPCController.OrdersSquad;
			break;
		default:
			SetScriptError( MsgInvalidOrdersNotSupported $ ": " $ Orders );
			return;
	}
	
	if( ArgsName[1] != 'none' )
	{
		OrdersObject = Actor(CurrentCommand.CommandTarget);
		if( OrdersObject == None )
			SetScriptError( MsgInvalidOrdersObject $ ": " $ ArgsName[1]  );
	}
	
	if( ArgsName[2] != '' )
	{
		OrderGiver = FindTarget( ArgsName[2] );
		if( Pawn(OrderGiver) != None )
			OrderGiver = Pawn(OrderGiver).Controller;
		if( OrderGiver == None )
			SetScriptError( MsgInvalidOrderGiver $ ": " $ ArgsName[2]  );
	}

	//NPCOwner.DM( "ExecSetOrders calling SetOrders -- Orders: " $ Orders $ " OrderGiver: " $ OrderGiver $ " OrdersObject: " $ OrdersObject );
	if( !NPCOwner.SetOrders( Orders, OrdersObject, ArgsFloat[0], OrderGiver, false ) )
	{
		//NPCOwner.DM( "  failed" );
		SetScriptError( MsgInvalidOrders $ ": " $ Orders  );
	}
}

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

function ExecSetPhysics()
{
	local Actor.EPhysics NewPhysics;
	local Actor TargetActor;
	local bool bError;

	TargetActor = Actor(FindTarget( ArgsName[0] ));
	if( TargetActor != None )
	{
		switch( ArgsName[1] )
		{
		case 'PHYS_Falling':
			NewPhysics = PHYS_Falling;
			break;
		case 'PHYS_Flying':
			NewPhysics = PHYS_Flying;
			break;
		case 'PHYS_None':
			NewPhysics = PHYS_None;
			break;
		case 'PHYS_Swimming':
			NewPhysics = PHYS_Swimming;
			break;
		case 'PHYS_Walking':
			NewPhysics = PHYS_Walking;
			break;
		default:
			SetScriptError( "Invalid slot " $ ArgsName[1] );
			bError = true;
			break;
		}

		if( !bError )
			TargetActor.SetPhysics( NewPhysics );
	}
}

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

function ExecSetProperty()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanSetProperty( ArgsString[0] ) )
		{
			if( ArgsString[1] == DefaultPropertyString )
				O.SetPropertyTextDefault( ArgsString[0] );
			else
				O.SetPropertyText( ArgsString[0], ArgsString[1] );
		}
		else
		{
			SetScriptError( "can't set property " $ ArgsString[0] $ " in " $ O );
		}
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecSetProperties()
{
	local Actor A;
	local class<Actor> ActorClass;

	ActorClass = class<Actor>(DynamicLoadObject( ArgsString[0], class'Class' ));
	if( ActorClass != None )
	{
		foreach NPCOwner.DynamicActors( ActorClass, A )
		{
			if( A.CanSetProperty( ArgsString[1] ) )
			{
				if( ArgsString[2] == DefaultPropertyString )
					A.SetPropertyTextDefault( ArgsString[1] );
				else
					A.SetPropertyText( ArgsString[1], ArgsString[2] );
			}
			else
			{
				SetScriptError( "can't set property " $ ArgsString[1] $ " in " $ A );
			}
		}
	}
	else
	{
		SetScriptError( "Invalid class type for SetProperties: " $ ArgsString[0] );
	}
}

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

function ExecSetSatellite()
{
	local Actor A;

	A = Actor(CurrentCommand.CommandTarget); // can be none
	if( U2PawnOwner != None )
		U2PawnOwner.MeshSetSatellite( ArgsName[0], A );
		//U2PawnOwner.MeshSetSatellite(ArgsName[0], None, A.Location);
}

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

function ExecSetScript()
{
	NPCOwner.SetScript( ArgsString[0], ArgsString[1] );
	
	// we're now executing a new script -- decrement CurrentCommandIndex to 
	// compensate fact that when this call returns it will be incremented
	// which would cause us to start executing the new script at the line
	// after the intended line.
	CurrentCommandIndex--;
}

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

function ExecSetSkill()
{
	NPCOwner.SetSkill( ArgsFloat[0] );
}

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

function bool ExecSetStance()
{
	local byte TargetStance;
	local bool bChangedState;

	TargetStance = U2PawnOwner.GetStance();

	switch( ArgsString[0] )
	{
	case "standing":
		TargetStance = Actor.ST_Standing;
		break;
	case "crouching":
		TargetStance = Actor.ST_Crouching;
		break;
	case "prone":
		TargetStance = Actor.ST_Prone;
		break;
	default:
		SetScriptError( "Invalid stance specified " $ ArgsString[0] );
		break;
	}

	if( TargetStance != U2PawnOwner.GetStance() )
	{
		//DMSC( "Setting stance to " $ ArgsString[0] );

		if( TargetStance == Actor.ST_Crouching && !U2PawnOwner.bCanCrouch )
			SetScriptError( "NPC can't crouch" );
		else if( TargetStance == Actor.ST_Prone && !U2PawnOwner.bCanCrawl )
			SetScriptError( "NPC can't go prone" );
		else
		{	
			NPCOwner.StopMovement( true, true ); // mdf-tbd: otherwise SetStance won't play drop animation
			U2PawnOwner.SetStance( TargetStance );
	 		GotoState( ChangingStanceState );
			bChangedState = true;
		}
	}

	return bChangedState;
}

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

function ExecSetStationary()
{
	NPCOwner.SetStationary( ArgsByte[0] == 1, ArgsByte[1] == 1 );
}

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

function ExecSetTacticalMoveType()
{
	switch( ArgsInt[0] )
	{
		case 0:
			NPCOwner.SetScriptedTacticalMoveType( TMT_None );
			break;
		case 1:
			NPCOwner.SetScriptedTacticalMoveType( TMT_Basic );
			break;
		case 2:
			NPCOwner.SetScriptedTacticalMoveType( TMT_Serpentine );
			break;
		default:
			SetScriptError( "Invalid tactical move type specified " $ ArgsInt[0] );
			break;
	}
}

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

function ExecSetWeapon()
{
	local Weapon W;

	W = class'UtilGame'.static.SetCurrentWeaponString( U2PawnOwner, ArgsString[0] );

	if( W == None )
		SetScriptError( "Couldn't set NPC weapon to " $ ArgsString[0] );

	// mdf-tbi: force NPC to use this weapon even if weapon selecting code would select
	// a different one
	//	else if( ArgsByte[0] != 0 )
	//		NPCOwner.ForceWeapon( W );
}

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

function ExecShutdown()
{
	NPCOwner.Shutdown( ArgsByte[ 0 ] == 1 );
}

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

function ExecSleep()
{
	GotoState( SleepingState );
}

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

function ExecSleepRand()
{
	if( ArgsFloat[0] ~= 0.0 )
		ArgsFloat[0] = 1.0;

	// don't want to allow 0.0 or will sleep indefinitely
	ArgsFloat[0] = RandRange( 0.001, ArgsFloat[0] );

	GotoState( SleepingState );
}

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

function ExecSpawn()
{
	local Inventory Inv;
	local Class<Actor> TargetClass;
	local Actor A;

	TargetClass = class<Actor>(DynamicLoadObject( ArgsString[0], class'Class' ));
	if( TargetClass != None )
		A = Actor(CurrentCommand.CommandTarget).Spawn( TargetClass );

	if( ArgsString[1] != "" && U2Pawn(A) != None && U2NPCController(U2Pawn(A).Controller) != None )
		U2NPCController(U2Pawn(A).Controller).SetScript( ArgsString[1], ArgsString[2] );
	
	if( A == None && ArgsByte[0] == 1 )
		SetScriptError( "Spawn: couldn't spawn a " $ ArgsString[0] );
}

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

function bool ExecStop()
{
	local bool bSuccess;

	// mdf-tbd: I think this check make sense
	// If the command stack isn't empty it means that at least one call 
	// never returned during the current execution phase. It should be
	// possible to have a subroutine that might not call return (unless
	// we add return values this is a necessary evil), but this should
	// be made explicit by clearing the stack so this error won't
	// occur using the clearcalls command?
	if( NumPushedCommandIndices != 0 )
	{
		SetScriptError( MsgCallInterruptReturnError );
	}
	else
	{
		// mdf-tbd:
		DetachScriptController();
		bSuccess = true;
	}

	return bSuccess;
}

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

function ExecStopMovement()
{
	NPCOwner.StopMovement( true, true );
}

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

function ExecStopSound()
{
	local Actor A;
	local Actor.ESoundSlot Slot;

	A = Actor(CurrentCommand.CommandTarget);

	Slot = FindSoundSlot( ArgsName[1] );

	U2PawnOwner.DM("ExecStopSound -- Actor:" @ A @ "Slot:" @ Slot @ "bStopNoOverrideSounds:" @ ArgsByte[0] );

	A.StopSoundSlot( Slot, bool(ArgsByte[0]) );
}

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

function HandleCallOrGotoLabel( bool bResult, string BranchStr )
{
//	DMSC( "HandleCallOrGotoLabel: '" $ BranchStr $ "'" $ " bResult: " $ bResult );
	if( bResult )
	{
		// true: if call/gotolabel given jump to it, otherwise fall through to next line
		if( BranchStr == TextCall )
			DoCall( ArgsLabel[0] );			// call
		else if( BranchStr != "" )
			DoGoto( ArgsLabel[0] );			// gotolabel
	}
	else
	{
		// false: if gotolabel given fall through to next line, otherwise skip next line
		if( BranchStr == "" )
			CurrentCommandIndex++;
	}
}

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

function ExecTestActorInRange()
{
	local Actor TargetActor;

	TargetActor = Actor(FindTarget( ArgsName[0] ));
	if( TargetActor != None )
		HandleCallOrGotoLabel( NPCOwner.CheckActorInRange( TargetActor, ArgsFloat[0] ), ArgsString[0] );

	//DMSC( "ExecTestInRange: " $ ArgsName[0] $ " " $ ArgsFloat[0] $ " " $ ArgsString[0] $ " " $ ArgsString[0] );
}

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

// mdf-tbd: add "default" support to all testproperty functions
function ExecTestProperty()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( O.GetPropertyText( ArgsString[0] ) == ArgsString[1], ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}

	//DMSC( "ExecTestProperty: " $ ArgsString[0] $ " " $ O.GetPropertyText( ArgsString[0] ) $ " " $ ArgsString[1] );
}

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

function ExecTestPropertyCI()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( O.GetPropertyText( ArgsString[0] ) ~= ArgsString[1], ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestPropertyE()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( float(O.GetPropertyText( ArgsString[0] )) == float(ArgsString[1]), ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestPropertyG()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( float(O.GetPropertyText( ArgsString[0] )) > float(ArgsString[1]), ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestPropertyGE()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( float(O.GetPropertyText( ArgsString[0] )) >= float(ArgsString[1]), ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestPropertyL()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( float(O.GetPropertyText( ArgsString[0] )) < float(ArgsString[1]), ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestPropertyLE()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
	{
		if( O.CanGetProperty( ArgsString[0] ) )
			HandleCallOrGotoLabel( float(O.GetPropertyText( ArgsString[0] )) <= float(ArgsString[1]), ArgsString[2] );
		else
			SetScriptError( "can't get property " $ ArgsString[0] $ " in " $ O );
	}
	else
	{
		SetScriptError( "can't find target for command" );
	}
}

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

function ExecTestRandom()
{
	HandleCallOrGotoLabel( FDecision( ArgsFloat[0] ), ArgsString[0] );
}

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

function ExecTestState()
{
	local Object O;

	O = CurrentCommand.CommandTarget;
	if( O != None )
		HandleCallOrGotoLabel( O.IsInState( ArgsName[1] ), ArgsString[0] );
}

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

function bool ExecTurnToActor()
{
	local Actor A;
	local bool bHasLOS;
	local bool bChangedState;

	if( ArgsName[0] != '' )
	{
		A = Actor(CurrentCommand.CommandTarget);
		if( A != None )
		{
			// make sure Pawn can see actor?
			bHasLOS = class'UtilGame'.static.ActorCanSeeActor( U2PawnOwner, A, -1.0 );

			if( bHasLOS || ArgsInt[0] == 2 )
			{
				NPCOwner.TurnToActor( A, (ArgsByte[0] != 0) );
				GotoState( WaitFinishedRotationState );
				bChangedState = true;
			}
			else if( ArgsInt[0] == 1 )
			{
				SetScriptError( "TurnToActor -- can't see " $ A );
			}
		}
		else
		{
			SetScriptError( "TurnToActor -- can't find " $ ArgsName[0] );
		}
	}
	else
	{
		NPCOwner.ClearScriptTarget();
	}

	return bChangedState;
}

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

function ExecUse()
{
	local Actor A;

	A = Actor(CurrentCommand.CommandTarget);
	if( A != None )
	{
		if( A.IsUsable( NPCOwner ) )
			NPCOwner.UseActor( A );
		else
			SetScriptError( "Use: can't use " $ A );
	}
}

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

function ExecUnuse()
{
	local Actor A;

	A = Actor(CurrentCommand.CommandTarget);
	if( A != None )
	{
		if( A.IsUsable( NPCOwner ) )
			NPCOwner.UnuseActor( A );
		else
			SetScriptError( "Unuse: can't unuse " $ A );
	}
}

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

function ExecUsePickups()
{
	// mdf-tbi:
}

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

function ExecFire()
{
	ArgsByte[0] = 0;
	GotoState( FiringState );
}

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

function ExecFireAlt()
{
	ArgsByte[0] = 1;
	GotoState( FiringState );
}

//-------------------------------------------------------------------------
// Used to enable/disable support for firing/altfiring specific weapons.

function WeaponSupports( out array<name> WeaponsList )
{
	local int WeaponPos;
	local int ii;

	// scan U2PawnOwner's DisabledAltFireWeapons list
	ii=0;
	WeaponPos = -1;
	while( ii < WeaponsList.Length )
	{
		if( WeaponsList[ ii ] == ArgsName[ 0 ] )
		{
			WeaponPos = ii;
			break;
		}
		ii++;
	}

	if( ArgsByte[0] == 1 )
	{
		// make sure its not in the list
		if( WeaponPos != -1 )
			WeaponsList.Remove( WeaponPos, 1 );
	}
	else
	{
		// make sure its in the list
		if( WeaponPos == -1 )
			WeaponsList[ WeaponsList.Length ] = ArgsName[ 0 ];
	}

	//mdf-tbd: generalize?
	NPCOwner.RefreshWeapon( ArgsName[0] );
}

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

function ExecWeaponLoad()
{
	if( U2Weapon(U2PawnOwner.Weapon) != None )
		U2Weapon(U2PawnOwner.Weapon).Reload();
	else
		SetScriptError( "WeaponLoad: Pawn not holding a valid weapon" );
}

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

function ExecWeaponSetAmmoType()
{
	if( !NPCOwner.SetAmmoTypeStr( ArgsString[ 0 ] ) )
		SetScriptError( "WeaponSetAmmoType: couldn't select given ammo" );
}

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

function ExecWeaponSupportsAltFire()
{
	WeaponSupports( U2PawnAdvanced(U2PawnOwner).DisabledAltFireWeapons );
}

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

function ExecWeaponSupportsFire()
{
	WeaponSupports( U2PawnAdvanced(U2PawnOwner).DisabledFireWeapons );
}

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

function ExecEnableXMPHandling()
{
	bXMPHandlingEnabled = bool(ArgsByte[0]);
	NPCOwner.SetXMPHandlingEnabled( bXMPHandlingEnabled );
}

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

function bool ExecuteCommand()
{
	local bool bChangeState;
	local ECommandCode CurrentCommandCode;

	//!!!Log( "ExecuteCommand - Begin" );

	// tbd: can get rid of bChangeState gunk if use actors or add state code support for objects
	bChangeState = false;

	if( CurrentCommand.CommandIndex == CommandsListIndex_Stop )
		CurrentCommandCode = CMD_Stop;
	else
		CurrentCommandCode = CommandInfo[ CurrentCommand.CommandIndex ].CommandCode;

	//!!!Log( "  CurrentCommandCode:    " $ EnumStr( enum'ECommandCode', CurrentCommandCode ) );
	//!!!Log( "  CurrentCommandIndex:   " $ CurrentCommand.CommandIndex );
	//!!!Log( "  CurrentCommandString:  " $ CurrentCommand.CommandString );
	//!!!Log( "  CurrentCommandTarget:  " $ CurrentCommand.CommandTarget );

	switch( CurrentCommandCode )
	{
	case CMD_AddAmmo:
		ExecAddAmmo();
		break;

	case CMD_AgentBind:
		ExecAgentBind();
		break;

	case CMD_AgentCall:
		bChangeState = ExecAgentCall();
		break;

	case CMD_AgentExecute:
		bChangeState = ExecAgentExecute();

	case CMD_AgentUnbind:
		ExecAgentUnbind();
		break;

   	case CMD_AnimLoop:
	case CMD_AnimPlay:
	case CMD_AnimTween:
		bChangeState = ExecAnim( CurrentCommandCode, 0 );
		break;

   	case CMD_AnimLoopEx:
	case CMD_AnimPlayEx:
	case CMD_AnimTweenEx:
		bChangeState = ExecAnim( CurrentCommandCode, ArgsInt[0] );
		break;

	case CMD_AnimRelease:
		ExecAnimRelease();
		break;

	case CMD_Call:
		ExecCall();
		break;

	case CMD_CallScript:
		ExecCallScript();
		break;

	case CMD_CallEnd:
		ExecCallEnd();
		break;

	case CMD_ClearEvents:
		ExecClearEvents();
		break;

	case CMD_ClearTimers:
		ExecClearTimers();
		break;

	case CMD_ClearTriggers:
		//NPCOwner.DMTNS( "CMD_ClearTriggers calling ExecClearTriggers" );
		ExecClearTriggers();
		break;

	case CMD_ConsoleCommand:
		ExecConsoleCommand();
		break;
		
	case CMD_DebugAI:
		ExecDebugAI();
		break;

	case CMD_DebugAIEvents:
		ExecDebugAIEvents();
		break;

	case CMD_DebugAIFlags:
		ExecDebugAIFlags();
		break;

	case CMD_DebugMode:
		ExecDebugMode();
		break;

	case CMD_DecProperty:
		ExecDecProperty();
		break;

	case CMD_DeployInventory:
		ExecDeployInventory();
		break;

	case CMD_Destroy:
		ExecDestroy();
		break;

	case CMD_DialogDisable:
		ExecDialogDisable();
		break;

	case CMD_DialogEnable:
		ExecDialogEnable();
		break;

	case CMD_DialogFar:
		ExecDialogFar( false );
		break;

	case CMD_DialogFarWait:
		bChangeState = ExecDialogFar( true );
		break;

	case CMD_DialogInitiate:
		ExecDialogInitiate();
		break;

	case CMD_DialogTerminate:
		ExecDialogTerminate();
		break;

	case CMD_DirectionalPatrol:
		ExecDirectionalPatrol();
		break;

	case CMD_Dormant:
		ExecDormant();
		break;

	case CMD_DropInventory:
		ExecDropInventory();
		break;

	case CMD_EnableProbeEvent:
		ExecEnableProbeEvent();
		break;

	case CMD_EventDisable:
		ExecEventDisable();
		break;

	case CMD_EventEnable:
		ExecEventEnable();
		break;

	case CMD_EventWait:
		ExecEventWait();
		bChangeState = true;
		break;

	case CMD_FindActor:
		ExecFindActor();
		break;

	case CMD_Fire:
		ExecFire();
		bChangeState = true;
		break;

	case CMD_FireAlt:
		ExecFireAlt();
		bChangeState = true;
		break;

	case CMD_Gib:
		ExecGib();
		break;

	case CMD_GibAll:
		ExecGibAll();
		break;

	case CMD_GiveInventory:
		ExecGiveInventory();
		break;

	case CMD_GiveItemToPlayer:
		ExecGiveItemToPlayer();
		break;

	case CMD_GiveTossedItem:
		ExecGiveTossedItem();
		break;

	case CMD_GotoActor:
		ExecGotoActor();
		bChangeState = true;
		break;

	case CMD_GotoActorSafe:
		bChangeState = ExecGotoActorSafe();
		break;

	case CMD_GotoLabel:
		ExecGotoLabel();
		break;

	case CMD_IncProperty:
		ExecIncProperty();
		break;

	case CMD_Inert:
		ExecInert();
		break;

	case CMD_EnableXMPHandling:
		ExecEnableXMPHandling();
		break;

	case CMD_HandlerGroup:
		ExecHandlerGroup();
		break;

	case CMD_HandlerGroupEnd:
		ExecHandlerGroupEnd();
		break;

	case CMD_HeadTracking:
		ExecHeadTracking();
		break;

	case CMD_Jump:
		ExecJump();
		break;

	case CMD_Kill:
		ExecKill();
		break;

	case CMD_KillAll:
		ExecKillAll();
		break;

	case CMD_LockStep:
		ExecLockStep();
		break;

	case CMD_Message:
		ExecMessage();
		break;

	case CMD_OnEvent:
		ExecOnEvent();
		break;

	case CMD_OnTimer:
		ExecOnTimer();
		break;

	case CMD_OnTrigger:
		ExecOnTrigger();
		break;

	case CMD_PlaySound:
		ExecPlaySound( false );
		break;

	case CMD_PlaySoundWait:
		bChangeState = ExecPlaySound( true );
		break;

	case CMD_PlaySoundTableSlot:
		ExecPlaySoundTableSlot( false );
		break;

	case CMD_PlaySoundTableSlotWait:
		bChangeState = ExecPlaySoundTableSlot( true );
		break;

	case CMD_RemoveInventory:
		ExecRemoveInventory();
		break;

	case CMD_RemoveInventoryFromPlayer:
		ExecRemoveInventoryFromPlayer();
		break;

	case CMD_RemoveItemFromPlayer:
		ExecRemoveItemFromPlayer();
		break;

	case CMD_RemoveTossedItem:
		ExecRemoveTossedItem();
		break;

	case CMD_ResumePatrol:
		ExecResumePatrol();
		break;

	case CMD_Return:
		ExecReturn();
		break;

	case CMD_Rotate:
		ExecRotate();
		break;

	case CMD_SaveDestination:
		ExecSaveDestination();
		break;

	case CMD_SendEvent:
		ExecSendEvent();
		break;

	case CMD_SetActorRangeTest:
		ExecSetActorRangeTest();
		break;

	case CMD_SetAimOdds:
		ExecSetAimOdds();
		break;

	case CMD_SetAlert:
		ExecSetAlert();
		break;

	case CMD_SetAmmo:
		ExecSetAmmo();
		break;

	case CMD_SetFocus:
		ExecSetFocus();
		break;

	case CMD_SetHealth:
		ExecSetHealth();
		break;

	case CMD_SetInventory:
		ExecSetInventory();
		break;

	case CMD_SetLocation:
		ExecSetLocation();
		break;

	case CMD_SetLocationNamed:
		ExecSetLocationNamed();
		break;

	case CMD_SetLocationVector:
		ExecSetLocationVector();
		break;

	case CMD_SetMoveSpeed:
		ExecSetMoveSpeed();
		break;

	case CMD_SetMoveSpeedAuto:
		ExecSetMoveSpeedAuto();
		break;

	case CMD_SetOrders:
		ExecSetOrders();
		break;

	case CMD_SetPhysics:
		ExecSetPhysics();
		break;

	case CMD_SetProperty:
		ExecSetProperty();
		break;

	case CMD_SetProperties:
		ExecSetProperties();
		break;

	case CMD_SetSatellite:
		ExecSetSatellite();
		break;

	case CMD_SetScript:
		ExecSetScript();
		break;

	case CMD_SetSkill:
		ExecSetSkill();
		break;

	case CMD_SetStance:
		bChangeState = ExecSetStance();
		break;

	case CMD_SetStationary:
		ExecSetStationary();
		break;

	case CMD_SetTacticalMoveType:
		ExecSetTacticalMoveType();
		break;
		
	case CMD_SetWeapon:
		ExecSetWeapon();
		break;

	case CMD_Shutdown:
		ExecShutdown();
		break;

	case CMD_Sleep:
		ExecSleep();
		bChangeState = true;
		break;

	case CMD_SleepRand:
		ExecSleepRand();
		bChangeState = true;
		break;

	case CMD_Spawn:
		ExecSpawn();
		break;

	case CMD_Stop:
		bChangeState = ExecStop();
		break;

	case CMD_StopMovement:
		ExecStopMovement();
		break;

	case CMD_StopSound:
		ExecStopSound();
		break;

	case CMD_TestActorInRange:
		ExecTestActorInRange();
		break;

	case CMD_TestProperty:
		ExecTestProperty();
		break;

	case CMD_TestPropertyCI:
		ExecTestPropertyCI();
		break;

	case CMD_TestPropertyE:
		ExecTestPropertyE();
		break;

	case CMD_TestPropertyG:
		ExecTestPropertyG();
		break;

	case CMD_TestPropertyGE:
		ExecTestPropertyGE();
		break;

	case CMD_TestPropertyL:
		ExecTestPropertyL();
		break;

	case CMD_TestPropertyLE:
		ExecTestPropertyLE();
		break;

	case CMD_TestRandom:
		ExecTestRandom();
		break;

	case CMD_TestState:
		ExecTestState();
		break;

	case CMD_TurnToActor:
		bChangeState = ExecTurnToActor();
		break;

	case CMD_Unuse:
		ExecUnuse();
		break;

	case CMD_Use:
		ExecUse();
		break;

	case CMD_UsePickups:
		ExecUsePickups();
		break;

	case CMD_WeaponLoad:
		ExecWeaponLoad();
		break;

	case CMD_WeaponSetAmmoType:
		ExecWeaponSetAmmoType();
		break;

	case CMD_WeaponSupportsAltFire:
		ExecWeaponSupportsAltFire();
		break;

	case CMD_WeaponSupportsFire:
		ExecWeaponSupportsFire();
		break;

	default:
		SetScriptError( "invalid CMD in ExecuteCommand?!" );
		break;
	}

	if( ScriptErrorMessage != "" )
	{
		ScriptError();
		bChangeState = true;
	}

	//!!!Log( "ExecuteCommand - End" );

	return bChangeState;
} // ExecuteCommand

//-----------------------------------------------------------------------------
// STATES
//-----------------------------------------------------------------------------

function ResumeExecuting()
{
	if( NPCOwner.IsDialogPaused() )
		GotoState( WaitDialogPausedState );
	else
		GotoState( ExecuteCommandsState );
}

//-----------------------------------------------------------------------------
// Note: no state code since object-derived unless we add support for this.
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Some error occured. The controlled NPC should already have been turned red,
// but periodically broadcast a message so that its pretty obvious there is a
// problem (in case the NPC isn't immediately visible). Also, Trace debugger
// should show current error.

state @ BroadcastErrorState
{
	//-------------------------------------------------------------------------

	function BroadcastErrorMessage()
	{
		// mdf-tbd: hack fix for ProcessEvent crash if owner killed while not attached to this controller
		if( NPCOwner != None && U2PawnOwner.Health <= 0 )
		{
			RemoveTimer( BroadcastErrorMessageTimerName );
		}
		else if( NPCOwner != None )
		{
			NPCOwner.BM( ScriptErrorMessage );
		}
	}

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

	function string GetDebugInformation1()
	{
		return Global.GetDebugInformation1() $ " " $ ScriptErrorMessage;
	}

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

	event BeginState()
	{
		ScriptErrorMessage =
			U2PawnOwner.Name $ " (" $
			CommandFileName $ DefaultExt $ ") " $
			ScriptErrorMessage $ " (" $ Commands[ CurrentCommandIndex-1 ].CommandString $ ")";

		BroadcastErrorMessage();

		// mdf-tbd: I'd like to see bRepeat replaced with a optional float RepeatFrequency for flexibility
		// also, repeat rate appears to be 1/2 what it should be?

		if( ErrorMessageFrequency > 0.0 )
			AddTimer( BroadcastErrorMessageTimerName, ErrorMessageFrequency, true );
	}

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

	event EndState()
	{
		RemoveTimer( BroadcastErrorMessageTimerName );
	}
}

//-----------------------------------------------------------------------------
// state ExecuteCommands
//
// Decode the next command and execute it. For many commands this will involve 
// switching to another state which will wait for a specific event which 
// indicates that the command has been completed (e.g. gotoactor).

/*tbr: don't want to start in this automatically: auto*/ 

state @ ExecuteCommandsState
{
	event BeginState()
	{
		local bool bChangeState;
		local bool bDecodeResult; 
		
		// MAIN SCRIPT CONTROLLER EXECUTION LOOP -- this is where commands are decoded and executed

		bChangeState = false;
		while( (NPCOwner != None) && !bChangeState )
		{
			bDecodeResult = DecodeCommand( false, true );
			if( bDecodeResult )
			{
				if( CurrentCommand.CommandIndex != CommandsListIndex_Label )
					bChangeState = ExecuteCommand();
				
				CurrentCommandIndex++;
			}
			else
			{
				bChangeState = true;
				ScriptError();
			}
		}
	}
}

//-----------------------------------------------------------------------------
// mdf-tbd: sometimes animend is never happening? Maybe adding check for 
// IsAnimating before going to this state will fix this?

state @ ChangingStanceState
{
	function StanceChangeDone()
	{
		ResumeExecuting();
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		//NPCOwner.DMTNS( "BeginState" );
		// just wait a fixed amount of time before continuing since we aren't using animations currently
		AddTimer( StanceChangeDoneTimerName, 1.0 );
	}
}

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

state @ DetachingState
{
	event BeginState()
	{
		GotoState( NoState );
		CleanupScriptController();
	}
}

//-----------------------------------------------------------------------------
// If no time was given will sleep indefinitely (an onevent will be needed to
// wake up the controller). If a time was given, will sleep for the given
// length of time unless an onevent is handled.

state @ SleepingState
{
	//-------------------------------------------------------------------------
	// note: objects can't use script code or latent functions and don't get Ticked or Timer events

	function ResumeProcessing()
	{
		RemoveTimer( ResumeProcessingTimerName );
		ResumeExecuting();
	}

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

	function string GetDebugInformation1()
	{
		return Global.GetDebugInformation1() $ " " $ class'Util'.static.GetFloatString(TimeRemaining( 'ResumeProcessing' ));
	}

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

	event BeginState()
	{
		if( ArgsFloat[0] > 0.0 )
		{
			AddTimer( ResumeProcessingTimerName, ArgsFloat[0] );
		}
	}

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

	event EndState()
	{
		RemoveTimer( ResumeProcessingTimerName );
	}
}

//-----------------------------------------------------------------------------
// mdf-tbd: pbly more flexible to have fire [0|1] and firealt [0|1] so these 
// can be used to start firing, navigate to some location and/or sleep etc. 
// then turn firing off.

state @ FiringState
{
	//-------------------------------------------------------------------------

	function RemoveFiringTimers()
	{	
		RemoveTimer( StopFiringTimerName );
		RemoveTimer( StopFiringBackupTimerName );
	}
	
	//-------------------------------------------------------------------------

	function DoStopFiring()
	{
		//NPCOwner.DMTNS( "StopFiring BEGIN bFire:" $ NPCOwner.bFire $ " bAltFire: " $ NPCOwner.bAltFire );
		RemoveFiringTimers();
		#debug   NPCOwner.StopFiring( 0.0, SFI_Behavior, GetContext() );
		#release NPCOwner.StopFiring( 0.0, SFI_Behavior );
		//NPCOwner.DMTNS( "StopFiring END bFire:" $ NPCOwner.bFire $ " bAltFire: " $ NPCOwner.bAltFire );
		ResumeExecuting();
	}
	
	//-------------------------------------------------------------------------

	function StopFiring()
	{
		DoStopFiring();
	}

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

	function StopFiringBackup()
	{
		DoStopFiring();
	}

	//-------------------------------------------------------------------------
	// NPC letting us know that firing has started (NPC rotation is ok and 
	// weapon is prepared to fire).

	function StartScriptedFiring()
	{
		local float StopFiringTime;

		// firing has started (might have had to wait for rotation), so start timing now
		if( ArgsFloat[0] < 0.0 )
		{
			if( NPCOwner.IsRepeatFire( ArgsByte[ 0 ] == 0 ) )
				StopFiringTime = -ArgsFloat[0]; // fire continuously for repeat fire weapons
			else
				StopFiringTime = 0.0; // fire single shot for non-repeating weapons -- stop firing with next tick
		}
		else
		{
			StopFiringTime = ArgsFloat[0];
		}

		//NPCOwner.DMTNS( "Add StopFiring Timer: " $ StopFiringTime );
		AddTimer( StopFiringTimerName, StopFiringTime );
	}

	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		//NPCOwner.DMTNS( "FiringState.BeginState BEGIN bFire:" $ NPCOwner.bFire $ " bAltFire: " $ NPCOwner.bAltFire );
		NPCOwner.MaybeFire( ArgsByte[0] );
		AddTimer( StopFiringBackupTimerName, FMax( 2.0, Abs( ArgsFloat[0] ) ) ); // just in case StartScriptedFiring never called
		//NPCOwner.DMTNS( "FiringState.BeginState END bFire:" $ NPCOwner.bFire $ " bAltFire: " $ NPCOwner.bAltFire );
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		RemoveFiringTimers();
	}	
}

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

state @ WaitActorInRangeState
{
	//-------------------------------------------------------------------------
	function eventSCActorInRange( U2NPCControllerScriptable NPC )
	{
		Global.eventSCActorInRange( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitActorOutOfRangeState
{
	//-------------------------------------------------------------------------
	function eventSCActorOutOfRange( U2NPCControllerScriptable NPC )
	{
		Global.eventSCActorOutOfRange( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitAnimEndState
{
	//-------------------------------------------------------------------------

	function eventSCAnimEnd( U2NPCControllerScriptable NPC, int Channel )
	{
		Global.eventSCAnimEnd( NPC, Channel );
		ResumeExecuting();
	}
}

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

state @ WaitBumpEnemyState
{
	//-------------------------------------------------------------------------

	function eventSCBumpEnemy( U2NPCControllerScriptable NPC, Pawn Other )
	{
		Global.eventSCBumpEnemy( NPC, Other );
		ResumeExecuting();
	}
}

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

state @ WaitBumpFriendState
{
	//-------------------------------------------------------------------------

	function eventSCBumpFriend( U2NPCControllerScriptable NPC, Pawn Other )
	{
		Global.eventSCBumpFriend( NPC, Other );
		ResumeExecuting();
	}
}

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

state @ WaitBumpOtherState
{
	//-------------------------------------------------------------------------

	function eventSCBumpOther( U2NPCControllerScriptable NPC, Actor Other )
	{
		Global.eventSCBumpOther( NPC, Other );
		ResumeExecuting();
	}
}

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

state @ WaitBumpPlayerState
{
	//-------------------------------------------------------------------------

	function bool eventSCBumpPlayer( U2NPCControllerScriptable NPC, Pawn Other, bool bFriendly )
	{
		local bool bResult;

		bResult = Global.eventSCBumpPlayer( NPC, Other, bFriendly );
		ResumeExecuting();
		return bResult;
	}
}

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

state @ WaitDestinationReachedState
{
	//-------------------------------------------------------------------------

	function string GetDebugInformation1()
	{
		return Global.GetDebugInformation1() $ " Destination: " $ GotoActorTarget;
	}

	//-------------------------------------------------------------------------
	
	function eventSCDestinationReached( U2NPCControllerScriptable NPC )
	{
		Global.eventSCDestinationReached( NPC );
		ResumeExecuting();
	}
}

//-----------------------------------------------------------------------------
// If any latent command (animplay, eventwait, sleep etc.) ends while the NPC
// is handling a dialog node with bPauseNPC=true, the script controller is put 
// into this state rather than resuming the execution of the script. When this
// happens, the only way that script execution can resume is
//
//    a) if the dialog ends or is unpaused -- eventSCDialogUnPaused generated
//    b) a timer expires or an ontrigger event arrives
//
// TBD: for any given dialog, we don't currently support pausing more than 
// once and if the script is unpaused (via a or b above), it will not be
// paused again (even if a latent function executes and the current dialog
// is still paused) until a new dialog starts. TBD: maybe nodes which have
// bUnPauseNPC=true can reset this?

state @ WaitDialogPausedState
{
	function eventSCDialogUnPause( U2NPCControllerScriptable NPC )
	{
		Global.eventSCDialogUnPause( NPC );
		GotoState( ExecuteCommandsState );
	}
}

//-----------------------------------------------------------------------------
// This state waits for the current DialogFar command to finish.
// Once the dialog between the NPC(s) finishes, resume script execution.

state @ WaitDialogFarPausedState
{
	function eventSCDialogUnPause( U2NPCControllerScriptable NPC )
	{
		Global.eventSCDialogUnPause( NPC );
		GotoState( ExecuteCommandsState );
	}
}

//-----------------------------------------------------------------------------
// Only used through WaitDestinationReached if NPC is using a directional 
// patrol and the movetarget is bDirectional to wait for the NPC to line itself
// up with the movetarget.

state @ WaitFinishedRotationState
{
	//-------------------------------------------------------------------------

	function eventSCFinishedRotation( U2NPCControllerScriptable NPC )
	{
		Global.eventSCFinishedRotation( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitDialogBeginState
{
	//-------------------------------------------------------------------------

	function eventSCDialogBegin( U2NPCControllerScriptable NPC )
	{
		Global.eventSCDialogBegin( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitDiedState
{
	//-------------------------------------------------------------------------

	function eventSCDied( U2NPCControllerScriptable NPC )
	{
		Global.eventSCDied( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitHearNoiseFriendlyState
{
	//-------------------------------------------------------------------------

	function eventSCHearNoiseFriendly( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
	{
		Global.eventSCHearNoiseFriendly( NPC, Loudness, NoiseMaker );
		ResumeExecuting();
	}
}

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

state @ WaitHearNoiseOtherState
{
	//-------------------------------------------------------------------------

	function eventSCHearNoiseOther( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
	{
		Global.eventSCHearNoiseOther( NPC, Loudness, NoiseMaker );
		ResumeExecuting();
	}
}

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

state @ WaitHearNoiseThreatState
{
	//-------------------------------------------------------------------------

	function eventSCHearNoiseThreat( U2NPCControllerScriptable NPC, float Loudness, Actor NoiseMaker )
	{
		Global.eventSCHearNoiseThreat( NPC, Loudness, NoiseMaker );
		ResumeExecuting();
	}
}

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

state @ WaitScriptedLandingState
{
	//-------------------------------------------------------------------------

	function eventSCScriptedLanding( U2NPCControllerScriptable NPC )
	{
		Global.eventSCScriptedLanding( NPC );
		ResumeExecuting();
	}
}

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

state @ WaitSeeEnemyState
{
	//-------------------------------------------------------------------------

	function eventSCSeeEnemy( U2NPCControllerScriptable NPC, Pawn Seen )
	{
		Global.eventSCSeeEnemy( NPC, Seen );
		ResumeExecuting();
	}
}

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

state @ WaitSeeFriendState
{
	//-------------------------------------------------------------------------

	function eventSCSeeFriend( U2NPCControllerScriptable NPC, Pawn Seen )
	{
		Global.eventSCSeeFriend( NPC, Seen );
		ResumeExecuting();
	}
}


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

state @ WaitSeeOtherState
{
	//-------------------------------------------------------------------------

	function eventSCSeeOther( U2NPCControllerScriptable NPC, Actor Seen )
	{
		Global.eventSCSeeOther( NPC, Seen );
		ResumeExecuting();
	}
}


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

state @ WaitSeePlayerState
{
	//-------------------------------------------------------------------------

	function bool eventSCSeePlayer( U2NPCControllerScriptable NPC, Pawn Seen, bool bFriendly )
	{
		local bool bResult;

		bResult = Global.eventSCSeePlayer( NPC, Seen, bFriendly );
		ResumeExecuting();
		return bResult;
	}
}

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

state @ WaitTakeDamageState
{
	//-------------------------------------------------------------------------

	function eventSCTakeDamage( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventSCTakeDamage( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
		ResumeExecuting();
	}
}

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

state @ WaitTookDamageState
{
	function eventSCTookDamage( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventSCTookDamage( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
		ResumeExecuting();
	}
}

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

state @ WaitTookDamageEnemyState
{
	function eventSCTookDamageEnemy( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventSCTookDamageEnemy( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
		ResumeExecuting();
	}
}

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

state @ WaitTookDamageFriendState
{
	function eventSCTookDamageFriend( U2NPCControllerScriptable NPC, int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventSCTookDamageFriend( NPC, Damage, EventInstigator, HitLocation, Momentum, DamageType );
		ResumeExecuting();
	}
}

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

state @ WaitTriggerState
{
	//-------------------------------------------------------------------------

	function eventSCTrigger( U2NPCControllerScriptable NPC, Actor Other, Pawn Instigator, name EventName )
	{
		Global.eventSCTrigger( NPC, Other, Instigator, EventName );

		if( WaitTriggerEvent == '' || (EventName == WaitTriggerEvent) )
		{
			ResumeExecuting();
		}
	}

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

	event BeginState()
	{
		WaitTriggerEvent = ArgsName[1];
	}
}

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

function string GetDebugInformation1()
{
	return string(Name) $ " (State=" $ GetStateName() $ " File=" $ CommandFileName $ DefaultExt $ " Cmd=" $ CurrentCommandIndex $ "/" $ Commands.Length $ "/" $ DecodedCount $ ")"; 
}

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

function GetEventInformation( out array<string> ReturnedStrings )
{
	local int ii;
	local int StrIndex;
	local int AddedStrs;
	
	StrIndex = ReturnedStrings.Length;
	
	ReturnedStrings[ StrIndex ] = " Handlers: ";
	
	// show events which are being handled
	if( NumEvents > 0 )
	{
		for( ii=0; ii<NumEvents; ii++ )
		{
			if( Events[ii].OnCmdIndex >= 0 )
			{
				AddedStrs++;
				if( (AddedStrs % 5) == 0 )
				{
					StrIndex++;
					ReturnedStrings[ StrIndex ] = "    ";
				}
				ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ Events[ii].EventName $ "(->" $ Events[ii].OnCmdIndex $ "!" $ Events[ii].Group $ ") ";
			}
		}
	}
	
	if( AddedStrs == 0 )
		ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ "NA";
}

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

function GetTriggerInformation( out array<string> ReturnedStrings )
{
	local int ii;
	local int StrIndex;
	local int AddedStrs;
	
	StrIndex = ReturnedStrings.Length;
	
	ReturnedStrings[ StrIndex ] = " Triggers: ";

	// show triggers which are being handled
	if( NumTriggerEvents > 0 )
	{
		for( ii=0; ii<NumTriggerEvents; ii++ )
		{
			AddedStrs++;
			if( (AddedStrs % 5) == 0 )
			{
				StrIndex++;
				ReturnedStrings[ StrIndex ] = "    ";
			}
			
			ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ TriggerEvents[ii].EventName $ "(->" $ TriggerEvents[ii].OnCmdIndex $ "!" $ TriggerEvents[ii].Group $ " ";
			if( TriggerEvents[ii].TimerIndex != -1 )
				ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ " @ " $ class'Util'.static.GetFloatString(HandleTimeRemaining(TriggerEvents[ii].TimerIndex )) $ "->" $ Timers[TriggerEvents[ii].TimerIndex].OnCmdIndex;
			ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ ") ";
		}
	}
	else
	{
		ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ "NA";
	}
}

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

function GetTimerInformation( out array<string> ReturnedStrings )
{
	local int ii;
	local int StrIndex;
	local int AddedStrs;
		
	StrIndex = ReturnedStrings.Length;
	
	ReturnedStrings[ StrIndex ] = " Timers:   ";

	// show non-trigger timers which are being handled
	for( ii=0; ii<MaxGeneralTimers; ii++ )
	{
		if( Timers[ii].OnCmdIndex != -1 )
		{
			AddedStrs++;
			if( (AddedStrs % 5) == 0 )
			{
				StrIndex++;
				ReturnedStrings[ StrIndex ] = "    ";
			}
			
			ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ ii $ " " $ class'Util'.static.GetFloatString(HandleTimeRemaining( ii )) $ "/" $ class'Util'.static.GetFloatString(Timers[ii].RepeatFrequency) $ "(->" $ Timers[ii].OnCmdIndex $ "!" $ Timers[ii].Group $ ") ";
		}
	}
	
	if( AddedStrs == 0 )
		ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ "NA";
}

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

function GetDisabledInformation( out array<string> ReturnedStrings )
{
	local int ii;
	local int StrIndex;
	local int AddedStrs;
		
	StrIndex = ReturnedStrings.Length;
	
	ReturnedStrings[ StrIndex ] = " Disabled: ";

	// show events which are disabled
	for( ii=0; ii<NumEvents; ii++ )
	{
		if( !Events[ii].bEnabled )
		{
			AddedStrs++;
			if( (AddedStrs % 10) == 0 )
			{
				StrIndex++;
				ReturnedStrings[ StrIndex ] = "    ";
			}
			ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ Events[ii].EventName $ " ";
		}
	}
	
	if( AddedStrs == 0 )
		ReturnedStrings[ StrIndex ] = ReturnedStrings[ StrIndex ] $ "NA";
}

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

function GetDebugInformation( U2NPCControllerScriptable NPC, out array<string> ReturnedStrings )
{
	ReturnedStrings[ 0 ] = GetDebugInformation1( );
	GetEventInformation( ReturnedStrings );
	GetTriggerInformation( ReturnedStrings );
	GetTimerInformation( ReturnedStrings );
	GetDisabledInformation( ReturnedStrings );
}

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

function string GetScriptContextStr( optional bool bMinimal )
{
	local string ReturnedStr;
	local string ControllerStr;

	if( bMinimal )
	{
		if( NPCOwner != None )
		{
			if( NPCOwner.Pawn != None )
				ReturnedStr = "Pawn=" $ NPCOwner.Pawn.Name;
			else
				ReturnedStr = "Controller=" $ NPCOwner.Name;
		}
		else
		{
			ReturnedStr = "NPCOwner=None";
		}
	}
	else
	{
		if( NPCOwner != None )
		{
			ControllerStr = "Controller=" $ NPCOwner.Name $ "." $ NPCOwner.GetStateName() $ " SCState=" $ GetStateName();
			if( NPCOwner.Pawn != None )
				ReturnedStr = "Pawn=" $ NPCOwner.Pawn.Name $ "." $ NPCOwner.Pawn.GetStateName() $ " " $ ControllerStr;
			else
				ReturnedStr = "Pawn=None " $ ControllerStr;
		}
		else
		{
			ReturnedStr = "NPCOwner=None " $ GetStateName();
		}
	}

	return "(" $ ReturnedStr $ ")";
}

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

function DMH( coerce string Str )
{
	if( NPCOwner != None )
		NPCOwner.BM( "SC: " $ Str );
	Log( Str, 'SC' );	
}

//-----------------------------------------------------------------------------
// Script logging helper. All calls to this should be removed/disabled before 
// shipping with the exception of Debug_Command logs which are always handy.
// Note that internal errors should go through DMs/logs or SetScriptError
// instead of DMSC so that these aren't only visible when debugging is enabled 
// and remain after shipping.

function DMSC( coerce string Str, optional bool bStrict )
{
	if( DebugMode != 0 )
	{
		if( bStrict )
		{
			// don't add anything to string
			if( NPCOwner != None )
				NPCOwner.DMT( Str, false, false, 'SC' );
			else
				Log( Str, 'SC' );
		}
		else
		{
			Str = Str $ " " $ GetScriptContextStr( true );
			if( NPCOwner != None )
				NPCOwner.DMT( Str, false, false, 'SC' );
			else
				Log( Str, 'SC' );
		}
	}
}

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

defaultproperties
{
	ErrorMessageFrequency=3.000000
	CommandInfo(0)=(CommandString="error",CommandCode=CMD_Error,Signature="X")
	CommandInfo(1)=(CommandString="addammo",CommandCode=CMD_AddAmmo,Signature="SIb")
	CommandInfo(2)=(CommandString="agentbind",CommandCode=CMD_AgentBind,Signature="MM")
	CommandInfo(3)=(CommandString="agentcall",CommandCode=CMD_AgentCall,Signature="Mb")
	CommandInfo(4)=(CommandString="agentexecute",CommandCode=CMD_AgentExecute,Signature="Sb")
	CommandInfo(5)=(CommandString="agentunbind",CommandCode=CMD_AgentUnbind,Signature="M")
	CommandInfo(6)=(CommandString="animloop",CommandCode=CMD_AnimLoop,Signature="Mffb")
	CommandInfo(7)=(CommandString="animloopex",CommandCode=CMD_AnimLoopEx,Signature="IMffb")
	CommandInfo(8)=(CommandString="animplay",CommandCode=CMD_AnimPlay,Signature="Mffb")
	CommandInfo(9)=(CommandString="animplayex",CommandCode=CMD_AnimPlayEx,Signature="IMffb")
	CommandInfo(10)=(CommandString="animrelease",CommandCode=CMD_AnimRelease,Signature="X")
	CommandInfo(11)=(CommandString="animtween",CommandCode=CMD_AnimTween,Signature="Mfb")
	CommandInfo(12)=(CommandString="animtweenex",CommandCode=CMD_AnimTweenEx,Signature="IMfb")
	CommandInfo(13)=(CommandString="call",CommandCode=CMD_Call,Signature="S")
	CommandInfo(14)=(CommandString="callend",CommandCode=CMD_CallEnd,Signature="X")
	CommandInfo(15)=(CommandString="clearevents",CommandCode=CMD_ClearEvents,Signature="X")
	CommandInfo(16)=(CommandString="cleartimers",CommandCode=CMD_ClearTimers,Signature="X")
	CommandInfo(17)=(CommandString="cleartriggers",CommandCode=CMD_ClearTriggers,Signature="X")
	CommandInfo(18)=(CommandString="consolecommand",CommandCode=CMD_ConsoleCommand,Signature="S")
	CommandInfo(19)=(CommandString="debugai",CommandCode=CMD_DebugAI,Signature="B")
	CommandInfo(20)=(CommandString="debugaievents",CommandCode=CMD_DebugAIEvents,Signature="B")
	CommandInfo(21)=(CommandString="debugaiflags",CommandCode=CMD_DebugAIFlags,Signature="I")
	CommandInfo(22)=(CommandString="debugmode",CommandCode=CMD_DebugMode,Signature="I")
	CommandInfo(23)=(CommandString="decproperty",CommandCode=CMD_DecProperty,Signature="TSf")
	CommandInfo(24)=(CommandString="deployinventory",CommandCode=CMD_DeployInventory,Signature="Sb")
	CommandInfo(25)=(CommandString="destroy",CommandCode=CMD_Destroy,Signature="X")
	CommandInfo(26)=(CommandString="dialogdisable",CommandCode=CMD_DialogDisable,Signature="M")
	CommandInfo(27)=(CommandString="dialogenable",CommandCode=CMD_DialogEnable,Signature="M")
	CommandInfo(28)=(CommandString="dialogfar",CommandCode=CMD_DialogFar,Signature="MSs")
	CommandInfo(29)=(CommandString="dialogfarwait",CommandCode=CMD_DialogFarWait,Signature="MSs")
	CommandInfo(30)=(CommandString="dialoginitiate",CommandCode=CMD_DialogInitiate,Signature="sm")
	CommandInfo(31)=(CommandString="dialogterminate",CommandCode=CMD_DialogTerminate,Signature="S")
	CommandInfo(32)=(CommandString="directionalpatrol",CommandCode=CMD_DirectionalPatrol,Signature="B")
	CommandInfo(33)=(CommandString="dormant",CommandCode=CMD_Dormant,Signature="Bb")
	CommandInfo(34)=(CommandString="dropinventory",CommandCode=CMD_DropInventory,Signature="S")
	CommandInfo(35)=(CommandString="enableprobeevent",CommandCode=CMD_EnableProbeEvent,Signature="NB")
	CommandInfo(36)=(CommandString="enablexmphandling",CommandCode=CMD_EnableXMPHandling,Signature="B")
	CommandInfo(37)=(CommandString="eventdisable",CommandCode=CMD_EventDisable,Signature="N")
	CommandInfo(38)=(CommandString="eventenable",CommandCode=CMD_EventEnable,Signature="N")
	CommandInfo(39)=(CommandString="eventwait",CommandCode=CMD_EventWait,Signature="Nn")
	CommandInfo(40)=(CommandString="findactor",CommandCode=CMD_FindActor,Signature="sffiiiss")
	CommandInfo(41)=(CommandString="fire",CommandCode=CMD_Fire,Signature="f")
	CommandInfo(42)=(CommandString="firealt",CommandCode=CMD_FireAlt,Signature="f")
	CommandInfo(43)=(CommandString="gib",CommandCode=CMD_Gib,Signature="bi")
	CommandInfo(44)=(CommandString="giball",CommandCode=CMD_GibAll,Signature="Sbi")
	CommandInfo(45)=(CommandString="giveinventory",CommandCode=CMD_GiveInventory,Signature="S")
	CommandInfo(46)=(CommandString="giveitemtoplayer",CommandCode=CMD_GiveItemToPlayer,Signature="Si")
	CommandInfo(47)=(CommandString="givetosseditem",CommandCode=CMD_GiveTossedItem,Signature="S")
	CommandInfo(48)=(CommandString="gotoactor",CommandCode=CMD_GotoActor,Signature="Tfb")
	CommandInfo(49)=(CommandString="gotoactorsafe",CommandCode=CMD_GotoActorSafe,Signature="Nfb")
	CommandInfo(50)=(CommandString="gotolabel",CommandCode=CMD_GotoLabel,Signature="S")
	CommandInfo(51)=(CommandString="incproperty",CommandCode=CMD_IncProperty,Signature="TSf")
	CommandInfo(52)=(CommandString="inert",CommandCode=CMD_Inert,Signature="B")
	CommandInfo(53)=(CommandString="handlergroup",CommandCode=CMD_HandlerGroup,Signature="X")
	CommandInfo(54)=(CommandString="handlergroupend",CommandCode=CMD_HandlerGroupEnd,Signature="X")
	CommandInfo(55)=(CommandString="headtracking",CommandCode=CMD_HeadTracking,Signature="B")
	CommandInfo(56)=(CommandString="jump",CommandCode=CMD_Jump,Signature="FFF")
	CommandInfo(57)=(CommandString="kill",CommandCode=CMD_Kill,Signature="X")
	CommandInfo(58)=(CommandString="killall",CommandCode=CMD_KillAll,Signature="S")
	CommandInfo(59)=(CommandString="message",CommandCode=CMD_Message,Signature="Si")
	CommandInfo(60)=(CommandString="onevent",CommandCode=CMD_OnEvent,Signature="Nssb")
	CommandInfo(61)=(CommandString="ontimer",CommandCode=CMD_OnTimer,Signature="Iffssi")
	CommandInfo(62)=(CommandString="ontrigger",CommandCode=CMD_OnTrigger,Signature="Mssbfss")
	CommandInfo(63)=(CommandString="playsound",CommandCode=CMD_PlaySound,Signature="TSnfbff")
	CommandInfo(64)=(CommandString="playsoundwait",CommandCode=CMD_PlaySoundWait,Signature="TSnfbff")
	CommandInfo(65)=(CommandString="playsoundtableslot",CommandCode=CMD_PlaySoundTableSlot,Signature="TS")
	CommandInfo(66)=(CommandString="playsoundtableslotwait",CommandCode=CMD_PlaySoundTableSlotWait,Signature="TS")
	CommandInfo(67)=(CommandString="removeinventory",CommandCode=CMD_RemoveInventory,Signature="s")
	CommandInfo(68)=(CommandString="removeinventoryfromplayer",CommandCode=CMD_RemoveInventoryFromPlayer,Signature="s")
	CommandInfo(69)=(CommandString="removeitemfromplayer",CommandCode=CMD_RemoveItemFromPlayer,Signature="S")
	CommandInfo(70)=(CommandString="removetosseditem",CommandCode=CMD_RemoveTossedItem,Signature="s")
	CommandInfo(71)=(CommandString="resumepatrol",CommandCode=CMD_ResumePatrol,Signature="SSN")
	CommandInfo(72)=(CommandString="return",CommandCode=CMD_Return,Signature="X")
	CommandInfo(73)=(CommandString="savedestination",CommandCode=CMD_SaveDestination,Signature="X")
	CommandInfo(74)=(CommandString="sendevent",CommandCode=CMD_SendEvent,Signature="MB")
	CommandInfo(75)=(CommandString="setactorrangetest",CommandCode=CMD_SetActorRangeTest,Signature="NFb")
	CommandInfo(76)=(CommandString="setaimodds",CommandCode=CMD_SetAimOdds,Signature="F")
	CommandInfo(77)=(CommandString="setalert",CommandCode=CMD_SetAlert,Signature="B")
	CommandInfo(78)=(CommandString="setammo",CommandCode=CMD_SetAmmo,Signature="SIb")
	CommandInfo(79)=(CommandString="setfocus",CommandCode=CMD_SetFocus,Signature="t")
	CommandInfo(80)=(CommandString="sethealth",CommandCode=CMD_SetHealth,Signature="I")
	CommandInfo(81)=(CommandString="setinventory",CommandCode=CMD_SetInventory,Signature="TS")
	CommandInfo(82)=(CommandString="setlocation",CommandCode=CMD_SetLocation,Signature="Mb")
	CommandInfo(83)=(CommandString="setlocationnamed",CommandCode=CMD_SetLocationNamed,Signature="TMb")
	CommandInfo(84)=(CommandString="setlocationvector",CommandCode=CMD_SetLocationVector,Signature="TFFFb")
	CommandInfo(85)=(CommandString="setmovespeed",CommandCode=CMD_SetMoveSpeed,Signature="Fs")
	CommandInfo(86)=(CommandString="setmovespeedauto",CommandCode=CMD_SetMoveSpeedAuto,Signature="f")
	CommandInfo(87)=(CommandString="setorders",CommandCode=CMD_SetOrders,Signature="ntfn")
	CommandInfo(88)=(CommandString="setphysics",CommandCode=CMD_SetPhysics,Signature="NM")
	CommandInfo(89)=(CommandString="setproperty",CommandCode=CMD_SetProperty,Signature="TSS")
	CommandInfo(90)=(CommandString="setproperties",CommandCode=CMD_SetProperties,Signature="SSS")
	CommandInfo(91)=(CommandString="setsatellite",CommandCode=CMD_SetSatellite,Signature="Mt")
	CommandInfo(92)=(CommandString="setscript",CommandCode=CMD_SetScript,Signature="Ss")
	CommandInfo(93)=(CommandString="setskill",CommandCode=CMD_SetSkill,Signature="F")
	CommandInfo(94)=(CommandString="setstance",CommandCode=CMD_SetStance,Signature="S")
	CommandInfo(95)=(CommandString="setstationary",CommandCode=CMD_SetStationary,Signature="Bb")
	CommandInfo(96)=(CommandString="settacticalmovetype",CommandCode=CMD_SetTacticalMoveType,Signature="I")
	CommandInfo(97)=(CommandString="setweapon",CommandCode=CMD_SetWeapon,Signature="s")
	CommandInfo(98)=(CommandString="shutdown",CommandCode=CMD_Shutdown,Signature="B")
	CommandInfo(99)=(CommandString="sleep",CommandCode=CMD_Sleep,Signature="f")
	CommandInfo(100)=(CommandString="sleeprand",CommandCode=CMD_SleepRand,Signature="f")
	CommandInfo(101)=(CommandString="spawn",CommandCode=CMD_Spawn,Signature="TSbss")
	CommandInfo(102)=(CommandString="stop",CommandCode=CMD_Stop,Signature="X")
	CommandInfo(103)=(CommandString="stopmovement",CommandCode=CMD_StopMovement,Signature="X")
	CommandInfo(104)=(CommandString="stopsound",CommandCode=CMD_StopSound,Signature="TNb")
	CommandInfo(105)=(CommandString="testactorinrange",CommandCode=CMD_TestActorInRange,Signature="NFss")
	CommandInfo(106)=(CommandString="testproperty",CommandCode=CMD_TestProperty,Signature="TSSss")
	CommandInfo(107)=(CommandString="testpropertyci",CommandCode=CMD_TestPropertyCI,Signature="TSSss")
	CommandInfo(108)=(CommandString="testpropertye",CommandCode=CMD_TestPropertyE,Signature="TSSss")
	CommandInfo(109)=(CommandString="testpropertyg",CommandCode=CMD_TestPropertyG,Signature="TSSss")
	CommandInfo(110)=(CommandString="testpropertyge",CommandCode=CMD_TestPropertyGE,Signature="TSSss")
	CommandInfo(111)=(CommandString="testpropertyl",CommandCode=CMD_TestPropertyL,Signature="TSSss")
	CommandInfo(112)=(CommandString="testpropertyle",CommandCode=CMD_TestPropertyLE,Signature="TSSss")
	CommandInfo(113)=(CommandString="testrandom",CommandCode=CMD_TestRandom,Signature="Fss")
	CommandInfo(114)=(CommandString="teststate",CommandCode=CMD_TestState,Signature="TNss")
	CommandInfo(115)=(CommandString="turntoactor",CommandCode=CMD_TurnToActor,Signature="tib")
	CommandInfo(116)=(CommandString="use",CommandCode=CMD_Use,Signature="T")
	CommandInfo(117)=(CommandString="unuse",CommandCode=CMD_Unuse,Signature="T")
	CommandInfo(118)=(CommandString="weaponload",CommandCode=CMD_WeaponLoad,Signature="X")
	CommandInfo(119)=(CommandString="weaponsetammotype",CommandCode=CMD_WeaponSetAmmoType,Signature="S")
	CommandInfo(120)=(CommandString="weaponsupportsaltfire",CommandCode=CMD_WeaponSupportsAltFire,Signature="NB")
	CommandInfo(121)=(CommandString="weaponsupportsfire",CommandCode=CMD_WeaponSupportsFire,Signature="NB")
	Events(0)=(EventName=ActorInRange,EventWaitState=WaitActorInRange,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(1)=(EventName=ActorOutOfRange,EventWaitState=WaitActorOutOfRange,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(2)=(EventName=AnimEnd,bEnabled=true,OnCmdIndex=-1)
	Events(3)=(EventName=AutoBegin,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(4)=(EventName=AutoEnd,bEnabled=true,OnCmdIndex=-1)
	Events(5)=(EventName=BumpEnemy,EventWaitState=WaitBumpEnemy,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(6)=(EventName=BumpFriend,EventWaitState=WaitBumpFriend,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(7)=(EventName=BumpOther,EventWaitState=WaitBumpOther,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(8)=(EventName=BumpPlayer,EventWaitState=WaitBumpPlayer,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(9)=(EventName=DestinationReached,EventWaitState=WaitDestinationReached,bEnabled=true,OnCmdIndex=-1)
	Events(10)=(EventName=DialogBegin,EventWaitState=WaitDialogBegin,bEnabled=true,OnCmdIndex=-1)
	Events(11)=(EventName=DialogUnPause,bEnabled=true,OnCmdIndex=-1)
	Events(12)=(EventName=Died,EventWaitState=WaitDied,bEnabled=true,OnCmdIndex=-1)
	Events(13)=(EventName=EnemyNotVisible,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(14)=(EventName=HearNoiseFriendly,EventWaitState=WaitHearNoiseFriendly,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(15)=(EventName=HearNoiseOther,EventWaitState=WaitHearNoiseOther,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(16)=(EventName=HearNoiseThreat,EventWaitState=WaitHearNoiseThreat,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(17)=(EventName=InheritEnemy,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(18)=(EventName=ScriptedLanding,EventWaitState=WaitScriptedLanding,bEnabled=true,OnCmdIndex=-1)
	Events(19)=(EventName=SeeAlertFriend,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(20)=(EventName=SeeEnemy,EventWaitState=WaitSeeEnemy,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(21)=(EventName=SeeFriend,EventWaitState=WaitSeeFriend,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(22)=(EventName=SeeOther,EventWaitState=WaitSeeOther,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(23)=(EventName=SeePlayer,EventWaitState=WaitSeePlayer,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(24)=(EventName=TakeDamage,EventWaitState=WaitTakeDamage,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(25)=(EventName=TookDamage,EventWaitState=WaitTookDamage,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	Events(26)=(EventName=TookDamageEnemy,EventWaitState=WaitTookDamageEnemy,bEnabled=true,OnCmdIndex=-1)
	Events(27)=(EventName=TookDamageFriend,EventWaitState=WaitTookDamageFriend,bEnabled=true,OnCmdIndex=-1)
	Events(28)=(EventName=Trigger,EventWaitState=WaitTrigger,bEnabled=true,bCanToggle=true,OnCmdIndex=-1)
	NextHandlerGroupIndex=1
	bHasScript=true
}