mirror of
https://github.com/FlightControl-Master/MOOSE.git
synced 2025-10-29 16:58:06 +00:00
FSM restructuring
This commit is contained in:
FlightControl
parent
0a4630bde6
commit
e46d7be91b
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 )
|
||||
|
||||
@ -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" )
|
||||
|
||||
@ -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, {
|
||||
|
||||
@ -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" )
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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" )
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user