SEAD task is working!

Moose Development/Moose/StateMachine.lua

@@ -1,6 +1,3 @@
-local machine = {}
-machine.__index = machine
-
 --- This module contains the STATEMACHINE class.
 -- 
 -- ===
@@ -23,42 +20,42 @@ STATEMACHINE = {
 --- Creates a new STATEMACHINE object.
 -- @param #STATEMACHINE self
 -- @return #STATEMACHINE
-function STATEMACHINE:New(options)
+function STATEMACHINE:New( options )
 
   local self = routines.utils.deepCopy( self ) -- Create a new self instance
 
   assert(options.events)
 
-  local FiniteStateMachine = {}
-  setmetatable( FiniteStateMachine, self )
+  local MT = {}
+  setmetatable( self, MT )
   self.__index = self
 
-  FiniteStateMachine.options = options
-  FiniteStateMachine.current = options.initial or 'none'
-  FiniteStateMachine.events = {}
+  self.options = options
+  self.current = options.initial or 'none'
+  self.events = {}
 
   for _, event in ipairs(options.events or {}) do
     local name = event.name
-    FiniteStateMachine[name] = FiniteStateMachine[name] or self:create_transition(name)
-    FiniteStateMachine.events[name] = FiniteStateMachine.events[name] or { map = {} }
-    self:add_to_map(FiniteStateMachine.events[name].map, event)
+    self[name] = self[name] or self:_create_transition(name)
+    self.events[name] = self.events[name] or { map = {} }
+    self:_add_to_map(self.events[name].map, event)
   end
   
   for name, callback in pairs(options.callbacks or {}) do
-    FiniteStateMachine[name] = callback
+    self[name] = callback
   end
 
-  return FiniteStateMachine
+  return self
 end
 
 
-function STATEMACHINE:call_handler(handler, params)
+function STATEMACHINE:_call_handler(handler, params)
   if handler then
     return handler(unpack(params))
   end
 end
 
-function STATEMACHINE:create_transition(name)
+function STATEMACHINE:_create_transition(name)
   return function(self, ...)
     local can, to = self:can(name)
 
@@ -66,16 +63,16 @@ function STATEMACHINE:create_transition(name)
       local from = self.current
       local params = { self, name, from, to, ... }
 
-      if self:call_handler(self["onbefore" .. name], params) == false
-      or self:call_handler(self["onleave" .. from], params) == false then
+      if self:_call_handler(self["onbefore" .. name], params) == false
+      or self:_call_handler(self["onleave" .. from], params) == false then
         return false
       end
 
       self.current = to
 
-      self:call_handler(self["onenter" .. to] or self["on" .. to], params)
-      self:call_handler(self["onafter" .. name] or self["on" .. name], params)
-      self:call_handler(self["onstatechange"], params)
+      self:_call_handler(self["onenter" .. to] or self["on" .. to], params)
+      self:_call_handler(self["onafter" .. name] or self["on" .. name], params)
+      self:_call_handler(self["onstatechange"], params)
 
       return true
     end
@@ -84,7 +81,7 @@ function STATEMACHINE:create_transition(name)
   end
 end
 
-function STATEMACHINE:add_to_map(map, event)
+function STATEMACHINE:_add_to_map(map, event)
   if type(event.from) == 'string' then
     map[event.from] = event.to
   else
@@ -126,3 +123,33 @@ function STATEMACHINE:todot(filename)
   dotfile:write('}\n')
   dotfile:close()
 end
+
+--- STATEMACHINE_TASK class
+-- @type STATEMACHINE_TASK
+-- @field Task2#TASK2 Task
+-- @extends StateMachine#STATEMACHINE
+STATEMACHINE_TASK = {
+  ClassName = "STATEMACHINE_TASK",
+}
+
+--- Creates a new STATEMACHINE_TASK object.
+-- @param #STATEMACHINE_TASK self
+-- @return #STATEMACHINE_TASK
+function STATEMACHINE_TASK:New( Task, options )
+
+  local FsmT = routines.utils.deepCopy( self ) -- Create a new self instance
+  local Parent = STATEMACHINE:New(options)
+
+  setmetatable( FsmT, Parent )
+  FsmT.__index = FsmT
+
+  FsmT.Task = Task
+
+  return FsmT
+end
+
+function STATEMACHINE_TASK:_call_handler( handler, params )
+  if handler then
+    return handler( self.Task, unpack( params ) )
+  end
+end