Progress SEAD Tasking

Moose Development/Moose/Actions/Act_Route.lua

@@ -81,7 +81,7 @@ do -- ACT_ROUTE
   -- @type ACT_ROUTE
   -- @field Tasking.Task#TASK TASK
   -- @field Wrapper.Unit#UNIT ProcessUnit
-  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @field Core.Zone#ZONE_BASE Zone
   -- @extends Core.Fsm#FSM_PROCESS
   ACT_ROUTE = { 
     ClassName = "ACT_ROUTE",
@@ -189,16 +189,16 @@ do -- ACT_ROUTE_POINT
 
 
   --- Creates a new routing state machine. 
-  -- The task will route a controllable to a TargetPointVec2 until the controllable is within the TargetDistance.
+  -- The task will route a controllable to a PointVec2 until the controllable is within the Range.
   -- @param #ACT_ROUTE_POINT self
   -- @param Core.Point#POINT_VEC2 The PointVec2 to Target.
-  -- @param #number TargetDistance The Distance to Target.
+  -- @param #number Range The Distance to Target.
-  -- @param Core.Zone#ZONE_BASE TargetZone
+  -- @param Core.Zone#ZONE_BASE Zone
-  function ACT_ROUTE_POINT:New( TargetPointVec2, TargetDistance )
+  function ACT_ROUTE_POINT:New( PointVec2, Range )
     local self = BASE:Inherit( self, ACT_ROUTE:New() ) -- #ACT_ROUTE_POINT
 
-    self.TargetPointVec2 = TargetPointVec2
+    self.PointVec2 = PointVec2
-    self.TargetDistance = TargetDistance
+    self.Range = Range
     
     self.DisplayInterval = 30
     self.DisplayCount = 30
@@ -210,8 +210,8 @@ do -- ACT_ROUTE_POINT
   
   function ACT_ROUTE_POINT:Init( FsmRoute )
   
-    self.TargetPointVec2 = FsmRoute.TargetPointVec2
+    self.PointVec2 = FsmRoute.PointVec2
-    self.TargetDistance = FsmRoute.TargetDistance
+    self.Range = FsmRoute.Range
     
     self.DisplayInterval = 30
     self.DisplayCount = 30
@@ -221,9 +221,30 @@ do -- ACT_ROUTE_POINT
 
   --- Set PointVec2
   -- @param #ACT_ROUTE_POINT self
-  -- @param Core.Point#POINT_VEC2 TargetPointVec2 The PointVec2 to Target.
+  -- @param Core.Point#POINT_VEC2 PointVec2 The PointVec2 to route to.
-  function ACT_ROUTE_POINT:SetTargetPointVec2( TargetPointVec2 )
+  function ACT_ROUTE_POINT:SetPointVec2( PointVec2 )
-    self.TargetPointVec2 = TargetPointVec2
+    self.PointVec2 = PointVec2
+  end  
+
+  --- Get PointVec2
+  -- @param #ACT_ROUTE_POINT self
+  -- @return Core.Point#POINT_VEC2 PointVec2 The PointVec2 to route to.
+  function ACT_ROUTE_POINT:GetPointVec2()
+    return self.PointVec2
+  end  
+
+  --- Set Range around PointVec2
+  -- @param #ACT_ROUTE_POINT self
+  -- @param #number Range The Range to consider the arrival. Default is 10000 meters.
+  function ACT_ROUTE_POINT:SetRange( Range )
+    self.Range = Range or 10000
+  end  
+  
+  --- Get Range around PointVec2
+  -- @param #ACT_ROUTE_POINT self
+  -- @return #number The Range to consider the arrival. Default is 10000 meters.
+  function ACT_ROUTE_POINT:GetRange()
+    return self.Range
   end  
   
   --- Method override to check if the controllable has arrived.
@@ -232,10 +253,10 @@ do -- ACT_ROUTE_POINT
   -- @return #boolean
   function ACT_ROUTE_POINT:onfuncHasArrived( ProcessUnit )
 
-    local Distance = self.TargetPointVec2:Get2DDistance( ProcessUnit:GetPointVec2() )
+    local Distance = self.PointVec2:Get2DDistance( ProcessUnit:GetPointVec2() )
     
-    if Distance <= self.TargetDistance then
+    if Distance <= self.Range then
-      local RouteText = "You have arrived within engagement range."
+      local RouteText = "You have arrived."
       self:Message( RouteText )
       return true
     end
@@ -254,7 +275,7 @@ do -- ACT_ROUTE_POINT
   function ACT_ROUTE_POINT:onenterReporting( ProcessUnit, From, Event, To )
   
     local TaskUnitPointVec2 = ProcessUnit:GetPointVec2()
-    local RouteText = "Route to " .. TaskUnitPointVec2:GetBRText( self.TargetPointVec2 ) .. " km to target."
+    local RouteText = "Route to " .. TaskUnitPointVec2:GetBRText( self.PointVec2 ) .. " km."
     self:Message( RouteText )
   end
 
@@ -267,7 +288,7 @@ do -- ACT_ROUTE_ZONE
   -- @type ACT_ROUTE_ZONE
   -- @field Tasking.Task#TASK TASK
   -- @field Wrapper.Unit#UNIT ProcessUnit
-  -- @field Core.Zone#ZONE_BASE TargetZone
+  -- @field Core.Zone#ZONE_BASE Zone
   -- @extends #ACT_ROUTE
   ACT_ROUTE_ZONE = { 
     ClassName = "ACT_ROUTE_ZONE",
@@ -276,11 +297,11 @@ do -- ACT_ROUTE_ZONE
 
   --- Creates a new routing state machine. The task will route a controllable to a ZONE until the controllable is within that ZONE.
   -- @param #ACT_ROUTE_ZONE self
-  -- @param Core.Zone#ZONE_BASE TargetZone
+  -- @param Core.Zone#ZONE_BASE Zone
-  function ACT_ROUTE_ZONE:New( TargetZone )
+  function ACT_ROUTE_ZONE:New( Zone )
     local self = BASE:Inherit( self, ACT_ROUTE:New() ) -- #ACT_ROUTE_ZONE
 
-    self.TargetZone = TargetZone
+    self.Zone = Zone
     
     self.DisplayInterval = 30
     self.DisplayCount = 30
@@ -292,7 +313,7 @@ do -- ACT_ROUTE_ZONE
   
   function ACT_ROUTE_ZONE:Init( FsmRoute )
   
-    self.TargetZone = FsmRoute.TargetZone
+    self.Zone = FsmRoute.Zone
     
     self.DisplayInterval = 30
     self.DisplayCount = 30
@@ -300,18 +321,32 @@ do -- ACT_ROUTE_ZONE
     self.DisplayTime = 10 -- 10 seconds is the default
   end  
   
+  --- Set Zone
+  -- @param #ACT_ROUTE_ZONE self
+  -- @param Core.Zone#ZONE_BASE Zone The Zone object where to route to.
+  function ACT_ROUTE_ZONE:SetZone( Zone )
+    self.Zone = Zone
+  end  
+
+  --- Get Zone
+  -- @param #ACT_ROUTE_ZONE self
+  -- @return Core.Zone#ZONE_BASE Zone The Zone object where to route to.
+  function ACT_ROUTE_ZONE:GetZone()
+    return self.Zone 
+  end  
+
   --- Method override to check if the controllable has arrived.
   -- @param #ACT_ROUTE self
   -- @param Wrapper.Controllable#CONTROLLABLE ProcessUnit
   -- @return #boolean
   function ACT_ROUTE_ZONE:onfuncHasArrived( ProcessUnit )
 
-    if ProcessUnit:IsInZone( self.TargetZone ) then
+    if ProcessUnit:IsInZone( self.Zone ) then
       local RouteText = "You have arrived within the zone."
       self:Message( RouteText )
     end
 
-    return ProcessUnit:IsInZone( self.TargetZone )
+    return ProcessUnit:IsInZone( self.Zone )
   end
   
   --- Task Events
@@ -324,11 +359,11 @@ do -- ACT_ROUTE_ZONE
   -- @param #string To
   function ACT_ROUTE_ZONE:onenterReporting( ProcessUnit, From, Event, To )
   
-    local ZoneVec2 = self.TargetZone:GetVec2()
+    local ZoneVec2 = self.Zone:GetVec2()
     local ZonePointVec2 = POINT_VEC2:New( ZoneVec2.x, ZoneVec2.y )
     local TaskUnitVec2 = ProcessUnit:GetVec2()
     local TaskUnitPointVec2 = POINT_VEC2:New( TaskUnitVec2.x, TaskUnitVec2.y )
-    local RouteText = "Route to " .. TaskUnitPointVec2:GetBRText( ZonePointVec2 ) .. " km to target."
+    local RouteText = "Route to " .. TaskUnitPointVec2:GetBRText( ZonePointVec2 ) .. " km."
     self:Message( RouteText )
   end
 

Moose Development/Moose/Tasking/Task_SEAD.lua

@@ -40,7 +40,7 @@ do -- TASK_SEAD
   -- @param Core.Zone#ZONE_BASE TargetZone The target zone, if known.
   -- If the TargetZone parameter is specified, the player will be routed to the center of the zone where all the targets are assumed to be.
   -- @return #TASK_SEAD self
-  function TASK_SEAD:New( Mission, SetGroup, TaskName, TargetSetUnit, TargetDistance )
+  function TASK_SEAD:New( Mission, SetGroup, TaskName, TargetSetUnit )
     local self = BASE:Inherit( self, TASK:New( Mission, SetGroup, TaskName, "SEAD" ) ) -- Tasking.Task#TASK_SEAD
     self:F()
   
@@ -52,79 +52,102 @@ do -- TASK_SEAD
     local Fsm = self:GetUnitProcess()
     
 
-    Fsm:AddProcess   ( "Planned",                   "Accept",         ACT_ASSIGN_ACCEPT:New( self.TaskBriefing ), { Assigned = "Route", Rejected = "Reject" }  )
+    Fsm:AddProcess   ( "Planned",                   "Accept",         ACT_ASSIGN_ACCEPT:New( self.TaskBriefing ), { Assigned = "RouteToRendezVous", Rejected = "Reject" }  )
-    Fsm:AddTransition( "Assigned",                  "Route",          "Routing" )
+    
-    Fsm:AddProcess   ( "Routing",                   "RouteToPoint",   ACT_ROUTE_POINT:New( self.TargetPointVec2, self.TargetDistance ), { Arrived = "Arrive" } )
+    Fsm:AddTransition( "Assigned",                  "RouteToRendezVous",          "RoutingToRendezVous" )
-    Fsm:AddProcess   ( "Routing",                   "RouteToZone",    ACT_ROUTE_ZONE:New( self.TargetZone ), { Arrived = "Arrive" } )
+    Fsm:AddProcess   ( "RoutingToRendezVous",       "RouteToRendezVousPoint",   ACT_ROUTE_POINT:New(), { Arrived = "ArriveAtRendezVous" } )
+    Fsm:AddProcess   ( "RoutingToRendezVous",       "RouteToRendezVousZone",    ACT_ROUTE_ZONE:New(), { Arrived = "ArriveAtRendezVous" } )
+    
+    Fsm:AddTransition( "Arrived",                   "ArriveAtRendezVous",         "ArrivedAtRendezVous" )
+    
+    Fsm:AddTransition( { "ArrivedAtRendezVous", "HoldingAtRendezVous" },    "Engage",         "Engaging" )
+    Fsm:AddTransition( { "ArrivedAtRendezVous", "HoldingAtRendezVous" },    "HoldAtRendezVous",         "HoldingAtRendezVous" )
+     
+    Fsm:AddProcess   ( "Engaging",                  "Account",        ACT_ACCOUNT_DEADS:New( self.TargetSetUnit, "SEAD" ), { Accounted = "Success" } )
+    --Fsm:AddProcess   ( "Accounting",                "Smoke",          ACT_ASSIST_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) )
+    Fsm:AddTransition( "Engaging", "RouteToTarget", "Engaging" )
+    Fsm:AddProcess( "Engaging", "RouteToTargetZone", ACT_ROUTE_ZONE:New(), {} )
+    Fsm:AddProcess( "Engaging", "RouteToTargetPoint", ACT_ROUTE_POINT:New(), {} )
+    Fsm:AddTransition( "Engaging", "RouteToTargets", "Engaging" )
+    
+    Fsm:AddTransition( "Accounted",                "DestroyedAll",        "Accounted" )
     Fsm:AddTransition( "Rejected",                  "Reject",         "Aborted" )
-    Fsm:AddTransition( "Arrived",                   "Arrive",         "Accounting" ) 
-    Fsm:AddProcess   ( "Accounting",                "Account",        ACT_ACCOUNT_DEADS:New( self.TargetSetUnit, "SEAD" ), { Accounted = "Success" } )
-    Fsm:AddProcess   ( "Accounting",                "Smoke",          ACT_ASSIST_SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone ) )
-    Fsm:AddTransition( "Accounting",                "CheckRange",     "Accounting" )
-    Fsm:AddTransition( "Accounting",                "InRange",        "Accounting" )
-    Fsm:AddTransition( "Accounting",                "NotInRange",     "Assigned" )
-    Fsm:AddTransition( "Accounting",                "Success",        "Success" )
     Fsm:AddTransition( "Failed",                    "Fail",           "Failed" )
     
     
+    --- Test 
+    -- @param #FSM_PROCESS self
+    -- @param Wrapper.Unit#UNIT TaskUnit
+    -- @param Tasking.Task_SEAD#TASK_SEAD Task
+    function Fsm:onafterRouteToRendezVous( TaskUnit, Task )
+      self:E( { TaskUnit = TaskUnit, Task = Task and Task:GetClassNameAndID() } )
+      -- Determine the first Unit from the self.RendezVousSetUnit
+      
+      if Task:GetRendezVousZone() then
+        self:__RouteToRendezVousZone( 0.1 )
+      else
+        if Task:GetRendezVousPointVec2() then
+          self:__RouteToPoint( 0.1 )
+        else
+          self:__ArriveAtRendezVous( 0.1 )
+        end
+      end
+    end
+
     --- Test 
     -- @param #FSM_PROCESS self
     -- @param Wrapper.Unit#UNIT TaskUnit
     -- @param Tasking.Task#TASK_SEAD Task
-    function Fsm:onenterRouting( TaskUnit, Task )
+    function Fsm:OnAfterArriveAtRendezVous( TaskUnit, Task )
       self:E( { TaskUnit = TaskUnit, Task = Task and Task:GetClassNameAndID() } )
       -- Determine the first Unit from the self.TargetSetUnit
       
-      local TargetUnit = Task.TargetSetUnit:GetFirst() -- Wrapper.Unit#UNIT
+      self:__Engage( 0.1 )      
-      if TargetUnit then
+    end
-        self:E( { TargetZone = Task.TargetZone } )
+    
-        if Task.TargetZone then
+    --- Test 
-          self:__RouteToZone( 0.1 )
+    -- @param #FSM_PROCESS self
+    -- @param Wrapper.Unit#UNIT TaskUnit
+    -- @param Tasking.Task#TASK_SEAD Task
+    function Fsm:onafterEngage( TaskUnit, Task )
+      self:E( { self } )
+      self:__Account( 0.1 )
+      self:__RouteToTarget(0.1 )
+      self:__RouteToTargets( -10 )
+    end
+    
+    --- Test 
+    -- @param #FSM_PROCESS self
+    -- @param Wrapper.Unit#UNIT TaskUnit
+    -- @param Tasking.Task_SEAD#TASK_SEAD Task
+    function Fsm:onafterRouteToTarget( TaskUnit, Task )
+      self:E( { TaskUnit = TaskUnit, Task = Task and Task:GetClassNameAndID() } )
+      -- Determine the first Unit from the self.TargetSetUnit
+      
+        if Task:GetTargetZone() then
+          self:__RouteToTargetZone( 0.1 )
         else
-          local TargetPointVec2 = TargetUnit:GetPointVec2()
+          if Task:GetTargetPointVec2() then
-          local RoutePointProcess = self:GetProcess( "Routing", "RouteToPoint" )
+            local TargetUnit = Task.TargetSetUnit:GetFirst() -- Wrapper.Unit#UNIT
-          RoutePointProcess:SetTargetPointVec2( TargetPointVec2 )
+            if TargetUnit then
-          self:__RouteToPoint( 0.1 )
+              Task:SetTargetPointVec2( TargetUnit:GetPointVec2() )
+            end
+            self:__RouteToTargetPoint( 0.1 )
+          end
         end
       end        
     end
     
-    function Fsm:onenterAccounting( TaskUnit, Task )
+    --- Test 
-      self:E( { self } )
+    -- @param #FSM_PROCESS self
-      self:Account()
-      self:Smoke()
-      self:__CheckRange( -5 )
-    end
-    
-    --- @param #FSM_PROCESS self
     -- @param Wrapper.Unit#UNIT TaskUnit
-    function Fsm:onafterCheckRange( TaskUnit, Task )
+    -- @param Tasking.Task_SEAD#TASK_SEAD Task
-      self:E( "CheckRange" )
+    function Fsm:onafterRouteToTargets( TaskUnit, Task )
+      self:E( { TaskUnit = TaskUnit, Task = Task and Task:GetClassNameAndID() } )
       local TargetUnit = Task.TargetSetUnit:GetFirst() -- Wrapper.Unit#UNIT
       if TargetUnit then
-        local PointVec2 = TargetUnit:GetPointVec2()
+        Task:SetTargetPointVec2( TargetUnit:GetPointVec2() )
-        local Distance = PointVec2:Get2DDistance( TaskUnit:GetPointVec2() )
-        if Distance > Task.TargetDistance then
-          self:NotInRange()
-        else
-          self:InRange()
-        end
       end
-    end  
-    
-    function Fsm:onafterNotInRange( TaskUnit )
-      self:E( "Not In Range" )
-      -- Stop accounting etc. and go back to routing.
-      local FsmAccount = self:GetProcess( "Accounting", "Account" )
-      local FsmSmoke = self:GetProcess( "Accounting", "Smoke" )
-      FsmAccount:Stop() -- Stop the Accounting
-      FsmSmoke:Stop() -- Stop the Smoking
-      self:__Route( 1 )
-    end
-
-    function Fsm:onafterInRange( TaskUnit )
-      self:E( "In Range" )
-      self:__CheckRange( -5 )
     end
     
     return self
@@ -137,8 +160,72 @@ do -- TASK_SEAD
   end
 
   --- @param #TASK_SEAD self
+  -- @param Core.Point#POINT_VEC2 RendezVousPointVec2 The PointVec2 object referencing to the 2D point where the RendezVous point is located on the map.
+  -- @param #number RendezVousRange The RendezVousRange that defines when the player is considered to have arrived at the RendezVous point.
+  function TASK_SEAD:SetRendezVousPointVec2( RendezVousPointVec2, RendezVousRange )
+  
+    local ActRouteRendezVous = self:GetProcess( "RoutingToRendezVous", "RouteToRendezVousPoint" ) -- Actions.Act_Route#ACT_ROUTE_POINT
+    ActRouteRendezVous:SetPointVec2( RendezVousPointVec2 )
+    ActRouteRendezVous:SetRange( RendezVousRange )
+  end
+  
+  --- @param #TASK_SEAD self
+  -- @return Core.Point#POINT_VEC2 The PointVec2 object referencing to the 2D point where the RendezVous point is located on the map.
+  -- @return #number The RendezVousRange that defines when the player is considered to have arrived at the RendezVous point.
+  function TASK_SEAD:GetRendezVousPointVec2()
+  
+    local ActRouteRendezVous = self:GetProcess( "RoutingToRendezVous", "RouteToRendezVousPoint" ) -- Actions.Act_Route#ACT_ROUTE_POINT
+    return ActRouteRendezVous:GetPointVec2(), ActRouteRendezVous:GetRange()
+  end
+  
+  
+  
+  --- @param #TASK_SEAD self
+  -- @param Core.Zone#ZONE_BASE RendezVousZone The Zone object where the RendezVous is located on the map.
+  function TASK_SEAD:SetRendezVousZone( RendezVousZone )
+  
+    local ActRouteRendezVous = self:GetProcess( "RoutingToRendezVous", "RouteToRendezVousZone" ) -- Actions.Act_Route#ACT_ROUTE_ZONE
+    ActRouteRendezVous:SetZone( RendezVousZone )
+  end
+
+  --- @param #TASK_SEAD self
+  -- @return Core.Zone#ZONE_BASE The Zone object where the RendezVous is located on the map.
+  function TASK_SEAD:GetRendezVousZone()
+    local ActRouteRendezVous = self:GetProcess( "RoutingToRendezVous", "RouteToRendezVousZone" ) -- Actions.Act_Route#ACT_ROUTE_ZONE
+    return ActRouteRendezVous:GetZone()
+  end
+  
+  --- @param #TASK_SEAD self
+  -- @param Core.Point#POINT_VEC2 TargetPointVec2 The PointVec2 object where the Target is located on the map.
+  function TASK_SEAD:SetTargetPointVec2( TargetPointVec2 )
+  
+    local ActRouteTarget = self:GetProcess( "Engaging", "RouteToTargetPoint" ) -- Actions.Act_Route#ACT_ROUTE_POINT
+    ActRouteTarget:SetPointVec2( TargetPointVec2 )
+  end
+   
+
+  --- @param #TASK_SEAD self
+  -- @return Core.Point#POINT_VEC2 The PointVec2 object where the Target is located on the map.
+  function TASK_SEAD:GetTargetPointVec2()
+    local ActRouteTarget = self:GetProcess( "Engaging", "RouteToTargetPoint" ) -- Actions.Act_Route#ACT_ROUTE_POINT
+    return ActRouteTarget:GetPointVec2()
+  end
+
+
+  --- @param #TASK_SEAD self
+  -- @param Core.Zone#ZONE_BASE TargetZone The Zone object where the Target is located on the map.
   function TASK_SEAD:SetTargetZone( TargetZone )
-    self.TargetZone = TargetZone
+  
+    local ActRouteTarget = self:GetProcess( "Engaging", "RouteToTargetZone" ) -- Actions.Act_Route#ACT_ROUTE_ZONE
+    ActRouteTarget:SetZone( TargetZone )
+  end
+   
+
+  --- @param #TASK_SEAD self
+  -- @return Core.Zone#ZONE_BASE The Zone object where the Target is located on the map.
+  function TASK_SEAD:GetTargetZone()
+    local ActRouteTarget = self:GetProcess( "Engaging", "RouteToTargetZone" ) -- Actions.Act_Route#ACT_ROUTE_ZONE
+    return ActRouteTarget:GetZone()
   end
   
 end 

Moose Test Missions/TSK - Task Modelling/TSK-010 - Task Modelling - SEAD/TSK-010 - Task Modelling - SEAD.lua

@@ -90,6 +90,9 @@ SEADSet:Flush()
 -- and will not be continuously updated!
 local TargetSet = SET_UNIT:New():FilterPrefixes( "US Hawk SR" ):FilterOnce()
 
+-- Define the RendezVous Zone where the pilot needs to RendezVous with other players before engaging.
+local RendezVousZone = ZONE:New( "RendezVous Zone" )
+
 -- Define the zone to where the pilot needs to navigate.
 local TargetZone = ZONE:New( "Target Zone" )
 
@@ -109,7 +112,10 @@ local SEADTask = TASK_SEAD:New(
   SEADSet, 
   "SEAD Radars Vector 1", 
   TargetSet,
-  15000 ) -- Tasking.Task#TASK_SEAD
+  15000 ) -- Tasking.Task_SEAD#TASK_SEAD
+
+SEADTask:SetRendezVousPointVec2( TargetZone:GetPointVec2(), 6000 ) -- Done to test the RendezVousPointVec2 mechanism.
+SEADTask:SetTargetZone( TargetZone )
 
 -- This is now an important part of the Task process definition.
 -- Each TASK contains a "Process Template".