From e46d7be91bbc42eb8056370873a0a925c7bd1363 Mon Sep 17 00:00:00 2001 From: FlightControl Date: Tue, 6 Dec 2016 10:30:05 +0100 Subject: [PATCH] FSM restructuring --- Moose Development/Moose/Fsm/FsmTAccount.lua | 90 ++++++------- Moose Development/Moose/Fsm/FsmTAssign.lua | 122 +++++++++--------- Moose Development/Moose/Fsm/FsmTRoute.lua | 80 ++++++------ Moose Development/Moose/Fsm/FsmTSmoke.lua | 72 +++++------ Moose Development/Moose/Fsm/Patrol.lua | 2 +- Moose Development/Moose/Tasking/Task_A2G.lua | 12 +- .../Moose/Tasking/Task_Pickup.lua | 6 +- Moose Development/Moose/Tasking/Task_SEAD.lua | 12 +- .../Moose/Wrapper/Controllable.lua | 2 +- Moose Development/Old/Stage.lua | 8 +- .../Moose_Test_Task_SEAD.lua | 14 +- 11 files changed, 210 insertions(+), 210 deletions(-) diff --git a/Moose Development/Moose/Fsm/FsmTAccount.lua b/Moose Development/Moose/Fsm/FsmTAccount.lua index a009807b5..ec9685c20 100644 --- a/Moose Development/Moose/Fsm/FsmTAccount.lua +++ b/Moose Development/Moose/Fsm/FsmTAccount.lua @@ -2,16 +2,16 @@ -- -- === -- --- # @{#PROCESS_ACCOUNT} FSM class, extends @{Process#PROCESS} +-- # @{#FSMT_ACCOUNT} FSM class, extends @{Process#PROCESS} -- --- ## PROCESS_ACCOUNT state machine: +-- ## FSMT_ACCOUNT state machine: -- -- This class is a state machine: it manages a process that is triggered by events causing state transitions to occur. -- All derived classes from this class will start with the class name, followed by a \_. See the relevant derived class descriptions below. -- Each derived class follows exactly the same process, using the same events and following the same state transitions, -- but will have **different implementation behaviour** upon each event or state transition. -- --- ### PROCESS_ACCOUNT **Events**: +-- ### FSMT_ACCOUNT **Events**: -- -- These are the events defined in this class: -- @@ -21,7 +21,7 @@ -- * **More**: There are more DCS events that need to be accounted for. The process will go back into the Report state. -- * **NoMore**: There are no more DCS events that need to be accounted for. The process will go into the Success state. -- --- ### PROCESS_ACCOUNT **Event methods**: +-- ### FSMT_ACCOUNT **Event methods**: -- -- Event methods are available (dynamically allocated by the state machine), that accomodate for state transitions occurring in the process. -- There are two types of event methods, which you can use to influence the normal mechanisms in the state machine: @@ -29,7 +29,7 @@ -- * **Immediate**: The event method has exactly the name of the event. -- * **Delayed**: The event method starts with a __ + the name of the event. The first parameter of the event method is a number value, expressing the delay in seconds when the event will be executed. -- --- ### PROCESS_ACCOUNT **States**: +-- ### FSMT_ACCOUNT **States**: -- -- * **Assigned**: The player is assigned to the task. This is the initialization state for the process. -- * **Waiting**: the process is waiting for a DCS event to occur within the simulator. This state is set automatically. @@ -40,7 +40,7 @@ -- -- (*) End states of the process. -- --- ### PROCESS_ACCOUNT state transition methods: +-- ### FSMT_ACCOUNT state transition methods: -- -- State transition functions can be set **by the mission designer** customizing or improving the behaviour of the state. -- There are 2 moments when state transition methods will be called by the state machine: @@ -55,41 +55,41 @@ -- The state transition method needs to start with the name **OnAfter + the name of the state**. -- These state transition methods need to provide a return value, which is specified at the function description. -- --- # 1) @{#PROCESS_ACCOUNT_DEADS} FSM class, extends @{Fsm.Account#PROCESS_ACCOUNT} +-- # 1) @{#FSMT_ACCOUNT_DEADS} FSM class, extends @{Fsm.Account#FSMT_ACCOUNT} -- --- The PROCESS_ACCOUNT_DEADS class accounts (detects, counts and reports) successful kills of DCS units. +-- The FSMT_ACCOUNT_DEADS class accounts (detects, counts and reports) successful kills of DCS units. -- The process is given a @{Set} of units that will be tracked upon successful destruction. -- The process will end after each target has been successfully destroyed. -- Each successful dead will trigger an Account state transition that can be scored, modified or administered. -- -- --- ## PROCESS_ACCOUNT_DEADS constructor: +-- ## FSMT_ACCOUNT_DEADS constructor: -- --- * @{#PROCESS_ACCOUNT_DEADS.New}(): Creates a new PROCESS_ACCOUNT_DEADS object. +-- * @{#FSMT_ACCOUNT_DEADS.New}(): Creates a new FSMT_ACCOUNT_DEADS object. -- -- === -- -- @module Account -do -- PROCESS_ACCOUNT +do -- FSMT_ACCOUNT - --- PROCESS_ACCOUNT class - -- @type PROCESS_ACCOUNT + --- FSMT_ACCOUNT class + -- @type FSMT_ACCOUNT -- @field Set#SET_UNIT TargetSetUnit -- @extends Core.StateMachine#FSM_TEMPLATE - PROCESS_ACCOUNT = { - ClassName = "PROCESS_ACCOUNT", + FSMT_ACCOUNT = { + ClassName = "FSMT_ACCOUNT", TargetSetUnit = nil, } --- Creates a new DESTROY process. - -- @param #PROCESS_ACCOUNT self - -- @return #PROCESS_ACCOUNT - function PROCESS_ACCOUNT:New() + -- @param #FSMT_ACCOUNT self + -- @return #FSMT_ACCOUNT + function FSMT_ACCOUNT:New() -- Inherits from BASE - local self = BASE:Inherit( self, FSM_TEMPLATE:New( "PROCESS_ACCOUNT" ) ) -- Core.StateMachine#FSM_TEMPLATE + local self = BASE:Inherit( self, FSM_TEMPLATE:New( "FSMT_ACCOUNT" ) ) -- Core.StateMachine#FSM_TEMPLATE self:AddTransition( "Assigned", "Start", "Waiting") self:AddTransition( "*", "Wait", "Waiting") @@ -110,12 +110,12 @@ do -- PROCESS_ACCOUNT --- Process Events --- StateMachine callback function - -- @param #PROCESS_ACCOUNT self + -- @param #FSMT_ACCOUNT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT:onafterStart( ProcessUnit, Event, From, To ) + function FSMT_ACCOUNT:onafterStart( ProcessUnit, Event, From, To ) self:EventOnDead( self.onfuncEventDead ) @@ -124,12 +124,12 @@ do -- PROCESS_ACCOUNT --- StateMachine callback function - -- @param #PROCESS_ACCOUNT self + -- @param #FSMT_ACCOUNT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT:onenterWaiting( ProcessUnit, Event, From, To ) + function FSMT_ACCOUNT:onenterWaiting( ProcessUnit, Event, From, To ) if self.DisplayCount >= self.DisplayInterval then self:Report() @@ -142,37 +142,37 @@ do -- PROCESS_ACCOUNT end --- StateMachine callback function - -- @param #PROCESS_ACCOUNT self + -- @param #FSMT_ACCOUNT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT:onafterEvent( ProcessUnit, Event, From, To, Event ) + function FSMT_ACCOUNT:onafterEvent( ProcessUnit, Event, From, To, Event ) self:__NoMore( 1 ) end -end -- PROCESS_ACCOUNT +end -- FSMT_ACCOUNT -do -- PROCESS_ACCOUNT_DEADS +do -- FSMT_ACCOUNT_DEADS - --- PROCESS_ACCOUNT_DEADS class - -- @type PROCESS_ACCOUNT_DEADS + --- FSMT_ACCOUNT_DEADS class + -- @type FSMT_ACCOUNT_DEADS -- @field Set#SET_UNIT TargetSetUnit - -- @extends #PROCESS_ACCOUNT - PROCESS_ACCOUNT_DEADS = { - ClassName = "PROCESS_ACCOUNT_DEADS", + -- @extends #FSMT_ACCOUNT + FSMT_ACCOUNT_DEADS = { + ClassName = "FSMT_ACCOUNT_DEADS", TargetSetUnit = nil, } --- Creates a new DESTROY process. - -- @param #PROCESS_ACCOUNT_DEADS self + -- @param #FSMT_ACCOUNT_DEADS self -- @param Set#SET_UNIT TargetSetUnit -- @param #string TaskName - function PROCESS_ACCOUNT_DEADS:New( TargetSetUnit, TaskName ) + function FSMT_ACCOUNT_DEADS:New( TargetSetUnit, TaskName ) -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS_ACCOUNT:New() ) -- #PROCESS_ACCOUNT_DEADS + local self = BASE:Inherit( self, FSMT_ACCOUNT:New() ) -- #FSMT_ACCOUNT_DEADS self:SetParameters( { TargetSetUnit = TargetSetUnit, @@ -188,7 +188,7 @@ do -- PROCESS_ACCOUNT_DEADS end - function PROCESS_ACCOUNT_DEADS:_Destructor() + function FSMT_ACCOUNT_DEADS:_Destructor() self:E("_Destructor") self:EventRemoveAll() @@ -198,12 +198,12 @@ do -- PROCESS_ACCOUNT_DEADS --- Process Events --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT_DEADS:onenterReport( ProcessUnit, Event, From, To ) + function FSMT_ACCOUNT_DEADS:onenterReport( ProcessUnit, Event, From, To ) self:E( { ProcessUnit, Event, From, To } ) local TaskGroup = ProcessUnit:GetGroup() @@ -212,12 +212,12 @@ do -- PROCESS_ACCOUNT_DEADS --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT_DEADS:onenterAccount( ProcessUnit, Event, From, To, EventData ) + function FSMT_ACCOUNT_DEADS:onenterAccount( ProcessUnit, Event, From, To, EventData ) self:T( { ProcessUnit, EventData, Event, From, To } ) self:T({self.Controllable}) @@ -232,12 +232,12 @@ do -- PROCESS_ACCOUNT_DEADS end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ACCOUNT_DEADS:onafterEvent( ProcessUnit, Event, From, To, EventData ) + function FSMT_ACCOUNT_DEADS:onafterEvent( ProcessUnit, Event, From, To, EventData ) if self.TargetSetUnit:Count() > 0 then self:__More( 1 ) @@ -248,9 +248,9 @@ do -- PROCESS_ACCOUNT_DEADS --- DCS Events - --- @param #PROCESS_ACCOUNT_DEADS self + --- @param #FSMT_ACCOUNT_DEADS self -- @param Event#EVENTDATA EventData - function PROCESS_ACCOUNT_DEADS:onfuncEventDead( EventData ) + function FSMT_ACCOUNT_DEADS:onfuncEventDead( EventData ) self:T( { "EventDead", EventData } ) if EventData.IniDCSUnit then @@ -258,4 +258,4 @@ do -- PROCESS_ACCOUNT_DEADS end end -end -- PROCESS_ACCOUNT DEADS +end -- FSMT_ACCOUNT DEADS diff --git a/Moose Development/Moose/Fsm/FsmTAssign.lua b/Moose Development/Moose/Fsm/FsmTAssign.lua index bb24cc28c..8b2943000 100644 --- a/Moose Development/Moose/Fsm/FsmTAssign.lua +++ b/Moose Development/Moose/Fsm/FsmTAssign.lua @@ -2,16 +2,16 @@ -- -- === -- --- # @{#PROCESS_ASSIGN} FSM class, extends @{Process#PROCESS} +-- # @{#FSMT_ASSIGN} FSM class, extends @{Process#PROCESS} -- --- ## PROCESS_ASSIGN state machine: +-- ## FSMT_ASSIGN state machine: -- -- This class is a state machine: it manages a process that is triggered by events causing state transitions to occur. -- All derived classes from this class will start with the class name, followed by a \_. See the relevant derived class descriptions below. -- Each derived class follows exactly the same process, using the same events and following the same state transitions, -- but will have **different implementation behaviour** upon each event or state transition. -- --- ### PROCESS_ASSIGN **Events**: +-- ### FSMT_ASSIGN **Events**: -- -- These are the events defined in this class: -- @@ -19,7 +19,7 @@ -- * **Assign**: Assign the task. -- * **Reject**: Reject the task.. -- --- ### PROCESS_ASSIGN **Event methods**: +-- ### FSMT_ASSIGN **Event methods**: -- -- Event methods are available (dynamically allocated by the state machine), that accomodate for state transitions occurring in the process. -- There are two types of event methods, which you can use to influence the normal mechanisms in the state machine: @@ -27,7 +27,7 @@ -- * **Immediate**: The event method has exactly the name of the event. -- * **Delayed**: The event method starts with a __ + the name of the event. The first parameter of the event method is a number value, expressing the delay in seconds when the event will be executed. -- --- ### PROCESS_ASSIGN **States**: +-- ### FSMT_ASSIGN **States**: -- -- * **UnAssigned**: The player has not accepted the task. -- * **Assigned (*)**: The player has accepted the task. @@ -37,7 +37,7 @@ -- -- (*) End states of the process. -- --- ### PROCESS_ASSIGN state transition methods: +-- ### FSMT_ASSIGN state transition methods: -- -- State transition functions can be set **by the mission designer** customizing or improving the behaviour of the state. -- There are 2 moments when state transition methods will be called by the state machine: @@ -54,52 +54,52 @@ -- -- === -- --- # 1) @{#PROCESS_ASSIGN_ACCEPT} class, extends @{Fsm.Assign#PROCESS_ASSIGN} +-- # 1) @{#FSMT_ASSIGN_ACCEPT} class, extends @{Fsm.Assign#FSMT_ASSIGN} -- --- The PROCESS_ASSIGN_ACCEPT class accepts by default a task for a player. No player intervention is allowed to reject the task. +-- The FSMT_ASSIGN_ACCEPT class accepts by default a task for a player. No player intervention is allowed to reject the task. -- --- ## 1.1) PROCESS_ASSIGN_ACCEPT constructor: +-- ## 1.1) FSMT_ASSIGN_ACCEPT constructor: -- --- * @{#PROCESS_ASSIGN_ACCEPT.New}(): Creates a new PROCESS_ASSIGN_ACCEPT object. +-- * @{#FSMT_ASSIGN_ACCEPT.New}(): Creates a new FSMT_ASSIGN_ACCEPT object. -- -- === -- --- # 2) @{#PROCESS_ASSIGN_MENU_ACCEPT} class, extends @{Fsm.Assign#PROCESS_ASSIGN} +-- # 2) @{#FSMT_ASSIGN_MENU_ACCEPT} class, extends @{Fsm.Assign#FSMT_ASSIGN} -- --- The PROCESS_ASSIGN_MENU_ACCEPT class accepts a task when the player accepts the task through an added menu option. +-- The FSMT_ASSIGN_MENU_ACCEPT class accepts a task when the player accepts the task through an added menu option. -- This assignment type is useful to conditionally allow the player to choose whether or not he would accept the task. -- The assignment type also allows to reject the task. -- --- ## 2.1) PROCESS_ASSIGN_MENU_ACCEPT constructor: +-- ## 2.1) FSMT_ASSIGN_MENU_ACCEPT constructor: -- ----------------------------------------- -- --- * @{#PROCESS_ASSIGN_MENU_ACCEPT.New}(): Creates a new PROCESS_ASSIGN_MENU_ACCEPT object. +-- * @{#FSMT_ASSIGN_MENU_ACCEPT.New}(): Creates a new FSMT_ASSIGN_MENU_ACCEPT object. -- -- === -- -- @module Assign -do -- PROCESS_ASSIGN +do -- FSMT_ASSIGN - --- PROCESS_ASSIGN class - -- @type PROCESS_ASSIGN + --- FSMT_ASSIGN class + -- @type FSMT_ASSIGN -- @field Tasking.Task#TASK_BASE Task -- @field Wrapper.Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone -- @extends Core.StateMachine#FSM_TEMPLATE - PROCESS_ASSIGN = { - ClassName = "PROCESS_ASSIGN", + FSMT_ASSIGN = { + ClassName = "FSMT_ASSIGN", } --- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted. - -- @param #PROCESS_ASSIGN self - -- @return #PROCESS_ASSIGN The task acceptance process. - function PROCESS_ASSIGN:New() + -- @param #FSMT_ASSIGN self + -- @return #FSMT_ASSIGN The task acceptance process. + function FSMT_ASSIGN:New() -- Inherits from BASE - local self = BASE:Inherit( self, FSM_TEMPLATE:New( "PROCESS_ASSIGN" ) ) -- Core.StateMachine#FSM_TEMPLATE + local self = BASE:Inherit( self, FSM_TEMPLATE:New( "FSMT_ASSIGN" ) ) -- Core.StateMachine#FSM_TEMPLATE self:AddTransition( "UnAssigned", "Start", "Waiting" ) self:AddTransition( "Waiting", "Assign", "Assigned" ) @@ -115,29 +115,29 @@ do -- PROCESS_ASSIGN return self end -end -- PROCESS_ASSIGN +end -- FSMT_ASSIGN -do -- PROCESS_ASSIGN_ACCEPT +do -- FSMT_ASSIGN_ACCEPT - --- PROCESS_ASSIGN_ACCEPT class - -- @type PROCESS_ASSIGN_ACCEPT + --- FSMT_ASSIGN_ACCEPT class + -- @type FSMT_ASSIGN_ACCEPT -- @field Tasking.Task#TASK_BASE Task -- @field Wrapper.Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone -- @extends Fsm.Process#PROCESS - PROCESS_ASSIGN_ACCEPT = { - ClassName = "PROCESS_ASSIGN_ACCEPT", + FSMT_ASSIGN_ACCEPT = { + ClassName = "FSMT_ASSIGN_ACCEPT", } --- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted. - -- @param #PROCESS_ASSIGN_ACCEPT self + -- @param #FSMT_ASSIGN_ACCEPT self -- @param #string TaskBriefing - function PROCESS_ASSIGN_ACCEPT:New( TaskBriefing ) + function FSMT_ASSIGN_ACCEPT:New( TaskBriefing ) - local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_ACCEPT + local self = BASE:Inherit( self, FSMT_ASSIGN:New() ) -- #FSMT_ASSIGN_ACCEPT self:SetParameters( { TaskBriefing = TaskBriefing } ) @@ -145,12 +145,12 @@ do -- PROCESS_ASSIGN_ACCEPT end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_ACCEPT self + -- @param #FSMT_ASSIGN_ACCEPT self -- @param Wrapper.Unit#UNIT ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ASSIGN_ACCEPT:onafterStart( ProcessUnit, Event, From, To ) + function FSMT_ASSIGN_ACCEPT:onafterStart( ProcessUnit, Event, From, To ) self:E( { ProcessUnit, Event, From, To } ) local ProcessGroup = ProcessUnit:GetGroup() @@ -160,12 +160,12 @@ do -- PROCESS_ASSIGN_ACCEPT end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_ACCEPT self + -- @param #FSMT_ASSIGN_ACCEPT self -- @param Wrapper.Unit#UNIT ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ASSIGN_ACCEPT:onenterAssigned( ProcessUnit, Event, From, To ) + function FSMT_ASSIGN_ACCEPT:onenterAssigned( ProcessUnit, Event, From, To ) env.info( "in here" ) self:E( { ProcessUnit, Event, From, To } ) @@ -176,30 +176,30 @@ do -- PROCESS_ASSIGN_ACCEPT self.Task:Assign() end -end -- PROCESS_ASSIGN_ACCEPT +end -- FSMT_ASSIGN_ACCEPT -do -- PROCESS_ASSIGN_MENU_ACCEPT +do -- FSMT_ASSIGN_MENU_ACCEPT - --- PROCESS_ASSIGN_MENU_ACCEPT class - -- @type PROCESS_ASSIGN_MENU_ACCEPT + --- FSMT_ASSIGN_MENU_ACCEPT class + -- @type FSMT_ASSIGN_MENU_ACCEPT -- @field Tasking.Task#TASK_BASE Task -- @field Wrapper.Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends #PROCESS_ASSIGN - PROCESS_ASSIGN_MENU_ACCEPT = { - ClassName = "PROCESS_ASSIGN_MENU_ACCEPT", + -- @extends #FSMT_ASSIGN + FSMT_ASSIGN_MENU_ACCEPT = { + ClassName = "FSMT_ASSIGN_MENU_ACCEPT", } --- Init. - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param #string TaskName -- @param #string TaskBriefing - -- @return #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing ) + -- @return #FSMT_ASSIGN_MENU_ACCEPT self + function FSMT_ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing ) -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_MENU_ACCEPT + local self = BASE:Inherit( self, FSMT_ASSIGN:New() ) -- #FSMT_ASSIGN_MENU_ACCEPT self:SetParameters( { TaskName = TaskName, TaskBriefing = TaskBriefing } ) @@ -208,11 +208,11 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT --- Creates a new task assignment state machine. The process will request from the menu if it accepts the task, if not, the unit is removed from the simulator. - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param #string TaskName -- @param #string TaskBriefing - -- @return #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:Init( TaskName, TaskBriefing ) + -- @return #FSMT_ASSIGN_MENU_ACCEPT self + function FSMT_ASSIGN_MENU_ACCEPT:Init( TaskName, TaskBriefing ) self.TaskBriefing = TaskBriefing self.TaskName = TaskName @@ -221,12 +221,12 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ASSIGN_MENU_ACCEPT:onafterStart( ProcessUnit, Event, From, To ) + function FSMT_ASSIGN_MENU_ACCEPT:onafterStart( ProcessUnit, Event, From, To ) self:E( { ProcessUnit, Event, From, To } ) MESSAGE:New( self.TaskBriefing .. "\nAccess the radio menu to accept the task. You have 30 seconds or the assignment will be cancelled.", 30, "Task Assignment" ):ToGroup( ProcessUnit:GetGroup() ) @@ -239,40 +239,40 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT end --- Menu function. - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:MenuAssign() + -- @param #FSMT_ASSIGN_MENU_ACCEPT self + function FSMT_ASSIGN_MENU_ACCEPT:MenuAssign() self:E( ) self:__Assign( 1 ) end --- Menu function. - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:MenuReject() + -- @param #FSMT_ASSIGN_MENU_ACCEPT self + function FSMT_ASSIGN_MENU_ACCEPT:MenuReject() self:E( ) self:__Reject( 1 ) end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ASSIGN_MENU_ACCEPT:onafterAssign( ProcessUnit, Event, From, To ) + function FSMT_ASSIGN_MENU_ACCEPT:onafterAssign( ProcessUnit, Event, From, To ) self:E( { ProcessUnit.UnitNameEvent, From, To } ) self.Menu:Remove() end --- StateMachine callback function - -- @param #PROCESS_ASSIGN_MENU_ACCEPT self + -- @param #FSMT_ASSIGN_MENU_ACCEPT self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ASSIGN_MENU_ACCEPT:onafterReject( ProcessUnit, Event, From, To ) + function FSMT_ASSIGN_MENU_ACCEPT:onafterReject( ProcessUnit, Event, From, To ) self:E( { ProcessUnit.UnitName, Event, From, To } ) self.Menu:Remove() @@ -281,4 +281,4 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT ProcessUnit:Destroy() end -end -- PROCESS_ASSIGN_MENU_ACCEPT +end -- FSMT_ASSIGN_MENU_ACCEPT diff --git a/Moose Development/Moose/Fsm/FsmTRoute.lua b/Moose Development/Moose/Fsm/FsmTRoute.lua index 7765699d6..ac9ab319e 100644 --- a/Moose Development/Moose/Fsm/FsmTRoute.lua +++ b/Moose Development/Moose/Fsm/FsmTRoute.lua @@ -2,16 +2,16 @@ -- -- === -- --- # @{#PROCESS_ROUTE} FSM class, extends @{Process#PROCESS} +-- # @{#FSMT_ROUTE} FSM class, extends @{Process#PROCESS} -- --- ## PROCESS_ROUTE state machine: +-- ## FSMT_ROUTE state machine: -- -- This class is a state machine: it manages a process that is triggered by events causing state transitions to occur. -- All derived classes from this class will start with the class name, followed by a \_. See the relevant derived class descriptions below. -- Each derived class follows exactly the same process, using the same events and following the same state transitions, -- but will have **different implementation behaviour** upon each event or state transition. -- --- ### PROCESS_ROUTE **Events**: +-- ### FSMT_ROUTE **Events**: -- -- These are the events defined in this class: -- @@ -23,7 +23,7 @@ -- * **More**: There are more route points that need to be followed. The process will go back into the Report state. -- * **NoMore**: There are no more route points that need to be followed. The process will go into the Success state. -- --- ### PROCESS_ROUTE **Event methods**: +-- ### FSMT_ROUTE **Event methods**: -- -- Event methods are available (dynamically allocated by the state machine), that accomodate for state transitions occurring in the process. -- There are two types of event methods, which you can use to influence the normal mechanisms in the state machine: @@ -31,7 +31,7 @@ -- * **Immediate**: The event method has exactly the name of the event. -- * **Delayed**: The event method starts with a __ + the name of the event. The first parameter of the event method is a number value, expressing the delay in seconds when the event will be executed. -- --- ### PROCESS_ROUTE **States**: +-- ### FSMT_ROUTE **States**: -- -- * **None**: The controllable did not receive route commands. -- * **Arrived (*)**: The controllable has arrived at a route point. @@ -43,7 +43,7 @@ -- -- (*) End states of the process. -- --- ### PROCESS_ROUTE state transition methods: +-- ### FSMT_ROUTE state transition methods: -- -- State transition functions can be set **by the mission designer** customizing or improving the behaviour of the state. -- There are 2 moments when state transition methods will be called by the state machine: @@ -60,41 +60,41 @@ -- -- === -- --- # 1) @{#PROCESS_ROUTE_ZONE} class, extends @{Fsm.Route#PROCESS_ROUTE} +-- # 1) @{#FSMT_ROUTE_ZONE} class, extends @{Fsm.Route#FSMT_ROUTE} -- --- The PROCESS_ROUTE_ZONE class implements the core functions to route an AIR @{Controllable} player @{Unit} to a @{Zone}. +-- The FSMT_ROUTE_ZONE class implements the core functions to route an AIR @{Controllable} player @{Unit} to a @{Zone}. -- The player receives on perioding times messages with the coordinates of the route to follow. -- Upon arrival at the zone, a confirmation of arrival is sent, and the process will be ended. -- --- # 1.1) PROCESS_ROUTE_ZONE constructor: +-- # 1.1) FSMT_ROUTE_ZONE constructor: -- --- * @{#PROCESS_ROUTE_ZONE.New}(): Creates a new PROCESS_ROUTE_ZONE object. +-- * @{#FSMT_ROUTE_ZONE.New}(): Creates a new FSMT_ROUTE_ZONE object. -- -- === -- -- @module Route -do -- PROCESS_ROUTE +do -- FSMT_ROUTE - --- PROCESS_ROUTE class - -- @type PROCESS_ROUTE + --- FSMT_ROUTE class + -- @type FSMT_ROUTE -- @field Tasking.Task#TASK TASK -- @field Wrapper.Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone -- @extends Core.StateMachine#FSM_TEMPLATE - PROCESS_ROUTE = { - ClassName = "PROCESS_ROUTE", + FSMT_ROUTE = { + ClassName = "FSMT_ROUTE", } --- Creates a new routing state machine. The process will route a CLIENT to a ZONE until the CLIENT is within that ZONE. - -- @param #PROCESS_ROUTE self - -- @return #PROCESS_ROUTE self - function PROCESS_ROUTE:New() + -- @param #FSMT_ROUTE self + -- @return #FSMT_ROUTE self + function FSMT_ROUTE:New() -- Inherits from BASE - local self = BASE:Inherit( self, FSM_TEMPLATE:New( "PROCESS_ROUTE" ) ) -- Core.StateMachine#FSM_TEMPLATE + local self = BASE:Inherit( self, FSM_TEMPLATE:New( "FSMT_ROUTE" ) ) -- Core.StateMachine#FSM_TEMPLATE self:AddTransition( "None", "Start", "Routing" ) self:AddTransition( "*", "Report", "Reporting" ) @@ -118,32 +118,32 @@ do -- PROCESS_ROUTE --- Task Events --- StateMachine callback function - -- @param #PROCESS_ROUTE self + -- @param #FSMT_ROUTE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ROUTE:onafterStart( ProcessUnit, Event, From, To ) + function FSMT_ROUTE:onafterStart( ProcessUnit, Event, From, To ) self:__Route( 1 ) end --- Check if the controllable has arrived. - -- @param #PROCESS_ROUTE self + -- @param #FSMT_ROUTE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @return #boolean - function PROCESS_ROUTE:onfuncHasArrived( ProcessUnit ) + function FSMT_ROUTE:onfuncHasArrived( ProcessUnit ) return false end --- StateMachine callback function - -- @param #PROCESS_ROUTE self + -- @param #FSMT_ROUTE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ROUTE:onbeforeRoute( ProcessUnit, Event, From, To ) + function FSMT_ROUTE:onbeforeRoute( ProcessUnit, Event, From, To ) if ProcessUnit:IsAlive() then local HasArrived = self:onfuncHasArrived( ProcessUnit ) -- Polymorphic @@ -172,28 +172,28 @@ do -- PROCESS_ROUTE end -end -- PROCESS_ROUTE +end -- FSMT_ROUTE -do -- PROCESS_ROUTE_ZONE +do -- FSMT_ROUTE_ZONE - --- PROCESS_ROUTE_ZONE class - -- @type PROCESS_ROUTE_ZONE + --- FSMT_ROUTE_ZONE class + -- @type FSMT_ROUTE_ZONE -- @field Tasking.Task#TASK TASK -- @field Wrapper.Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends #PROCESS_ROUTE - PROCESS_ROUTE_ZONE = { - ClassName = "PROCESS_ROUTE_ZONE", + -- @extends #FSMT_ROUTE + FSMT_ROUTE_ZONE = { + ClassName = "FSMT_ROUTE_ZONE", } --- Creates a new routing state machine. The task will route a controllable to a ZONE until the controllable is within that ZONE. - -- @param #PROCESS_ROUTE_ZONE self + -- @param #FSMT_ROUTE_ZONE self -- @param Zone#ZONE_BASE TargetZone - function PROCESS_ROUTE_ZONE:New( TargetZone ) - local self = BASE:Inherit( self, PROCESS_ROUTE:New() ) -- #PROCESS_ROUTE_ZONE + function FSMT_ROUTE_ZONE:New( TargetZone ) + local self = BASE:Inherit( self, FSMT_ROUTE:New() ) -- #FSMT_ROUTE_ZONE self:SetParameters( { TargetZone = TargetZone, @@ -208,10 +208,10 @@ do -- PROCESS_ROUTE_ZONE end --- Method override to check if the controllable has arrived. - -- @param #PROCESS_ROUTE self + -- @param #FSMT_ROUTE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @return #boolean - function PROCESS_ROUTE_ZONE:onfuncHasArrived( ProcessUnit ) + function FSMT_ROUTE_ZONE:onfuncHasArrived( ProcessUnit ) if ProcessUnit:IsInZone( self.TargetZone ) then local RouteText = ProcessUnit:GetCallsign() .. ": You have arrived within the zone!" @@ -224,12 +224,12 @@ do -- PROCESS_ROUTE_ZONE --- Task Events --- StateMachine callback function - -- @param #PROCESS_ROUTE_ZONE self + -- @param #FSMT_ROUTE_ZONE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_ROUTE_ZONE:onenterReporting( ProcessUnit, Event, From, To ) + function FSMT_ROUTE_ZONE:onenterReporting( ProcessUnit, Event, From, To ) local ZoneVec2 = self.TargetZone:GetVec2() local ZonePointVec2 = POINT_VEC2:New( ZoneVec2.x, ZoneVec2.y ) @@ -239,4 +239,4 @@ do -- PROCESS_ROUTE_ZONE MESSAGE:New( RouteText, self.DisplayTime, self.DisplayCategory ):ToGroup( ProcessUnit:GetGroup() ) end -end -- PROCESS_ROUTE_ZONE +end -- FSMT_ROUTE_ZONE diff --git a/Moose Development/Moose/Fsm/FsmTSmoke.lua b/Moose Development/Moose/Fsm/FsmTSmoke.lua index 0f16217f3..f89e22c1f 100644 --- a/Moose Development/Moose/Fsm/FsmTSmoke.lua +++ b/Moose Development/Moose/Fsm/FsmTSmoke.lua @@ -2,23 +2,23 @@ -- -- === -- --- # @{#PROCESS_SMOKE} FSM class, extends @{Process#PROCESS} +-- # @{#FSMT_SMOKE} FSM class, extends @{Process#PROCESS} -- --- ## PROCESS_SMOKE state machine: +-- ## FSMT_SMOKE state machine: -- -- This class is a state machine: it manages a process that is triggered by events causing state transitions to occur. -- All derived classes from this class will start with the class name, followed by a \_. See the relevant derived class descriptions below. -- Each derived class follows exactly the same process, using the same events and following the same state transitions, -- but will have **different implementation behaviour** upon each event or state transition. -- --- ### PROCESS_SMOKE **Events**: +-- ### FSMT_SMOKE **Events**: -- -- These are the events defined in this class: -- -- * **Start**: The process is started. -- * **Next**: The process is smoking the targets in the given zone. -- --- ### PROCESS_SMOKE **Event methods**: +-- ### FSMT_SMOKE **Event methods**: -- -- Event methods are available (dynamically allocated by the state machine), that accomodate for state transitions occurring in the process. -- There are two types of event methods, which you can use to influence the normal mechanisms in the state machine: @@ -26,7 +26,7 @@ -- * **Immediate**: The event method has exactly the name of the event. -- * **Delayed**: The event method starts with a __ + the name of the event. The first parameter of the event method is a number value, expressing the delay in seconds when the event will be executed. -- --- ### PROCESS_SMOKE **States**: +-- ### FSMT_SMOKE **States**: -- -- * **None**: The controllable did not receive route commands. -- * **AwaitSmoke (*)**: The process is awaiting to smoke the targets in the zone. @@ -35,7 +35,7 @@ -- -- (*) End states of the process. -- --- ### PROCESS_SMOKE state transition methods: +-- ### FSMT_SMOKE state transition methods: -- -- State transition functions can be set **by the mission designer** customizing or improving the behaviour of the state. -- There are 2 moments when state transition methods will be called by the state machine: @@ -52,36 +52,36 @@ -- -- === -- --- # 1) @{#PROCESS_SMOKE_TARGETS_ZONE} class, extends @{Fsm.Route#PROCESS_SMOKE} +-- # 1) @{#FSMT_SMOKE_TARGETS_ZONE} class, extends @{Fsm.Route#FSMT_SMOKE} -- --- The PROCESS_SMOKE_TARGETS_ZONE class implements the core functions to smoke targets in a @{Zone}. +-- The FSMT_SMOKE_TARGETS_ZONE class implements the core functions to smoke targets in a @{Zone}. -- The targets are smoked within a certain range around each target, simulating a realistic smoking behaviour. -- At random intervals, a new target is smoked. -- --- # 1.1) PROCESS_SMOKE_TARGETS_ZONE constructor: +-- # 1.1) FSMT_SMOKE_TARGETS_ZONE constructor: -- --- * @{#PROCESS_SMOKE_TARGETS_ZONE.New}(): Creates a new PROCESS_SMOKE_TARGETS_ZONE object. +-- * @{#FSMT_SMOKE_TARGETS_ZONE.New}(): Creates a new FSMT_SMOKE_TARGETS_ZONE object. -- -- === -- -- @module Smoke -do -- PROCESS_SMOKE +do -- FSMT_SMOKE - --- PROCESS_SMOKE class - -- @type PROCESS_SMOKE + --- FSMT_SMOKE class + -- @type FSMT_SMOKE -- @extends Core.StateMachine#FSM_TEMPLATE - PROCESS_SMOKE = { - ClassName = "PROCESS_SMOKE", + FSMT_SMOKE = { + ClassName = "FSMT_SMOKE", } --- Creates a new target smoking state machine. The process will request from the menu if it accepts the task, if not, the unit is removed from the simulator. - -- @param #PROCESS_SMOKE self - -- @return #PROCESS_SMOKE - function PROCESS_SMOKE:New() + -- @param #FSMT_SMOKE self + -- @return #FSMT_SMOKE + function FSMT_SMOKE:New() -- Inherits from BASE - local self = BASE:Inherit( self, FSM_TEMPLATE:New( "PROCESS_SMOKE" ) ) -- Core.StateMachine#FSM_TEMPLATE + local self = BASE:Inherit( self, FSM_TEMPLATE:New( "FSMT_SMOKE" ) ) -- Core.StateMachine#FSM_TEMPLATE self:AddTransition( "None", "Start", "AwaitSmoke" ) self:AddTransition( "AwaitSmoke", "Next", "Smoking" ) @@ -100,12 +100,12 @@ do -- PROCESS_SMOKE --- Task Events --- StateMachine callback function - -- @param #PROCESS_SMOKE self + -- @param #FSMT_SMOKE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_SMOKE:onafterStart( ProcessUnit, Event, From, To ) + function FSMT_SMOKE:onafterStart( ProcessUnit, Event, From, To ) local ProcessGroup = ProcessUnit:GetGroup() local MissionMenu = self:GetMission():GetMissionMenu( ProcessGroup ) @@ -128,18 +128,18 @@ do -- PROCESS_SMOKE end -do -- PROCESS_SMOKE_TARGETS_ZONE +do -- FSMT_SMOKE_TARGETS_ZONE - --- PROCESS_SMOKE_TARGETS_ZONE class - -- @type PROCESS_SMOKE_TARGETS_ZONE + --- FSMT_SMOKE_TARGETS_ZONE class + -- @type FSMT_SMOKE_TARGETS_ZONE -- @field Set#SET_UNIT TargetSetUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends #PROCESS_SMOKE - PROCESS_SMOKE_TARGETS_ZONE = { - ClassName = "PROCESS_SMOKE_TARGETS_ZONE", + -- @extends #FSMT_SMOKE + FSMT_SMOKE_TARGETS_ZONE = { + ClassName = "FSMT_SMOKE_TARGETS_ZONE", } --- function PROCESS_SMOKE_TARGETS_ZONE:_Destructor() +-- function FSMT_SMOKE_TARGETS_ZONE:_Destructor() -- self:E("_Destructor") -- -- self.Menu:Remove() @@ -147,11 +147,11 @@ do -- PROCESS_SMOKE_TARGETS_ZONE -- end --- Creates a new target smoking state machine. The process will request from the menu if it accepts the task, if not, the unit is removed from the simulator. - -- @param #PROCESS_SMOKE_TARGETS_ZONE self + -- @param #FSMT_SMOKE_TARGETS_ZONE self -- @param Set#SET_UNIT TargetSetUnit -- @param Zone#ZONE_BASE TargetZone - function PROCESS_SMOKE_TARGETS_ZONE:New( TargetSetUnit, TargetZone ) - local self = BASE:Inherit( self, PROCESS_SMOKE:New() ) -- #PROCESS_SMOKE + function FSMT_SMOKE_TARGETS_ZONE:New( TargetSetUnit, TargetZone ) + local self = BASE:Inherit( self, FSMT_SMOKE:New() ) -- #FSMT_SMOKE self:SetParameters( { TargetSetUnit, TargetZone } ) @@ -159,11 +159,11 @@ do -- PROCESS_SMOKE_TARGETS_ZONE end --- Creates a new target smoking state machine. The process will request from the menu if it accepts the task, if not, the unit is removed from the simulator. - -- @param #PROCESS_SMOKE_TARGETS_ZONE self + -- @param #FSMT_SMOKE_TARGETS_ZONE self -- @param Set#SET_UNIT TargetSetUnit -- @param Zone#ZONE_BASE TargetZone - -- @return #PROCESS_SMOKE_TARGETS_ZONE self - function PROCESS_SMOKE_TARGETS_ZONE:Init( TargetSetUnit, TargetZone ) + -- @return #FSMT_SMOKE_TARGETS_ZONE self + function FSMT_SMOKE_TARGETS_ZONE:Init( TargetSetUnit, TargetZone ) self.TargetSetUnit = TargetSetUnit self.TargetZone = TargetZone @@ -172,12 +172,12 @@ do -- PROCESS_SMOKE_TARGETS_ZONE end --- StateMachine callback function - -- @param #PROCESS_SMOKE_TARGETS_ZONE self + -- @param #FSMT_SMOKE_TARGETS_ZONE self -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit -- @param #string Event -- @param #string From -- @param #string To - function PROCESS_SMOKE_TARGETS_ZONE:onenterSmoking( ProcessUnit, Event, From, To ) + function FSMT_SMOKE_TARGETS_ZONE:onenterSmoking( ProcessUnit, Event, From, To ) self.TargetSetUnit:ForEachUnit( --- @param Wrapper.Unit#UNIT SmokeUnit diff --git a/Moose Development/Moose/Fsm/Patrol.lua b/Moose Development/Moose/Fsm/Patrol.lua index 00bb31237..c30dd8d4b 100644 --- a/Moose Development/Moose/Fsm/Patrol.lua +++ b/Moose Development/Moose/Fsm/Patrol.lua @@ -349,7 +349,7 @@ function PATROLZONE:onenterRoute() self.Controllable:SetState( self.Controllable, "PatrolZone", self ) self.Controllable:WayPointFunction( #PatrolRoute, 1, "_NewPatrolRoute" ) - --- NOW PROCESS_ROUTE THE GROUP! + --- NOW FSMT_ROUTE THE GROUP! self.Controllable:WayPointExecute( 1 ) self:__Patrol( 30 ) diff --git a/Moose Development/Moose/Tasking/Task_A2G.lua b/Moose Development/Moose/Tasking/Task_A2G.lua index be78d986b..3d47ba3d5 100644 --- a/Moose Development/Moose/Tasking/Task_A2G.lua +++ b/Moose Development/Moose/Tasking/Task_A2G.lua @@ -7,8 +7,8 @@ -- The TASK_A2G is implemented using a @{Statemachine#FSM_TASK}, and has the following statuses: -- -- * **None**: Start of the process --- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#PROCESS_ASSIGN_ACCEPT} is started to accept the task. --- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#PROCESS_ROUTE} is started to route the active Units in the Group to the attack zone. +-- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#FSMT_ASSIGN_ACCEPT} is started to accept the task. +-- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#FSMT_ROUTE} is started to route the active Units in the Group to the attack zone. -- * **Success**: The SEAD task is successfully completed. Upon Success, the sub-process @{Process_SEAD#PROCESS_SEAD} is started to follow-up successful SEADing of the targets assigned in the task. -- * **Failed**: The SEAD task has failed. This will happen if the player exists the task early, without communicating a possible cancellation to HQ. -- @@ -47,12 +47,12 @@ do -- TASK_A2G local Fsm = self:GetFsmTemplate() - Fsm:AddProcess( "Planned", "Accept", PROCESS_ASSIGN_ACCEPT:New( "Attack the Area" ), { Assigned = "Route", Rejected = "Eject" } ) - Fsm:AddProcess( "Assigned", "Route", PROCESS_ROUTE_ZONE:New( self.TargetZone ), { Arrived = "Update" } ) + Fsm:AddProcess( "Planned", "Accept", FSMT_ASSIGN_ACCEPT:New( "Attack the Area" ), { Assigned = "Route", Rejected = "Eject" } ) + Fsm:AddProcess( "Assigned", "Route", FSMT_ROUTE_ZONE:New( self.TargetZone ), { Arrived = "Update" } ) Fsm:AddAction ( "Rejected", "Eject", "Planned" ) Fsm:AddAction ( "Arrived", "Update", "Updated" ) - Fsm:AddProcess( "Updated", "Account", PROCESS_ACCOUNT_DEADS:New( self.TargetSetUnit, "Attack" ), { Accounted = "Success" } ) - Fsm:AddProcess( "Updated", "Smoke", PROCESS_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) ) + Fsm:AddProcess( "Updated", "Account", FSMT_ACCOUNT_DEADS:New( self.TargetSetUnit, "Attack" ), { Accounted = "Success" } ) + Fsm:AddProcess( "Updated", "Smoke", FSMT_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) ) --Fsm:AddProcess( "Updated", "JTAC", PROCESS_JTAC:New( self, TaskUnit, self.TargetSetUnit, self.FACUnit ) ) Fsm:AddAction ( "Accounted", "Success", "Success" ) Fsm:AddAction ( "Failed", "Fail", "Failed" ) diff --git a/Moose Development/Moose/Tasking/Task_Pickup.lua b/Moose Development/Moose/Tasking/Task_Pickup.lua index b0dd6747e..c05bfd445 100644 --- a/Moose Development/Moose/Tasking/Task_Pickup.lua +++ b/Moose Development/Moose/Tasking/Task_Pickup.lua @@ -7,8 +7,8 @@ -- The TASK_PICKUP is implemented using a @{Statemachine#FSM_TASK}, and has the following statuses: -- -- * **None**: Start of the process --- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#PROCESS_ASSIGN_ACCEPT} is started to accept the task. --- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#PROCESS_ROUTE} is started to route the active Units in the Group to the attack zone. +-- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#FSMT_ASSIGN_ACCEPT} is started to accept the task. +-- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#FSMT_ROUTE} is started to route the active Units in the Group to the attack zone. -- * **Success**: The SEAD task is successfully completed. Upon Success, the sub-process @{Process_SEAD#PROCESS_SEAD} is started to follow-up successful SEADing of the targets assigned in the task. -- * **Failed**: The SEAD task has failed. This will happen if the player exists the task early, without communicating a possible cancellation to HQ. -- @@ -67,7 +67,7 @@ do -- TASK_PICKUP function TASK_PICKUP:AssignToUnit( TaskUnit ) self:F( TaskUnit:GetName() ) - local ProcessAssign = self:AddProcess( TaskUnit, PROCESS_ASSIGN_ACCEPT:New( self, TaskUnit, self.TaskBriefing ) ) + local ProcessAssign = self:AddProcess( TaskUnit, FSMT_ASSIGN_ACCEPT:New( self, TaskUnit, self.TaskBriefing ) ) local ProcessPickup = self:AddProcess( TaskUnit, PROCESS_PICKUP:New( self, self.TaskType, TaskUnit ) ) local Process = self:AddStateMachine( TaskUnit, FSM_TASK:New( self, TaskUnit, { diff --git a/Moose Development/Moose/Tasking/Task_SEAD.lua b/Moose Development/Moose/Tasking/Task_SEAD.lua index 8aef6410c..ed5aaa1ae 100644 --- a/Moose Development/Moose/Tasking/Task_SEAD.lua +++ b/Moose Development/Moose/Tasking/Task_SEAD.lua @@ -7,8 +7,8 @@ -- The TASK_SEAD is implemented using a @{Statemachine#FSM_TASK}, and has the following statuses: -- -- * **None**: Start of the process --- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#PROCESS_ASSIGN_ACCEPT} is started to accept the task. --- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#PROCESS_ROUTE} is started to route the active Units in the Group to the attack zone. +-- * **Planned**: The SEAD task is planned. Upon Planned, the sub-process @{Process_Fsm.Assign#FSMT_ASSIGN_ACCEPT} is started to accept the task. +-- * **Assigned**: The SEAD task is assigned to a @{Wrapper.Group#GROUP}. Upon Assigned, the sub-process @{Process_Fsm.Route#FSMT_ROUTE} is started to route the active Units in the Group to the attack zone. -- * **Success**: The SEAD task is successfully completed. Upon Success, the sub-process @{Process_SEAD#PROCESS_SEAD} is started to follow-up successful SEADing of the targets assigned in the task. -- * **Failed**: The SEAD task has failed. This will happen if the player exists the task early, without communicating a possible cancellation to HQ. -- @@ -47,12 +47,12 @@ do -- TASK_SEAD local Fsm = self:GetFsmTemplate() - Fsm:AddProcess( "Planned", "Accept", PROCESS_ASSIGN_ACCEPT:New( self.TaskBriefing ), { Assigned = "Route", Rejected = "Eject" } ) - Fsm:AddProcess( "Assigned", "Route", PROCESS_ROUTE_ZONE:New( self.TargetZone ), { Arrived = "Update" } ) + Fsm:AddProcess( "Planned", "Accept", FSMT_ASSIGN_ACCEPT:New( self.TaskBriefing ), { Assigned = "Route", Rejected = "Eject" } ) + Fsm:AddProcess( "Assigned", "Route", FSMT_ROUTE_ZONE:New( self.TargetZone ), { Arrived = "Update" } ) Fsm:AddAction ( "Rejected", "Eject", "Planned" ) Fsm:AddAction ( "Arrived", "Update", "Updated" ) - Fsm:AddProcess( "Updated", "Account", PROCESS_ACCOUNT_DEADS:New( self.TargetSetUnit, "SEAD" ), { Accounted = "Success" } ) - Fsm:AddProcess( "Updated", "Smoke", PROCESS_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) ) + Fsm:AddProcess( "Updated", "Account", FSMT_ACCOUNT_DEADS:New( self.TargetSetUnit, "SEAD" ), { Accounted = "Success" } ) + Fsm:AddProcess( "Updated", "Smoke", FSMT_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) ) Fsm:AddAction ( "Accounted", "Success", "Success" ) Fsm:AddAction ( "Failed", "Fail", "Failed" ) diff --git a/Moose Development/Moose/Wrapper/Controllable.lua b/Moose Development/Moose/Wrapper/Controllable.lua index a357d44b1..4cc427862 100644 --- a/Moose Development/Moose/Wrapper/Controllable.lua +++ b/Moose Development/Moose/Wrapper/Controllable.lua @@ -970,7 +970,7 @@ function CONTROLLABLE:TaskFAC_AttackGroup( AttackGroup, WeaponType, Designation, return DCSTask end --- EN-PROCESS_ROUTE TASKS FOR AIRBORNE CONTROLLABLES +-- EN-FSMT_ROUTE TASKS FOR AIRBORNE CONTROLLABLES --- (AIR) Engaging targets of defined types. -- @param #CONTROLLABLE self diff --git a/Moose Development/Old/Stage.lua b/Moose Development/Old/Stage.lua index 687f31557..fd43fbd85 100644 --- a/Moose Development/Old/Stage.lua +++ b/Moose Development/Old/Stage.lua @@ -915,7 +915,7 @@ end _TransportStage: Defines the different stages of which of transport missions can be in. This table is internal and is used to control the sequence of messages, actions and flow. - _TransportStage.START - - _TransportStage.PROCESS_ROUTE + - _TransportStage.FSMT_ROUTE - _TransportStage.LAND - _TransportStage.EXECUTE - _TransportStage.DONE @@ -924,7 +924,7 @@ end _TransportStage = { HOLD = "HOLD", START = "START", - PROCESS_ROUTE = "PROCESS_ROUTE", + FSMT_ROUTE = "FSMT_ROUTE", LANDING = "LANDING", LANDED = "LANDED", EXECUTING = "EXECUTING", @@ -937,7 +937,7 @@ _TransportStage = { _TransportStageMsgTime = { HOLD = 10, START = 60, - PROCESS_ROUTE = 5, + FSMT_ROUTE = 5, LANDING = 10, LANDED = 30, EXECUTING = 30, @@ -950,7 +950,7 @@ _TransportStageMsgTime = { _TransportStageTime = { HOLD = 10, START = 5, - PROCESS_ROUTE = 5, + FSMT_ROUTE = 5, LANDING = 1, LANDED = 1, EXECUTING = 5, diff --git a/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua b/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua index c5c6dc151..f0e8b3def 100644 --- a/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua +++ b/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua @@ -66,19 +66,19 @@ local FsmSEADTemplate = TaskSEAD:GetFsmTemplate() -- Adding a new sub-process to the Task Template. -- At first, the task needs to be accepted by a pilot. --- We use for this the SUB-PROCESS PROCESS_ASSIGN_ACCEPT. +-- We use for this the SUB-PROCESS FSMT_ASSIGN_ACCEPT. -- The method on the FsmSEAD AddProcess accepts the following parameters: -- 1. State From "Planned". When the Fsm is in state "Planned", allow the event "Accept". -- 2. Event "Accept". This event can be triggered through FsmSEAD:Accept() or FsmSEAD:__Accept( 1 ). See documentation on state machines. --- 3. The PROCESS derived class. In this case, we use the PROCESS_ASSIGN_ACCEPT to accept the task and provide a briefing. So, when the event "Accept" is fired, this process is executed. --- 4. A table with the "return" states of the PROCESS_ASSIGN_ACCEPT process. This table indicates that for a certain return state, a further event needs to be called. +-- 3. The PROCESS derived class. In this case, we use the FSMT_ASSIGN_ACCEPT to accept the task and provide a briefing. So, when the event "Accept" is fired, this process is executed. +-- 4. A table with the "return" states of the FSMT_ASSIGN_ACCEPT process. This table indicates that for a certain return state, a further event needs to be called. -- 4.1 When the return state is Assigned, fire the event in the Task FsmSEAD:Route() -- 4.2 When the return state is Rejected, fire the event in the Task FsmSEAD:Eject() -- All other AddProcess calls are working in a similar manner. -FsmSEADTemplate:AddProcess ( "Planned", "Accept", PROCESS_ASSIGN_ACCEPT:New( "SEAD the Area" ), { Assigned = "Route", Rejected = "Eject" } ) +FsmSEADTemplate:AddProcess ( "Planned", "Accept", FSMT_ASSIGN_ACCEPT:New( "SEAD the Area" ), { Assigned = "Route", Rejected = "Eject" } ) -- Same, adding a process. -FsmSEADTemplate:AddProcess ( "Assigned", "Route", PROCESS_ROUTE_ZONE:New( TargetZone ), { Arrived = "Update" } ) +FsmSEADTemplate:AddProcess ( "Assigned", "Route", FSMT_ROUTE_ZONE:New( TargetZone ), { Arrived = "Update" } ) -- Adding a new Action... -- Actions define also the flow of the Task, but the actions will need to be programmed within your script. @@ -89,8 +89,8 @@ FsmSEADTemplate:AddProcess ( "Assigned", "Route", PROCESS_ROUTE_ZONE:New -- 3. State To "Planned". After the event has been fired, the FsmSEAD will transition to Planned. FsmSEADTemplate:AddTransition ( "Rejected", "Eject", "Planned" ) FsmSEADTemplate:AddTransition ( "Arrived", "Update", "Updated" ) -FsmSEADTemplate:AddProcess ( "Updated", "Account", PROCESS_ACCOUNT_DEADS:New( TargetSet, "SEAD" ), { Accounted = "Success" } ) -FsmSEADTemplate:AddProcess ( "Updated", "Smoke", PROCESS_SMOKE_TARGETS_ZONE:New( TargetSet, TargetZone ) ) +FsmSEADTemplate:AddProcess ( "Updated", "Account", FSMT_ACCOUNT_DEADS:New( TargetSet, "SEAD" ), { Accounted = "Success" } ) +FsmSEADTemplate:AddProcess ( "Updated", "Smoke", FSMT_SMOKE_TARGETS_ZONE:New( TargetSet, TargetZone ) ) FsmSEADTemplate:AddTransition ( "Accounted", "Success", "Success" ) FsmSEADTemplate:AddTransition ( "*", "Fail", "Failed" )