FlightControl-Master/MOOSE
1
0
Fork 0
mirror of https://github.com/FlightControl-Master/MOOSE.git synced 2025-10-29 16:58:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

First incomplete version

Browse Source
This commit is contained in:
FlightControl 2016-11-30 12:00:32 +01:00
parent 9ab3a2f74d
commit 9c4b147b6b
8 changed files with 222 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
Moose Development/Moose/Core/StateMachine.lua
View File

@ -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

42
Moose Development/Moose/Fsm/Process.lua
View File

@ -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

57
Moose Development/Moose/Process/Account.lua
View File

@ -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
end -- PROCESS_ACCOUNT DEADS

51
Moose Development/Moose/Process/Assign.lua
View File

@ -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

55
Moose Development/Moose/Process/Route.lua
View File

@ -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

41
Moose Development/Moose/Process/Smoke.lua
View File

@ -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

28
Moose Development/Moose/Tasking/Task.lua
View File

@ -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

17
Moose Test Missions/Moose_Test_Tasking/Moose_Test_Task_SEAD/Moose_Test_Task_SEAD.lua
View File

@ -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 )