Progress

Moose Development/Moose/Actions/Act_Account.lua

@@ -0,0 +1,266 @@
+--- (SP) (MP) (FSM) Account for (Detect, count and report) DCS events occuring on DCS objects (units).
+-- 
+-- ===
+-- 
+-- # @{#ACT_ACCOUNT} FSM class, extends @{Core.Fsm#FSM_PROCESS}
+-- 
+-- ## ACT_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.
+-- 
+-- ### ACT_ACCOUNT **Events**:
+-- 
+-- These are the events defined in this class:
+-- 
+--   * **Start**:  The process is started. The process will go into the Report state.
+--   * **Event**:  A relevant event has occured that needs to be accounted for. The process will go into the Account state.
+--   * **Report**: The process is reporting to the player the accounting status of the DCS events.
+--   * **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.
+-- 
+-- ### ACT_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:
+-- 
+--   * **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. 
+-- 
+-- ### ACT_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.
+--   * **Report**: The process is Reporting to the players in the group of the unit. This state is set automatically every 30 seconds.
+--   * **Account**: The relevant DCS event has occurred, and is accounted for.
+--   * **Success (*)**: All DCS events were accounted for. 
+--   * **Failed (*)**: The process has failed.
+--   
+-- (*) End states of the process.
+--   
+-- ### ACT_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:
+-- 
+--   * **Before** the state transition. 
+--     The state transition method needs to start with the name **OnBefore + the name of the state**. 
+--     If the state transition method returns false, then the processing of the state transition will not be done!
+--     If you want to change the behaviour of the AIControllable at this event, return false, 
+--     but then you'll need to specify your own logic using the AIControllable!
+--   
+--   * **After** the state transition. 
+--     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) @{#ACT_ACCOUNT_DEADS} FSM class, extends @{Fsm.Account#ACT_ACCOUNT}
+-- 
+-- The ACT_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.
+-- 
+-- 
+-- ## ACT_ACCOUNT_DEADS constructor:
+-- 
+--   * @{#ACT_ACCOUNT_DEADS.New}(): Creates a new ACT_ACCOUNT_DEADS object.
+-- 
+-- === 
+-- 
+-- @module Account
+
+
+do -- ACT_ACCOUNT
+  
+  --- ACT_ACCOUNT class
+  -- @type ACT_ACCOUNT
+  -- @field Set#SET_UNIT TargetSetUnit
+  -- @extends Core.Fsm#FSM_PROCESS
+  ACT_ACCOUNT = { 
+    ClassName = "ACT_ACCOUNT",
+    TargetSetUnit = nil,
+  }
+  
+  --- Creates a new DESTROY process.
+  -- @param #ACT_ACCOUNT self
+  -- @return #ACT_ACCOUNT
+  function ACT_ACCOUNT:New()
+
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, FSM_PROCESS:New() ) -- Core.Fsm#FSM_PROCESS
+  
+    self:AddTransition( "Assigned", "Start", "Waiting")
+    self:AddTransition( "*", "Wait", "Waiting")
+    self:AddTransition( "*", "Report", "Report")
+    self:AddTransition( "*", "Event", "Account")
+    self:AddTransition( "Account", "More", "Wait")
+    self:AddTransition( "Account", "NoMore", "Accounted")
+    self:AddTransition( "*", "Fail", "Failed")
+    
+    self:AddEndState( "Accounted" )
+    self:AddEndState( "Failed" )
+    
+    self:SetStartState( "Assigned" ) 
+        
+    return self
+  end
+
+  --- Process Events
+  
+  --- StateMachine callback function
+  -- @param #ACT_ACCOUNT self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ACCOUNT:onafterStart( ProcessUnit, Event, From, To )
+
+    self:EventOnDead( self.onfuncEventDead )
+
+    self:__Wait( 1 )
+  end
+
+  
+    --- StateMachine callback function
+    -- @param #ACT_ACCOUNT self
+    -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+    -- @param #string Event
+    -- @param #string From
+    -- @param #string To
+  function ACT_ACCOUNT:onenterWaiting( ProcessUnit, Event, From, To )
+  
+    if self.DisplayCount >= self.DisplayInterval then
+      self:Report()
+      self.DisplayCount = 1
+    else
+      self.DisplayCount = self.DisplayCount + 1
+    end
+    
+    return true -- Process always the event.
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ACCOUNT self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ACCOUNT:onafterEvent( ProcessUnit, Event, From, To, Event )
+  
+    self:__NoMore( 1 )
+  end
+  
+end -- ACT_ACCOUNT
+
+do -- ACT_ACCOUNT_DEADS
+
+  --- ACT_ACCOUNT_DEADS class
+  -- @type ACT_ACCOUNT_DEADS
+  -- @field Set#SET_UNIT TargetSetUnit
+  -- @extends #ACT_ACCOUNT
+  ACT_ACCOUNT_DEADS = { 
+    ClassName = "ACT_ACCOUNT_DEADS",
+    TargetSetUnit = nil,
+  }
+
+
+  --- Creates a new DESTROY process.
+  -- @param #ACT_ACCOUNT_DEADS self
+  -- @param Set#SET_UNIT TargetSetUnit
+  -- @param #string TaskName
+  function ACT_ACCOUNT_DEADS:New( TargetSetUnit, TaskName )
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, ACT_ACCOUNT:New() ) -- #ACT_ACCOUNT_DEADS
+    
+    self.TargetSetUnit = TargetSetUnit 
+    self.TaskName = TaskName
+      
+    self.DisplayInterval = 30
+    self.DisplayCount = 30
+    self.DisplayMessage = true
+    self.DisplayTime = 10 -- 10 seconds is the default
+    self.DisplayCategory = "HQ" -- Targets is the default display category
+      
+    return self
+  end
+  
+  function ACT_ACCOUNT_DEADS:Init( FsmAccount )
+  
+    self.TargetSetUnit = FsmAccount.TargetSetUnit 
+    self.TaskName = FsmAccount.TaskName
+  end
+
+
+  
+  function ACT_ACCOUNT_DEADS:_Destructor()
+    self:E("_Destructor")
+  
+    self:EventRemoveAll()
+  
+  end
+  
+  --- Process Events
+  
+  --- StateMachine callback function
+  -- @param #ACT_ACCOUNT_DEADS self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ACCOUNT_DEADS:onenterReport( ProcessUnit, Event, From, To )
+    self:E( { ProcessUnit, Event, From, To } )
+  
+    self:Message( "Your group with assigned " .. self.TaskName .. " task has " .. self.TargetSetUnit:GetUnitTypesText() .. " targets left to be destroyed." )
+  end
+  
+  
+  --- StateMachine callback function
+  -- @param #ACT_ACCOUNT_DEADS self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ACCOUNT_DEADS:onenterAccount( ProcessUnit, Event, From, To, EventData  )
+    self:T( { ProcessUnit, EventData, Event, From, To } )
+    
+    self:T({self.Controllable})
+  
+    self.TargetSetUnit:Flush()
+    
+    if self.TargetSetUnit:FindUnit( EventData.IniUnitName ) then
+      local TaskGroup = ProcessUnit:GetGroup()
+      self.TargetSetUnit:RemoveUnitsByName( EventData.IniUnitName )
+      self:Message( "You hit a target. Your group with assigned " .. self.TaskName .. " task has " .. self.TargetSetUnit:Count() .. " targets ( " .. self.TargetSetUnit:GetUnitTypesText() .. " ) left to be destroyed." )
+    end
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ACCOUNT_DEADS self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ACCOUNT_DEADS:onafterEvent( ProcessUnit, Event, From, To, EventData )
+  
+    if self.TargetSetUnit:Count() > 0 then
+      self:__More( 1 )
+    else
+      self:__NoMore( 1 )
+    end
+  end
+  
+  --- DCS Events
+  
+  --- @param #ACT_ACCOUNT_DEADS self
+  -- @param Event#EVENTDATA EventData
+  function ACT_ACCOUNT_DEADS:onfuncEventDead( EventData )
+    self:T( { "EventDead", EventData } )
+
+    if EventData.IniDCSUnit then
+      self:__Event( 1, EventData )
+    end
+  end
+
+end -- ACT_ACCOUNT DEADS

Moose Development/Moose/Actions/Act_Assign.lua

@@ -0,0 +1,293 @@
+--- (SP) (MP) (FSM) Accept or reject process for player (task) assignments.
+-- 
+-- ===
+-- 
+-- # @{#ACT_ASSIGN} FSM template class, extends @{Core.Fsm#FSM_PROCESS}
+-- 
+-- ## ACT_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.
+-- 
+-- ### ACT_ASSIGN **Events**:
+-- 
+-- These are the events defined in this class:
+-- 
+--   * **Start**:  Start the tasking acceptance process.
+--   * **Assign**:  Assign the task.
+--   * **Reject**:  Reject the task..
+-- 
+-- ### ACT_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:
+-- 
+--   * **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. 
+-- 
+-- ### ACT_ASSIGN **States**:
+-- 
+--   * **UnAssigned**: The player has not accepted the task.
+--   * **Assigned (*)**: The player has accepted the task.
+--   * **Rejected (*)**: The player has not accepted the task.
+--   * **Waiting**: The process is awaiting player feedback.
+--   * **Failed (*)**: The process has failed.
+--   
+-- (*) End states of the process.
+--   
+-- ### ACT_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:
+-- 
+--   * **Before** the state transition. 
+--     The state transition method needs to start with the name **OnBefore + the name of the state**. 
+--     If the state transition method returns false, then the processing of the state transition will not be done!
+--     If you want to change the behaviour of the AIControllable at this event, return false, 
+--     but then you'll need to specify your own logic using the AIControllable!
+--   
+--   * **After** the state transition. 
+--     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) @{#ACT_ASSIGN_ACCEPT} class, extends @{Fsm.Assign#ACT_ASSIGN}
+-- 
+-- The ACT_ASSIGN_ACCEPT class accepts by default a task for a player. No player intervention is allowed to reject the task.
+-- 
+-- ## 1.1) ACT_ASSIGN_ACCEPT constructor:
+--   
+--   * @{#ACT_ASSIGN_ACCEPT.New}(): Creates a new ACT_ASSIGN_ACCEPT object.
+-- 
+-- ===
+-- 
+-- # 2) @{#ACT_ASSIGN_MENU_ACCEPT} class, extends @{Fsm.Assign#ACT_ASSIGN}
+-- 
+-- The ACT_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) ACT_ASSIGN_MENU_ACCEPT constructor:
+-- -----------------------------------------
+--   
+--   * @{#ACT_ASSIGN_MENU_ACCEPT.New}(): Creates a new ACT_ASSIGN_MENU_ACCEPT object.
+-- 
+-- ===
+-- 
+-- @module Assign
+
+
+do -- ACT_ASSIGN
+
+  --- ACT_ASSIGN class
+  -- @type ACT_ASSIGN
+  -- @field Tasking.Task#TASK Task
+  -- @field Wrapper.Unit#UNIT ProcessUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends Core.Fsm#FSM_PROCESS
+  ACT_ASSIGN = { 
+    ClassName = "ACT_ASSIGN",
+  }
+  
+  
+  --- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted.
+  -- @param #ACT_ASSIGN self
+  -- @return #ACT_ASSIGN The task acceptance process.
+  function ACT_ASSIGN:New()
+
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, FSM_PROCESS:New( "ACT_ASSIGN" ) ) -- Core.Fsm#FSM_PROCESS
+
+    self:AddTransition( "UnAssigned", "Start", "Waiting" )
+    self:AddTransition( "Waiting",  "Assign", "Assigned" )
+    self:AddTransition( "Waiting", "Reject", "Rejected" )
+    self:AddTransition( "*", "Fail", "Failed" )
+    
+    self:AddEndState( "Assigned" )
+    self:AddEndState( "Rejected" )
+    self:AddEndState( "Failed" )
+    
+    self:SetStartState( "UnAssigned" )  
+    
+    return self
+  end
+  
+end -- ACT_ASSIGN
+
+
+
+do -- ACT_ASSIGN_ACCEPT
+
+  --- ACT_ASSIGN_ACCEPT class
+  -- @type ACT_ASSIGN_ACCEPT
+  -- @field Tasking.Task#TASK Task
+  -- @field Wrapper.Unit#UNIT ProcessUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends #ACT_ASSIGN
+  ACT_ASSIGN_ACCEPT = { 
+    ClassName = "ACT_ASSIGN_ACCEPT",
+  }
+  
+  
+  --- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted.
+  -- @param #ACT_ASSIGN_ACCEPT self
+  -- @param #string TaskBriefing
+  function ACT_ASSIGN_ACCEPT:New( TaskBriefing )
+    
+    local self = BASE:Inherit( self, ACT_ASSIGN:New() ) -- #ACT_ASSIGN_ACCEPT
+
+    self.TaskBriefing = TaskBriefing
+    
+    return self
+  end
+
+  function ACT_ASSIGN_ACCEPT:Init( FsmAssign )
+  
+    self.TaskBriefing = FsmAssign.TaskBriefing  
+  end
+
+  --- StateMachine callback function
+  -- @param #ACT_ASSIGN_ACCEPT self
+  -- @param Wrapper.Unit#UNIT ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIGN_ACCEPT:onafterStart( ProcessUnit, Event, From, To )
+    self:E( { ProcessUnit, Event, From, To } )
+  
+    self:__Assign( 1 )   
+  end
+
+  --- StateMachine callback function
+  -- @param #ACT_ASSIGN_ACCEPT self
+  -- @param Wrapper.Unit#UNIT ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIGN_ACCEPT:onenterAssigned( ProcessUnit, Event, From, To )
+    env.info( "in here" )
+    self:E( { ProcessUnit, Event, From, To } )
+  
+    local ProcessGroup = ProcessUnit:GetGroup()
+
+    self:Message( "You are assigned to the task " .. self.Task:GetName() )  
+
+    self.Task:Assign()
+  end
+  
+end -- ACT_ASSIGN_ACCEPT
+
+
+do -- ACT_ASSIGN_MENU_ACCEPT
+
+  --- ACT_ASSIGN_MENU_ACCEPT class
+  -- @type ACT_ASSIGN_MENU_ACCEPT
+  -- @field Tasking.Task#TASK Task
+  -- @field Wrapper.Unit#UNIT ProcessUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends #ACT_ASSIGN
+  ACT_ASSIGN_MENU_ACCEPT = { 
+    ClassName = "ACT_ASSIGN_MENU_ACCEPT",
+  }
+
+  --- Init.
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  -- @param #string TaskName
+  -- @param #string TaskBriefing
+  -- @return #ACT_ASSIGN_MENU_ACCEPT self
+  function ACT_ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing )
+
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, ACT_ASSIGN:New() ) -- #ACT_ASSIGN_MENU_ACCEPT
+
+    self.TaskName = TaskName 
+    self.TaskBriefing = TaskBriefing
+    
+    return self
+  end
+
+  function ACT_ASSIGN_MENU_ACCEPT:Init( FsmAssign )
+  
+    self.TaskName = FsmAssign.TaskName 
+    self.TaskBriefing = FsmAssign.TaskBriefing  
+  end
+  
+  
+  --- 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 #ACT_ASSIGN_MENU_ACCEPT self
+  -- @param #string TaskName
+  -- @param #string TaskBriefing
+  -- @return #ACT_ASSIGN_MENU_ACCEPT self
+  function ACT_ASSIGN_MENU_ACCEPT:Init( TaskName, TaskBriefing )
+  
+    self.TaskBriefing = TaskBriefing
+    self.TaskName = TaskName
+
+    return self
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIGN_MENU_ACCEPT:onafterStart( ProcessUnit, Event, From, To )
+    self:E( { ProcessUnit, Event, From, To } )
+
+    self:Message( "Access the radio menu to accept the task. You have 30 seconds or the assignment will be cancelled." )  
+   
+    local ProcessGroup = ProcessUnit:GetGroup() 
+    
+    self.Menu = MENU_GROUP:New( ProcessGroup, "Task " .. self.TaskName .. " acceptance" )
+    self.MenuAcceptTask = MENU_GROUP_COMMAND:New( ProcessGroup, "Accept task " .. self.TaskName, self.Menu, self.MenuAssign, self )
+    self.MenuRejectTask = MENU_GROUP_COMMAND:New( ProcessGroup, "Reject task " .. self.TaskName, self.Menu, self.MenuReject, self )
+  end
+  
+  --- Menu function.
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  function ACT_ASSIGN_MENU_ACCEPT:MenuAssign()
+    self:E( )
+  
+    self:__Assign( 1 )
+  end
+  
+  --- Menu function.
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  function ACT_ASSIGN_MENU_ACCEPT:MenuReject()
+    self:E( )
+  
+    self:__Reject( 1 )
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIGN_MENU_ACCEPT:onafterAssign( ProcessUnit, Event, From, To )
+    self:E( { ProcessUnit.UnitNameEvent, From, To } )
+  
+    self.Menu:Remove()
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ASSIGN_MENU_ACCEPT self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIGN_MENU_ACCEPT:onafterReject( ProcessUnit, Event, From, To )
+    self:E( { ProcessUnit.UnitName, Event, From, To } )
+  
+    self.Menu:Remove()
+    --TODO: need to resolve this problem ... it has to do with the events ...
+    --self.Task:UnAssignFromUnit( ProcessUnit )needs to become a callback funtion call upon the event
+    ProcessUnit:Destroy()
+  end
+
+end -- ACT_ASSIGN_MENU_ACCEPT

Moose Development/Moose/Actions/Act_Assist.lua

@@ -0,0 +1,206 @@
+--- (SP) (MP) (FSM) Route AI or players through waypoints or to zones.
+-- 
+-- ===
+-- 
+-- # @{#ACT_ASSIST} FSM class, extends @{Core.Fsm#FSM_PROCESS}
+-- 
+-- ## ACT_ASSIST 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.
+-- 
+-- ### ACT_ASSIST **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.
+-- 
+-- ### ACT_ASSIST **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:
+-- 
+--   * **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. 
+-- 
+-- ### ACT_ASSIST **States**:
+-- 
+--   * **None**: The controllable did not receive route commands.
+--   * **AwaitSmoke (*)**: The process is awaiting to smoke the targets in the zone.
+--   * **Smoking (*)**: The process is smoking the targets in the zone.
+--   * **Failed (*)**: The process has failed.
+--   
+-- (*) End states of the process.
+--   
+-- ### ACT_ASSIST 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:
+-- 
+--   * **Before** the state transition. 
+--     The state transition method needs to start with the name **OnBefore + the name of the state**. 
+--     If the state transition method returns false, then the processing of the state transition will not be done!
+--     If you want to change the behaviour of the AIControllable at this event, return false, 
+--     but then you'll need to specify your own logic using the AIControllable!
+--   
+--   * **After** the state transition. 
+--     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) @{#ACT_ASSIST_SMOKE_TARGETS_ZONE} class, extends @{Fsm.Route#ACT_ASSIST}
+-- 
+-- The ACT_ASSIST_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) ACT_ASSIST_SMOKE_TARGETS_ZONE constructor:
+--   
+--   * @{#ACT_ASSIST_SMOKE_TARGETS_ZONE.New}(): Creates a new ACT_ASSIST_SMOKE_TARGETS_ZONE object.
+-- 
+-- ===
+-- 
+-- @module Smoke
+
+do -- ACT_ASSIST
+
+  --- ACT_ASSIST class
+  -- @type ACT_ASSIST
+  -- @extends Core.Fsm#FSM_PROCESS
+  ACT_ASSIST = { 
+    ClassName = "ACT_ASSIST",
+  }
+
+  --- 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 #ACT_ASSIST self
+  -- @return #ACT_ASSIST
+  function ACT_ASSIST:New()
+
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, FSM_PROCESS:New( "ACT_ASSIST" ) ) -- Core.Fsm#FSM_PROCESS
+
+    self:AddTransition( "None", "Start", "AwaitSmoke" )
+    self:AddTransition( "AwaitSmoke", "Next", "Smoking" )
+    self:AddTransition( "Smoking", "Next", "AwaitSmoke" )
+    self:AddTransition( "*", "Stop", "Success" )
+    self:AddTransition( "*", "Fail", "Failed" )
+    
+    self:AddEndState( "Failed" )
+    self:AddEndState( "Success" )
+    
+    self:SetStartState( "None" )  
+
+    return self
+  end
+  
+  --- Task Events
+
+  --- StateMachine callback function
+  -- @param #ACT_ASSIST self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIST:onafterStart( ProcessUnit, Event, From, To )
+  
+    local ProcessGroup = ProcessUnit:GetGroup()
+    local MissionMenu = self:GetMission():GetMissionMenu( ProcessGroup )
+     
+    local function MenuSmoke( MenuParam )
+      self:E( MenuParam )
+      local self = MenuParam.self
+      local SmokeColor = MenuParam.SmokeColor
+      self.SmokeColor = SmokeColor
+      self:__Next( 1 )
+    end
+     
+    self.Menu = MENU_GROUP:New( ProcessGroup, "Target acquisition", MissionMenu )
+    self.MenuSmokeBlue   = MENU_GROUP_COMMAND:New( ProcessGroup, "Drop blue smoke on targets", self.Menu, MenuSmoke, { self = self, SmokeColor = SMOKECOLOR.Blue } )
+    self.MenuSmokeGreen  = MENU_GROUP_COMMAND:New( ProcessGroup, "Drop green smoke on targets", self.Menu, MenuSmoke, { self = self, SmokeColor = SMOKECOLOR.Green } )
+    self.MenuSmokeOrange = MENU_GROUP_COMMAND:New( ProcessGroup, "Drop Orange smoke on targets", self.Menu, MenuSmoke, { self = self, SmokeColor = SMOKECOLOR.Orange } )
+    self.MenuSmokeRed    = MENU_GROUP_COMMAND:New( ProcessGroup, "Drop Red smoke on targets", self.Menu, MenuSmoke, { self = self, SmokeColor = SMOKECOLOR.Red } )
+    self.MenuSmokeWhite  = MENU_GROUP_COMMAND:New( ProcessGroup, "Drop White smoke on targets", self.Menu, MenuSmoke, { self = self, SmokeColor = SMOKECOLOR.White } )
+  end
+  
+end
+
+do -- ACT_ASSIST_SMOKE_TARGETS_ZONE
+
+  --- ACT_ASSIST_SMOKE_TARGETS_ZONE class
+  -- @type ACT_ASSIST_SMOKE_TARGETS_ZONE
+  -- @field Set#SET_UNIT TargetSetUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends #ACT_ASSIST
+  ACT_ASSIST_SMOKE_TARGETS_ZONE = { 
+    ClassName = "ACT_ASSIST_SMOKE_TARGETS_ZONE",
+  }
+  
+--  function ACT_ASSIST_SMOKE_TARGETS_ZONE:_Destructor()
+--    self:E("_Destructor")
+--  
+--    self.Menu:Remove()
+--    self:EventRemoveAll()
+--  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 #ACT_ASSIST_SMOKE_TARGETS_ZONE self
+  -- @param Set#SET_UNIT TargetSetUnit
+  -- @param Core.Zone#ZONE_BASE TargetZone
+  function ACT_ASSIST_SMOKE_TARGETS_ZONE:New( TargetSetUnit, TargetZone )
+    local self = BASE:Inherit( self, ACT_ASSIST:New() ) -- #ACT_ASSIST
+
+    self.TargetSetUnit = TargetSetUnit
+    self.TargetZone = TargetZone
+  
+    return self
+  end
+
+  function ACT_ASSIST_SMOKE_TARGETS_ZONE:Init( FsmSmoke )
+    
+    self.TargetSetUnit = FsmSmoke.TargetSetUnit
+    self.TargetZone = FsmSmoke.TargetZone
+  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 #ACT_ASSIST_SMOKE_TARGETS_ZONE self
+  -- @param Set#SET_UNIT TargetSetUnit
+  -- @param Core.Zone#ZONE_BASE TargetZone
+  -- @return #ACT_ASSIST_SMOKE_TARGETS_ZONE self
+  function ACT_ASSIST_SMOKE_TARGETS_ZONE:Init( TargetSetUnit, TargetZone )
+    
+    self.TargetSetUnit = TargetSetUnit
+    self.TargetZone = TargetZone
+    
+    return self
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ASSIST_SMOKE_TARGETS_ZONE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ASSIST_SMOKE_TARGETS_ZONE:onenterSmoking( ProcessUnit, Event, From, To )
+    
+    self.TargetSetUnit:ForEachUnit(
+      --- @param Wrapper.Unit#UNIT SmokeUnit
+      function( SmokeUnit )
+        if math.random( 1, ( 100 * self.TargetSetUnit:Count() ) / 4 ) <= 100 then
+          SCHEDULER:New( self,
+            function()
+              if SmokeUnit:IsAlive() then
+                SmokeUnit:Smoke( self.SmokeColor, 150 )
+              end
+            end, {}, math.random( 10, 60 ) 
+          )
+        end
+      end
+    )
+    
+  end
+  
+end

Moose Development/Moose/Actions/Act_JTAC.lua

@@ -0,0 +1,199 @@
+--- @module Process_JTAC
+
+--- PROCESS_JTAC class
+-- @type PROCESS_JTAC
+-- @field Wrapper.Unit#UNIT ProcessUnit
+-- @field Core.Set#SET_UNIT TargetSetUnit
+-- @extends Core.Fsm#FSM_PROCESS
+PROCESS_JTAC = { 
+  ClassName = "PROCESS_JTAC",
+  Fsm = {},
+  TargetSetUnit = nil,
+}
+
+
+--- Creates a new DESTROY process.
+-- @param #PROCESS_JTAC self
+-- @param Tasking.Task#TASK Task
+-- @param Wrapper.Unit#UNIT ProcessUnit
+-- @param Core.Set#SET_UNIT TargetSetUnit
+-- @param Wrapper.Unit#UNIT FACUnit
+-- @return #PROCESS_JTAC self
+function PROCESS_JTAC:New( Task, ProcessUnit, TargetSetUnit, FACUnit )
+
+  -- Inherits from BASE
+  local self = BASE:Inherit( self, PROCESS:New( "JTAC", Task, ProcessUnit ) ) -- #PROCESS_JTAC
+  
+  self.TargetSetUnit = TargetSetUnit
+  self.FACUnit = FACUnit
+
+  self.DisplayInterval = 60
+  self.DisplayCount = 30
+  self.DisplayMessage = true
+  self.DisplayTime = 10 -- 10 seconds is the default
+  self.DisplayCategory = "HQ" -- Targets is the default display category
+
+
+  self.Fsm = FSM_PROCESS:New( self, {
+    initial = 'Assigned',
+    events = {
+      { name = 'Start', from = 'Assigned', to = 'CreatedMenu'    },
+      { name = 'JTACMenuUpdate', from = 'CreatedMenu', to = 'AwaitingMenu'    },
+      { name = 'JTACMenuAwait', from = 'AwaitingMenu', to = 'AwaitingMenu'    },
+      { name = 'JTACMenuSpot', from = 'AwaitingMenu', to = 'AwaitingMenu'    },
+      { name = 'JTACMenuCancel', from = 'AwaitingMenu', to = 'AwaitingMenu'  },
+      { name = 'JTACStatus', from = 'AwaitingMenu', to = 'AwaitingMenu'  },
+      { name = 'Fail', from = 'AwaitingMenu', to = 'Failed' },
+      { name = 'Fail', from = 'CreatedMenu', to = 'Failed' },
+    },
+    callbacks = {
+      onStart =  self.OnStart,
+      onJTACMenuUpdate = self.OnJTACMenuUpdate,
+      onJTACMenuAwait =  self.OnJTACMenuAwait,
+      onJTACMenuSpot = self.OnJTACMenuSpot,
+      onJTACMenuCancel = self.OnJTACMenuCancel,
+    },
+    endstates = { 'Failed' }
+  } )
+
+
+  _EVENTDISPATCHER:OnDead( self.EventDead, self )
+  
+  return self
+end
+
+--- Process Events
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_JTAC self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_JTAC:OnStart( Fsm, Event, From, To )
+
+  self:NextEvent( Fsm.JTACMenuUpdate )
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_JTAC self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_JTAC:OnJTACMenuUpdate( Fsm, Event, From, To )
+
+  local function JTACMenuSpot( MenuParam )
+    self:E( MenuParam.TargetUnit.UnitName )
+    local self = MenuParam.self
+    local TargetUnit = MenuParam.TargetUnit
+
+    self:NextEvent( self.Fsm.JTACMenuSpot, TargetUnit )
+  end
+
+  local function JTACMenuCancel( MenuParam )
+    self:E( MenuParam )
+    local self = MenuParam.self
+    local TargetUnit = MenuParam.TargetUnit
+ 
+    self:NextEvent( self.Fsm.JTACMenuCancel, TargetUnit )
+  end
+
+
+  -- Loop each unit in the target set, and determine the threat levels map table.
+  local UnitThreatLevels = self.TargetSetUnit:GetUnitThreatLevels()
+  
+  self:E( {"UnitThreadLevels", UnitThreatLevels } )
+  
+  local JTACMenu = self.ProcessGroup:GetState( self.ProcessGroup, "JTACMenu" )
+  
+  if not JTACMenu then
+    JTACMenu = MENU_GROUP:New( self.ProcessGroup, "JTAC", self.MissionMenu )
+    for ThreatLevel, ThreatLevelTable in pairs( UnitThreatLevels ) do
+      local JTACMenuThreatLevel = MENU_GROUP:New( self.ProcessGroup, ThreatLevelTable.UnitThreatLevelText, JTACMenu )
+      for ThreatUnitName, ThreatUnit in pairs( ThreatLevelTable.Units ) do
+        local JTACMenuUnit = MENU_GROUP:New( self.ProcessGroup, ThreatUnit:GetTypeName(), JTACMenuThreatLevel )
+        MENU_GROUP_COMMAND:New( self.ProcessGroup, "Lase Target", JTACMenuUnit, JTACMenuSpot, { self = self, TargetUnit = ThreatUnit } )
+        MENU_GROUP_COMMAND:New( self.ProcessGroup, "Cancel Target", JTACMenuUnit, JTACMenuCancel, { self = self, TargetUnit = ThreatUnit } )
+      end
+    end
+  end  
+  
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_JTAC self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_JTAC:OnJTACMenuAwait( Fsm, Event, From, To )
+
+  if self.DisplayCount >= self.DisplayInterval then
+
+    local TaskJTAC = self.Task -- Tasking.Task#TASK_JTAC
+    TaskJTAC.Spots = TaskJTAC.Spots or {}
+    for TargetUnitName, SpotData in pairs( TaskJTAC.Spots) do
+      local TargetUnit = UNIT:FindByName( TargetUnitName )
+      self.FACUnit:MessageToGroup( "Lasing " .. TargetUnit:GetTypeName() .. " with laser code " .. SpotData:getCode(), 15, self.ProcessGroup )
+    end
+    self.DisplayCount = 1
+  else
+    self.DisplayCount = self.DisplayCount + 1
+  end
+  
+  self:NextEvent( Fsm.JTACMenuAwait )
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_JTAC self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+-- @param Wrapper.Unit#UNIT TargetUnit
+function PROCESS_JTAC:OnJTACMenuSpot( Fsm, Event, From, To, TargetUnit )
+
+  local TargetUnitName = TargetUnit:GetName()
+  
+  local TaskJTAC = self.Task -- Tasking.Task#TASK_JTAC
+  
+  TaskJTAC.Spots = TaskJTAC.Spots or {}
+  TaskJTAC.Spots[TargetUnitName] = TaskJTAC.Spots[TargetUnitName] or {}
+
+  local DCSFACObject = self.FACUnit:GetDCSObject()
+  local TargetVec3 = TargetUnit:GetVec3()
+
+  TaskJTAC.Spots[TargetUnitName] = Spot.createInfraRed( self.FACUnit:GetDCSObject(), { x = 0, y = 1, z = 0 }, TargetUnit:GetVec3(), math.random( 1000, 9999 ) )
+  
+  local SpotData = TaskJTAC.Spots[TargetUnitName]
+  self.FACUnit:MessageToGroup( "Lasing " .. TargetUnit:GetTypeName() .. " with laser code " .. SpotData:getCode(), 15, self.ProcessGroup )
+
+  self:NextEvent( Fsm.JTACMenuAwait )
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_JTAC self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+-- @param Wrapper.Unit#UNIT TargetUnit
+function PROCESS_JTAC:OnJTACMenuCancel( Fsm, Event, From, To, TargetUnit )
+
+  local TargetUnitName = TargetUnit:GetName()
+  
+  local TaskJTAC = self.Task -- Tasking.Task#TASK_JTAC
+  
+  TaskJTAC.Spots = TaskJTAC.Spots or {}
+  if TaskJTAC.Spots[TargetUnitName] then
+    TaskJTAC.Spots[TargetUnitName]:destroy() -- destroys the spot
+    TaskJTAC.Spots[TargetUnitName] = nil
+  end
+
+  self.FACUnit:MessageToGroup( "Stopped lasing " .. TargetUnit:GetTypeName(), 15, self.ProcessGroup )
+
+  self:NextEvent( Fsm.JTACMenuAwait )
+end
+
+

Moose Development/Moose/Actions/Act_Pickup.lua

@@ -0,0 +1,173 @@
+--- @module Process_Pickup
+
+--- PROCESS_PICKUP class
+-- @type PROCESS_PICKUP
+-- @field Wrapper.Unit#UNIT ProcessUnit
+-- @field Core.Set#SET_UNIT TargetSetUnit
+-- @extends Core.Fsm#FSM_PROCESS
+PROCESS_PICKUP = { 
+  ClassName = "PROCESS_PICKUP",
+  Fsm = {},
+  TargetSetUnit = nil,
+}
+
+
+--- Creates a new DESTROY process.
+-- @param #PROCESS_PICKUP self
+-- @param Tasking.Task#TASK Task
+-- @param Wrapper.Unit#UNIT ProcessUnit
+-- @param Core.Set#SET_UNIT TargetSetUnit
+-- @return #PROCESS_PICKUP self
+function PROCESS_PICKUP:New( Task, ProcessName, ProcessUnit )
+
+  -- Inherits from BASE
+  local self = BASE:Inherit( self, PROCESS:New( ProcessName, Task, ProcessUnit ) ) -- #PROCESS_PICKUP
+  
+  self.DisplayInterval = 30
+  self.DisplayCount = 30
+  self.DisplayMessage = true
+  self.DisplayTime = 10 -- 10 seconds is the default
+  self.DisplayCategory = "HQ" -- Targets is the default display category
+
+  self.Fsm = FSM_PROCESS:New( self, {
+    initial = 'Assigned',
+    events = {
+      { name = 'Start',     from = 'Assigned',        to = 'Navigating'    },
+      { name = 'Start',     from = 'Navigating',      to = 'Navigating'    },
+      { name = 'Nearby',    from = 'Navigating',      to = 'Preparing' },
+      { name = 'Pickup',    from = 'Preparing',       to = 'Loading'  },
+      { name = 'Load',      from = 'Loading',         to = 'Success'  },
+      { name = 'Fail',      from = 'Assigned',        to = 'Failed' },
+      { name = 'Fail',      from = 'Navigating',      to = 'Failed' },
+      { name = 'Fail',      from = 'Preparing',       to = 'Failed' },
+    },
+    callbacks = {
+      onStart =  self.OnStart,
+      onNearby = self.OnNearby,
+      onPickup =  self.OnPickup,
+      onLoad = self.OnLoad,
+    },
+    endstates = { 'Success', 'Failed' }
+  } )
+
+  return self
+end
+
+--- Process Events
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_PICKUP:OnStart( Fsm, Event, From, To )
+
+  self:NextEvent( Fsm.Start )
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_PICKUP:OnNavigating( Fsm, Event, From, To )
+
+  local TaskGroup = self.ProcessUnit:GetGroup()
+  if self.DisplayCount >= self.DisplayInterval then
+    MESSAGE:New( "Your group with assigned " .. self.Task:GetName() .. " task has " .. self.TargetSetUnit:GetUnitTypesText() .. " targets left to be destroyed.", 5, "HQ" ):ToGroup( TaskGroup )
+    self.DisplayCount = 1
+  else
+    self.DisplayCount = self.DisplayCount + 1
+  end
+  
+  return true -- Process always the event.
+  
+end
+
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+-- @param Core.Event#EVENTDATA Event
+function PROCESS_PICKUP:OnHitTarget( Fsm, Event, From, To, Event )
+
+
+  self.TargetSetUnit:Flush()
+  
+  if self.TargetSetUnit:FindUnit( Event.IniUnitName ) then
+    self.TargetSetUnit:RemoveUnitsByName( Event.IniUnitName )
+    local TaskGroup = self.ProcessUnit:GetGroup()
+    MESSAGE:New( "You hit a target. Your group with assigned " .. self.Task:GetName() .. " task has " .. self.TargetSetUnit:Count() .. " targets ( " .. self.TargetSetUnit:GetUnitTypesText() .. " ) left to be destroyed.", 15, "HQ" ):ToGroup( TaskGroup )
+  end
+
+  
+  if self.TargetSetUnit:Count() > 0 then
+    self:NextEvent( Fsm.MoreTargets )
+  else
+    self:NextEvent( Fsm.Destroyed )
+  end
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_PICKUP:OnMoreTargets( Fsm, Event, From, To )
+
+
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+-- @param Core.Event#EVENTDATA DCSEvent
+function PROCESS_PICKUP:OnKilled( Fsm, Event, From, To )
+
+  self:NextEvent( Fsm.Restart )
+
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_PICKUP:OnRestart( Fsm, Event, From, To )
+
+  self:NextEvent( Fsm.Menu )
+
+end
+
+--- StateMachine callback function for a PROCESS
+-- @param #PROCESS_PICKUP self
+-- @param Core.Fsm#FSM_PROCESS Fsm
+-- @param #string Event
+-- @param #string From
+-- @param #string To
+function PROCESS_PICKUP:OnDestroyed( Fsm, Event, From, To )
+
+end
+
+--- DCS Events
+
+--- @param #PROCESS_PICKUP self
+-- @param Core.Event#EVENTDATA Event
+function PROCESS_PICKUP:EventDead( Event )
+
+  if Event.IniDCSUnit then
+    self:NextEvent( self.Fsm.HitTarget, Event )
+  end
+end
+
+

Moose Development/Moose/Actions/Act_Route.lua

@@ -0,0 +1,249 @@
+--- (SP) (MP) (FSM) Route AI or players through waypoints or to zones.
+-- 
+-- ===
+-- 
+-- # @{#ACT_ROUTE} FSM class, extends @{Core.Fsm#FSM_PROCESS}
+-- 
+-- ## ACT_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.
+-- 
+-- ### ACT_ROUTE **Events**:
+-- 
+-- These are the events defined in this class:
+-- 
+--   * **Start**:  The process is started. The process will go into the Report state.
+--   * **Report**: The process is reporting to the player the route to be followed.
+--   * **Route**: The process is routing the controllable.
+--   * **Pause**: The process is pausing the route of the controllable.
+--   * **Arrive**: The controllable has arrived at a route point.
+--   * **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.
+-- 
+-- ### ACT_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:
+-- 
+--   * **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. 
+-- 
+-- ### ACT_ROUTE **States**:
+-- 
+--   * **None**: The controllable did not receive route commands.
+--   * **Arrived (*)**: The controllable has arrived at a route point.
+--   * **Aborted (*)**: The controllable has aborted the route path.
+--   * **Routing**: The controllable is understay to the route point.
+--   * **Pausing**: The process is pausing the routing. AI air will go into hover, AI ground will stop moving. Players can fly around.
+--   * **Success (*)**: All route points were reached. 
+--   * **Failed (*)**: The process has failed.
+--   
+-- (*) End states of the process.
+--   
+-- ### ACT_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:
+-- 
+--   * **Before** the state transition. 
+--     The state transition method needs to start with the name **OnBefore + the name of the state**. 
+--     If the state transition method returns false, then the processing of the state transition will not be done!
+--     If you want to change the behaviour of the AIControllable at this event, return false, 
+--     but then you'll need to specify your own logic using the AIControllable!
+--   
+--   * **After** the state transition. 
+--     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) @{#ACT_ROUTE_ZONE} class, extends @{Fsm.Route#ACT_ROUTE}
+-- 
+-- The ACT_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) ACT_ROUTE_ZONE constructor:
+--   
+--   * @{#ACT_ROUTE_ZONE.New}(): Creates a new ACT_ROUTE_ZONE object.
+-- 
+-- ===
+-- 
+-- @module Route
+
+
+do -- ACT_ROUTE
+
+  --- ACT_ROUTE class
+  -- @type ACT_ROUTE
+  -- @field Tasking.Task#TASK TASK
+  -- @field Wrapper.Unit#UNIT ProcessUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends Core.Fsm#FSM_PROCESS
+  ACT_ROUTE = { 
+    ClassName = "ACT_ROUTE",
+  }
+  
+  
+  --- Creates a new routing state machine. The process will route a CLIENT to a ZONE until the CLIENT is within that ZONE.
+  -- @param #ACT_ROUTE self
+  -- @return #ACT_ROUTE self
+  function ACT_ROUTE:New()
+
+    -- Inherits from BASE
+    local self = BASE:Inherit( self, FSM_PROCESS:New( "ACT_ROUTE" ) ) -- Core.Fsm#FSM_PROCESS
+ 
+    self:AddTransition( "None", "Start", "Routing" )
+    self:AddTransition( "*", "Report", "Reporting" )
+    self:AddTransition( "*", "Route", "Routing" )
+    self:AddTransition( "Routing", "Pause", "Pausing" )
+    self:AddTransition( "*", "Abort", "Aborted" )
+    self:AddTransition( "Routing", "Arrive", "Arrived" )
+    self:AddTransition( "Arrived", "Success", "Success" )
+    self:AddTransition( "*", "Fail", "Failed" )
+    self:AddTransition( "", "", "" )
+    self:AddTransition( "", "", "" )
+ 
+    self:AddEndState( "Arrived" )
+    self:AddEndState( "Failed" )
+    
+    self:SetStartState( "None" )  
+  
+    return self
+  end
+
+  --- Task Events
+
+  --- StateMachine callback function
+  -- @param #ACT_ROUTE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ROUTE:onafterStart( ProcessUnit, Event, From, To )
+  
+
+    self:__Route( 1 )
+  end
+  
+  --- Check if the controllable has arrived.
+  -- @param #ACT_ROUTE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @return #boolean
+  function ACT_ROUTE:onfuncHasArrived( ProcessUnit )
+    return false
+  end
+  
+  --- StateMachine callback function
+  -- @param #ACT_ROUTE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ROUTE:onbeforeRoute( ProcessUnit, Event, From, To )
+  
+    if ProcessUnit:IsAlive() then
+      local HasArrived = self:onfuncHasArrived( ProcessUnit ) -- Polymorphic
+      if self.DisplayCount >= self.DisplayInterval then
+        self:T( { HasArrived = HasArrived } )
+        if not HasArrived then
+          self:__Report( 1 )
+        end
+        self.DisplayCount = 1
+      else
+        self.DisplayCount = self.DisplayCount + 1
+      end
+      
+      self:T( { DisplayCount = self.DisplayCount } )
+      
+      if HasArrived then
+        self:__Arrive( 1 )
+      else
+        self:__Route( 1 )
+      end
+    
+      return HasArrived -- if false, then the event will not be executed...
+    end
+    
+    return false
+    
+  end
+
+end -- ACT_ROUTE
+
+
+
+do -- ACT_ROUTE_ZONE
+
+  --- ACT_ROUTE_ZONE class
+  -- @type ACT_ROUTE_ZONE
+  -- @field Tasking.Task#TASK TASK
+  -- @field Wrapper.Unit#UNIT ProcessUnit
+  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @extends #ACT_ROUTE
+  ACT_ROUTE_ZONE = { 
+    ClassName = "ACT_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 #ACT_ROUTE_ZONE self
+  -- @param Core.Zone#ZONE_BASE TargetZone
+  function ACT_ROUTE_ZONE:New( TargetZone )
+    local self = BASE:Inherit( self, ACT_ROUTE:New() ) -- #ACT_ROUTE_ZONE
+
+    self.TargetZone = TargetZone
+    
+    self.DisplayInterval = 30
+    self.DisplayCount = 30
+    self.DisplayMessage = true
+    self.DisplayTime = 10 -- 10 seconds is the default
+    
+    return self
+  end
+  
+  function ACT_ROUTE_ZONE:Init( FsmRoute )
+  
+    self.TargetZone = FsmRoute.TargetZone
+    self.DisplayInterval = 30
+    self.DisplayCount = 30
+    self.DisplayMessage = true
+    self.DisplayTime = 10 -- 10 seconds is the default
+  end  
+  
+  --- Method override to check if the controllable has arrived.
+  -- @param #ACT_ROUTE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @return #boolean
+  function ACT_ROUTE_ZONE:onfuncHasArrived( ProcessUnit )
+
+    if ProcessUnit:IsInZone( self.TargetZone ) then
+      local RouteText = "You have arrived within the zone."
+      self:Message( RouteText )
+    end
+
+    return ProcessUnit:IsInZone( self.TargetZone )
+  end
+  
+  --- Task Events
+  
+  --- StateMachine callback function
+  -- @param #ACT_ROUTE_ZONE self
+  -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
+  -- @param #string Event
+  -- @param #string From
+  -- @param #string To
+  function ACT_ROUTE_ZONE:onenterReporting( ProcessUnit, Event, From, To )
+  
+    local ZoneVec2 = self.TargetZone:GetVec2()
+    local ZonePointVec2 = POINT_VEC2:New( ZoneVec2.x, ZoneVec2.y )
+    local TaskUnitVec2 = ProcessUnit:GetVec2()
+    local TaskUnitPointVec2 = POINT_VEC2:New( TaskUnitVec2.x, TaskUnitVec2.y )
+    local RouteText = "Route to " .. TaskUnitPointVec2:GetBRText( ZonePointVec2 ) .. " km to target."
+    self:Message( RouteText )
+  end
+
+end -- ACT_ROUTE_ZONE