The #AICAPZONE class implements the core functions to patrol a Zone by an AI Controllable or Group -and automatically engage any airborne enemies that are within a certain range or within a certain zone.
+AI CAP classes makes AI Controllables execute a Combat Air Patrol.
-
The AICAPZONE is assigned a Group and this must be done before the AICAPZONE process can be started using the Start event.
- -
The AI will fly towards the random 3D point within the patrol zone, using a random speed within the given altitude and speed limits. -Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits.
- -
This cycle will continue.
- -
During the patrol, the AI will detect enemy targets, which are reported through the Detected event.
- -
When enemies are detected, the AI will automatically engage the enemy.
- -
Until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB. -When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
- -
There are the following types of CAP classes defined:
An optional range can be set in meters, -that will define when the AI will engage with the detected airborne enemy targets. -The range can be beyond or smaller than the range of the Patrol Zone. -The range is applied at the position of the AI. -Use the method AICAP#AICAP_ZONE.SetEngageRange() to define that range.
- -
An optional Zone can be set, -that will define when the AI will engage with the detected airborne enemy targets. -Use the method AICap#AICAP_ZONE.SetEngageZone() to define that Zone.
-The #AICAPZONE class implements the core functions to patrol a Zone by an AI Controllable or Group +and automatically engage any airborne enemies that are within a certain range or within a certain zone.
The #AICAPZONE class implements the core functions to patrol a Zone by an AI Controllable or Group +and automatically engage any airborne enemies that are within a certain range or within a certain zone.
+ + + +
The AICAPZONE is assigned a Group and this must be done before the AICAPZONE process can be started using the Start event.
+ +
The AI will fly towards the random 3D point within the patrol zone, using a random speed within the given altitude and speed limits. +Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits.
+ +
This cycle will continue.
+ +
During the patrol, the AI will detect enemy targets, which are reported through the Detected event.
+ +
When enemies are detected, the AI will automatically engage the enemy.
+ +
Until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB. +When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
+ +
An optional range can be set in meters, +that will define when the AI will engage with the detected airborne enemy targets. +The range can be beyond or smaller than the range of the Patrol Zone. +The range is applied at the position of the AI. +Use the method AICAP#AICAP_ZONE.SetEngageRange() to define that range.
+ +
An optional Zone can be set, +that will define when the AI will engage with the detected airborne enemy targets. +Use the method AICap#AICAP_ZONE.SetEngageZone() to define that Zone.
+ +AI_Cap
AI_CAP_ZONEAICAPZONE class
- -#AICASZONE derives from the AIPatrol#AIPATROL_ZONE, inheriting its methods and behaviour.
+AI CAS classes makes AI Controllables execute a Close Air Support.
--The #AICASZONE class implements the core functions to provide Close Air Support in an Engage Zone by an AIR Controllable or Group. -The AICASZONE runs a process. It holds an AI in a Patrol Zone and when the AI is commanded to engage, it will fly to an Engage Zone.
-
The AICASZONE is assigned a Group and this must be done before the AICASZONE process can be started through the Start event.
- -
Upon started, The AI will Route itself towards the random 3D point within a patrol zone, -using a random speed within the given altitude and speed limits. -Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits. -This cycle will continue until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB.
- -
When the AI is commanded to provide Close Air Support (through the event Engage), the AI will fly towards the Engage Zone. -Any target that is detected in the Engage Zone will be reported and will be destroyed by the AI.
- -
The AI will detect the targets and will only destroy the targets within the Engage Zone.
- -
Every target that is destroyed, is reported< by the AI.
- -
Note that the AI does not know when the Engage Zone is cleared, and therefore will keep circling in the zone.
- -
Until it is notified through the event Accomplish, which is to be triggered by an observing party:
+There are the following types of CAS classes defined:
When the AI has accomplished the CAS, it will fly back to the Patrol Zone.
- -
It will keep patrolling there, until it is notified to RTB or move to another CAS Zone. -It can be notified to go RTB through the RTB event.
- -When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
- -
#AICASZONE derives from the AIPatrol#AIPATROL_ZONE, inheriting its methods and behaviour.
#AICASZONE derives from the AIPatrol#AIPATROL_ZONE, inheriting its methods and behaviour.
+ + ++The #AICASZONE class implements the core functions to provide Close Air Support in an Engage Zone by an AIR Controllable or Group. +The AICASZONE runs a process. It holds an AI in a Patrol Zone and when the AI is commanded to engage, it will fly to an Engage Zone.
+ +
The AICASZONE is assigned a Group and this must be done before the AICASZONE process can be started through the Start event.
+ +
Upon started, The AI will Route itself towards the random 3D point within a patrol zone, +using a random speed within the given altitude and speed limits. +Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits. +This cycle will continue until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB.
+ +
When the AI is commanded to provide Close Air Support (through the event Engage), the AI will fly towards the Engage Zone. +Any target that is detected in the Engage Zone will be reported and will be destroyed by the AI.
+ +
The AI will detect the targets and will only destroy the targets within the Engage Zone.
+ +
Every target that is destroyed, is reported< by the AI.
+ +
Note that the AI does not know when the Engage Zone is cleared, and therefore will keep circling in the zone.
+ +
Until it is notified through the event Accomplish, which is to be triggered by an observing party:
+ +
When the AI has accomplished the CAS, it will fly back to the Patrol Zone.
+ +
It will keep patrolling there, until it is notified to RTB or move to another CAS Zone. +It can be notified to go RTB through the RTB event.
+ +When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
+ +
The #AIPATROLZONE class implements the core functions to patrol a Zone by an AI Controllable or Group.
+AI PATROL classes makes AI Controllables execute an Patrol.
-
The AIPATROLZONE is assigned a Group and this must be done before the AIPATROLZONE process can be started using the Start event.
- -
The AI will fly towards the random 3D point within the patrol zone, using a random speed within the given altitude and speed limits. -Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits.
- -
This cycle will continue.
- -
During the patrol, the AI will detect enemy targets, which are reported through the Detected event.
- -
-- Note that the enemy is not engaged! To model enemy engagement, either tailor the Detected event, or -use derived AI_ classes to model AI offensive or defensive behaviour.
- -
Until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB. -When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
- -
There are the following types of PATROL classes defined:
The detection process of the AI controllable can be manipulated. -Detection requires an amount of CPU power, which has an impact on your mission performance. -Only put detection on when absolutely necessary, and the frequency of the detection can also be set.
- -The detection frequency can be set with AIPATROLZONE.SetDetectionInterval( seconds ), where the amount of seconds specify how much seconds will be waited before the next detection. -Use the method AIPATROLZONE.GetDetectedUnits() to obtain a list of the Units detected by the AI.
- -The detection can be filtered to potential targets in a specific zone. -Use the method AIPATROLZONE.SetDetectionZone() to set the zone where targets need to be detected. -Note that when the zone is too far away, or the AI is not heading towards the zone, or the AI is too high, no targets may be detected -according the weather conditions.
- -When the AI is out of fuel, it is required that a new AI is started, before the old AI can return to the home base. -Therefore, with a parameter and a calculation of the distance to the home base, the fuel treshold is calculated. -When the fuel treshold is reached, the AI will continue for a given time its patrol task in orbit, -while a new AI is targetted to the AIPATROLZONE. -Once the time is finished, the old AI will return to the base. -Use the method AIPATROLZONE.ManageFuel() to have this proces in place.
- -When the AI is damaged, it is required that a new AIControllable is started. However, damage cannon be foreseen early on. -Therefore, when the damage treshold is reached, the AI will return immediately to the home base (RTB). -Use the method AIPATROLZONE.ManageDamage() to have this proces in place.
-The #AIPATROLZONE class implements the core functions to patrol a Zone by an AI Controllable or Group.
The #AIPATROLZONE class implements the core functions to patrol a Zone by an AI Controllable or Group.
+ + + +
The AIPATROLZONE is assigned a Group and this must be done before the AIPATROLZONE process can be started using the Start event.
+ +
The AI will fly towards the random 3D point within the patrol zone, using a random speed within the given altitude and speed limits. +Upon arrival at the 3D point, a new random 3D point will be selected within the patrol zone using the given limits.
+ +
This cycle will continue.
+ +
During the patrol, the AI will detect enemy targets, which are reported through the Detected event.
+ +
-- Note that the enemy is not engaged! To model enemy engagement, either tailor the Detected event, or +use derived AI_ classes to model AI offensive or defensive behaviour.
+ +
Until a fuel or damage treshold has been reached by the AI, or when the AI is commanded to RTB. +When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
+ +
The detection process of the AI controllable can be manipulated. +Detection requires an amount of CPU power, which has an impact on your mission performance. +Only put detection on when absolutely necessary, and the frequency of the detection can also be set.
+ +The detection frequency can be set with AIPATROLZONE.SetDetectionInterval( seconds ), where the amount of seconds specify how much seconds will be waited before the next detection. +Use the method AIPATROLZONE.GetDetectedUnits() to obtain a list of the Units detected by the AI.
+ +The detection can be filtered to potential targets in a specific zone. +Use the method AIPATROLZONE.SetDetectionZone() to set the zone where targets need to be detected. +Note that when the zone is too far away, or the AI is not heading towards the zone, or the AI is too high, no targets may be detected +according the weather conditions.
+ +When the AI is out of fuel, it is required that a new AI is started, before the old AI can return to the home base. +Therefore, with a parameter and a calculation of the distance to the home base, the fuel treshold is calculated. +When the fuel treshold is reached, the AI will continue for a given time its patrol task in orbit, +while a new AI is targetted to the AIPATROLZONE. +Once the time is finished, the old AI will return to the base. +Use the method AIPATROLZONE.ManageFuel() to have this proces in place.
+ +When the AI is damaged, it is required that a new AIControllable is started. However, damage cannon be foreseen early on. +Therefore, when the damage treshold is reached, the AI will return immediately to the home base (RTB). +Use the method AIPATROLZONE.ManageDamage() to have this proces in place.
+ +All classes within the MOOSE framework are derived from the #BASE class.
- -BASE provides facilities for :
- -Note: The BASE class is an abstract class and is not meant to be used directly.
- -Any class derived from BASE, will use the Base#BASE.New constructor embedded in the Base#BASE.Inherit method. -See an example at the Base#BASE.New method how this is done.
- -The BASE class contains trace methods to trace progress within a mission execution of a certain object. -These trace methods are inherited by each MOOSE class interiting BASE, soeach object created from derived class from BASE can use the tracing methods to trace its execution.
- -Any type of information can be passed to these tracing methods. See the following examples:
- -self:E( "Hello" )
-Result in the word "Hello" in the dcs.log.
- -local Array = { 1, nil, "h", { "a","b" }, "x" }
-self:E( Array )
-Results with the text [1]=1,[3]="h",[4]={[1]="a",[2]="b"},[5]="x"} in the dcs.log.
- -local Object1 = "Object1"
-local Object2 = 3
-local Object3 = { Object 1, Object 2 }
-self:E( { Object1, Object2, Object3 } )
-Results with the text [1]={[1]="Object",[2]=3,[3]={[1]="Object",[2]=3}} in the dcs.log.
- -local SpawnObject = SPAWN:New( "Plane" )
-local GroupObject = GROUP:FindByName( "Group" )
-self:E( { Spawn = SpawnObject, Group = GroupObject } )
-Results with the text [1]={Spawn={....),Group={...}} in the dcs.log.
- -Below a more detailed explanation of the different method types for tracing.
- -There are basically 3 types of tracing methods available:
- -There are 3 tracing levels within MOOSE.
-These tracing levels were defined to avoid bulks of tracing to be generated by lots of objects.
As such, the F and T methods have additional variants to trace level 2 and 3 respectively:
- -Tracing can be activated in several ways:
- -The method BASE.IsTrace() will validate if tracing is activated or not.
- -The BASE class provides methods to catch DCS Events. These are events that are triggered from within the DCS simulator, -and handled through lua scripting. MOOSE provides an encapsulation to handle these events more efficiently.
- -At first, the mission designer will need to Subscribe to a specific DCS event for the class. -So, when the DCS event occurs, the class will be notified of that event. -There are two methods which you use to subscribe to or unsubscribe from an event.
- -Once the class is subscribed to the event, an Event Handling method on the object or class needs to be written that will be called -when the DCS event occurs. The Event Handling method receives an Event#EVENTDATA structure, which contains a lot of information -about the event that occurred.
- -Find below an example of the prototype how to write an event handling function for two units:
- - local Tank1 = UNIT:FindByName( "Tank A" )
- local Tank2 = UNIT:FindByName( "Tank B" )
-
- -- Here we subscribe to the Dead events. So, if one of these tanks dies, the Tank1 or Tank2 objects will be notified.
- Tank1:HandleEvent( EVENTS.Dead )
- Tank2:HandleEvent( EVENTS.Dead )
-
- --- This function is an Event Handling function that will be called when Tank1 is Dead.
- -- @param Wrapper.Unit#UNIT self
- -- @param Core.Event#EVENTDATA EventData
- function Tank1:OnEventDead( EventData )
-
- self:SmokeGreen()
- end
-
- --- This function is an Event Handling function that will be called when Tank2 is Dead.
- -- @param Wrapper.Unit#UNIT self
- -- @param Core.Event#EVENTDATA EventData
- function Tank2:OnEventDead( EventData )
-
- self:SmokeBlue()
- end
-See the Event module for more information about event handling.
- -BASE provides methods to get more information of each object:
- -A mechanism is in place in MOOSE, that allows to let the objects administer states.
-States are essentially properties of objects, which are identified by a Key and a Value.
The method BASE.SetState() can be used to set a Value with a reference Key to the object.
-To read or retrieve a state Value based on a Key, use the BASE.GetState method.
These two methods provide a very handy way to keep state at long lasting processes. -Values can be stored within the objects, and later retrieved or changed when needed. -There is one other important thing to note, the BASE.SetState() and BASE.GetState methods -receive as the first parameter the object for which the state needs to be set. -Thus, if the state is to be set for the same object as the object for which the method is used, then provide the same -object name to the method.
- -The following methods are available to implement inheritance
- -The #BASE class is the core root class from where every other class in moose is derived.
All classes within the MOOSE framework are derived from the BASE class.
Remove all subscribed events
-Set a state or property of the Object given a Key and a Value.
-Trace a function call.
-All classes within the MOOSE framework are derived from the BASE class.
+ + ++BASE provides facilities for :
+ +Note: The BASE class is an abstract class and is not meant to be used directly.
+ +Any class derived from BASE, will use the Base#BASE.New constructor embedded in the Base#BASE.Inherit method. +See an example at the Base#BASE.New method how this is done.
+ +The BASE class contains trace methods to trace progress within a mission execution of a certain object. +These trace methods are inherited by each MOOSE class interiting BASE, soeach object created from derived class from BASE can use the tracing methods to trace its execution.
+ +Any type of information can be passed to these tracing methods. See the following examples:
+ +self:E( "Hello" )
+Result in the word "Hello" in the dcs.log.
+ +local Array = { 1, nil, "h", { "a","b" }, "x" }
+self:E( Array )
+Results with the text [1]=1,[3]="h",[4]={[1]="a",[2]="b"},[5]="x"} in the dcs.log.
+ +local Object1 = "Object1"
+local Object2 = 3
+local Object3 = { Object 1, Object 2 }
+self:E( { Object1, Object2, Object3 } )
+Results with the text [1]={[1]="Object",[2]=3,[3]={[1]="Object",[2]=3}} in the dcs.log.
+ +local SpawnObject = SPAWN:New( "Plane" )
+local GroupObject = GROUP:FindByName( "Group" )
+self:E( { Spawn = SpawnObject, Group = GroupObject } )
+Results with the text [1]={Spawn={....),Group={...}} in the dcs.log.
+ +Below a more detailed explanation of the different method types for tracing.
+ +There are basically 3 types of tracing methods available:
+ +There are 3 tracing levels within MOOSE.
+These tracing levels were defined to avoid bulks of tracing to be generated by lots of objects.
As such, the F and T methods have additional variants to trace level 2 and 3 respectively:
+ +Tracing can be activated in several ways:
+ +The method BASE.IsTrace() will validate if tracing is activated or not.
+ +The BASE class provides methods to catch DCS Events. These are events that are triggered from within the DCS simulator, +and handled through lua scripting. MOOSE provides an encapsulation to handle these events more efficiently.
+ +At first, the mission designer will need to Subscribe to a specific DCS event for the class. +So, when the DCS event occurs, the class will be notified of that event. +There are two methods which you use to subscribe to or unsubscribe from an event.
+ +Once the class is subscribed to the event, an Event Handling method on the object or class needs to be written that will be called +when the DCS event occurs. The Event Handling method receives an Event#EVENTDATA structure, which contains a lot of information +about the event that occurred.
+ +Find below an example of the prototype how to write an event handling function for two units:
+ + local Tank1 = UNIT:FindByName( "Tank A" )
+ local Tank2 = UNIT:FindByName( "Tank B" )
+
+ -- Here we subscribe to the Dead events. So, if one of these tanks dies, the Tank1 or Tank2 objects will be notified.
+ Tank1:HandleEvent( EVENTS.Dead )
+ Tank2:HandleEvent( EVENTS.Dead )
+
+ --- This function is an Event Handling function that will be called when Tank1 is Dead.
+ -- @param Wrapper.Unit#UNIT self
+ -- @param Core.Event#EVENTDATA EventData
+ function Tank1:OnEventDead( EventData )
+
+ self:SmokeGreen()
+ end
+
+ --- This function is an Event Handling function that will be called when Tank2 is Dead.
+ -- @param Wrapper.Unit#UNIT self
+ -- @param Core.Event#EVENTDATA EventData
+ function Tank2:OnEventDead( EventData )
+
+ self:SmokeBlue()
+ end
+See the Event module for more information about event handling.
+ +BASE provides methods to get more information of each object:
+ +A mechanism is in place in MOOSE, that allows to let the objects administer states.
+States are essentially properties of objects, which are identified by a Key and a Value.
The method BASE.SetState() can be used to set a Value with a reference Key to the object.
+To read or retrieve a state Value based on a Key, use the BASE.GetState method.
These two methods provide a very handy way to keep state at long lasting processes. +Values can be stored within the objects, and later retrieved or changed when needed. +There is one other important thing to note, the BASE.SetState() and BASE.GetState methods +receive as the first parameter the object for which the state needs to be set. +Thus, if the state is to be set for the same object as the object for which the method is used, then provide the same +object name to the method.
+ +The following methods are available to implement inheritance
+ +BaseBASEThe BASE Class
- -The underlying change log documents the API changes. Please read this carefully. The following notation is used:
+ +YYYY-MM-DD: CLASS:NewFunction( Params ) replaces CLASS:OldFunction( Params ) +YYYY-MM-DD: CLASS:NewFunction( Params ) added
+ +Hereby the change log:
+ +| FSM | +
+1) FSM class, extends Base#BASE
The FSM class is the base class of all FSM_ derived classes. It implements the main functionality to define and execute Finite State Machines. + The FSM class is the base class of all FSM_ derived classes. + |
+
| FSM_CONTROLLABLE | +
+FSM_CONTROLLABLE, extends #FSM+ +FSM_CONTROLLABLE class models Finite State Machines for Controllables, which are Groups, Units, Clients. + |
+
| FSM_PROCESS | +
+FSM_PROCESS, extends #FSM+ +FSM_PROCESS class models Finite State Machines for Task actions, which control Clients. + |
+
| FSM_SET | +
+FSM_SET, extends #FSM+ +FSM_SET class models Finite State Machines for Sets. + |
+
| FSM_TASK | +
+FSM_TASK, extends #FSM+ +FSM_TASK class models Finite State Machines for Tasks. + |
+
FSM| FSM:AddEndState(State) | +
+ Adds an End state. + |
+
| FSM:AddProcess(From, Event, Process, ReturnEvents) | +
+ Set the default Process template with key ProcessName providing the ProcessClass and the process object when it is assigned to a Controllable by the task. + |
+
| FSM:AddScore(State, ScoreText, Score) | +
+ Adds a score for the FSM to be achieved. + |
+
| FSM:AddScoreProcess(From, Event, State, ScoreText, Score) | +
+ Adds a score for the FSM_PROCESS to be achieved. + |
+
| FSM:AddTransition(From, Event, To) | +
+ Add a new transition rule to the FSM. + |
+
| FSM.CallScheduler | ++ + | +
| FSM.Events | ++ + | +
| FSM:GetEndStates() | +
+ Returns the End states. + |
+
| FSM:GetProcess(From, Event) | ++ + | +
| FSM:GetProcesses() | +
+ Returns a table of the SubFSM rules defined within the FSM. + |
+
| FSM:GetScores() | +
+ Returns a table with the scores defined. + |
+
| FSM:GetStartState() | +
+ Returns the start state of the FSM. + |
+
| FSM:GetState() | ++ + | +
| FSM:GetSubs() | +
+ Returns a table with the Subs defined. + |
+
| FSM:GetTransitions() | +
+ Returns a table of the transition rules defined within the FSM. + |
+
| FSM:Is(State) | ++ + | +
| FSM:LoadCallBacks(CallBackTable) | ++ + | +
| FSM:New(FsmT) | +
+ Creates a new FSM object. + |
+
| FSM.Scores | ++ + | +
| FSM:SetStartState(State) | +
+ Sets the start state of the FSM. + |
+
| FSM._EndStates | ++ + | +
| FSM._EventSchedules | ++ + | +
| FSM._Processes | ++ + | +
| FSM._Scores | ++ + | +
| FSM._StartState | ++ + | +
| FSM._Transitions | ++ + | +
| FSM:_add_to_map(Map, Event) | ++ + | +
| FSM:_call_handler(handler, params, EventName) | ++ + | +
| FSM:_create_transition(EventName) | ++ + | +
| FSM:_delayed_transition(EventName) | ++ + | +
| FSM:_eventmap(Events, EventStructure) | ++ + | +
| FSM:_gosub(ParentFrom, ParentEvent) | ++ + | +
| FSM:_handler(EventName, ...) | ++ + | +
| FSM:_isendstate(Current) | ++ + | +
| FSM:_submap(subs, sub, name) | ++ + | +
| FSM:can(e) | ++ + | +
| FSM:cannot(e) | ++ + | +
| FSM.current | ++ + | +
| FSM.endstates | ++ + | +
| FSM:is(state) | ++ + | +
| FSM.options | ++ + | +
| FSM.subs | ++ + | +
FSM_CONTROLLABLE| FSM_CONTROLLABLE.Controllable | ++ + | +
| FSM_CONTROLLABLE:GetControllable() | +
+ Gets the CONTROLLABLE object that the FSM_CONTROLLABLE governs. + |
+
| FSM_CONTROLLABLE:New(FSMT, Controllable) | +
+ Creates a new FSM_CONTROLLABLE object. + |
+
| FSM_CONTROLLABLE:OnAfterStop(Controllable, From, Event, To) | +
+ OnAfter Transition Handler for Event Stop. + |
+
| FSM_CONTROLLABLE:OnBeforeStop(Controllable, From, Event, To) | +
+ OnBefore Transition Handler for Event Stop. + |
+
| FSM_CONTROLLABLE:OnEnterStopped(Controllable, From, Event, To) | +
+ OnEnter Transition Handler for State Stopped. + |
+
| FSM_CONTROLLABLE:OnLeaveStopped(Controllable, From, Event, To) | +
+ OnLeave Transition Handler for State Stopped. + |
+
| FSM_CONTROLLABLE:SetControllable(FSMControllable) | +
+ Sets the CONTROLLABLE object that the FSM_CONTROLLABLE governs. + |
+
| FSM_CONTROLLABLE:Stop() | +
+ Synchronous Event Trigger for Event Stop. + |
+
| FSM_CONTROLLABLE:__Stop(Delay) | +
+ Asynchronous Event Trigger for Event Stop. + |
+
| FSM_CONTROLLABLE:_call_handler(handler, params, EventName) | ++ + | +
FSM_PROCESS| FSM_PROCESS:Assign(Task, ProcessUnit) | +
+ Assign the process to a Unit and activate the process. + |
+
| FSM_PROCESS:Copy(Controllable, Task) | +
+ Creates a new FSMPROCESS object based on this FSMPROCESS. + |
+
| FSM_PROCESS:GetCommandCenter() | +
+ Gets the mission of the process. + |
+
| FSM_PROCESS:GetMission() | +
+ Gets the mission of the process. + |
+
| FSM_PROCESS:GetTask() | +
+ Gets the task of the process. + |
+
| FSM_PROCESS:Init(FsmProcess) | ++ + | +
| FSM_PROCESS:Message(Message) | +
+ Send a message of the Task to the Group of the Unit. + |
+
| FSM_PROCESS:New(Controllable, Task) | +
+ Creates a new FSM_PROCESS object. + |
+
| FSM_PROCESS:Remove() | +
+ Removes an FSM_PROCESS object. + |
+
| FSM_PROCESS:SetTask(Task) | +
+ Sets the task of the process. + |
+
| FSM_PROCESS.Task | ++ + | +
| FSM_PROCESS:_call_handler(handler, params, EventName) | ++ + | +
| FSM_PROCESS:onenterAssigned(ProcessUnit) | ++ + | +
| FSM_PROCESS:onenterFailed(ProcessUnit) | ++ + | +
| FSM_PROCESS:onenterSuccess(ProcessUnit) | ++ + | +
| FSM_PROCESS:onstatechange(ProcessUnit, Event, From, To, Task, Dummy) | +
+ StateMachine callback function for a FSM_PROCESS + |
+
FSM_SET| FSM_SET:Get() | +
+ Gets the SETBASE object that the FSMSET governs. + |
+
| FSM_SET:New(FSMT, Set_SET_BASE, FSMSet) | +
+ Creates a new FSM_SET object. + |
+
| FSM_SET.Set | ++ + | +
| FSM_SET:_call_handler(handler, params, EventName) | ++ + | +
FSM_TASK| FSM_TASK:New(FSMT, Task, TaskUnit) | +
+ Creates a new FSM_TASK object. + |
+
| FSM_TASK.Task | ++ + | +
| FSM_TASK:_call_handler(handler, params, EventName) | ++ + | +
The FSM class is the base class of all FSM_ derived classes.
+ + +It implements the main functionality to define and execute Finite State Machines. The derived FSM_ classes extend the Finite State Machine functionality to run a workflow process for a specific purpose or component.
Finite State Machines have Transition Rules, Transition Handlers and Event Triggers.
@@ -373,592 +953,6 @@ Depending upon which state is returned, the main FSM can continThe underlying change log documents the API changes. Please read this carefully. The following notation is used:
- -YYYY-MM-DD: CLASS:NewFunction( Params ) replaces CLASS:OldFunction( Params ) -YYYY-MM-DD: CLASS:NewFunction( Params ) added
- -Hereby the change log:
- -| FSM | -- - | -
| FSM_CONTROLLABLE | -- - | -
| FSM_PROCESS | -- - | -
| FSM_SET | -- - | -
| FSM_TASK | -- - | -
FSM| FSM:AddEndState(State) | -
- Adds an End state. - |
-
| FSM:AddProcess(From, Event, Process, ReturnEvents) | -
- Set the default Process template with key ProcessName providing the ProcessClass and the process object when it is assigned to a Controllable by the task. - |
-
| FSM:AddScore(State, ScoreText, Score) | -
- Adds a score for the FSM to be achieved. - |
-
| FSM:AddScoreProcess(From, Event, State, ScoreText, Score) | -
- Adds a score for the FSM_PROCESS to be achieved. - |
-
| FSM:AddTransition(From, Event, To) | -
- Add a new transition rule to the FSM. - |
-
| FSM.CallScheduler | -- - | -
| FSM.ClassName | -- - | -
| FSM.Events | -- - | -
| FSM:GetEndStates() | -
- Returns the End states. - |
-
| FSM:GetProcess(From, Event) | -- - | -
| FSM:GetProcesses() | -
- Returns a table of the SubFSM rules defined within the FSM. - |
-
| FSM:GetScores() | -
- Returns a table with the scores defined. - |
-
| FSM:GetStartState() | -
- Returns the start state of the FSM. - |
-
| FSM:GetState() | -- - | -
| FSM:GetSubs() | -
- Returns a table with the Subs defined. - |
-
| FSM:GetTransitions() | -
- Returns a table of the transition rules defined within the FSM. - |
-
| FSM:Is(State) | -- - | -
| FSM:LoadCallBacks(CallBackTable) | -- - | -
| FSM:New(FsmT) | -
- Creates a new FSM object. - |
-
| FSM.Scores | -- - | -
| FSM:SetStartState(State) | -
- Sets the start state of the FSM. - |
-
| FSM._EndStates | -- - | -
| FSM._EventSchedules | -- - | -
| FSM._Processes | -- - | -
| FSM._Scores | -- - | -
| FSM._StartState | -- - | -
| FSM._Transitions | -- - | -
| FSM:_add_to_map(Map, Event) | -- - | -
| FSM:_call_handler(handler, params, EventName) | -- - | -
| FSM:_create_transition(EventName) | -- - | -
| FSM:_delayed_transition(EventName) | -- - | -
| FSM:_eventmap(Events, EventStructure) | -- - | -
| FSM:_gosub(ParentFrom, ParentEvent) | -- - | -
| FSM:_handler(EventName, ...) | -- - | -
| FSM:_isendstate(Current) | -- - | -
| FSM:_submap(subs, sub, name) | -- - | -
| FSM:can(e) | -- - | -
| FSM:cannot(e) | -- - | -
| FSM.current | -- - | -
| FSM.endstates | -- - | -
| FSM:is(state) | -- - | -
| FSM.options | -- - | -
| FSM.subs | -- - | -
FSM_CONTROLLABLE| FSM_CONTROLLABLE.ClassName | -- - | -
| FSM_CONTROLLABLE.Controllable | -- - | -
| FSM_CONTROLLABLE:GetControllable() | -
- Gets the CONTROLLABLE object that the FSM_CONTROLLABLE governs. - |
-
| FSM_CONTROLLABLE:New(FSMT, Controllable) | -
- Creates a new FSM_CONTROLLABLE object. - |
-
| FSM_CONTROLLABLE:OnAfterStop(Controllable, From, Event, To) | -
- OnAfter Transition Handler for Event Stop. - |
-
| FSM_CONTROLLABLE:OnBeforeStop(Controllable, From, Event, To) | -
- OnBefore Transition Handler for Event Stop. - |
-
| FSM_CONTROLLABLE:OnEnterStopped(Controllable, From, Event, To) | -
- OnEnter Transition Handler for State Stopped. - |
-
| FSM_CONTROLLABLE:OnLeaveStopped(Controllable, From, Event, To) | -
- OnLeave Transition Handler for State Stopped. - |
-
| FSM_CONTROLLABLE:SetControllable(FSMControllable) | -
- Sets the CONTROLLABLE object that the FSM_CONTROLLABLE governs. - |
-
| FSM_CONTROLLABLE:Stop() | -
- Synchronous Event Trigger for Event Stop. - |
-
| FSM_CONTROLLABLE:__Stop(Delay) | -
- Asynchronous Event Trigger for Event Stop. - |
-
| FSM_CONTROLLABLE:_call_handler(handler, params, EventName) | -- - | -
FSM_PROCESS| FSM_PROCESS:Assign(Task, ProcessUnit) | -
- Assign the process to a Unit and activate the process. - |
-
| FSM_PROCESS.ClassName | -- - | -
| FSM_PROCESS:Copy(Controllable, Task) | -
- Creates a new FSMPROCESS object based on this FSMPROCESS. - |
-
| FSM_PROCESS:GetCommandCenter() | -
- Gets the mission of the process. - |
-
| FSM_PROCESS:GetMission() | -
- Gets the mission of the process. - |
-
| FSM_PROCESS:GetTask() | -
- Gets the task of the process. - |
-
| FSM_PROCESS:Init(FsmProcess) | -- - | -
| FSM_PROCESS:Message(Message) | -
- Send a message of the Task to the Group of the Unit. - |
-
| FSM_PROCESS:New(Controllable, Task) | -
- Creates a new FSM_PROCESS object. - |
-
| FSM_PROCESS:Remove() | -
- Removes an FSM_PROCESS object. - |
-
| FSM_PROCESS:SetTask(Task) | -
- Sets the task of the process. - |
-
| FSM_PROCESS.Task | -- - | -
| FSM_PROCESS:_call_handler(handler, params, EventName) | -- - | -
| FSM_PROCESS:onenterAssigned(ProcessUnit) | -- - | -
| FSM_PROCESS:onenterFailed(ProcessUnit) | -- - | -
| FSM_PROCESS:onenterSuccess(ProcessUnit) | -- - | -
| FSM_PROCESS:onstatechange(ProcessUnit, Event, From, To, Task, Dummy) | -
- StateMachine callback function for a FSM_PROCESS - |
-
FSM_SET| FSM_SET.ClassName | -- - | -
| FSM_SET:Get() | -
- Gets the SETBASE object that the FSMSET governs. - |
-
| FSM_SET:New(FSMT, Set_SET_BASE, FSMSet) | -
- Creates a new FSM_SET object. - |
-
| FSM_SET.Set | -- - | -
| FSM_SET:_call_handler(handler, params, EventName) | -- - | -
FSM_TASK| FSM_TASK.ClassName | -- - | -
| FSM_TASK:New(FSMT, Task, TaskUnit) | -
- Creates a new FSM_TASK object. - |
-
| FSM_TASK.Task | -- - | -
| FSM_TASK:_call_handler(handler, params, EventName) | -- - | -
FSM_CONTROLLABLE class models Finite State Machines for Controllables, which are Groups, Units, Clients.
+ + + +FSM_PROCESS class models Finite State Machines for Task actions, which control Clients.
+ + + +FSM_SET class models Finite State Machines for Sets.
+ + +Note that these FSMs control multiple objects!!! So State concerns here +for multiple objects or the position of the state machine in the process.
+ +FSM_TASK class models Finite State Machines for Tasks.
+ + + +FsmFSMFSM class
- -FSM_CONTROLLABLEFSM_CONTROLLABLE class
- -FSM_PROCESSFSM_PROCESS class
- -#FSM_PROCESS: self
- -Mission designers can use the Set#SET_AIRBASE class to build sets of airbases optionally belonging to certain:
+ +Create a new SET_AIRBASE object with the SET_AIRBASE.New method:
+ +The Set#SET_BASE class defines the core functions that define a collection of objects.
Mission designers can use the Set#SET_CLIENT class to build sets of units belonging to certain:
+ +Mission designers can use the Set#SET_GROUP class to build sets of groups belonging to certain:
+ +Mission designers can use the SET_UNIT class to build sets of units belonging to certain:
+ +Handles the Database to check on an event (birth) that the Object was added in the Database.
-Builds a set of airbases of coalitions.
-Gets the Set.
-Handles the Database to check on an event (birth) that the Object was added in the Database.
-Builds a set of clients of defined countries.
-Handles the Database to check on an event (birth) that the Object was added in the Database.
-Builds a set of groups of defined countries.
-Calculate the maxium A2G threat level of the SET_UNIT.
-Builds a set of SEADable units.
-Remove UNIT(s) from SET_UNIT.
-SetSET_AIRBASEMission designers can use the Set#SET_AIRBASE class to build sets of airbases optionally belonging to certain:
@@ -1012,8 +890,292 @@ The following iterator methods are currently available within the SETAIRBASThe Set#SET_BASE class defines the core functions that define a collection of objects.
+ + +A SET provides iterators to iterate the SET, but will temporarily yield the ForEach interator loop at defined "intervals" to the mail simulator loop. +In this way, large loops can be done while not blocking the simulator main processing loop. +The default "yield interval" is after 10 objects processed. +The default "time interval" is after 0.001 seconds.
+ +Some key core functions are Set#SET_BASE.Add and Set#SET_BASE.Remove to add or remove objects from the SET in your logic.
+ +Modify the iterator intervals with the Set#SET_BASE.SetInteratorIntervals method. +You can set the "yield interval", and the "time interval". (See above).
+ + +Mission designers can use the Set#SET_CLIENT class to build sets of units belonging to certain:
+ ++
Create a new SET_CLIENT object with the SET_CLIENT.New method:
+ +CLIENTs can be added and removed using the Set#SET_CLIENT.AddClientsByName and Set#SET_CLIENT.RemoveClientsByName respectively. +These methods take a single CLIENT name or an array of CLIENT names to be added or removed from SET_CLIENT.
+ +You can set filter criteria to define the set of clients within the SET_CLIENT. +Filter criteria are defined by:
+ +Once the filter criteria have been set for the SET_CLIENT, you can start filtering using:
+ +Planned filter criteria within development are (so these are not yet available):
+ +Once the filters have been defined and the SETCLIENT has been built, you can iterate the SETCLIENT with the available iterator methods. +The iterator methods will walk the SETCLIENT set, and call for each element within the set a function that you provide. +The following iterator methods are currently available within the SETCLIENT:
+ +Mission designers can use the Set#SET_GROUP class to build sets of groups belonging to certain:
+ ++
Create a new SET_GROUP object with the SET_GROUP.New method:
+ +GROUPS can be added and removed using the Set#SET_GROUP.AddGroupsByName and Set#SET_GROUP.RemoveGroupsByName respectively. +These methods take a single GROUP name or an array of GROUP names to be added or removed from SET_GROUP.
+ +You can set filter criteria to define the set of groups within the SET_GROUP. +Filter criteria are defined by:
+ +Once the filter criteria have been set for the SET_GROUP, you can start filtering using:
+ +Planned filter criteria within development are (so these are not yet available):
+ +Once the filters have been defined and the SETGROUP has been built, you can iterate the SETGROUP with the available iterator methods. +The iterator methods will walk the SETGROUP set, and call for each element within the set a function that you provide. +The following iterator methods are currently available within the SETGROUP:
+ +Mission designers can use the SET_UNIT class to build sets of units belonging to certain:
+ ++
Create a new SET_UNIT object with the SET_UNIT.New method:
+ +UNITs can be added and removed using the Set#SET_UNIT.AddUnitsByName and Set#SET_UNIT.RemoveUnitsByName respectively. +These methods take a single UNIT name or an array of UNIT names to be added or removed from SET_UNIT.
+ +You can set filter criteria to define the set of units within the SET_UNIT. +Filter criteria are defined by:
+ +Once the filter criteria have been set for the SET_UNIT, you can start filtering using:
+ +Planned filter criteria within development are (so these are not yet available):
+ +Once the filters have been defined and the SETUNIT has been built, you can iterate the SETUNIT with the available iterator methods. +The iterator methods will walk the SETUNIT set, and call for each element within the set a function that you provide. +The following iterator methods are currently available within the SETUNIT:
+ +Planned iterators methods in development are (so these are not yet available):
+ +Various methods exist for a SETUNIT to perform actions or calculations and retrieve results from the SETUNIT:
+ +SetSET_AIRBASE#SET_AIRBASE: self
- -SET_BASEThe Set#SET_BASE class defines the core functions that define a collection of objects.
- - -A SET provides iterators to iterate the SET, but will temporarily yield the ForEach interator loop at defined "intervals" to the mail simulator loop. -In this way, large loops can be done while not blocking the simulator main processing loop. -The default "yield interval" is after 10 objects processed. -The default "time interval" is after 0.001 seconds.
- -Some key core functions are Set#SET_BASE.Add and Set#SET_BASE.Remove to add or remove objects from the SET in your logic.
- -Modify the iterator intervals with the Set#SET_BASE.SetInteratorIntervals method. -You can set the "yield interval", and the "time interval". (See above).
- - -#SET_BASE: self
- -SET_CLIENTMission designers can use the Set#SET_CLIENT class to build sets of units belonging to certain:
- --
Create a new SET_CLIENT object with the SET_CLIENT.New method:
- -CLIENTs can be added and removed using the Set#SET_CLIENT.AddClientsByName and Set#SET_CLIENT.RemoveClientsByName respectively. -These methods take a single CLIENT name or an array of CLIENT names to be added or removed from SET_CLIENT.
- -You can set filter criteria to define the set of clients within the SET_CLIENT. -Filter criteria are defined by:
- -Once the filter criteria have been set for the SET_CLIENT, you can start filtering using:
- -Planned filter criteria within development are (so these are not yet available):
- -Once the filters have been defined and the SETCLIENT has been built, you can iterate the SETCLIENT with the available iterator methods. -The iterator methods will walk the SETCLIENT set, and call for each element within the set a function that you provide. -The following iterator methods are currently available within the SETCLIENT:
- -#SET_CLIENT: self
- -SET_GROUPMission designers can use the Set#SET_GROUP class to build sets of groups belonging to certain:
- --
Create a new SET_GROUP object with the SET_GROUP.New method:
- -GROUPS can be added and removed using the Set#SET_GROUP.AddGroupsByName and Set#SET_GROUP.RemoveGroupsByName respectively. -These methods take a single GROUP name or an array of GROUP names to be added or removed from SET_GROUP.
- -You can set filter criteria to define the set of groups within the SET_GROUP. -Filter criteria are defined by:
- -Once the filter criteria have been set for the SET_GROUP, you can start filtering using:
- -Planned filter criteria within development are (so these are not yet available):
- -Once the filters have been defined and the SETGROUP has been built, you can iterate the SETGROUP with the available iterator methods. -The iterator methods will walk the SETGROUP set, and call for each element within the set a function that you provide. -The following iterator methods are currently available within the SETGROUP:
- -#SET_GROUP: self
- -SET_UNITMission designers can use the SET_UNIT class to build sets of units belonging to certain:
- --
Create a new SET_UNIT object with the SET_UNIT.New method:
- -UNITs can be added and removed using the Set#SET_UNIT.AddUnitsByName and Set#SET_UNIT.RemoveUnitsByName respectively. -These methods take a single UNIT name or an array of UNIT names to be added or removed from SET_UNIT.
- -You can set filter criteria to define the set of units within the SET_UNIT. -Filter criteria are defined by:
- -Once the filter criteria have been set for the SET_UNIT, you can start filtering using:
- -Planned filter criteria within development are (so these are not yet available):
- -Once the filters have been defined and the SETUNIT has been built, you can iterate the SETUNIT with the available iterator methods. -The iterator methods will walk the SETUNIT set, and call for each element within the set a function that you provide. -The following iterator methods are currently available within the SETUNIT:
- -Planned iterators methods in development are (so these are not yet available):
- -Various methods exist for a SETUNIT to perform actions or calculations and retrieve results from the SETUNIT:
- -Calculate the maxium A2G threat level of the SET_UNIT.
- -#SET_UNIT: self
- -self
- -Don't repeat the group from Take-Off till Landing and back Take-Off by ReSpawning.
-By default, no InitLimit
-Flag that indicates if all the Groups of the SpawnGroup need to be visible when Spawned.
+When the first Spawn executes, all the Groups need to be made visible before start.
Each of these ZONE classes have a zone name, and specific parameters defining the zone type:
This class is an abstract BASE class for derived classes, and is not meant to be instantiated.
- -The ZONERADIUS class defined by a zone name, a location and a radius. -This class implements the inherited functions from Core.Zone#ZONEBASE taking into account the own zone format and properties.
- -Various functions exist to find random points within the zone.
- -The ZONE class, defined by the zone name as defined within the Mission Editor. -This class implements the inherited functions from {Core.Zone#ZONE_RADIUS} taking into account the own zone format and properties.
- -The ZONE_UNIT class defined by a zone around a Unit#UNIT with a radius. -This class implements the inherited functions from Zone#ZONE_RADIUS taking into account the own zone format and properties.
- -The ZONE_GROUP class defines by a zone around a Group#GROUP with a radius. The current leader of the group defines the center of the zone. -This class implements the inherited functions from Zone#ZONE_RADIUS taking into account the own zone format and properties.
- -The ZONEPOLYGONBASE class defined by a sequence of Group#GROUP waypoints within the Mission Editor, forming a polygon. -This class implements the inherited functions from Zone#ZONE_RADIUS taking into account the own zone format and properties. -This class is an abstract BASE class for derived classes, and is not meant to be instantiated.
- -Various functions exist to find random points within the zone.
- -The ZONE_POLYGON class defined by a sequence of Group#GROUP waypoints within the Mission Editor, forming a polygon. -This class implements the inherited functions from Zone#ZONE_RADIUS taking into account the own zone format and properties.
- -The underlying change log documents the API changes. Please read this carefully. The following notation is used:
@@ -286,55 +154,63 @@ This class implements the inherited functions from ZONEThe ZONE class, defined by the zone name as defined within the Mission Editor.
This class is an abstract BASE class for derived classes, and is not meant to be instantiated.
The ZONE_GROUP class defines by a zone around a Group#GROUP with a radius.
The ZONE_POLYGON class defined by a sequence of Group#GROUP waypoints within the Mission Editor, forming a polygon.
The ZONEPOLYGONBASE class defined by a sequence of Group#GROUP waypoints within the Mission Editor, forming a polygon.
The ZONE_RADIUS class defined by a zone name, a location and a radius.
The ZONE_UNIT class defined by a zone around a Unit#UNIT with a radius.
ZONE| ZONE.ClassName | -- - | -||||||||||||||||
| ZONE:New(ZoneName) |
Constructor of ZONE, taking the zone name. @@ -348,12 +224,6 @@ This class implements the inherited functions from ZONE_BASE:BoundZone() |
Bound the zone boundaries with a tires. - |
- |||||||||||||||
| ZONE_BASE.ClassName | -- | ||||||||||||||||
| ZONE_GROUP.ClassName | -- - | -||||||||||||||
| ZONE_GROUP:GetRandomVec2() |
Returns a random location within the zone of the Group. @@ -531,12 +395,6 @@ This class implements the inherited functions from TypeZONE_POLYGON
|