mirror of
https://github.com/FlightControl-Master/MOOSE.git
synced 2025-10-29 16:58:06 +00:00
Got SEAD tasking working now with new Process Templates...
This commit is contained in:
FlightControl
@@ -1,249 +0,0 @@
|
||||
--- (SP) (MP) (FSM) Account for (Detect, count and report) DCS events occuring on DCS objects (units).
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- # @{#ACCOUNT} FSM class, extends @{Process#PROCESS}
|
||||
--
|
||||
-- ## 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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) @{#ACCOUNT_DEADS} FSM class, extends @{Account#ACCOUNT}
|
||||
--
|
||||
-- The 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.
|
||||
--
|
||||
--
|
||||
-- ## ACCOUNT_DEADS constructor:
|
||||
--
|
||||
-- * @{#ACCOUNT_DEADS.New}(): Creates a new ACCOUNT_DEADS object.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- @module Account
|
||||
|
||||
|
||||
do -- ACCOUNT
|
||||
|
||||
--- ACCOUNT class
|
||||
-- @type ACCOUNT
|
||||
-- @field Set#SET_UNIT TargetSetUnit
|
||||
-- @extends Process#PROCESS
|
||||
ACCOUNT = {
|
||||
ClassName = "ACCOUNT",
|
||||
TargetSetUnit = nil,
|
||||
}
|
||||
|
||||
--- Creates a new DESTROY process.
|
||||
-- @param #ACCOUNT self
|
||||
-- @return #ACCOUNT
|
||||
function ACCOUNT:New()
|
||||
|
||||
local FSMT = {
|
||||
initial = 'Assigned',
|
||||
events = {
|
||||
{ name = 'Start', from = 'Assigned', to = 'Waiting' },
|
||||
{ name = 'Wait', from = '*', to = 'Waiting' },
|
||||
{ name = 'Report', from = '*', to = 'Report' },
|
||||
{ name = 'Event', from = '*', to = 'Account' },
|
||||
{ name = 'More', from = 'Account', to = 'Wait' },
|
||||
{ name = 'NoMore', from = 'Account', to = 'Success' },
|
||||
{ name = 'Fail', from = '*', to = 'Failed' },
|
||||
},
|
||||
endstates = { 'Success', 'Failed' }
|
||||
}
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, PROCESS:New( FSMT, "ACCOUNT" ) ) -- #ACCOUNT
|
||||
|
||||
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
|
||||
|
||||
--- Process Events
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ACCOUNT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ACCOUNT:onafterStart( ProcessUnit, Event, From, To )
|
||||
|
||||
self:__Wait( 1 )
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ACCOUNT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function 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 #ACCOUNT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ACCOUNT:onafterEvent( ProcessUnit, Event, From, To, Event )
|
||||
|
||||
self:__NoMore( 1 )
|
||||
end
|
||||
|
||||
end -- ACCOUNT
|
||||
|
||||
do -- ACCOUNT_DEADS
|
||||
|
||||
--- ACCOUNT_DEADS class
|
||||
-- @type ACCOUNT_DEADS
|
||||
-- @field Set#SET_UNIT TargetSetUnit
|
||||
-- @extends Process#PROCESS
|
||||
ACCOUNT_DEADS = {
|
||||
ClassName = "ACCOUNT_DEADS",
|
||||
TargetSetUnit = nil,
|
||||
}
|
||||
|
||||
|
||||
--- Creates a new DESTROY process.
|
||||
-- @param #ACCOUNT_DEADS self
|
||||
-- @param Set#SET_UNIT TargetSetUnit
|
||||
-- @param #string TaskName
|
||||
-- @return #ACCOUNT_DEADS self
|
||||
function ACCOUNT_DEADS:New( TargetSetUnit, TaskName )
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, ACCOUNT:New() ) -- #ACCOUNT_DEADS
|
||||
|
||||
self.TargetSetUnit = TargetSetUnit
|
||||
self.TaskName = TaskName
|
||||
|
||||
_EVENTDISPATCHER:OnDead( self.EventDead, self )
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- Process Events
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ACCOUNT_DEADS:onenterReport( ProcessUnit, Event, From, To )
|
||||
|
||||
local TaskGroup = ProcessUnit:GetGroup()
|
||||
MESSAGE:New( "Your group with assigned " .. self.TaskName .. " task has " .. self.TargetSetUnit:GetUnitTypesText() .. " targets left to be destroyed.", 5, "HQ" ):ToGroup( TaskGroup )
|
||||
end
|
||||
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ACCOUNT_DEADS:onenterAccount( ProcessUnit, Event, From, To, Event )
|
||||
|
||||
self.TargetSetUnit:Flush()
|
||||
|
||||
if self.TargetSetUnit:FindUnit( Event.IniUnitName ) then
|
||||
self.TargetSetUnit:RemoveUnitsByName( Event.IniUnitName )
|
||||
local TaskGroup = ProcessUnit:GetGroup()
|
||||
MESSAGE:New( "You hit a target. Your group with assigned " .. self.TaskName .. " task has " .. self.TargetSetUnit:Count() .. " targets ( " .. self.TargetSetUnit:GetUnitTypesText() .. " ) left to be destroyed.", 15, "HQ" ):ToGroup( TaskGroup )
|
||||
end
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ACCOUNT_DEADS:onafterEvent( ProcessUnit, Event, From, To, Event )
|
||||
|
||||
if self.TargetSetUnit:Count() > 0 then
|
||||
self:__More( 1 )
|
||||
else
|
||||
self:__NoMore( 1 )
|
||||
end
|
||||
end
|
||||
|
||||
--- DCS Events
|
||||
|
||||
--- @param #ACCOUNT_DEADS self
|
||||
-- @param Event#EVENTDATA Event
|
||||
function ACCOUNT_DEADS:EventDead( Event )
|
||||
|
||||
if Event.IniDCSUnit then
|
||||
self:__Event( 1 )
|
||||
end
|
||||
end
|
||||
|
||||
end -- ACCOUNT DEADS
|
||||
@@ -1,259 +0,0 @@
|
||||
--- (SP) (MP) (FSM) Accept or reject process for player (task) assignments.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- # @{#ASSIGN} FSM class, extends @{Process#PROCESS}
|
||||
--
|
||||
-- ## 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.
|
||||
--
|
||||
-- ### ASSIGN **Events**:
|
||||
--
|
||||
-- These are the events defined in this class:
|
||||
--
|
||||
-- * **Start**: Start the tasking acceptance process.
|
||||
-- * **Assign**: Assign the task.
|
||||
-- * **Reject**: Reject the task..
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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) @{#ASSIGN_ACCEPT} class, extends @{Assign#ASSIGN}
|
||||
--
|
||||
-- The ASSIGN_ACCEPT class accepts by default a task for a player. No player intervention is allowed to reject the task.
|
||||
--
|
||||
-- ## 1.1) ASSIGN_ACCEPT constructor:
|
||||
--
|
||||
-- * @{#ASSIGN_ACCEPT.New}(): Creates a new ASSIGN_ACCEPT object.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- # 2) @{#ASSIGN_MENU_ACCEPT} class, extends @{Assign#ASSIGN}
|
||||
--
|
||||
-- The 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) ASSIGN_MENU_ACCEPT constructor:
|
||||
-- -----------------------------------------
|
||||
--
|
||||
-- * @{#ASSIGN_MENU_ACCEPT.New}(): Creates a new ASSIGN_MENU_ACCEPT object.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- @module Assign
|
||||
|
||||
|
||||
do -- ASSIGN
|
||||
|
||||
--- ASSIGN class
|
||||
-- @type ASSIGN
|
||||
-- @field Task#TASK_BASE Task
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Process#PROCESS
|
||||
ASSIGN = {
|
||||
ClassName = "ASSIGN",
|
||||
}
|
||||
|
||||
|
||||
--- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted.
|
||||
-- @param #ASSIGN self
|
||||
-- @return #ASSIGN The task acceptance process.
|
||||
function ASSIGN:New()
|
||||
|
||||
local FSMT = {
|
||||
initial = 'UnAssigned',
|
||||
events = {
|
||||
{ name = 'Start', from = 'UnAssigned', to = 'Waiting' },
|
||||
{ name = 'Assign', from = 'Waiting', to = 'Assigned' },
|
||||
{ name = 'Reject', from = 'Waiting', to = 'Rejected' },
|
||||
{ name = 'Fail', from = '*', to = 'Failed' },
|
||||
},
|
||||
endstates = {
|
||||
'Assigned', 'Rejected', 'Failed'
|
||||
},
|
||||
}
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, PROCESS:New( FSMT, "ASSIGN" ) ) -- #ASSIGN
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
end -- ASSIGN
|
||||
|
||||
|
||||
|
||||
do -- ASSIGN_ACCEPT
|
||||
|
||||
--- ASSIGN_ACCEPT class
|
||||
-- @type ASSIGN_ACCEPT
|
||||
-- @field Task#TASK_BASE Task
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Process#PROCESS
|
||||
ASSIGN_ACCEPT = {
|
||||
ClassName = "ASSIGN_ACCEPT",
|
||||
}
|
||||
|
||||
|
||||
--- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted.
|
||||
-- @param #ASSIGN_ACCEPT self
|
||||
-- @param #string TaskBriefing
|
||||
-- @return #ASSIGN_ACCEPT The task acceptance process.
|
||||
function ASSIGN_ACCEPT:New( TaskBriefing )
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, ASSIGN:New() ) -- #ASSIGN_ACCEPT
|
||||
|
||||
self.TaskBriefing = TaskBriefing
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ASSIGN_ACCEPT:onafterStart( ProcessUnit, Event, From, To )
|
||||
self:E( { ProcessUnit, Event, From, To } )
|
||||
|
||||
MESSAGE:New( self.TaskBriefing, 30, "Task Assignment" ):ToGroup( ProcessUnit:GetGroup() )
|
||||
|
||||
self:__Assign( 1 )
|
||||
end
|
||||
|
||||
end -- ASSIGN_ACCEPT
|
||||
|
||||
|
||||
do -- ASSIGN_MENU_ACCEPT
|
||||
|
||||
--- ASSIGN_MENU_ACCEPT class
|
||||
-- @type ASSIGN_MENU_ACCEPT
|
||||
-- @field Task#TASK_BASE Task
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Task2#TASK2
|
||||
ASSIGN_MENU_ACCEPT = {
|
||||
ClassName = "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 #ASSIGN_MENU_ACCEPT self
|
||||
-- @param #string TaskName
|
||||
-- @param #string TaskBriefing
|
||||
-- @return #ASSIGN_MENU_ACCEPT self
|
||||
function ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing )
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, ASSIGN:New() ) -- #ASSIGN_MENU_ACCEPT
|
||||
|
||||
self.TaskBriefing = TaskBriefing
|
||||
self.TaskName = TaskName
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function 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() )
|
||||
|
||||
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 #ASSIGN_MENU_ACCEPT self
|
||||
function ASSIGN_MENU_ACCEPT:MenuAssign()
|
||||
self:E( )
|
||||
|
||||
self:__Assign( 1 )
|
||||
end
|
||||
|
||||
--- Menu function.
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
function ASSIGN_MENU_ACCEPT:MenuReject()
|
||||
self:E( )
|
||||
|
||||
self:__Reject( 1 )
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ASSIGN_MENU_ACCEPT:onafterAssign( ProcessUnit, Event, From, To )
|
||||
self:E( { ProcessUnit.UnitNameEvent, From, To } )
|
||||
|
||||
self.Menu:Remove()
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ASSIGN_MENU_ACCEPT self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function 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 -- ASSIGN_MENU_ACCEPT
|
||||
@@ -20,15 +20,15 @@
|
||||
-- The CARGO_BASE is a state machine: it manages the different events and states of the cargo.
|
||||
-- All derived classes from CARGO_BASE follow the same state machine, expose the same cargo event functions, and provide the same cargo states.
|
||||
--
|
||||
-- ## 1.2.1) CARBO_BASE Events:
|
||||
-- ## 1.2.1) CARGO_BASE Events:
|
||||
--
|
||||
-- * @{#CARBO_BASE.Board}( ToCarrier ): Boards the cargo to a carrier.
|
||||
-- * @{#CARBO_BASE.Load}( ToCarrier ): Loads the cargo into a carrier, regardless of its position.
|
||||
-- * @{#CARBO_BASE.UnBoard}( ToPointVec2 ): UnBoard the cargo from a carrier. This will trigger a movement of the cargo to the option ToPointVec2.
|
||||
-- * @{#CARBO_BASE.UnLoad}( ToPointVec2 ): UnLoads the cargo from a carrier.
|
||||
-- * @{#CARBO_BASE.Dead}( Controllable ): The cargo is dead. The cargo process will be ended.
|
||||
-- * @{#CARGO_BASE.Board}( ToCarrier ): Boards the cargo to a carrier.
|
||||
-- * @{#CARGO_BASE.Load}( ToCarrier ): Loads the cargo into a carrier, regardless of its position.
|
||||
-- * @{#CARGO_BASE.UnBoard}( ToPointVec2 ): UnBoard the cargo from a carrier. This will trigger a movement of the cargo to the option ToPointVec2.
|
||||
-- * @{#CARGO_BASE.UnLoad}( ToPointVec2 ): UnLoads the cargo from a carrier.
|
||||
-- * @{#CARGO_BASE.Dead}( Controllable ): The cargo is dead. The cargo process will be ended.
|
||||
--
|
||||
-- ## 1.2.2) CARBO_BASE States:
|
||||
-- ## 1.2.2) CARGO_BASE States:
|
||||
--
|
||||
-- * **UnLoaded**: The cargo is unloaded from a carrier.
|
||||
-- * **Boarding**: The cargo is currently boarding (= running) into a carrier.
|
||||
@@ -37,7 +37,7 @@
|
||||
-- * **Dead**: The cargo is dead ...
|
||||
-- * **End**: The process has come to an end.
|
||||
--
|
||||
-- ## 1.2.3) CARBO_BASE state transition methods:
|
||||
-- ## 1.2.3) CARGO_BASE 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:
|
||||
@@ -72,14 +72,14 @@
|
||||
|
||||
--- Boards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo to the Carrier.
|
||||
-- The cargo must be in the **UnLoaded** state.
|
||||
-- @function [parent=#CARBO_BASE] Board
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] Board
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
|
||||
|
||||
--- Boards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo to the Carrier.
|
||||
-- The cargo must be in the **UnLoaded** state.
|
||||
-- @function [parent=#CARBO_BASE] __Board
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] __Board
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param #number DelaySeconds The amount of seconds to delay the action.
|
||||
-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
|
||||
|
||||
@@ -88,14 +88,14 @@
|
||||
|
||||
--- UnBoards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo from the Carrier.
|
||||
-- The cargo must be in the **Loaded** state.
|
||||
-- @function [parent=#CARBO_BASE] UnBoard
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] UnBoard
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Point#POINT_VEC2 ToPointVec2 (optional) @{Point#POINT_VEC2) to where the cargo should run after onboarding. If not provided, the cargo will run to 60 meters behind the Carrier location.
|
||||
|
||||
--- UnBoards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo from the Carrier.
|
||||
-- The cargo must be in the **Loaded** state.
|
||||
-- @function [parent=#CARBO_BASE] __UnBoard
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] __UnBoard
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param #number DelaySeconds The amount of seconds to delay the action.
|
||||
-- @param Point#POINT_VEC2 ToPointVec2 (optional) @{Point#POINT_VEC2) to where the cargo should run after onboarding. If not provided, the cargo will run to 60 meters behind the Carrier location.
|
||||
|
||||
@@ -104,14 +104,14 @@
|
||||
|
||||
--- Loads the cargo to a Carrier. The event will load the cargo into the Carrier regardless of its position. There will be no movement simulated of the cargo loading.
|
||||
-- The cargo must be in the **UnLoaded** state.
|
||||
-- @function [parent=#CARBO_BASE] Load
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] Load
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
|
||||
|
||||
--- Loads the cargo to a Carrier. The event will load the cargo into the Carrier regardless of its position. There will be no movement simulated of the cargo loading.
|
||||
-- The cargo must be in the **UnLoaded** state.
|
||||
-- @function [parent=#CARBO_BASE] __Load
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] __Load
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param #number DelaySeconds The amount of seconds to delay the action.
|
||||
-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
|
||||
|
||||
@@ -120,14 +120,14 @@
|
||||
|
||||
--- UnLoads the cargo to a Carrier. The event will unload the cargo from the Carrier. There will be no movement simulated of the cargo loading.
|
||||
-- The cargo must be in the **Loaded** state.
|
||||
-- @function [parent=#CARBO_BASE] UnLoad
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] UnLoad
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Point#POINT_VEC2 ToPointVec2 (optional) @{Point#POINT_VEC2) to where the cargo will be placed after unloading. If not provided, the cargo will be placed 60 meters behind the Carrier location.
|
||||
|
||||
--- UnLoads the cargo to a Carrier. The event will unload the cargo from the Carrier. There will be no movement simulated of the cargo loading.
|
||||
-- The cargo must be in the **Loaded** state.
|
||||
-- @function [parent=#CARBO_BASE] __UnLoad
|
||||
-- @param #CARBO_BASE self
|
||||
-- @function [parent=#CARGO_BASE] __UnLoad
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param #number DelaySeconds The amount of seconds to delay the action.
|
||||
-- @param Point#POINT_VEC2 ToPointVec2 (optional) @{Point#POINT_VEC2) to where the cargo will be placed after unloading. If not provided, the cargo will be placed 60 meters behind the Carrier location.
|
||||
|
||||
@@ -135,46 +135,46 @@
|
||||
|
||||
-- UnLoaded
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnBeforeUnLoaded
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnBeforeUnLoaded
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
-- @return #boolean
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnAfterUnLoaded
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnAfterUnLoaded
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
|
||||
-- Loaded
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnBeforeLoaded
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnBeforeLoaded
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
-- @return #boolean
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnAfterLoaded
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnAfterLoaded
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
|
||||
-- Boarding
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnBeforeBoarding
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnBeforeBoarding
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
-- @return #boolean
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnAfterBoarding
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnAfterBoarding
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
|
||||
-- UnBoarding
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnBeforeUnBoarding
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnBeforeUnBoarding
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
-- @return #boolean
|
||||
|
||||
--- @function [parent=#CARBO_BASE] OnAfterUnBoarding
|
||||
-- @param #CARBO_BASE self
|
||||
--- @function [parent=#CARGO_BASE] OnAfterUnBoarding
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Controllable#CONTROLLABLE Controllable
|
||||
|
||||
|
||||
@@ -182,9 +182,9 @@
|
||||
|
||||
CARGOS = {}
|
||||
|
||||
do -- CARBO_BASE
|
||||
do -- CARGO_BASE
|
||||
|
||||
--- @type CARBO_BASE
|
||||
--- @type CARGO_BASE
|
||||
-- @extends StateMachine#STATEMACHINE_PROCESS
|
||||
-- @field #string Type A string defining the type of the cargo. eg. Engineers, Equipment, Screwdrivers.
|
||||
-- @field #string Name A string defining the name of the cargo. The name is the unique identifier of the cargo.
|
||||
@@ -197,8 +197,8 @@ do -- CARBO_BASE
|
||||
-- @field #boolean Moveable This flag defines if the cargo is moveable.
|
||||
-- @field #boolean Representable This flag defines if the cargo can be represented by a DCS Unit.
|
||||
-- @field #boolean Containable This flag defines if the cargo can be contained within a DCS Unit.
|
||||
CARBO_BASE = {
|
||||
ClassName = "CARBO_BASE",
|
||||
CARGO_BASE = {
|
||||
ClassName = "CARGO_BASE",
|
||||
Type = nil,
|
||||
Name = nil,
|
||||
Weight = nil,
|
||||
@@ -210,19 +210,19 @@ do -- CARBO_BASE
|
||||
Containable = false,
|
||||
}
|
||||
|
||||
--- @type CARBO_BASE.CargoObjects
|
||||
--- @type CARGO_BASE.CargoObjects
|
||||
-- @map < #string, Positionable#POSITIONABLE > The alive POSITIONABLE objects representing the the cargo.
|
||||
|
||||
|
||||
--- CARBO_BASE Constructor. This class is an abstract class and should not be instantiated.
|
||||
-- @param #CARBO_BASE self
|
||||
--- CARGO_BASE Constructor. This class is an abstract class and should not be instantiated.
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param #string Type
|
||||
-- @param #string Name
|
||||
-- @param #number Weight
|
||||
-- @param #number ReportRadius (optional)
|
||||
-- @param #number NearRadius (optional)
|
||||
-- @return #CARBO_BASE
|
||||
function CARBO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius )
|
||||
-- @return #CARGO_BASE
|
||||
function CARGO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius )
|
||||
|
||||
FSMT = {
|
||||
initial = 'UnLoaded',
|
||||
@@ -238,7 +238,7 @@ function CARBO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius )
|
||||
},
|
||||
}
|
||||
|
||||
local self = BASE:Inherit( self, STATEMACHINE_PROCESS:New( FSMT ) ) -- #CARBO_BASE
|
||||
local self = BASE:Inherit( self, STATEMACHINE_PROCESS:New( FSMT ) ) -- #CARGO_BASE
|
||||
self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
|
||||
|
||||
|
||||
@@ -263,20 +263,20 @@ function CARBO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius )
|
||||
end
|
||||
|
||||
|
||||
--- Template method to spawn a new representation of the CARBO_BASE in the simulator.
|
||||
-- @param #CARBO_BASE self
|
||||
-- @return #CARBO_BASE
|
||||
function CARBO_BASE:Spawn( PointVec2 )
|
||||
--- Template method to spawn a new representation of the CARGO_BASE in the simulator.
|
||||
-- @param #CARGO_BASE self
|
||||
-- @return #CARGO_BASE
|
||||
function CARGO_BASE:Spawn( PointVec2 )
|
||||
self:F()
|
||||
|
||||
end
|
||||
|
||||
|
||||
--- Check if CargoCarrier is near the Cargo to be Loaded.
|
||||
-- @param #CARBO_BASE self
|
||||
-- @param #CARGO_BASE self
|
||||
-- @param Point#POINT_VEC2 PointVec2
|
||||
-- @return #boolean
|
||||
function CARBO_BASE:IsNear( PointVec2 )
|
||||
function CARGO_BASE:IsNear( PointVec2 )
|
||||
self:F( { PointVec2 } )
|
||||
|
||||
local Distance = PointVec2:DistanceFromPointVec2( self.CargoObject:GetPointVec2() )
|
||||
@@ -294,7 +294,7 @@ end
|
||||
do -- CARGO_REPRESENTABLE
|
||||
|
||||
--- @type CARGO_REPRESENTABLE
|
||||
-- @extends #CARBO_BASE
|
||||
-- @extends #CARGO_BASE
|
||||
CARGO_REPRESENTABLE = {
|
||||
ClassName = "CARGO_REPRESENTABLE"
|
||||
}
|
||||
@@ -309,7 +309,7 @@ do -- CARGO_REPRESENTABLE
|
||||
-- @param #number NearRadius (optional)
|
||||
-- @return #CARGO_REPRESENTABLE
|
||||
function CARGO_REPRESENTABLE:New( CargoObject, Type, Name, Weight, ReportRadius, NearRadius )
|
||||
local self = BASE:Inherit( self, CARBO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARBO_BASE
|
||||
local self = BASE:Inherit( self, CARGO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO_BASE
|
||||
self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
|
||||
|
||||
|
||||
@@ -338,7 +338,7 @@ function CARGO_REPRESENTABLE:RouteTo( ToPointVec2, Speed )
|
||||
return self
|
||||
end
|
||||
|
||||
end -- CARBO_BASE
|
||||
end -- CARGO_BASE
|
||||
|
||||
do -- CARGO_UNIT
|
||||
|
||||
@@ -816,7 +816,7 @@ end
|
||||
do -- CARGO_GROUP
|
||||
|
||||
--- @type CARGO_GROUP
|
||||
-- @extends Cargo#CARBO_BASE
|
||||
-- @extends Cargo#CARGO_BASE
|
||||
-- @field Set#SET_BASE CargoSet A set of cargo objects.
|
||||
-- @field #string Name A string defining the name of the cargo group. The name is the unique identifier of the cargo.
|
||||
CARGO_GROUP = {
|
||||
@@ -833,7 +833,7 @@ do -- CARGO_GROUP
|
||||
-- @param #number NearRadius (optional)
|
||||
-- @return #CARGO_GROUP
|
||||
function CARGO_GROUP:New( CargoSet, Type, Name, ReportRadius, NearRadius )
|
||||
local self = BASE:Inherit( self, CARBO_BASE:New( Type, Name, 0, ReportRadius, NearRadius ) ) -- #CARGO_GROUP
|
||||
local self = BASE:Inherit( self, CARGO_BASE:New( Type, Name, 0, ReportRadius, NearRadius ) ) -- #CARGO_GROUP
|
||||
self:F( { Type, Name, ReportRadius, NearRadius } )
|
||||
|
||||
self.CargoSet = CargoSet
|
||||
|
||||
@@ -349,7 +349,7 @@ function PATROLZONE:onenterRoute()
|
||||
self.Controllable:SetState( self.Controllable, "PatrolZone", self )
|
||||
self.Controllable:WayPointFunction( #PatrolRoute, 1, "_NewPatrolRoute" )
|
||||
|
||||
--- NOW ROUTE THE GROUP!
|
||||
--- NOW PROCESS_ROUTE THE GROUP!
|
||||
self.Controllable:WayPointExecute( 1 )
|
||||
|
||||
self:__Patrol( 30 )
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
--- The PROCESS class
|
||||
-- @type PROCESS
|
||||
-- @field Task#TASK_BASE ProcessTask
|
||||
-- @field Group#GROUP ProcessGroup
|
||||
-- @field Menu#MENU_GROUP MissionMenu
|
||||
-- @field Task#TASK_BASE Task
|
||||
-- @field #string ProcessName
|
||||
-- @extends StateMachine#STATEMACHINE_CONTROLLABLE
|
||||
PROCESS = {
|
||||
@@ -16,8 +16,8 @@ PROCESS = {
|
||||
--- Instantiates a new TASK Base. Should never be used. Interface Class.
|
||||
-- @param #PROCESS self
|
||||
-- @param #string ProcessName
|
||||
-- @param Unit#UNIT ProcessUnit
|
||||
-- @return #PROCESS self
|
||||
-- @param Unit#UNIT ProcessUnit (Optional) If provided, it defines the UNIT for which the process is running.
|
||||
-- @return #PROCESS
|
||||
function PROCESS:New( FSMT, ProcessName, ProcessUnit )
|
||||
local self = BASE:Inherit( self, STATEMACHINE_CONTROLLABLE:New( FSMT, ProcessUnit ) )
|
||||
self:F()
|
||||
@@ -32,13 +32,50 @@ function PROCESS:New( FSMT, ProcessName, ProcessUnit )
|
||||
return self
|
||||
end
|
||||
|
||||
--- Gets the Group of the process.
|
||||
-- @param #PROCESS self
|
||||
-- @return Group#GROUP
|
||||
function PROCESS:GetGroup()
|
||||
|
||||
return self.ProcessGroup
|
||||
end
|
||||
|
||||
--- Sets the task of the process.
|
||||
-- @param #PROCESS self
|
||||
-- @param Tasking.Task#TASK_BASE ProcessTask
|
||||
-- @return #PROCESS
|
||||
function PROCESS:SetTask( ProcessTask )
|
||||
|
||||
self.ProcessTask = ProcessTask
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- Gets the task of the process.
|
||||
-- @param #PROCESS self
|
||||
-- @return Task#TASK_BASE
|
||||
function PROCESS:GetTask()
|
||||
|
||||
return self.ProcessTask
|
||||
end
|
||||
|
||||
--- Gets the mission of the process.
|
||||
-- @param #PROCESS self
|
||||
-- @return Mission#MISSION
|
||||
function PROCESS:GetMission()
|
||||
|
||||
return self.ProcessTask.Mission
|
||||
end
|
||||
|
||||
--- Assign the process to a @{Unit} and activate the process.
|
||||
-- @param #PROCESS self
|
||||
-- @param Unit#UNIT ProcessUnit
|
||||
-- @return #PROCESS self
|
||||
function PROCESS:Assign( ProcessUnit )
|
||||
function PROCESS:Assign( ProcessTask, ProcessUnit )
|
||||
|
||||
self:SetControllable( ProcessUnit )
|
||||
self:SetTask( ProcessTask )
|
||||
|
||||
self.ProcessGroup = ProcessUnit:GetGroup()
|
||||
--self:Activate()
|
||||
|
||||
|
||||
@@ -1,109 +0,0 @@
|
||||
--- @module Process_Smoke
|
||||
|
||||
do -- PROCESS_SMOKE_TARGETS
|
||||
|
||||
--- PROCESS_SMOKE_TARGETS class
|
||||
-- @type PROCESS_SMOKE_TARGETS
|
||||
-- @field Task#TASK_BASE Task
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Set#SET_UNIT TargetSetUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Task2#TASK2
|
||||
PROCESS_SMOKE_TARGETS = {
|
||||
ClassName = "PROCESS_SMOKE_TARGETS",
|
||||
}
|
||||
|
||||
|
||||
--- 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_SMOKE_TARGETS self
|
||||
-- @param Task#TASK Task
|
||||
-- @param Unit#UNIT Unit
|
||||
-- @return #PROCESS_SMOKE_TARGETS self
|
||||
function PROCESS_SMOKE_TARGETS:New( Task, ProcessUnit, TargetSetUnit, TargetZone )
|
||||
|
||||
local FSMT = {
|
||||
initial = 'None',
|
||||
events = {
|
||||
{ name = 'Start', from = 'None', to = 'AwaitSmoke' },
|
||||
{ name = 'Next', from = 'AwaitSmoke', to = 'Smoking' },
|
||||
{ name = 'Next', from = 'Smoking', to = 'AwaitSmoke' },
|
||||
{ name = 'Fail', from = 'Smoking', to = 'Failed' },
|
||||
{ name = 'Fail', from = 'AwaitSmoke', to = 'Failed' },
|
||||
{ name = 'Fail', from = 'None', to = 'Failed' },
|
||||
},
|
||||
callbacks = {
|
||||
onStart = self.OnStart,
|
||||
onNext = self.OnNext,
|
||||
onSmoking = self.OnSmoking,
|
||||
},
|
||||
endstates = {
|
||||
},
|
||||
}
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, PROCESS:New( FSMT, ProcessUnit, "SMOKE_TARGETS" ) ) -- #PROCESS_SMOKE_TARGETS
|
||||
|
||||
self.TargetSetUnit = TargetSetUnit
|
||||
self.TargetZone = TargetZone
|
||||
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #PROCESS_SMOKE_TARGETS self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function PROCESS_SMOKE_TARGETS:OnStart( ProcessUnit, Event, From, To )
|
||||
self:E( { Event, From, To, ProcessUnit.UnitName} )
|
||||
|
||||
self:E("Set smoke menu")
|
||||
|
||||
local ProcessGroup = ProcessUnit:GetGroup()
|
||||
--local MissionMenu = self.Task.Mission: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
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #PROCESS_SMOKE_TARGETS self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function PROCESS_SMOKE_TARGETS:OnSmoking( ProcessUnit, Event, From, To )
|
||||
self:E( { Event, From, To, ProcessUnit.UnitName} )
|
||||
|
||||
self.TargetSetUnit:ForEachUnit(
|
||||
--- @param 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
|
||||
@@ -1,233 +0,0 @@
|
||||
--- (SP) (MP) (FSM) Route AI or players through waypoints or to zones.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- # @{#ROUTE} FSM class, extends @{Process#PROCESS}
|
||||
--
|
||||
-- ## 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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.
|
||||
--
|
||||
-- ### 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) @{#ROUTE_ZONE} class, extends @{Route#ROUTE}
|
||||
--
|
||||
-- The 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) ROUTE_ZONE constructor:
|
||||
--
|
||||
-- * @{#ROUTE_ZONE.New}(): Creates a new ROUTE_ZONE object.
|
||||
--
|
||||
-- ===
|
||||
--
|
||||
-- @module Route
|
||||
|
||||
|
||||
do -- ROUTE
|
||||
|
||||
--- ROUTE class
|
||||
-- @type ROUTE
|
||||
-- @field Task#TASK TASK
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Task2#TASK2
|
||||
ROUTE = {
|
||||
ClassName = "ROUTE",
|
||||
}
|
||||
|
||||
|
||||
--- Creates a new routing state machine. The task will route a CLIENT to a ZONE until the CLIENT is within that ZONE.
|
||||
-- @param #ROUTE self
|
||||
-- @return #ROUTE self
|
||||
function ROUTE:New()
|
||||
|
||||
|
||||
local FSMT = {
|
||||
initial = 'None',
|
||||
events = {
|
||||
{ name = 'Start', from = 'None', to = 'Routing' },
|
||||
{ name = 'Report', from = '*', to = 'Reporting' },
|
||||
{ name = 'Route', from = '*', to = 'Routing' },
|
||||
{ name = 'Pause', from = 'Routing', to = 'Pausing' },
|
||||
{ name = 'Abort', from = '*', to = 'Aborted' },
|
||||
{ name = 'Arrive', from = 'Routing', to = 'Arrived' },
|
||||
{ name = 'Success', from = 'Arrived', to = 'Success' },
|
||||
{ name = 'Fail', from = '*', to = 'Failed' },
|
||||
},
|
||||
endstates = {
|
||||
'Arrived', 'Failed', 'Success'
|
||||
},
|
||||
}
|
||||
|
||||
-- Inherits from BASE
|
||||
local self = BASE:Inherit( self, PROCESS:New( FSMT, "ROUTE" ) ) -- #ROUTE
|
||||
|
||||
self.DisplayInterval = 30
|
||||
self.DisplayCount = 30
|
||||
self.DisplayMessage = true
|
||||
self.DisplayTime = 10 -- 10 seconds is the default
|
||||
self.DisplayCategory = "HQ" -- Route is the default display category
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- Task Events
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ROUTE self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ROUTE:onafterStart( ProcessUnit, Event, From, To )
|
||||
|
||||
self:__Route( 1 )
|
||||
end
|
||||
|
||||
--- Check if the controllable has arrived.
|
||||
-- @param #ROUTE self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @return #boolean
|
||||
function ROUTE:HasArrived( ProcessUnit )
|
||||
return false
|
||||
end
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ROUTE self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function ROUTE:onafterRoute( ProcessUnit, Event, From, To )
|
||||
|
||||
if ProcessUnit:IsAlive() then
|
||||
local HasArrived = self:HasArrived( ProcessUnit )
|
||||
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 } )
|
||||
self:__Route( 1 )
|
||||
|
||||
return HasArrived -- if false, then the event will not be executed...
|
||||
end
|
||||
|
||||
return false
|
||||
|
||||
end
|
||||
|
||||
end -- ROUTE
|
||||
|
||||
|
||||
|
||||
do -- ROUTE_ZONE
|
||||
|
||||
--- ROUTE_ZONE class
|
||||
-- @type ROUTE_ZONE
|
||||
-- @field Task#TASK TASK
|
||||
-- @field Unit#UNIT ProcessUnit
|
||||
-- @field Zone#ZONE_BASE TargetZone
|
||||
-- @extends Task2#TASK2
|
||||
ROUTE_ZONE = {
|
||||
ClassName = "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 #ROUTE_ZONE self
|
||||
-- @param Zone#ZONE_BASE TargetZone
|
||||
-- @return #ROUTE_ZONE self
|
||||
function ROUTE_ZONE:New( TargetZone )
|
||||
|
||||
local self = BASE:Inherit( self, ROUTE:New() ) -- #ROUTE_ZONE
|
||||
|
||||
self.TargetZone = TargetZone
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
--- Method override to check if the controllable has arrived.
|
||||
-- @param #ROUTE self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @return #boolean
|
||||
function ROUTE_ZONE:HasArrived( ProcessUnit )
|
||||
return ProcessUnit:IsInZone( self.TargetZone )
|
||||
end
|
||||
|
||||
--- Task Events
|
||||
|
||||
--- StateMachine callback function
|
||||
-- @param #ROUTE_ZONE self
|
||||
-- @param Controllable#CONTROLLABLE ProcessUnit
|
||||
-- @param #string Event
|
||||
-- @param #string From
|
||||
-- @param #string To
|
||||
function 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 = ProcessUnit:GetCallsign() .. ": Route to " .. TaskUnitPointVec2:GetBRText( ZonePointVec2 ) .. " km to target."
|
||||
MESSAGE:New( RouteText, self.DisplayTime, self.DisplayCategory ):ToGroup( ProcessUnit:GetGroup() )
|
||||
end
|
||||
|
||||
end -- ROUTE_ZONE
|
||||
Reference in New Issue
Block a user