AI State - Revision history

Greebo: categorised

2008-06-30T07:47:10Z

categorised

← Older revision		Revision as of 07:47, 30 June 2008
Line 56:		Line 56:
	The call to CheckAlertLevel() can also be used by other, non-backbone States, where appropriate.		The call to CheckAlertLevel() can also be used by other, non-backbone States, where appropriate.

	~~[[Category:AI]]~~		{{ai}} {{sdk}}
	~~[[Category:Scripting]]~~
	~~[[Category:Coding]]~~

Angua: /* Backbone States */

2008-05-07T14:53:20Z

Backbone States

← Older revision		Revision as of 14:53, 7 May 2008
Line 29:		Line 29:
	{{Things-To-Remember\|		{{Things-To-Remember\|
	* Only States are allowed to switch States		* Only States are allowed to switch States
	* Only Backbone States are allowed to switch to one of the ~~five~~ Backbone States (via PushState/EndState).		* Only Backbone States are allowed to switch to one of the six Backbone States (via PushState/EndState).
	* The Backbone States always take care that the right State is selected when the Alert Index is changing.		* The Backbone States always take care that the right State is selected when the Alert Index is changing.
	* State switches between Backbone States must happen via AI::SetAlertLevel.		* State switches between Backbone States must happen via AI::SetAlertLevel.

Angua: /* Backbone States */

2008-05-07T14:49:04Z

Backbone States

← Older revision		Revision as of 14:49, 7 May 2008
Line 8:		Line 8:

	There are a few so-called Backbone States, corresponding to the AI's alert indices:		There are a few so-called Backbone States, corresponding to the AI's alert indices:
	* Alert Index '''0''' => '''IdleState'''		* Alert Index '''0''' => '''IdleState''' (which is replaced by '''AlertIdleState''' when the AI has seen evidence of intruders)
	* Alert Index '''1''' => '''SuspiciousState'''		* Alert Index '''1''' => '''ObservantState'''
	* Alert Index '''2''' => '''SearchingState'''		* Alert Index '''2''' => '''SuspiciousState'''
	* Alert Index '''3''' => '''AgitatedSearchingState'''		* Alert Index '''3''' => '''SearchingState'''
	* Alert Index '''4''' => '''CombatState''' (only allowed if Enemy is known)		* Alert Index '''4''' => '''AgitatedSearchingState'''
			* Alert Index '''5''' => '''CombatState''' (only allowed if Enemy is known)

	The Backbone States form some kind of "ladder" and follow this pattern:		The Backbone States form some kind of "ladder" and follow this pattern:

	* When the AI's alert level '''exceeds''' a given threshold (e.g. from ~~thres_3~~ to ~~thresh_combat~~), the Backbone State switches to the next higher State (e.g. from '''AgitatedSearchingState''' to '''CombatState'''). This happens via a '''PushState''' command, so that the AgitatedSearchingState still stays within the Mind's StateQueue.		* When the AI's alert level '''exceeds''' a given threshold (e.g. from thresh_4 to thresh_5), the Backbone State switches to the next higher State (e.g. from '''AgitatedSearchingState''' to '''CombatState'''). This happens via a '''PushState''' command, so that the AgitatedSearchingState still stays within the Mind's StateQueue.
	* When the AI's alert level '''falls below''' the threshold for the current State, it is terminated via an '''EndState''' call.		* When the AI's alert level '''falls below''' the threshold for the current State, it is terminated via an '''EndState''' call.

	These two rules ensure that the Mind is always in the correct State according to the AI's alert index. Consequently, you don't need to actually switch to a higher Backbone State (in fact you're not allowed to), this is accomplished by calling '''SetAlertLevel''' instead. The States monitor the alert level changes on their own and automatically switch to the correct State.		These two rules ensure that the Mind is always in the correct State according to the AI's alert index. Consequently, you don't need to actually switch to a higher Backbone State (in fact you're not allowed to), this is accomplished by calling '''SetAlertLevel''' instead. The States monitor the alert level changes on their own and automatically switch to the correct State.

	Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''~~thresh_combat~~'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than ~~thresh_combat~~ it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''~~thresh_combat~~'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.		Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_5'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_5 it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_5'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.

	The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.		The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.

Greebo at 14:11, 8 November 2007

2007-11-08T14:11:44Z

← Older revision		Revision as of 14:11, 8 November 2007
Line 49:		Line 49:

	=== Backbone States ===		=== Backbone States ===
	The ~~State base class provides a convenience method~~ '''bool CheckAlertLevel()'''~~, which takes~~ a required alert index and the name of the higher State. ~~This method automatically checks if~~ the alert index is matching ~~and if not~~, it switches to the state below or above. For switching to the State "below" (e.g. from AgitatedSearching to Searching) it just takes a call to EndState() whereas for switching to the higher state, the actual name is needed (AgitatedSearchingState would pass the STATE_COMBAT string constant to the method).		The Backbone States override the default implementation '''bool State::CheckAlertLevel()''' and implement a check using a required alert index and the name of the higher State. If the alert index is not matching, it switches to the state below or above. For switching to the State "below" (e.g. from AgitatedSearching to Searching) it just takes a call to EndState() whereas for switching to the higher state, the actual name is needed (AgitatedSearchingState would pass the STATE_COMBAT string constant to the method).

	This method is checked each time the State is about to think or initialise, so setting the alert level/index almost instantly triggers a switch to the right State.		This method is checked each time the Backbone State is about to think or initialise, so setting the alert level/index almost instantly triggers a switch to the right State.

			The call to CheckAlertLevel() can also be used by other, non-backbone States, where appropriate.

	[[Category:AI]]		[[Category:AI]]
	[[Category:Scripting]]		[[Category:Scripting]]
	[[Category:Coding]]		[[Category:Coding]]

Greebo at 20:03, 6 November 2007

2007-11-06T20:03:06Z

← Older revision		Revision as of 20:03, 6 November 2007
Line 30:		Line 30:
	* Only Backbone States are allowed to switch to one of the five Backbone States (via PushState/EndState).		* Only Backbone States are allowed to switch to one of the five Backbone States (via PushState/EndState).
	* The Backbone States always take care that the right State is selected when the Alert Index is changing.		* The Backbone States always take care that the right State is selected when the Alert Index is changing.
			* State switches between Backbone States must happen via AI::SetAlertLevel.
	* States are responsible for handling the incoming stimuli and pushing the right Tasks into their Subsystems.		* States are responsible for handling the incoming stimuli and pushing the right Tasks into their Subsystems.
	}}		}}

Greebo at 20:02, 6 November 2007

2007-11-06T20:02:03Z

← Older revision		Revision as of 20:02, 6 November 2007
Line 12:		Line 12:
	* Alert Index '''2''' => '''SearchingState'''		* Alert Index '''2''' => '''SearchingState'''
	* Alert Index '''3''' => '''AgitatedSearchingState'''		* Alert Index '''3''' => '''AgitatedSearchingState'''
	* Alert Index '''4''' => '''CombatState'''		* Alert Index '''4''' => '''CombatState''' (only allowed if Enemy is known)

	The Backbone States form some kind of "ladder" and follow this pattern:		The Backbone States form some kind of "ladder" and follow this pattern:
Line 19:		Line 19:
	* When the AI's alert level '''falls below''' the threshold for the current State, it is terminated via an '''EndState''' call.		* When the AI's alert level '''falls below''' the threshold for the current State, it is terminated via an '''EndState''' call.

	These two rules ensure that the Mind is always in the correct State according to the AI's alert index.		These two rules ensure that the Mind is always in the correct State according to the AI's alert index. Consequently, you don't need to actually switch to a higher Backbone State (in fact you're not allowed to), this is accomplished by calling '''SetAlertLevel''' instead. The States monitor the alert level changes on their own and automatically switch to the correct State.

	Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.		Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.

Greebo at 19:41, 5 November 2007

2007-11-05T19:41:39Z

← Older revision		Revision as of 19:41, 5 November 2007
Line 1:		Line 1:
	An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.		An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.

	'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or ~~th'''e~~ AI class itself allowed to). Also, States are the only instances which are allowed to delegate Tasks into the Subsystems.		'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or the AI class itself allowed to). Also, States are the only instances which are allowed to delegate Tasks into the Subsystems.

	States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.		States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.
Line 21:		Line 21:
	These two rules ensure that the Mind is always in the correct State according to the AI's alert index.		These two rules ensure that the Mind is always in the correct State according to the AI's alert index.

	~~'''~~Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.		Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.

	The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.		The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.

Greebo at 19:40, 5 November 2007

2007-11-05T19:40:51Z

← Older revision		Revision as of 19:40, 5 November 2007
Line 1:		Line 1:
	An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.		An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.

	'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or ~~the~~ AI class itself allowed to). Also, States are the only instances which are allowed to delegate Tasks into the Subsystems.		'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or th'''e AI class itself allowed to). Also, States are the only instances which are allowed to delegate Tasks into the Subsystems.

	States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.		States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.
Line 21:		Line 21:
	These two rules ensure that the Mind is always in the correct State according to the AI's alert index.		These two rules ensure that the Mind is always in the correct State according to the AI's alert index.

	Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.		'''Example: Let's assume the AI is in SearchingState and encounters the player (visually). The alert index is increased immediately above ''thresh_combat'' which causes the SearchingState (in its role as Backbone State) to Push the next higher State (in this case this is AgitatedSearchingState). The AgitatedSearchingState peforms another check and as the alertlevel is higher than thresh_combat it passes the torch and pushes the CombatState into the StateQueue. Let's further assume that the player manages to escape and the AI's alert level is slowly decreasing again. As soon as it falls below ''thresh_combat'', the CombatState recognises itself not being appropriate anymore and calls EndState(). This lets the Mind fall back into the AgitatedSearchingState (which is still in the Mind's StateQueue). A further decrease of the Alert Level causes the AgitatedSearchingState to end itself and to fall back to SearchingState. This goes on until the bottom of the StateQueue is reached, which is always occupied by the IdleState.

	The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.		The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.
Line 46:		Line 46:
	* ...override one of the various OnVisualStimX() methods to implement behaviour different to the default.		* ...override one of the various OnVisualStimX() methods to implement behaviour different to the default.
	* ...override the OnAICommMessage() to handle the incoming messages differently than the base class.		* ...override the OnAICommMessage() to handle the incoming messages differently than the base class.

			=== Backbone States ===
			The State base class provides a convenience method '''bool CheckAlertLevel()''', which takes a required alert index and the name of the higher State. This method automatically checks if the alert index is matching and if not, it switches to the state below or above. For switching to the State "below" (e.g. from AgitatedSearching to Searching) it just takes a call to EndState() whereas for switching to the higher state, the actual name is needed (AgitatedSearchingState would pass the STATE_COMBAT string constant to the method).

			This method is checked each time the State is about to think or initialise, so setting the alert level/index almost instantly triggers a switch to the right State.

	[[Category:AI]]		[[Category:AI]]
	[[Category:Scripting]]		[[Category:Scripting]]
	[[Category:Coding]]		[[Category:Coding]]

Greebo at 18:27, 5 November 2007

2007-11-05T18:27:09Z

← Older revision		Revision as of 18:27, 5 November 2007
Line 4:		Line 4:

	States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.		States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.

			== Backbone States ==

	There are a few so-called Backbone States, corresponding to the AI's alert indices:		There are a few so-called Backbone States, corresponding to the AI's alert indices:
Line 23:		Line 25:
	The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.		The important part is that the Backbone States always use '''PushState''' to go ''upwards'' and '''EndState''' to go ''downwards''.

	It's of course not a problem, if the CombatState decides to some other State like FleeState or LostTrackOfEnemyState, as long as the BackBone stays intact. It's ok for the CombatState to use either SwitchState, PushState to jump to (say) FleeState. The important thing is that the FleeState must not directly push another Backbone State (like IdleState), as this would disrupt the StateQueue. If the FleeState wants to go back into IdleState, it's enough to set the AI alert level and call EndState. The BackBone States will take care of switching by subsequently calling EndState until the corresponding State is reached.		It's of course not a problem, if the CombatState decides to switch to some other State like FleeState or LostTrackOfEnemyState, as long as the BackBone stays intact. It's ok for the CombatState to use either SwitchState, PushState to jump to (say) FleeState. The important thing is that the FleeState must not directly push another Backbone State (like IdleState), as this would disrupt the StateQueue. If the FleeState wants to go back into IdleState, it's enough to set the AI alert level and call EndState. The BackBone States will take care of switching by subsequently calling EndState until the corresponding State is reached.
	{{Things-To-Remember\|		{{Things-To-Remember\|
	* Only States are allowed to switch States		* Only States are allowed to switch States

Greebo at 18:26, 5 November 2007

2007-11-05T18:26:17Z

← Older revision		Revision as of 18:26, 5 November 2007
Line 1:		Line 1:
	An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.		An AI's Mind is in a certain State all the time. It's the State class which does the actual thinking each frame, it pushes the Tasks to the Subsystems, it interprets the incoming stimuli, it decides which States the Mind will be switch to.

	'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or the AI class itself allowed to).		'''Note''': States are the '''only''' instances which are allowed to actually switch the Mind's State (Tasks are not allowed to do it, nor is the Mind or the AI class itself allowed to). Also, States are the only instances which are allowed to delegate Tasks into the Subsystems.

			States are allowed to Think() once per frame. This method is invoked by the Mind and gives them an opportunity to monitor their Tasks and to switch to other States.

	There are a few so-called Backbone States, corresponding to the AI's alert indices:		There are a few so-called Backbone States, corresponding to the AI's alert indices:
	* Alert Index '''0''': '''IdleState'''		* Alert Index '''0''' => '''IdleState'''
	* Alert Index '''1''': '''SuspiciousState'''		* Alert Index '''1''' => '''SuspiciousState'''
	* Alert Index '''2''': '''SearchingState'''		* Alert Index '''2''' => '''SearchingState'''
	* Alert Index '''3''': '''AgitatedSearchingState'''		* Alert Index '''3''' => '''AgitatedSearchingState'''
	* Alert Index '''4''': '''CombatState'''		* Alert Index '''4''' => '''CombatState'''

	The Backbone States form some kind of "ladder" and follow this pattern:		The Backbone States form some kind of "ladder" and follow this pattern: