From 9c4b147b6bab21fa8f5698dd95046692b9283431 Mon Sep 17 00:00:00 2001 From: FlightControl Date: Wed, 30 Nov 2016 12:00:32 +0100 Subject: [PATCH] First incomplete version --- Moose Development/Moose/Core/StateMachine.lua | 129 ++++++++++++++---- Moose Development/Moose/Fsm/Process.lua | 42 ------ Moose Development/Moose/Process/Account.lua | 57 ++++---- Moose Development/Moose/Process/Assign.lua | 51 ++++--- Moose Development/Moose/Process/Route.lua | 55 ++++---- Moose Development/Moose/Process/Smoke.lua | 41 +++--- Moose Development/Moose/Tasking/Task.lua | 28 +--- .../Moose_Test_Task_SEAD.lua | 17 +-- 8 files changed, 222 insertions(+), 198 deletions(-) diff --git a/Moose Development/Moose/Core/StateMachine.lua b/Moose Development/Moose/Core/StateMachine.lua index 7220b8a97..1cdf636d7 100644 --- a/Moose Development/Moose/Core/StateMachine.lua +++ b/Moose Development/Moose/Core/StateMachine.lua @@ -26,7 +26,7 @@ STATEMACHINE = { --- Creates a new STATEMACHINE object. -- @param #STATEMACHINE self -- @return #STATEMACHINE -function STATEMACHINE:New( options ) +function STATEMACHINE:New( FsmT ) -- Inherits from BASE local self = BASE:Inherit( self, BASE:New() ) @@ -40,6 +40,34 @@ function STATEMACHINE:New( options ) --setmetatable( self, MT ) --self.__index = self + for TransitionID, Transition in pairs( FsmT:GetTransitions() ) do + self:AddAction( Transition.From, Transition.Event, Transition.To ) + self.FsmT:CopyCallHandler( self, "onenter", Transition.From ) + self.FsmT:CopyCallHandler( self, "onleave", Transition.From ) + self.FsmT:CopyCallHandler( self, "onenter", Transition.To ) + self.FsmT:CopyCallHandler( self, "onleave", Transition.To ) + self.FsmT:CopyCallHandler( self, "onbefore", Transition.Event ) + self.FsmT:CopyCallHandler( self, "onafter", Transition.Event ) + end + + for ProcessID, Process in pairs( self.FsmT:GetProcesses() ) do + self:E( Process ) + local FsmProcess = self:AddProcess(Process.From, Process.Event, Process.Process:New( unpack( Process.Arguments ) ), Process.ReturnEvents ) + self.FsmT:CopyCallHandler( FsmProcess, "onenter", Process.From ) + self.FsmT:CopyCallHandler( FsmProcess, "onleave", Process.From ) + self.FsmT:CopyCallHandler( FsmProcess, "onbefore", Process.Event ) + self.FsmT:CopyCallHandler( FsmProcess, "onafter", Process.Event ) + + end + + for EndStateID, EndState in pairs( FsmT:EndStates() ) do + self:E( EndState ) + self:AddEndState( EndState ) + end + + self:SetStartState( FsmT:GetStartState() ) + + self.options = options or {} self.options.subs = self.options.subs or {} self.current = self.options.initial or 'none' @@ -47,26 +75,6 @@ function STATEMACHINE:New( options ) self.subs = {} self.endstates = {} - for _, event in pairs( self.options.events or {}) do - self:T3({ "events", event }) - self:_eventmap( self.events, event ) - end - - for name, callback in pairs( self.options.callbacks or {}) do - self:T3("callbacks") - self[name] = callback - end - - for name, sub in pairs( self.options.subs or {} ) do - self:T3("sub") - self:_submap( self.subs, sub, name ) - end - - for name, endstate in pairs( self.options.endstates or {} ) do - self:T3("endstate") - self.endstates[endstate] = endstate - end - return self end @@ -76,7 +84,7 @@ end -function STATEMACHINE:AddAction( From, Event, To ) +function STATEMACHINE:AddTransition( From, Event, To ) local event = {} event.from = From @@ -113,6 +121,10 @@ function STATEMACHINE:AddProcess( From, Event, Process, ReturnEvents ) return Process end +function STATEMACHINE:AddEndState( State ) + self.endstates[State] = State +end + function STATEMACHINE:GetSubs() return self.options.subs @@ -467,6 +479,31 @@ function STATEMACHINE_PROCESS:onenterSuccess( ProcessUnit ) self.Task:Success() end +--- StateMachine callback function for a STATEMACHINE_PROCESS +-- @param #STATEMACHINE_PROCESS self +-- @param Controllable#CONTROLLABLE ProcessUnit +-- @param #string Event +-- @param #string From +-- @param #string To +function STATEMACHINE_PROCESS:onstatechange( ProcessUnit, Event, From, To, Dummy ) + self:E( { ProcessUnit, Event, From, To, Dummy } ) + + if self:IsTrace() then + MESSAGE:New( "Process " .. self.ProcessName .. " : " .. Event .. " changed to state " .. To, 15 ):ToAll() + end + + self:E( self.Scores[To] ) + -- TODO: This needs to be reworked with a callback functions allocated within Task, and set within the mission script from the Task Objects... + if self.Scores[To] then + + local Task = self.Task + local Scoring = Task:GetScoring() + if Scoring then + Scoring:_AddMissionTaskScore( Task.Mission, ProcessUnit, self.Scores[To].ScoreText, self.Scores[To].Score ) + end + end +end + --- STATEMACHINE_TASK class -- @type STATEMACHINE_TASK -- @field Task#TASK_BASE Task @@ -559,13 +596,17 @@ STATEMACHINE_TEMPLATE = { --- Creates a new STATEMACHINE_TEMPLATE object. -- @param #STATEMACHINE_TEMPLATE self -- @return #STATEMACHINE_TEMPLATE -function STATEMACHINE_TEMPLATE:New( options ) +function STATEMACHINE_TEMPLATE:New( Name ) -- Inherits from BASE local self = BASE:Inherit( self, BASE:New() ) -- #STATEMACHINE_TEMPLATE self._Transitions = self.Transitions or {} self._Processes = self.Processes or {} + self._EndStates = self.EndStates or {} + self._StartState = "none" + + self._Name = Name return self end @@ -587,13 +628,13 @@ end --- Set the default @{Process} template with key ProcessName providing the ProcessClass and the process object when it is assigned to a @{Controllable} by the task. -- @return Process#PROCESS -function STATEMACHINE_TEMPLATE:AddProcess( From, Event, ProcessTemplate, ReturnEvents ) +function STATEMACHINE_TEMPLATE:AddProcess( From, Event, ProcessTemplate, ProcessArguments, ReturnEvents ) local Process = {} Process.From = From Process.Event = Event - Process.Process = ProcessTemplate[1] - Process.Arguments = ProcessTemplate[2] + Process.Process = ProcessTemplate + Process.Arguments = ProcessArguments Process.ReturnEvents = ReturnEvents -- Make the reference table weak. @@ -608,6 +649,42 @@ function STATEMACHINE_TEMPLATE:GetProcesses() return self._Processes end +function STATEMACHINE_TEMPLATE:AddEndState( State ) + + self._EndStates[EndState] = EndState +end + +function STATEMACHINE_TEMPLATE:GetEndStates() + + return self._EndStates +end + +function STATEMACHINE_TEMPLATE:AddStartState() + + self._StartState = StartState +end + +function STATEMACHINE_TEMPLATE:GetStartState() + + return self._StartState +end + +--- Adds a score for the STATEMACHINE_PROCESS to be achieved. +-- @param #STATEMACHINE_TEMPLATE self +-- @param #string State is the state of the process when the score needs to be given. (See the relevant state descriptions of the process). +-- @param #string ScoreText is a text describing the score that is given according the status. +-- @param #number Score is a number providing the score of the status. +-- @return #STATEMACHINE_TEMPLATE self +function STATEMACHINE_TEMPLATE:AddScore( State, ScoreText, Score ) + self:F2( { State, ScoreText, Score } ) + + self.Scores[State] = self.Scores[State] or {} + self.Scores[State].ScoreText = ScoreText + self.Scores[State].Score = Score + + return self +end + function STATEMACHINE_TEMPLATE:CopyCallHandler( Fsm, OnAction, Transition ) self:E( { Fsm.ClassName, OnAction, Transition } ) if OnAction and Transition and self[OnAction .. Transition] then diff --git a/Moose Development/Moose/Fsm/Process.lua b/Moose Development/Moose/Fsm/Process.lua index 4b180ea1b..b35a7350d 100644 --- a/Moose Development/Moose/Fsm/Process.lua +++ b/Moose Development/Moose/Fsm/Process.lua @@ -43,45 +43,3 @@ end ---- Adds a score for the PROCESS to be achieved. --- @param #PROCESS self --- @param #string ProcessStatus is the state of the process when the score needs to be given. (See the relevant state descriptions of the process). --- @param #string ScoreText is a text describing the score that is given according the status. --- @param #number Score is a number providing the score of the status. --- @return #PROCESS self -function PROCESS:AddScore( ProcessStatus, ScoreText, Score ) - self:F2( { ProcessStatus, ScoreText, Score } ) - - self.Scores[ProcessStatus] = self.Scores[ProcessStatus] or {} - self.Scores[ProcessStatus].ScoreText = ScoreText - self.Scores[ProcessStatus].Score = Score - - return self -end - ---- StateMachine callback function for a PROCESS --- @param #PROCESS self --- @param Controllable#CONTROLLABLE ProcessUnit --- @param #string Event --- @param #string From --- @param #string To -function PROCESS:onstatechange( ProcessUnit, Event, From, To, Dummy ) - self:E( { ProcessUnit, Event, From, To, Dummy } ) - - if self:IsTrace() then - MESSAGE:New( "Process " .. self.ProcessName .. " : " .. Event .. " changed to state " .. To, 15 ):ToAll() - end - - self:E( self.Scores[To] ) - -- TODO: This needs to be reworked with a callback functions allocated within Task, and set within the mission script from the Task Objects... - if self.Scores[To] then - - local Task = self.Task - local Scoring = Task:GetScoring() - if Scoring then - Scoring:_AddMissionTaskScore( Task.Mission, ProcessUnit, self.Scores[To].ScoreText, self.Scores[To].Score ) - end - end -end - - diff --git a/Moose Development/Moose/Process/Account.lua b/Moose Development/Moose/Process/Account.lua index 581e99368..7b2257204 100644 --- a/Moose Development/Moose/Process/Account.lua +++ b/Moose Development/Moose/Process/Account.lua @@ -77,7 +77,7 @@ do -- PROCESS_ACCOUNT --- PROCESS_ACCOUNT class -- @type PROCESS_ACCOUNT -- @field Set#SET_UNIT TargetSetUnit - -- @extends Fsm.Process#PROCESS + -- @extends Core.StateMachine#STATEMACHINE_TEMPLATE PROCESS_ACCOUNT = { ClassName = "PROCESS_ACCOUNT", TargetSetUnit = nil, @@ -87,24 +87,31 @@ do -- PROCESS_ACCOUNT -- @param #PROCESS_ACCOUNT self -- @return #PROCESS_ACCOUNT function PROCESS_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 = 'Accounted' }, - { name = 'Fail', from = '*', to = 'Failed' }, - }, - endstates = { 'Accounted', 'Failed' } - } - + -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS:New( FSMT, "PROCESS_ACCOUNT" ) ) -- #PROCESS_ACCOUNT + local self = BASE:Inherit( self, STATEMACHINE_TEMPLATE:New( "PROCESS_ACCOUNT" ) ) -- Core.StateMachine#STATEMACHINE_TEMPLATE + + 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:AddStartState( "Assigned" ) + + return self + end + + --- Creates a new DESTROY process. + -- @param #PROCESS_ACCOUNT self + -- @return #PROCESS_ACCOUNT + function PROCESS_ACCOUNT:Init() + self.DisplayInterval = 30 self.DisplayCount = 30 self.DisplayMessage = true @@ -166,7 +173,7 @@ do -- PROCESS_ACCOUNT_DEADS --- PROCESS_ACCOUNT_DEADS class -- @type PROCESS_ACCOUNT_DEADS -- @field Set#SET_UNIT TargetSetUnit - -- @extends Process#PROCESS + -- @extends #PROCESS_ACCOUNT PROCESS_ACCOUNT_DEADS = { ClassName = "PROCESS_ACCOUNT_DEADS", TargetSetUnit = nil, @@ -177,8 +184,11 @@ do -- PROCESS_ACCOUNT_DEADS -- @param #PROCESS_ACCOUNT_DEADS self -- @param Set#SET_UNIT TargetSetUnit -- @param #string TaskName - function PROCESS_ACCOUNT_DEADS:Template( TargetSetUnit, TaskName ) - return { self, { TargetSetUnit, TaskName } } + function PROCESS_ACCOUNT_DEADS:New( TargetSetUnit, TaskName ) + -- Inherits from BASE + local self = BASE:Inherit( self, PROCESS_ACCOUNT:New() ) -- #PROCESS_ACCOUNT_DEADS + + return self, { TargetSetUnit, TaskName } end @@ -187,11 +197,8 @@ do -- PROCESS_ACCOUNT_DEADS -- @param Set#SET_UNIT TargetSetUnit -- @param #string TaskName -- @return #PROCESS_ACCOUNT_DEADS self - function PROCESS_ACCOUNT_DEADS:New( TargetSetUnit, TaskName ) + function PROCESS_ACCOUNT_DEADS:Init( TargetSetUnit, TaskName ) - -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS_ACCOUNT:New() ) -- #PROCESS_ACCOUNT_DEADS - self.TargetSetUnit = TargetSetUnit self.TaskName = TaskName @@ -268,4 +275,4 @@ do -- PROCESS_ACCOUNT_DEADS end end -end -- PROCESS_ACCOUNT DEADS \ No newline at end of file +end -- PROCESS_ACCOUNT DEADS diff --git a/Moose Development/Moose/Process/Assign.lua b/Moose Development/Moose/Process/Assign.lua index 0724d55d6..ac7ef2c0b 100644 --- a/Moose Development/Moose/Process/Assign.lua +++ b/Moose Development/Moose/Process/Assign.lua @@ -87,7 +87,7 @@ do -- PROCESS_ASSIGN -- @field Tasking.Task#TASK_BASE Task -- @field Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends Fsm.Process#PROCESS + -- @extends Core.StateMachine#STATEMACHINE_TEMPLATE PROCESS_ASSIGN = { ClassName = "PROCESS_ASSIGN", } @@ -98,21 +98,19 @@ do -- PROCESS_ASSIGN -- @return #PROCESS_ASSIGN The task acceptance process. function PROCESS_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, "PROCESS_ASSIGN" ) ) -- #PROCESS_ASSIGN + local self = BASE:Inherit( self, STATEMACHINE_TEMPLATE:New( "PROCESS_ASSIGN" ) ) -- Core.StateMachine#STATEMACHINE_TEMPLATE + + 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:AddStartState( "UnAssigned" ) return self end @@ -137,8 +135,11 @@ do -- PROCESS_ASSIGN_ACCEPT --- Creates a new task assignment state machine. The process will accept the task by default, no player intervention accepted. -- @param #PROCESS_ASSIGN_ACCEPT self -- @param #string TaskBriefing - function PROCESS_ASSIGN_ACCEPT:Template( TaskBriefing ) - return { self, { TaskBriefing } } + function PROCESS_ASSIGN_ACCEPT:New( TaskBriefing ) + -- Inherits from BASE + local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_ACCEPT + + return self, { TaskBriefing } end @@ -146,10 +147,8 @@ do -- PROCESS_ASSIGN_ACCEPT -- @param #PROCESS_ASSIGN_ACCEPT self -- @param #string TaskBriefing -- @return #PROCESS_ASSIGN_ACCEPT The task acceptance process. - function PROCESS_ASSIGN_ACCEPT:New( TaskBriefing ) + function PROCESS_ASSIGN_ACCEPT:Init( TaskBriefing ) - -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_ACCEPT self.TaskBriefing = TaskBriefing @@ -208,9 +207,12 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT -- @param #string TaskName -- @param #string TaskBriefing -- @return #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:Template( TaskName, TaskBriefing ) + function PROCESS_ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing ) + + -- Inherits from BASE + local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_MENU_ACCEPT - return { self, { TaskName, TaskBriefing } } + return self, { TaskName, TaskBriefing } end @@ -219,11 +221,8 @@ do -- PROCESS_ASSIGN_MENU_ACCEPT -- @param #string TaskName -- @param #string TaskBriefing -- @return #PROCESS_ASSIGN_MENU_ACCEPT self - function PROCESS_ASSIGN_MENU_ACCEPT:New( TaskName, TaskBriefing ) + function PROCESS_ASSIGN_MENU_ACCEPT:Init( TaskName, TaskBriefing ) - -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS_ASSIGN:New() ) -- #PROCESS_ASSIGN_MENU_ACCEPT - self.TaskBriefing = TaskBriefing self.TaskName = TaskName diff --git a/Moose Development/Moose/Process/Route.lua b/Moose Development/Moose/Process/Route.lua index a5ad80715..ac743b19c 100644 --- a/Moose Development/Moose/Process/Route.lua +++ b/Moose Development/Moose/Process/Route.lua @@ -82,7 +82,7 @@ do -- PROCESS_ROUTE -- @field Task#TASK TASK -- @field Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends Fsm.Process#PROCESS + -- @extends Core.StateMachine#STATEMACHINE_TEMPLATE PROCESS_ROUTE = { ClassName = "PROCESS_ROUTE", } @@ -92,28 +92,31 @@ do -- PROCESS_ROUTE -- @param #PROCESS_ROUTE self -- @return #PROCESS_ROUTE self function PROCESS_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' - }, - } - + -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS:New( FSMT, "PROCESS_ROUTE" ) ) -- #PROCESS_ROUTE + local self = BASE:Inherit( self, STATEMACHINE_TEMPLATE:New( "PROCESS_ROUTE" ) ) -- Core.StateMachine#STATEMACHINE_TEMPLATE + + 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:AddStartState( "None" ) + + return self + end + + function PROCESS_ROUTE:Init() + self.DisplayInterval = 30 self.DisplayCount = 30 self.DisplayMessage = true @@ -190,7 +193,7 @@ do -- PROCESS_ROUTE_ZONE -- @field Task#TASK TASK -- @field Unit#UNIT ProcessUnit -- @field Zone#ZONE_BASE TargetZone - -- @extends Process.Route#PROCESS_ROUTE + -- @extends #PROCESS_ROUTE PROCESS_ROUTE_ZONE = { ClassName = "PROCESS_ROUTE_ZONE", } @@ -199,8 +202,10 @@ do -- PROCESS_ROUTE_ZONE --- Creates a new routing state machine. The task will route a controllable to a ZONE until the controllable is within that ZONE. -- @param #PROCESS_ROUTE_ZONE self -- @param Zone#ZONE_BASE TargetZone - function PROCESS_ROUTE_ZONE:Template( TargetZone ) - return { self, { TargetZone } } + function PROCESS_ROUTE_ZONE:New( TargetZone ) + local self = BASE:Inherit( self, PROCESS_ROUTE:New() ) -- #PROCESS_ROUTE_ZONE + + return self, { TargetZone } end @@ -210,8 +215,6 @@ do -- PROCESS_ROUTE_ZONE -- @return #PROCESS_ROUTE_ZONE self function PROCESS_ROUTE_ZONE:New( TargetZone ) - local self = BASE:Inherit( self, PROCESS_ROUTE:New() ) -- #PROCESS_ROUTE_ZONE - self.TargetZone = TargetZone return self diff --git a/Moose Development/Moose/Process/Smoke.lua b/Moose Development/Moose/Process/Smoke.lua index 4cad8227c..653d27ca2 100644 --- a/Moose Development/Moose/Process/Smoke.lua +++ b/Moose Development/Moose/Process/Smoke.lua @@ -70,7 +70,7 @@ do -- PROCESS_SMOKE --- PROCESS_SMOKE class -- @type PROCESS_SMOKE - -- @extends Fsm.Process#PROCESS + -- @extends Core.StateMachine#STATEMACHINE_TEMPLATE PROCESS_SMOKE = { ClassName = "PROCESS_SMOKE", } @@ -79,26 +79,21 @@ do -- PROCESS_SMOKE -- @param #PROCESS_SMOKE self -- @return #PROCESS_SMOKE function PROCESS_SMOKE:New() - - local FSMT = { - initial = 'None', - events = { - { name = 'Start', from = 'None', to = 'AwaitSmoke' }, - { name = 'Next', from = 'AwaitSmoke', to = 'Smoking' }, - { name = 'Next', from = 'Smoking', to = 'AwaitSmoke' }, - { name = 'Stop', from = '*', to = 'Success' }, - { name = 'Fail', from = 'Smoking', to = 'Failed' }, - { name = 'Fail', from = 'AwaitSmoke', to = 'Failed' }, - { name = 'Fail', from = 'None', to = 'Failed' }, - }, - endstates = { - 'Failed', 'Success' - }, - } -- Inherits from BASE - local self = BASE:Inherit( self, PROCESS:New( FSMT, "PROCESS_SMOKE" ) ) -- #PROCESS_SMOKE + local self = BASE:Inherit( self, STATEMACHINE_TEMPLATE:New( "PROCESS_SMOKE" ) ) -- Core.StateMachine#STATEMACHINE_TEMPLATE + + 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:AddStartState( "None" ) + return self end @@ -155,8 +150,10 @@ do -- PROCESS_SMOKE_TARGETS_ZONE -- @param #PROCESS_SMOKE_TARGETS_ZONE self -- @param Set#SET_UNIT TargetSetUnit -- @param Zone#ZONE_BASE TargetZone - function PROCESS_SMOKE_TARGETS_ZONE:Template( TargetSetUnit, TargetZone ) - return { self, { TargetSetUnit, TargetZone } } + function PROCESS_SMOKE_TARGETS_ZONE:New( TargetSetUnit, TargetZone ) + local self = BASE:Inherit( self, PROCESS_SMOKE:New() ) -- #PROCESS_SMOKE + + return self, { TargetSetUnit, 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. @@ -164,9 +161,7 @@ do -- PROCESS_SMOKE_TARGETS_ZONE -- @param Set#SET_UNIT TargetSetUnit -- @param Zone#ZONE_BASE TargetZone -- @return #PROCESS_SMOKE_TARGETS_ZONE self - function PROCESS_SMOKE_TARGETS_ZONE:New( TargetSetUnit, TargetZone ) - - local self = BASE:Inherit( self, PROCESS_SMOKE:New() ) -- #PROCESS_SMOKE + function PROCESS_SMOKE_TARGETS_ZONE:Init( TargetSetUnit, TargetZone ) self.TargetSetUnit = TargetSetUnit self.TargetZone = TargetZone diff --git a/Moose Development/Moose/Tasking/Task.lua b/Moose Development/Moose/Tasking/Task.lua index c0c4974af..7670b2d28 100644 --- a/Moose Development/Moose/Tasking/Task.lua +++ b/Moose Development/Moose/Tasking/Task.lua @@ -186,8 +186,10 @@ function TASK_BASE:AssignToUnit( TaskUnit ) self:F( TaskUnit:GetName() ) -- Assign a new FsmUnit to TaskUnit. - local FsmUnit = self:SetStateMachine( TaskUnit, STATEMACHINE_PROCESS:New() ) -- Core.StateMachine#STATEMACHINE_PROCESS + local FsmUnit = self:SetStateMachine( TaskUnit, STATEMACHINE_PROCESS:New( self:GetFsmTemplate() ) ) -- Core.StateMachine#STATEMACHINE_PROCESS self:E({"Address FsmUnit", tostring( FsmUnit ) } ) + + --TODO: need to check all this with templates ... FsmUnit:Assign( self, TaskUnit ) for TransitionID, Transition in pairs( self.FsmTemplate:GetTransitions() ) do @@ -711,12 +713,12 @@ end --- Adds a score for the TASK to be achieved. --- @param #TASK_BASE self +-- @param #STATEMACHINE_TEMPLATE self -- @param #string TaskStatus is the status of the TASK when the score needs to be given. -- @param #string ScoreText is a text describing the score that is given according the status. -- @param #number Score is a number providing the score of the status. --- @return #TASK_BASE self -function TASK_BASE:AddScoreTask( TaskStatus, ScoreText, Score ) +-- @return #STATEMACHINE_TEMPLATE self +function STATEMACHINE_TEMPLATE:AddScoreTask( TaskStatus, ScoreText, Score ) self:F2( { TaskStatus, ScoreText, Score } ) self.Scores[TaskStatus] = self.Scores[TaskStatus] or {} @@ -725,24 +727,6 @@ function TASK_BASE:AddScoreTask( TaskStatus, ScoreText, Score ) return self end ---- Adds a score for the TASK to be achieved. --- @param #TASK_BASE self --- @param #string TaskStatus is the status of the TASK when the score needs to be given. --- @param #string ScoreText is a text describing the score that is given according the status. --- @param #number Score is a number providing the score of the status. --- @return #TASK_BASE self -function TASK_BASE:AddScoreProcess( Event, State, ScoreText, Score ) - self:F2( { State, ScoreText, Score } ) - - - self:E( self:GetFsmTemplate():GetSubs()[Event].fsm ) - local Process = self:GetFsmTemplate():GetSubs()[Event].fsm - - Process:AddScore( State, ScoreText, Score ) - - return self -end - --- StateMachine callback function for a TASK -- @param #TASK_BASE self diff --git a/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua b/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua index dfd3b5721..341b9130d 100644 --- a/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua +++ b/Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua @@ -75,10 +75,10 @@ local FsmSEADTemplate = TaskSEAD:GetFsmTemplate() -- 4.1 When the return state is Assigned, fire the event in the Task FsmSEAD:Route() -- 4.2 When the return state is Rejected, fire the event in the Task FsmSEAD:Eject() -- All other AddProcess calls are working in a similar manner. -FsmSEADTemplate:AddProcess ( "Planned", "Accept", PROCESS_ASSIGN_ACCEPT:Template( "SEAD the Area" ), { Assigned = "Route", Rejected = "Eject" } ) +FsmSEADTemplate:AddProcess ( "Planned", "Accept", PROCESS_ASSIGN_ACCEPT:Init( "SEAD the Area" ), { Assigned = "Route", Rejected = "Eject" } ) -- Same, adding a process. -FsmSEADTemplate:AddProcess ( "Assigned", "Route", PROCESS_ROUTE_ZONE:Template( TargetZone, 3000 ), { Arrived = "Update" } ) +FsmSEADTemplate:AddProcess ( "Assigned", "Route", PROCESS_ROUTE_ZONE:Init( TargetZone, 3000 ), { Arrived = "Update" } ) -- Adding a new Action... -- Actions define also the flow of the Task, but the actions will need to be programmed within your script. @@ -89,18 +89,19 @@ FsmSEADTemplate:AddProcess ( "Assigned", "Route", PROCESS_ROUTE_ZONE:Tem -- 3. State To "Planned". After the event has been fired, the FsmSEAD will transition to Planned. FsmSEADTemplate:AddTransition ( "Rejected", "Eject", "Planned" ) FsmSEADTemplate:AddTransition ( "Arrived", "Update", "Updated" ) -FsmSEADTemplate:AddProcess ( "Updated", "Account", PROCESS_ACCOUNT_DEADS:Template( TargetSet, "SEAD" ), { Accounted = "Success" } ) -FsmSEADTemplate:AddProcess ( "Updated", "Smoke", PROCESS_SMOKE_TARGETS_ZONE:Template( TargetSet, TargetZone ) ) +FsmSEADTemplate:AddProcess ( "Updated", "Account", PROCESS_ACCOUNT_DEADS:Init( TargetSet, "SEAD" ), { Accounted = "Success" } ) +FsmSEADTemplate:AddProcess ( "Updated", "Smoke", PROCESS_SMOKE_TARGETS_ZONE:Init( TargetSet, TargetZone ) ) FsmSEADTemplate:AddTransition ( "Accounted", "Success", "Success" ) FsmSEADTemplate:AddTransition ( "*", "Fail", "Failed" ) +TaskSEAD:AddScoreProcess( "Account", "Account", "destroyed a radar", 25 ) +TaskSEAD:AddScoreProcess( "Account", "Failed", "failed to destroy a radar", -10 ) + -- Now we will set the SCORING. Scoring is set using the TaskSEAD object. -- Scores can be set on the status of the Task, and on Process level. ---FsmSEADTemplate:AddScoreTask( "Success", "Destroyed all target radars", 250 ) ---FsmSEADTemplate:AddScoreTask( "Failed", "Failed to destroy all target radars", -100 ) +FsmSEADTemplate:AddScoreTask( "Success", "Destroyed all target radars", 250 ) +FsmSEADTemplate:AddScoreTask( "Failed", "Failed to destroy all target radars", -100 ) ---TaskSEAD:AddScoreProcess( "Account", "Account", "destroyed a radar", 25 ) ---TaskSEAD:AddScoreProcess( "Account", "Failed", "failed to destroy a radar", -10 )