States - Revision history

SeriousBarbie: State Labels: Label "begin" and function BeginState()

2016-02-11T14:10:03Z

State Labels: Label "begin" and function BeginState()

SeriousBarbie: exchanged single quotes by ' to avoid wiki formatting

2015-12-06T06:48:55Z

exchanged single quotes by ' to avoid wiki formatting

58.161.66.60: /* State Labels and Latent Functions */

2010-12-20T01:45:59Z

‎State Labels and Latent Functions

Eliot: Modifiers

2010-09-19T20:08:36Z

Modifiers

Eliot: /* Advanced state programming */ Gave ignores it's own section for redirecting purpose.

2010-05-24T13:30:21Z

‎Advanced state programming: Gave ignores it's own section for redirecting purpose.

Eliot: fixed typos and replaced Expands to Extends

2010-04-19T00:39:06Z

fixed typos and replaced Expands to Extends

UnrealJoe: /* Advanced state programming */

2010-04-18T21:26:50Z

‎Advanced state programming

UnrealJoe: /* Overview of States */

2010-04-18T21:25:57Z

‎Overview of States

UnrealJoe: /* Overview of States */

2010-04-18T21:24:01Z

‎Overview of States

Eliot: added navbox

2009-12-30T02:38:08Z

added navbox

@@ Line 81: / Line 81: @@
 The above state code prints the message "MyState has just begun!", then it pauses for two seconds, then it prints the message "MyState has finished sleeping". The interesting thing in this example is the call to the latent function "Sleep": this function call doesn't return immediately, but returns after a certain amount of game time has passed. Latent functions can only be called from within state code, and not from within functions. Latent functions let you manage complex chains of events which include the passage of time.
-All state code begins with a label definition; in the above example the label is named "Begin". The label provides a convenient entry point into the state code. You can use any label name in state code, but the "Begin" label is special: it is the default starting point for code in that state.
+All state code begins with a label definition; in the above example the label is named "Begin". The label provides a convenient entry point into the state code. You can use any label name in state code, but the "Begin" label is special: it is the default starting point for code in that state. (But if the function ''BeginState()'' (see below) is defined, it is executed before this label is reached.)
 There are three main latent functions available to all actors:

@@ Line 94: / Line 94: @@
 * The "Goto" function (similar to the C/C++/Basic goto) within a state causes the state code to continue executing at a different label.
-* The special Goto('') command within a state causes the state code execution to stop. State code execution doesn't continue until you go to a new state, or go to a new label within the current state.
+* The special Goto(&apos;&apos;) command within a state causes the state code execution to stop. State code execution doesn't continue until you go to a new state, or go to a new label within the current state.
 * The "GotoState" function causes the actor to go to a new state, and optionally continue at a specified label (if you don't specify a label, the default is the "Begin" label). You can call GotoState from within state code, and it goes to the destination immediately. You can also call GotoState from within any function in the actor, but that does not take effect immediately: it doesn't take effect until execution returns back to the state code.

@@ Line 76: / Line 76: @@
 	Sleep( 2.0 );
 	Log( "MyState has finished sleeping" );
-	goto Begin;
+	goto 'Begin';
 }</uscript>

@@ Line 30: / Line 30: @@
+	}
+}
-−
 // Trigger turns the light off.
 state() TriggerTurnsOff
@@ Line 43: / Line 43: @@
 Here you are declaring two different states (TriggerTurnsOn and TriggerTurnsOff), and you're writing a different version of the Trigger function in each state. Though you could pull off this implementation without states, using states makes the code far more modular and expandable: in UnrealScript, you can easily subclass an existing class, add new states, and add new functions. If you had tried to do this without states, the resulting code would be more difficult to expand later.
 A state can be declared as editable, meaning that the user can set an actor's state in [[UnrealEd]], or not. To declare an editable state, do the following:
 <uscript>state() MyState
+{
@@ Line 52: / Line 57: @@
 To declare a non-editable state, do this:
 <uscript>state MyState
+{
@@ Line 58: / Line 62: @@
 }</uscript>
-You can also specify the automatic, or initial state that an actor should be in by using the "auto" keyword. This causes all new actors to be placed in that state when they first are activated:
+===Modifiers===
+; Auto: You can also specify the automatic, or initial state that an actor should be in. This causes all new actors to be placed in that state on the SetInitialState() event.
-<uscript>auto state MyState
+; Simulated: Marks the state as valid for execution on clients if the actor containing it was replicated to that client and the local [[role]] of that client is either ROLE_SimulatedProxy or ROLE_DumbProxy.<br/>'''Note:''' The modifier '''simulated''' does not imply any kind of replication or even broadcast! Also, this modifier is not inherited when overriding states!
-−
-	//...
-}</uscript>
 == State Labels and Latent Functions ==
@@ Line 113: / Line 114: @@
 	goto 'Begin';
+}
-−
 // Attacking state.
 state Attacking
@@ Line 149: / Line 150: @@
 <uscript>// Here is an example parent class.
 class MyParentClass extends Actor;
-−
 // A non-state function.
 function MyInstanceFunction()
@@ Line 155: / Line 156: @@
 	log( "Executing MyInstanceFunction" );
+}
-−
 // A state.
 state MyState
@@ Line 168: / Line 169: @@
 	Log("Beginning MyState");
+}
-−
 // Here is an example child class.
 class MyChildClass extends MyParentClass;
-−
 // Here I'm overriding a non-state function.
 function MyInstanceFunction()
@@ Line 178: / Line 179: @@
+}
-−
 // Here I'm redeclaring MyState so that I can override MyStateFunction.
 state MyState
@@ Line 206: / Line 207: @@
 	// Stick base functions here...
+}
-−
 // Attacking up-close.
 state MeleeAttacking extends Attacking
@@ Line 212: / Line 213: @@
 	// Stick specialized functions here...
+}
-−
 // Attacking from a distance.
 state RangeAttacking extends Attacking

@@ Line 217: / Line 217: @@
+{
 	// Stick specialized functions here...
 }</uscript>
@@ Line 237: / Line 226: @@
-States Execution Gotcha [UE3]
+States Execution Gotcha {{UE3}}
 States are executed during an actors tick, which is expected to be an asynchronous process. While EndState() and BeginState() execution might happen straight away, UnrealScript state changes from calls to GotoState('NewStateName') will only take effect once an actor has been Ticked.
 This means you should avoid state machines that become order-of-operation dependent or that lock, for example this script fragment:
@@ Line 269: / Line 258: @@
 ExampleActor.Action();</uscript>
 After executing the Action method twice, the class will still be in the SecondState, not the third as state execution is expected to be asynchronous and the engine hasn't ticked the actor yet. While this distinction doesn't often come up, it is a one-frame-bug that can cause unexpected results ingame.
 {{navbox unrealscript}}

@@ Line 1: / Line 1: @@
 == Overview of States ==
-Historically, game programmers have been using the concept of states ever since games evolved past the "pong" phase. States (and what is known as "state machine programming") are a natural way of making complex object behaviour manageable. However, before UnrealScript, states have not been supported at the language level, requiring developers to create C/C++ "switch" statements based on the object's state. Such code was difficult to write and update.
+Historically, game programmers have been using the concept of states ever since games evolved past the "pong" phase. States (and what is known as "state machine programming") are a natural way of making complex object behavior manageable. However, before UnrealScript, states have not been supported at the language level, requiring developers to create C/C++ "switch" statements based on the object's state. Such code was difficult to write and update.
 UnrealScript supports states at the language level.
@@ Line 23: / Line 23: @@
 state() TriggerTurnsOn
+{
-	function Trigger( actor Other, pawn EventInstigator )
+	function Trigger( Actor Other, Pawn EventInstigator )
+	{
 		Trigger = None;
@@ Line 34: / Line 34: @@
 state() TriggerTurnsOff
+{
-	function Trigger( actor Other, pawn EventInstigator )
+	function Trigger( Actor Other, Pawn EventInstigator )
+	{
 		Trigger = None;
@@ Line 44: / Line 44: @@
 Here you are declaring two different states (TriggerTurnsOn and TriggerTurnsOff), and you're writing a different version of the Trigger function in each state. Though you could pull off this implementation without states, using states makes the code far more modular and expandable: in UnrealScript, you can easily subclass an existing class, add new states, and add new functions. If you had tried to do this without states, the resulting code would be more difficult to expand later.
-A state can be declared as editable, meaning that the user can set an actor's state in UnrealEd, or not. To declare an editable state, do the following:
+A state can be declared as editable, meaning that the user can set an actor's state in [[UnrealEd]], or not. To declare an editable state, do the following:
 <uscript>state() MyState
@@ Line 133: / Line 133: @@
 Make sure you understand this important aspect of GotoState: When you call GotoState from within a function, it does not go to the destination immediately, rather it goes there once execution returns back to the state code.
-== State inheretance and scoping rules ==
+== State inheritance inheritance and scoping rules ==
-In UnrealScript, when you subclass an existing class, your new class inherets all of the variables, functions and states from its parent class. This is well-understood.
+In UnrealScript, when you subclass an existing class, your new class inherits all of the variables, functions and states from its parent class. This is well-understood.
-However, the addition of the state abstraction to the UnrealScript programming model adds additional twists to the inheretance and scoping rules.
+However, the addition of the state abstraction to the UnrealScript programming model adds additional twists to the inheritance and scoping rules.
-The complete inheretance rules are:
+The complete inheritance rules are:
-* A new class inherets all of the variables from its parent class.
+* A new class inherits all of the variables from its parent class.
-* A new class inherents all of its parent class's non-state functions. You can override any of those inhereted non-state functions. You can add entirely new non-state functions.
+* A new class inherits all of its parent class's non-state functions. You can override any of those inherited non-state functions. You can add entirely new non-state functions.
-* A new class inherets all of its parent class's states, including the functions and labels within those states. You can override any of the inhereted state functions, and you can override any of the inhereted state labels, you can add new state functions, and you can add new state labels.
+* A new class inherits all of its parent class's states, including the functions and labels within those states. You can override any of the inherited state functions, and you can override any of the inherited state labels, you can add new state functions, and you can add new state labels.
 Here is an example of all the overriding rules:
 <uscript>// Here is an example parent class.
-class MyParentClass expands Actor;
+class MyParentClass extends Actor;
 // A non-state function.
@@ Line 170: / Line 170: @@
 // Here is an example child class.
-class MyChildClass expands MyParentClass;
+class MyChildClass extends MyParentClass;
 // Here I'm overriding a non-state function.
@@ Line 199: / Line 199: @@
 == Advanced state programming ==
-If a state doesn't override a state of the same name in the parent class, then you can optionally use the "expands" keyword to make the state expand on an existing state in the current class. This is useful, for example, in a situatio where you have a group of similar states (such as MeleeAttacking and RangeAttacking) which have a lot of functionality in common. In this case you could declare a base Attacking state as follows:
+If a state doesn't override a state of the same name in the parent class, then you can optionally use the "extends" keyword to make the state extend an existing state in the current class. This is useful, for example, in a situation where you have a group of similar states (such as MeleeAttacking and RangeAttacking) which have a lot of functionality in common. In this case you could declare a base Attacking state as follows:
 <uscript>// Base Attacking state.
@@ Line 208: / Line 208: @@
 // Attacking up-close.
-state MeleeAttacking expands Attacking
+state MeleeAttacking extends Attacking
+{
 	// Stick specialized functions here...
@@ Line 214: / Line 214: @@
 // Attacking from a distance.
-state RangeAttacking expands Attacking
+state RangeAttacking extends Attacking
+{
 	// Stick specialized functions here...
@@ Line 234: / Line 234: @@
 It is possible for an actor to be in "no state" by using GotoState(''). When an actor is in "no state", only its global (non-state) functions are called.
-Whever you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.
+When you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.
 States Execution Gotcha [UE3]
-States are executed during an actors tick, which is expected to be an asynchronous process. While EndState() and BeginState() execution might happen straight away, unrealscript state changes from calls to GotoState('NewStateName') will only take effect once an actor has been Ticked.
+States are executed during an actors tick, which is expected to be an asynchronous process. While EndState() and BeginState() execution might happen straight away, UnrealScript state changes from calls to GotoState('NewStateName') will only take effect once an actor has been Ticked.
-This means you should avoid state machines that become order-of-operation dependant or that lock, for example this script fragment:
+This means you should avoid state machines that become order-of-operation dependent or that lock, for example this script fragment:
 <uscript>
 state FirstState
@@ Line 267: / Line 267: @@
 ...Will not transition to the ThirdState, even if you call:
 <uscript>ExampleActor.Action();
-ExamlpeActor.Action();</uscript>
+ExampleActor.Action();</uscript>
 After executing the Action method twice, the class will still be in the SecondState, not the third as state execution is expected to be asynchronous and the engine hasn't ticked the actor yet. While this distinction doesn't often come up, it is a one-frame-bug that can cause unexpected results ingame.
 {{navbox unrealscript}}

← Older revision		Revision as of 21:26, 18 April 2010
Line 235:		Line 235:

	Whever you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.		Whever you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.
		+
		+
		+	States Execution Gotcha [UE3]
		+	States are executed during an actors tick, which is expected to be an asynchronous process. While EndState() and BeginState() execution might happen straight away, unrealscript state changes from calls to GotoState('NewStateName') will only take effect once an actor has been Ticked.
		+	This means you should avoid state machines that become order-of-operation dependant or that lock, for example this script fragment:
		+	<uscript>
		+	state FirstState
		+	{
		+	event Action()
		+	{
		+	GotoState( 'SecondState' );
		+	}
		+	}
		+
		+	state SecondState
		+	{
		+	event Action()
		+	{
		+	GotoState( 'ThirdState' );
		+	}
		+	}
		+
		+	state ThirdState
		+	{
		+	event Action()
		+	{
		+	`Log( "ProcessComplete" );
		+	}
		+	}
		+	</uscript>
		+	...Will not transition to the ThirdState, even if you call:
		+	<uscript>ExampleActor.Action();
		+	ExamlpeActor.Action();</uscript>
		+	After executing the Action method twice, the class will still be in the SecondState, not the third as state execution is expected to be asynchronous and the engine hasn't ticked the actor yet. While this distinction doesn't often come up, it is a one-frame-bug that can cause unexpected results ingame.

	{{navbox unrealscript}}		{{navbox unrealscript}}

← Older revision		Revision as of 02:38, 30 December 2009
Line 235:		Line 235:

	Whever you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.		Whever you use the GotoState command to set an actor's state, the engine can call two special notification functions, if you have defined them: EndState() and BeginState(). EndState is called in the current state immediately before the new state is begun, and BeginState is called immediately after the new state begins. These functions provide a convenient place to do any state-specific initialization and cleanup which your state may require.
		+
		+	{{navbox unrealscript}}