Last Updates

Moose Development/Moose/Core/StateMachine.lua

@@ -285,24 +285,23 @@ STATEMACHINE_TASK = {
 
 --- Creates a new STATEMACHINE_TASK object.
 -- @param #STATEMACHINE_TASK self
+-- @param #table FSMT
+-- @param Task#TASK_BASE Task
+-- @param Unit#UNIT TaskUnit
 -- @return #STATEMACHINE_TASK
-function STATEMACHINE_TASK:New( Task, TaskUnit, options )
+function STATEMACHINE_TASK:New( FSMT, Task, TaskUnit )
 
-  local FsmTask = routines.utils.deepCopy( self ) -- Create a new self instance
-  local Parent = STATEMACHINE:New(options)
+  local self = BASE:Inherit( self, STATEMACHINE:New( FSMT ) ) -- StateMachine#STATEMACHINE_PROCESS
 
-  setmetatable( FsmTask, Parent )
-  FsmTask.__index = FsmTask
+  self["onstatechange"] = Task.OnStateChange
+  self["onAssigned"] = Task.OnAssigned
+  self["onSuccess"] = Task.OnSuccess
+  self["onFailed"] = Task.OnFailed
 
-  FsmTask["onstatechange"] = Task.OnStateChange
-  FsmTask["onAssigned"] = Task.OnAssigned
-  FsmTask["onSuccess"] = Task.OnSuccess
-  FsmTask["onFailed"] = Task.OnFailed
+  self.Task = Task
+  self.TaskUnit = TaskUnit
 
-  FsmTask.Task = Task
-  FsmTask.TaskUnit = TaskUnit
-
-  return FsmTask
+  return self
 end
 
 function STATEMACHINE_TASK:_call_handler( handler, params )
@@ -338,7 +337,7 @@ end
 
 --- Sets the CONTROLLABLE object that the STATEMACHINE_CONTROLLABLE governs.
 -- @param #STATEMACHINE_CONTROLLABLE self
--- @param Controllable#CONTROLLABLE Controllable
+-- @param Controllable#CONTROLLABLE FSMControllable
 -- @return #STATEMACHINE_CONTROLLABLE
 function STATEMACHINE_CONTROLLABLE:SetControllable( FSMControllable )
   self:F( FSMControllable )

Moose Development/Moose/Dcs/DCSAirbase.lua

@@ -0,0 +1,54 @@
+-------------------------------------------------------------------------------
+-- @module DCSAirbase
+
+
+--- Represents airbases: airdromes, helipads and ships with flying decks or landing pads.  
+-- @type Airbase
+-- @extends DCSCoalitionObject#CoalitionObject
+-- @field #Airbase.ID ID Identifier of an airbase. It assigned to an airbase by the Mission Editor automatically. This identifier is used in AI tasks to refer an airbase that exists (spawned and not dead) or not. 
+-- @field #Airbase.Category Category enum contains identifiers of airbase categories. 
+-- @field #Airbase.Desc Desc Airbase descriptor. Airdromes are unique and their types are unique, but helipads and ships are not always unique and may have the same type. 
+
+--- Enum contains identifiers of airbase categories.
+-- @type Airbase.Category
+-- @field AIRDROME
+-- @field HELIPAD
+-- @field SHIP
+
+--- Airbase descriptor. Airdromes are unique and their types are unique, but helipads and ships are not always unique and may have the same type. 
+-- @type Airbase.Desc
+-- @extends #Desc
+-- @field #Airbase.Category category Category of the airbase type.
+
+--- Returns airbase by its name. If no airbase found the function will return nil.
+-- @function [parent=#Airbase] getByName
+-- @param #string name
+-- @return #Airbase
+
+--- Returns airbase descriptor by type name. If no descriptor is found the function will return nil.
+-- @function [parent=#Airbase] getDescByName
+-- @param #TypeName typeName Airbase type name.
+-- @return #Airbase.Desc
+
+--- Returns Unit that is corresponded to the airbase. Works only for ships.
+-- @function [parent=#Airbase] getUnit
+-- @param self
+-- @return Unit#Unit
+
+--- Returns identifier of the airbase.
+-- @function [parent=#Airbase] getID
+-- @param self
+-- @return #Airbase.ID
+
+--- Returns the airbase's callsign - the localized string.
+-- @function [parent=#Airbase] getCallsign
+-- @param self
+-- @return #string
+
+--- Returns descriptor of the airbase. 
+-- @function [parent=#Airbase] getDesc
+-- @param self
+-- @return #Airbase.Desc
+
+
+Airbase = {} --#Airbase

Moose Development/Moose/Dcs/DCSCoalitionObject.lua

@@ -0,0 +1,28 @@
+-------------------------------------------------------------------------------
+-- @module DCSCoalitionObject
+
+--- @type CoalitionObject
+-- @extends DCSObject#Object
+
+--- @type coalition
+-- @field #coalition.side side
+
+--- @type coalition.side
+-- @field NEUTRAL
+-- @field RED
+-- @field BLUE
+
+coalition = {} --#coalition
+
+--- Returns coalition of the object.
+-- @function [parent=#CoalitionObject] getCoalition
+-- @param #CoalitionObject self
+-- @return DCSTypes#coalition.side
+
+--- Returns object country.
+-- @function [parent=#CoalitionObject] getCountry
+-- @param #CoalitionObject self
+-- @return #country.id
+
+
+CoalitionObject = {} --#CoalitionObject

Moose Development/Moose/Dcs/DCSCommand.lua

@@ -0,0 +1,10 @@
+--- @module DCSCommand
+
+
+--- @type Command
+-- @field #string id
+-- @field #Command.params params
+
+--- @type Command.params
+
+env.info( "Command defined" )

Moose Development/Moose/Dcs/DCSController.lua

@@ -0,0 +1,115 @@
+-------------------------------------------------------------------------------
+-- @module DCSController
+
+--- Controller is an object that performs A.I.-routines. Other words controller is an instance of A.I.. Controller stores current main task, active enroute tasks and behavior options. Controller performs commands. Please, read DCS A-10C GUI Manual EN.pdf chapter "Task Planning for Unit Groups", page 91 to understand A.I. system of DCS:A-10C. 
+-- 
+-- This class has 2 types of functions:
+-- 
+-- * Tasks
+-- * Commands: Commands are instant actions those required zero time to perform. Commands may be used both for control unit/group behavior and control game mechanics. 
+-- @type Controller
+-- @field #Controller.Detection Detection Enum contains identifiers of surface types. 
+
+--- Enables and disables the controller.
+-- Note: Now it works only for ground / naval groups!
+-- @function [parent=#Controller] setOnOff
+-- @param self
+-- @param #boolean value Enable / Disable.
+
+-- Tasks
+
+--- Resets current task and then sets the task to the controller. Task is a table that contains task identifier and task parameters.
+-- @function [parent=#Controller] setTask
+-- @param self
+-- @param #Task task
+
+--- Resets current task of the controller.
+-- @function [parent=#Controller] resetTask 
+-- @param self
+
+--- Pushes the task to the front of the queue and makes the task active. Further call of function Controller.setTask() function will stop current task, clear the queue and set the new task active. If the task queue is empty the function will work like function Controller.setTask() function.
+-- @function [parent=#Controller] pushTask
+-- @param self
+-- @param #Task task
+
+--- Pops current (front) task from the queue and makes active next task in the queue (if exists). If no more tasks in the queue the function works like function Controller.resetTask() function. Does nothing if the queue is empty.
+-- @function [parent=#Controller] popTask
+-- @param self
+
+--- Returns true if the controller has a task. 
+-- @function [parent=#Controller] hasTask
+-- @param self
+-- @return #boolean
+
+-- Commands
+
+--TODO: describe #Command structure
+--- Sets the command to perform by controller.
+-- @function [parent=#Controller] setCommand
+-- @param self
+-- @param #Command command Table that contains command identifier and command parameters. 
+
+
+-- Behaviours
+
+--- Sets the option to the controller.
+-- Option is a pair of identifier and value. Behavior options are global parameters those affect controller behavior in all tasks it performs.
+-- Option identifiers and values are stored in table AI.Option in subtables Air, Ground and Naval.
+-- 
+-- OptionId = @{#AI.Option.Air.id} or @{#AI.Option.Ground.id} or @{#AI.Option.Naval.id}
+-- OptionValue = AI.Option.Air.val[optionName] or AI.Option.Ground.val[optionName] or AI.Option.Naval.val[optionName]
+-- 
+-- @function [parent=#Controller] setOption
+-- @param self
+-- @param #OptionId optionId Option identifier. 
+-- @param #OptionValue optionValue Value of the option.
+
+
+-- Detection
+
+--- Enum contains identifiers of surface types. 
+-- @type Controller.Detection
+-- @field VISUAL
+-- @field OPTIC
+-- @field RADAR
+-- @field IRST
+-- @field RWR
+-- @field DLINK
+
+--- Detected target. 
+-- @type DetectedTarget
+-- @field Object#Object object The target
+-- @field #boolean visible The target is visible
+-- @field #boolean type The target type is known
+-- @field #boolean distance Distance to the target is known
+
+
+--- Checks if the target is detected or not. If one or more detection method is specified the function will return true if the target is detected by at least one of these methods. If no detection methods are specified the function will return true if the target is detected by any method. 
+-- @function [parent=#Controller] isTargetDetected
+-- @param self
+-- @param Object#Object target Target to check
+-- @param #Controller.Detection detection Controller.Detection detection1, Controller.Detection detection2, ... Controller.Detection detectionN 
+-- @return #boolean detected True if the target is detected. 
+-- @return #boolean visible Has effect only if detected is true. True if the target is visible now. 
+-- @return #ModelTime lastTime Has effect only if visible is false. Last time when target was seen. 
+-- @return #boolean type Has effect only if detected is true. True if the target type is known. 
+-- @return #boolean distance Has effect only if detected is true. True if the distance to the target is known. 
+-- @return #Vec3 lastPos Has effect only if visible is false. Last position of the target when it was seen. 
+-- @return #Vec3 lastVel Has effect only if visible is false. Last velocity of the target when it was seen. 
+
+
+--- Returns list of detected targets. If one or more detection method is specified the function will return targets which were detected by at least one of these methods. If no detection methods are specified the function will return targets which were detected by any method.
+-- @function [parent=#Controller] getDetectedTargets
+-- @param self
+-- @param #Controller.Detection detection Controller.Detection detection1, Controller.Detection detection2, ... Controller.Detection detectionN 
+-- @return #list<#DetectedTarget> array of DetectedTarget
+
+--- Know a target.
+-- @function [parent=#Controller] knowTarget
+-- @param self
+-- @param Object#Object object The target.
+-- @param #boolean type Target type is known.
+-- @param #boolean distance Distance to target is known.
+
+
+Controller = {} --#Controller

Moose Development/Moose/Dcs/DCSGroup.lua

@@ -0,0 +1,83 @@
+-------------------------------------------------------------------------------
+-- @module DCSGroup
+
+--- Represents group of Units.
+-- @type Group
+-- @field #ID ID Identifier of a group. It is assigned to a group by Mission Editor automatically. 
+-- @field #Group.Category Category Enum contains identifiers of group types. 
+
+--- Enum contains identifiers of group types.
+-- @type Group.Category
+-- @field AIRPLANE
+-- @field HELICOPTER
+-- @field GROUND
+-- @field SHIP
+
+-- Static Functions
+
+--- Returns group by the name assigned to the group in Mission Editor. 
+-- @function [parent=#Group] getByName
+-- @param #string name
+-- @return #Group
+
+-- Member Functions
+
+--- returns true if the group exist or false otherwise. 
+-- @function [parent=#Group] isExist
+-- @param #Group self 
+-- @return #boolean
+
+--- Destroys the group and all of its units.
+-- @function [parent=#Group] destroy
+-- @param #Group self 
+
+--- Returns category of the group.
+-- @function [parent=#Group] getCategory
+-- @param #Group self 
+-- @return #Group.Category
+
+--TODO check coalition.side
+
+--- Returns the coalition of the group.
+-- @function [parent=#Group] getCoalition
+-- @param #Group self 
+-- @return DCSCoalitionObject#coalition.side
+
+--- Returns the group's name. This is the same name assigned to the group in Mission Editor.
+-- @function [parent=#Group] getName
+-- @param #Group self 
+-- @return #string
+
+--- Returns the group identifier.
+-- @function [parent=#Group] getID
+-- @param #Group self 
+-- @return #ID
+
+--- Returns the unit with number unitNumber. If the unit is not exists the function will return nil.
+-- @function [parent=#Group] getUnit
+-- @param #Group self 
+-- @param #number unitNumber
+-- @return DCSUnit#Unit
+
+--- Returns current size of the group. If some of the units will be destroyed, As units are destroyed the size of the group will be changed.
+-- @function [parent=#Group] getSize
+-- @param #Group self 
+-- @return #number
+
+--- Returns initial size of the group. If some of the units will be destroyed, initial size of the group will not be changed. Initial size limits the unitNumber parameter for Group.getUnit() function.
+-- @function [parent=#Group] getInitialSize
+-- @param #Group self 
+-- @return #number
+
+--- Returns array of the units present in the group now. Destroyed units will not be enlisted at all.
+-- @function [parent=#Group] getUnits
+-- @param #Group self 
+-- @return #list<DCSUnit#Unit> array of Units
+
+--- Returns controller of the group. 
+-- @function [parent=#Group] getController
+-- @param #Group self 
+-- @return Controller#Controller
+
+Group = {} --#Group
+

Moose Development/Moose/Dcs/DCSObject.lua

@@ -0,0 +1,73 @@
+-------------------------------------------------------------------------------
+-- @module DCSObject
+
+--- @type Object
+-- @field #Object.Category Category
+-- @field #Object.Desc Desc
+
+--- @type Object.Category
+-- @field UNIT
+-- @field WEAPON
+-- @field STATIC
+-- @field SCENERY
+-- @field BASE
+
+--- @type Object.Desc
+-- @extends #Desc
+-- @field #number life initial life level
+-- @field #Box3 box bounding box of collision geometry
+
+--- @function [parent=#Object] isExist
+-- @param #Object self
+-- @return #boolean
+
+--- @function [parent=#Object] destroy
+-- @param #Object self
+
+--- @function [parent=#Object] getCategory
+-- @param #Object self
+-- @return #Object.Category
+
+--- Returns type name of the Object.
+-- @function [parent=#Object] getTypeName
+-- @param #Object self
+-- @return #string 
+
+--- Returns object descriptor.
+-- @function [parent=#Object] getDesc
+-- @param #Object self
+-- @return #Object.Desc
+
+--- Returns true if the object belongs to the category.
+-- @function [parent=#Object] hasAttribute
+-- @param #Object self
+-- @param #AttributeName attributeName Attribute name to check.
+-- @return #boolean
+
+--- Returns name of the object. This is the name that is assigned to the object in the Mission Editor.
+-- @function [parent=#Object] getName
+-- @param #Object self
+-- @return #string
+
+--- Returns object coordinates for current time.
+-- @function [parent=#Object] getPoint
+-- @param #Object self
+-- @return #Vec3
+
+--- Returns object position for current time. 
+-- @function [parent=#Object] getPosition
+-- @param #Object self
+-- @return #Position3
+
+--- Returns the unit's velocity vector.
+-- @function [parent=#Object] getVelocity
+-- @param #Object self
+-- @return #Vec3
+
+--- Returns true if the unit is in air.
+-- @function [parent=#Object] inAir
+-- @param #Object self
+-- @return #boolean
+
+Object = {} --#Object
+

Moose Development/Moose/Dcs/DCSStaticObject.lua

@@ -0,0 +1,34 @@
+-------------------------------------------------------------------------------
+-- @module DCSStaticObject
+
+
+-------------------------------------------------------------------------------
+-- @module StaticObject
+-- @extends CoalitionObject#CoalitionObject
+
+--- Represents static object added in the Mission Editor.
+-- @type StaticObject
+-- @field #StaticObject.ID ID Identifier of a StaticObject. It assigned to an StaticObject by the Mission Editor automatically.
+-- @field #StaticObject.Desc Desc Descriptor of StaticObject and Unit are equal. StaticObject is just a passive variant of Unit. 
+
+--- StaticObject descriptor. Airdromes are unique and their types are unique, but helipads and ships are not always unique and may have the same type. 
+-- @type StaticObject.Desc
+-- @extends Unit#Unit.Desc
+
+--- Returns static object by its name. If no static object found nil will be returned. 
+-- @function [parent=#StaticObject] getByName
+-- @param #string name Name of static object to find. 
+-- @return #StaticObject
+
+--- returns identifier of the static object.
+-- @function [parent=#StaticObject] getID
+-- @param #StaticObject self
+-- @return #StaticObject.ID
+
+--- Returns descriptor of the StaticObject. 
+-- @function [parent=#StaticObject] getDesc
+-- @param #StaticObject self
+-- @return #StaticObject.Desc
+
+
+StaticObject = {} --#StaticObject

Moose Development/Moose/Dcs/DCSTask.lua

@@ -0,0 +1,15 @@
+--- @module DCSTask
+
+
+--- A task descriptor (internal structure for DCS World)
+-- @type Task
+-- @field #string id
+-- @field #Task.param param
+
+--- @type Task.param
+
+--- List of @{#Task}
+-- @type TaskArray
+-- @list <#Task>
+
+env.info( "Task defined" )

Moose Development/Moose/Dcs/DCSTime.lua

@@ -0,0 +1,8 @@
+-------------------------------------------------------------------------------
+-- @module DCSTime
+
+--- @type ModelTime
+-- @extends #number
+
+--- @type Time
+-- @extends #number

Moose Development/Moose/Dcs/DCSTypes.lua

@@ -0,0 +1,246 @@
+-------------------------------------------------------------------------------
+-- @module DCSTypes
+
+
+
+--- Time is given in seconds.
+-- @type Time
+-- @extends #number
+
+--- Model time is the time that drives the simulation. Model time may be stopped, accelerated and decelerated relative real time. 
+-- @type ModelTime
+-- @extends #number
+
+--- Mission time is a model time plus time of the mission start.
+-- @type MissionTime
+-- @extends #number
+
+
+--- Distance is given in meters.
+-- @type Distance
+-- @extends #number
+
+--- Angle is given in radians.
+-- @type Angle
+-- @extends #number
+
+--- Azimuth is an angle of rotation around world axis y counter-clockwise.
+-- @type Azimuth
+-- @extends #number
+
+--- Mass is given in kilograms.
+-- @type Mass
+-- @extends #number
+
+--- Vec3 type is a 3D-vector.
+-- DCS world has 3-dimensional coordinate system. DCS ground is an infinite plain.
+-- @type Vec3
+-- @field #Distance x is directed to the north
+-- @field #Distance z is directed to the east
+-- @field #Distance y is directed up
+
+--- Vec2 is a 2D-vector for the ground plane as a reference plane.
+-- @type Vec2
+-- @field #Distance x Vec2.x = Vec3.x
+-- @field #Distance y Vec2.y = Vec3.z
+
+--- Position is a composite structure. It consists of both coordinate vector and orientation matrix. Position3 (also known as "Pos3" for short) is a table that has following format: 
+-- @type Position3
+-- @field #Vec3 p
+-- @field #Vec3 x
+-- @field #Vec3 y
+-- @field #Vec3 z
+
+--- 3-dimensional box.
+-- @type Box3
+-- @field #Vec3 min
+-- @field #Vec3 max
+
+--- Each object belongs to a type. Object type is a named couple of properties those independent of mission and common for all units of the same type. Name of unit type is a string. Samples of unit type: "Su-27", "KAMAZ" and "M2 Bradley". 
+-- @type TypeName
+-- @extends #string
+
+--- AttributeName = string 
+-- Each object type may have attributes.
+-- Attributes are enlisted in ./Scripts/Database/db_attributes.Lua.
+-- To know what attributes the object type has, look for the unit type script in sub-directories planes/, helicopter/s, vehicles, navy/ of ./Scripts/Database/ directory. 
+-- @type AttributeName
+-- @extends #string
+
+--- List of @{#AttributeName}
+-- @type AttributeNameArray 
+-- @list <#AttributeName>
+
+--- @type AI
+-- @field #AI.Skill Skill
+-- @field #AI.Task Task
+-- @field #AI.Option Option
+
+--- @type AI.Skill
+-- @field AVERAGE
+-- @field GOOD
+-- @field HIGH
+-- @field EXCELLENT
+-- @field PLAYER
+-- @field CLIENT
+
+--- @type AI.Task
+-- @field #AI.Task.WeaponExpend WeaponExpend
+-- @field #AI.Task.OrbitPattern OrbitPattern
+-- @field #AI.Task.Designation Designation
+-- @field #AI.Task.WaypointType WaypointType
+-- @field #AI.Task.TurnMethod TurnMethod
+-- @field #AI.Task.AltitudeType AltitudeType
+-- @field #AI.Task.VehicleFormation VehicleFormation
+
+--- @type AI.Task.WeaponExpend
+-- @field ONE
+-- @field TWO
+-- @field FOUR
+-- @field QUARTER
+-- @field HALF
+-- @field ALL
+
+--- @type AI.Task.OrbitPattern
+-- @field CIRCLE
+-- @field RACE_TRACK
+
+--- @type AI.Task.Designation
+-- @field NO
+-- @field AUTO
+-- @field WP
+-- @field IR_POINTER
+-- @field LASER
+
+--- @type AI.Task.WaypointType
+-- @field TAKEOFF
+-- @field TAKEOFF_PARKING
+-- @field TURNING_POINT
+-- @field LAND
+
+--- @type AI.Task.TurnMethod
+-- @field FLY_OVER_POINT
+-- @field FIN_POINT
+
+--- @type AI.Task.AltitudeType
+-- @field BARO
+-- @field RADIO
+
+--- @type AI.Task.VehicleFormation
+-- @field OFF_ROAD
+-- @field ON_ROAD
+-- @field RANK
+-- @field CONE
+-- @field DIAMOND
+-- @field VEE
+-- @field ECHELON_LEFT
+-- @field ECHELON_RIGHT
+
+--- @type AI.Option
+-- @field #AI.Option.Air                          Air
+-- @field #AI.Option.Ground                       Ground
+-- @field #AI.Option.Naval                        Naval
+
+--- @type AI.Option.Air
+-- @field #AI.Option.Air.id                       id
+-- @field #AI.Option.Air.val                      val
+
+--- @type AI.Option.Ground
+-- @field #AI.Option.Ground.id                    id
+-- @field #AI.Option.Ground.val                   val
+
+--- @type AI.Option.Naval
+-- @field #AI.Option.Naval.id                     id
+-- @field #AI.Option.Naval.val                    val
+
+--TODO: work on formation
+--- @type AI.Option.Air.id
+-- @field NO_OPTION
+-- @field ROE
+-- @field REACTION_ON_THREAT
+-- @field RADAR_USING
+-- @field FLARE_USING
+-- @field FORMATION
+-- @field RTB_ON_BINGO
+-- @field SILENCE 
+
+--- @type AI.Option.Air.val
+-- @field #AI.Option.Air.val.ROE ROE
+-- @field #AI.Option.Air.val.REACTION_ON_THREAT REACTION_ON_THREAT
+-- @field #AI.Option.Air.val.RADAR_USING RADAR_USING
+-- @field #AI.Option.Air.val.FLARE_USING FLARE_USING
+
+--- @type AI.Option.Air.val.ROE
+-- @field WEAPON_FREE
+-- @field OPEN_FIRE_WEAPON_FREE
+-- @field OPEN_FIRE
+-- @field RETURN_FIRE
+-- @field WEAPON_HOLD
+ 
+--- @type AI.Option.Air.val.REACTION_ON_THREAT
+-- @field NO_REACTION
+-- @field PASSIVE_DEFENCE
+-- @field EVADE_FIRE
+-- @field BYPASS_AND_ESCAPE
+-- @field ALLOW_ABORT_MISSION
+
+--- @type AI.Option.Air.val.RADAR_USING
+-- @field NEVER
+-- @field FOR_ATTACK_ONLY
+-- @field FOR_SEARCH_IF_REQUIRED
+-- @field FOR_CONTINUOUS_SEARCH
+
+--- @type AI.Option.Air.val.FLARE_USING
+-- @field NEVER
+-- @field AGAINST_FIRED_MISSILE
+-- @field WHEN_FLYING_IN_SAM_WEZ
+-- @field WHEN_FLYING_NEAR_ENEMIES
+
+--- @type AI.Option.Ground.id
+-- @field NO_OPTION
+-- @field ROE @{#AI.Option.Ground.val.ROE}
+-- @field DISPERSE_ON_ATTACK true or false
+-- @field ALARM_STATE @{#AI.Option.Ground.val.ALARM_STATE}
+
+--- @type AI.Option.Ground.val
+-- @field #AI.Option.Ground.val.ROE               ROE
+-- @field #AI.Option.Ground.val.ALARM_STATE       ALARM_STATE
+
+--- @type AI.Option.Ground.val.ROE
+-- @field OPEN_FIRE
+-- @field RETURN_FIRE
+-- @field WEAPON_HOLD
+
+--- @type AI.Option.Ground.val.ALARM_STATE
+-- @field AUTO
+-- @field GREEN
+-- @field RED
+
+--- @type AI.Option.Naval.id
+-- @field NO_OPTION
+-- @field ROE
+
+--- @type AI.Option.Naval.val
+-- @field #AI.Option.Naval.val.ROE ROE
+
+--- @type AI.Option.Naval.val.ROE
+-- @field OPEN_FIRE
+-- @field RETURN_FIRE
+-- @field WEAPON_HOLD
+
+AI = {} --#AI
+
+
+--- @type Desc
+-- @field #TypeName typeName type name
+-- @field #string displayName localized display name
+-- @field #table attributes object type attributes
+
+--- A distance type
+-- @type Distance
+
+--- An angle type
+-- @type Angle
+
+env.info( 'AI types created' )
+

Moose Development/Moose/Dcs/DCSUnit.lua

@@ -0,0 +1,241 @@
+-------------------------------------------------------------------------------
+-- @module DCSUnit
+
+--- @type Unit
+-- @extends DCSCoalitionObject#CoalitionObject
+-- @field ID Identifier of an unit. It assigned to an unit by the Mission Editor automatically. 
+-- @field #Unit.Category Category
+-- @field #Unit.RefuelingSystem RefuelingSystem
+-- @field #Unit.SensorType SensorType
+-- @field #Unit.OpticType OpticType
+-- @field #Unit.RadarType RadarType
+-- @field #Unit.Desc Desc
+-- @field #Unit.DescAircraft DescAircraft
+-- @field #Unit.DescAirplane DescAirplane
+-- @field #Unit.DescHelicopter DescHelicopter
+-- @field #Unit.DescVehicle DescVehicle
+-- @field #Unit.DescShip DescShip
+-- @field #Unit.AmmoItem AmmoItem
+-- @field #list<#Unit.AmmoItem> Ammo
+-- @field #Unit.Sensor Sensor
+-- @field #Unit.Optic Optic
+-- @field #Unit.Radar Radar
+-- @field #Unit.IRST IRST
+
+
+--- Enum that stores unit categories.
+-- @type Unit.Category
+-- @field AIRPLANE
+-- @field HELICOPTER
+-- @field GROUND_UNIT
+-- @field SHIP
+-- @field STRUCTURE
+
+--- Enum that stores aircraft refueling system types.
+-- @type Unit.RefuelingSystem
+-- @field BOOM_AND_RECEPTACLE
+-- @field PROBE_AND_DROGUE
+
+--- Enum that stores sensor types.
+-- @type Unit.SensorType
+-- @field OPTIC
+-- @field RADAR
+-- @field IRST
+-- @field RWR
+
+--- Enum that stores types of optic sensors.
+-- @type Unit.OpticType
+-- @field TV TV-sensor
+-- @field LLTV Low-level TV-sensor
+-- @field IR Infra-Red optic sensor
+
+--- Enum that stores radar types.
+-- @type Unit.RadarType
+-- @field AS air search radar
+-- @field SS surface/land search radar
+
+
+--- A unit descriptor. 
+-- @type Unit.Desc
+-- @extends Object#Object.Desc
+-- @field #Unit.Category category Unit Category
+-- @field #Mass massEmpty mass of empty unit
+-- @field #number speedMax istance / Time, --maximal velocity
+
+--- An aircraft descriptor. 
+-- @type Unit.DescAircraft
+-- @extends Unit#Unit.Desc
+-- @field #Mass fuelMassMax maximal inner fuel mass
+-- @field #Distance range Operational range
+-- @field #Distance Hmax Ceiling
+-- @field #number VyMax  #Distance / #Time, --maximal climb rate
+-- @field #number NyMin minimal safe acceleration
+-- @field #number NyMax maximal safe acceleration
+-- @field #Unit.RefuelingSystem tankerType refueling system type
+
+--- An airplane descriptor.
+-- @type Unit.DescAirplane 
+-- @extends Unit#Unit.DescAircraft
+-- @field #number speedMax0 Distance / Time maximal TAS at ground level
+-- @field #number speedMax10K Distance / Time maximal TAS at altitude of 10 km
+
+--- A helicopter descriptor.
+-- @type Unit.DescHelicopter 
+-- @extends Unit#Unit.DescAircraft
+-- @field #Distance HmaxStat static ceiling
+
+--- A vehicle descriptor.
+-- @type Unit.DescVehicle 
+-- @extends Unit#Unit.Desc
+-- @field #Angle maxSlopeAngle maximal slope angle
+-- @field #boolean riverCrossing can the vehicle cross a rivers
+
+--- A ship descriptor.
+-- @type Unit.DescShip 
+-- @extends #Unit.Desc
+ 
+--- ammunition item: "type-count" pair.
+-- @type Unit.AmmoItem
+-- @field #Weapon.Desc desc ammunition descriptor
+-- @field #number count ammunition count
+
+--- A unit sensor.
+-- @type Unit.Sensor
+-- @field #TypeName typeName
+-- @field #Unit.SensorType type
+
+--- An optic sensor.
+-- @type Unit.Optic 
+-- @extends Unit#Unit.Sensor
+-- @field #Unit.OpticType opticType
+
+--- A radar.
+-- @type  Unit.Radar 
+-- @extends Unit#Unit.Sensor
+-- @field #Distance detectionDistanceRBM detection distance for RCS=1m^2 in real-beam mapping mode, nil if radar doesn't support surface/land search
+-- @field #Distance detectionDistanceHRM detection distance for RCS=1m^2 in high-resolution mapping mode, nil if radar has no HRM
+-- @field #Unit.Radar.detectionDistanceAir detectionDistanceAir detection distance for RCS=1m^2 airborne target, nil if radar doesn't support air search
+
+--- @type Unit.Radar.detectionDistanceAir 
+-- @field #Unit.Radar.detectionDistanceAir.upperHemisphere upperHemisphere
+-- @field #Unit.Radar.detectionDistanceAir.lowerHemisphere lowerHemisphere
+
+--- @type Unit.Radar.detectionDistanceAir.upperHemisphere
+-- @field #Distance headOn
+-- @field #Distance tailOn
+
+--- @type Unit.Radar.detectionDistanceAir.lowerHemisphere 
+-- @field #Distance headOn
+-- @field #Distance tailOn
+
+--- An IRST.
+--  @type Unit#Unit.IRST 
+--  @extends Unit.Sensor
+--  @field #Distance detectionDistanceIdle detection of tail-on target with heat signature = 1 in upper hemisphere, engines are in idle
+--  @field #Distance detectionDistanceMaximal ..., engines are in maximal mode
+--  @field #Distance detectionDistanceAfterburner ..., engines are in afterburner mode
+
+--- An RWR.
+--  @type Unit.RWR 
+--  @extends Unit#Unit.Sensor
+
+--- table that stores all unit sensors.
+-- TODO @type Sensors
+-- 
+
+
+--- Returns unit object by the name assigned to the unit in Mission Editor. If there is unit with such name or the unit is destroyed the function will return nil. The function provides access to non-activated units too. 
+-- @function [parent=#Unit] getByName
+-- @param #string name
+-- @return #Unit
+
+--- Returns if the unit is activated.
+-- @function [parent=#Unit] isActive
+-- @param #Unit self
+-- @return #boolean
+
+--- Returns name of the player that control the unit or nil if the unit is controlled by A.I.
+-- @function [parent=#Unit] getPlayerName
+-- @param #Unit self
+-- @return #string
+
+--- returns the unit's unique identifier.
+-- @function [parent=#Unit] getID
+-- @param #Unit self
+-- @return #Unit.ID
+
+
+--- Returns the unit's number in the group. The number is the same number the unit has in ME. It may not be changed during the mission. If any unit in the group is destroyed, the numbers of another units will not be changed.
+-- @function [parent=#Unit] getNumber
+-- @param #Unit self
+-- @return #number
+
+--- Returns controller of the unit if it exist and nil otherwise
+-- @function [parent=#Unit] getController
+-- @param #Unit self
+-- @return #Controller
+
+--- Returns the unit's group if it exist and nil otherwise
+-- @function [parent=#Unit] getGroup
+-- @param #Unit self
+-- @return DCSGroup#Group
+
+--- Returns the unit's callsign - the localized string.
+-- @function [parent=#Unit] getCallsign
+-- @param #Unit self
+-- @return #string
+
+--- Returns the unit's health. Dead units has health <= 1.0
+-- @function [parent=#Unit] getLife
+-- @param #Unit self
+-- @return #number
+
+--- returns the unit's initial health.
+-- @function [parent=#Unit] getLife0
+-- @param #Unit self
+-- @return #number
+
+--- Returns relative amount of fuel (from 0.0 to 1.0) the unit has in its internal tanks. If there are additional fuel tanks the value may be greater than 1.0.
+-- @function [parent=#Unit] getFuel
+-- @param #Unit self
+-- @return #number
+
+--- Returns the unit ammunition.
+-- @function [parent=#Unit] getAmmo
+-- @param #Unit self
+-- @return #Unit.Ammo
+
+--- Returns the unit sensors. 
+-- @function [parent=#Unit] getSensors
+-- @param #Unit self
+-- @return #Unit.Sensors
+
+--- Returns true if the unit has specified types of sensors. This function is more preferable than Unit.getSensors() if you don't want to get information about all the unit's sensors, and just want to check if the unit has specified types of sensors.
+-- @function [parent=#Unit] hasSensors
+-- @param #Unit self
+-- @param #Unit.SensorType sensorType (= nil) Sensor type.
+-- @param ... Additional parameters.
+-- @return #boolean
+-- @usage
+-- If sensorType is Unit.SensorType.OPTIC, additional parameters are optic sensor types. Following example checks if the unit has LLTV or IR optics:
+-- unit:hasSensors(Unit.SensorType.OPTIC, Unit.OpticType.LLTV, Unit.OpticType.IR)
+-- If sensorType is Unit.SensorType.RADAR, additional parameters are radar types. Following example checks if the unit has air search radars:
+-- unit:hasSensors(Unit.SensorType.RADAR, Unit.RadarType.AS)
+-- If no additional parameters are specified the function returns true if the unit has at least one sensor of specified type.
+-- If sensor type is not specified the function returns true if the unit has at least one sensor of any type.
+-- 
+
+--- returns two values:
+-- First value indicates if at least one of the unit's radar(s) is on.
+-- Second value is the object of the radar's interest. Not nil only if at least one radar of the unit is tracking a target. 
+-- @function [parent=#Unit] getRadar
+-- @param #Unit self
+-- @return #boolean, Object#Object
+
+--- Returns unit descriptor. Descriptor type depends on unit category. 
+-- @function [parent=#Unit] getDesc
+-- @param #Unit self
+-- @return #Unit.Desc
+
+
+Unit = {} --#Unit

Moose Development/Moose/Dcs/DCScountry.lua

@@ -0,0 +1,27 @@
+-------------------------------------------------------------------------------
+-- @module DCScountry
+
+--- @type country
+-- @field #country.id id
+country = country -- #country
+
+--- @type country.id
+-- @field RUSSIA
+-- @field UKRAINE
+-- @field USA
+-- @field TURKEY
+-- @field UK
+-- @field FRANCE
+-- @field GERMANY
+-- @field CANADA
+-- @field SPAIN
+-- @field THE_NETHERLANDS
+-- @field BELGIUM
+-- @field NORWAY
+-- @field DENMARK
+-- @field ISRAEL
+-- @field GEORGIA
+-- @field INSURGENTS
+-- @field ABKHAZIA
+-- @field SOUTH_OSETIA
+-- @field ITALY

Moose Development/Moose/Dcs/DCSenv.lua

@@ -0,0 +1,27 @@
+-------------------------------------------------------------------------------
+-- @module env
+
+--- @type env
+
+--- Add message to simulator log with caption "INFO". Message box is optional.
+-- @function [parent=#env] info
+-- @field #string message message string to add to log.
+-- @field #boolean showMessageBox If the parameter is true Message Box will appear. Optional.
+
+--- Add message to simulator log with caption "WARNING". Message box is optional. 
+-- @function [parent=#env] warning
+-- @field #string message message string to add to log.
+-- @field #boolean showMessageBox If the parameter is true Message Box will appear. Optional.
+
+--- Add message to simulator log with caption "ERROR". Message box is optional.
+-- @function [parent=#env] error
+-- @field #string message message string to add to log.
+-- @field #boolean showMessageBox If the parameter is true Message Box will appear. Optional.
+
+--- Enables/disables appearance of message box each time lua error occurs.
+-- @function [parent=#env] setErrorMessageBoxEnabled
+-- @field #boolean on if true message box appearance is enabled.
+
+
+
+env = {} --#env

Moose Development/Moose/Dcs/DCSland.lua

@@ -0,0 +1,26 @@
+-------------------------------------------------------------------------------
+-- @module land
+
+--- @type land
+-- @field #land.SurfaceType SurfaceType
+
+
+--- @type land.SurfaceType
+-- @field LAND
+-- @field SHALLOW_WATER
+-- @field WATER
+-- @field ROAD
+-- @field RUNWAY
+
+--- Returns altitude MSL of the point.
+-- @function [parent=#land] getHeight
+-- @param #Vec2 point point on the ground. 
+-- @return DCSTypes#Distance
+
+--- returns surface type at the given point.
+-- @function [parent=#land] getSurfaceType
+-- @param #Vec2 point Point on the land. 
+-- @return #land.SurfaceType
+
+
+land = {} --#land

Moose Development/Moose/Dcs/DCStimer.lua

@@ -0,0 +1,45 @@
+-------------------------------------------------------------------------------
+-- @module DCStimer
+
+--- @type timer
+
+
+--- Returns model time in seconds.
+-- @function [parent=#timer] getTime
+-- @return #Time   
+
+--- Returns mission time in seconds.
+-- @function [parent=#timer] getAbsTime
+-- @return #Time
+
+--- Returns mission start time in seconds.
+-- @function [parent=#timer] getTime0
+-- @return #Time
+
+--- Schedules function to call at desired model time.
+--  Time function FunctionToCall(any argument, Time time)
+--  
+--  ...
+--  
+--  return ...
+--  
+--  end
+--  
+--  Must return model time of next call or nil. Note that the DCS scheduler calls the function in protected mode and any Lua errors in the called function will be trapped and not reported. If the function triggers a Lua error then it will be terminated and not scheduled to run again. 
+-- @function [parent=#timer] scheduleFunction
+-- @param #FunctionToCall functionToCall Lua-function to call. Must have prototype of FunctionToCall. 
+-- @param functionArgument Function argument of any type to pass to functionToCall.
+-- @param #Time time Model time of the function call.
+-- @return functionId
+
+--- Re-schedules function to call at another model time.
+-- @function [parent=#timer] setFunctionTime 
+-- @param functionId Lua-function to call. Must have prototype of FunctionToCall. 
+-- @param #Time time Model time of the function call. 
+
+
+--- Removes the function from schedule.
+-- @function [parent=#timer] removeFunction
+-- @param functionId Function identifier to remove from schedule 
+
+timer = {} --#timer

Moose Development/Moose/Dcs/DCStrigger.lua

@@ -0,0 +1,5 @@
+-------------------------------------------------------------------------------
+-- @module DCStrigger
+
+
+trigger = {} --#timer

Moose Development/Moose/Dcs/DCSworld.lua

@@ -0,0 +1,35 @@
+-------------------------------------------------------------------------------
+-- @module DCSWorld
+
+--- @type world
+-- @field #world.event event
+
+
+--- @type world.event
+-- @field S_EVENT_INVALID
+-- @field S_EVENT_SHOT
+-- @field S_EVENT_HIT
+-- @field S_EVENT_TAKEOFF
+-- @field S_EVENT_LAND
+-- @field S_EVENT_CRASH
+-- @field S_EVENT_EJECTION
+-- @field S_EVENT_REFUELING
+-- @field S_EVENT_DEAD
+-- @field S_EVENT_PILOT_DEAD
+-- @field S_EVENT_BASE_CAPTURED
+-- @field S_EVENT_MISSION_START
+-- @field S_EVENT_MISSION_END
+-- @field S_EVENT_TOOK_CONTROL
+-- @field S_EVENT_REFUELING_STOP
+-- @field S_EVENT_BIRTH
+-- @field S_EVENT_HUMAN_FAILURE
+-- @field S_EVENT_ENGINE_STARTUP
+-- @field S_EVENT_ENGINE_SHUTDOWN
+-- @field S_EVENT_PLAYER_ENTER_UNIT
+-- @field S_EVENT_PLAYER_LEAVE_UNIT
+-- @field S_EVENT_PLAYER_COMMENT
+-- @field S_EVENT_SHOOTING_START
+-- @field S_EVENT_SHOOTING_END
+-- @field S_EVENT_MAX
+
+world = {} --#world

Moose Development/Moose/Fsm/Account.lua

@@ -0,0 +1,249 @@
+--- (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

Moose Development/Moose/Fsm/Assign.lua

@@ -0,0 +1,258 @@
+--- (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.MenuText, self.Menu, self.MenuAssign, self )
+    self.MenuRejectTask = MENU_GROUP_COMMAND:New( ProcessGroup, "Reject task " .. self.MenuText, 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

Moose Development/Moose/Fsm/Cargo.lua

@@ -1,12 +1,7 @@
 --- Management of logical cargo objects, that can be transported from and to transportation carriers.
 --
 -- ===
---
--- 1) @{Cargo#CARGO_BASE} class, extends @{Base#BASE}
--- ==================================================
--- The @{#CARGO_BASE} class defines the core functions that defines a cargo object within MOOSE.
--- A cargo is a logical object defined that is available for transport, and has a life status within a simulation.
---
+-- 
 -- Cargo can be of various forms, always are composed out of ONE object ( one unit or one static or one slingload crate ):
 --
 --   * CARGO_UNIT, represented by a @{Unit} in a @{Group}: Cargo can be represented by a Unit in a Group. Destruction of the Unit will mean that the cargo is lost.
@@ -16,20 +11,24 @@
 --   * CARGO_SLINGLOAD, represented by a @{Cargo} that is transportable: Cargo can be represented by a Cargo object that is transportable. Destruction of the Cargo will mean that the cargo is lost.
 --   
 --   * CARGO_GROUPED, represented by a Group of CARGO_UNITs.
+-- 
+-- 1) @{Cargo#CARGO_BASE} class, extends @{StateMachine#STATEMACHINE_PROCESS}
+-- ==========================================================================
+-- The @{#CARGO_BASE} class defines the core functions that defines a cargo object within MOOSE.
+-- A cargo is a logical object defined that is available for transport, and has a life status within a simulation.
 --
--- 1.2) CARGO state machine:
--- -------------------------
--- The CARGO is a state machine: it manages the different events and states of the cargo.
+-- 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) CARGO Events:
+-- ## 1.2.1) CARBO_BASE Events:
 -- 
---   * @{#CARGO.Board}( ToCarrier ):  Boards the cargo to a Carrier.
---   * @{#CARGO.Load}( ToCarrier ): Loads the cargo into a Carrier, regardless of its position.
---   * @{#CARGO.UnBoard}( ToPointVec2 ): UnBoard the cargo from a Carrier. This will trigger a movement of the cargo to the option ToPointVec2.
---   * @{#CARGO.UnLoad}( ToPointVec2 ): UnLoads the cargo from a Carrier.
---   * @{#CARGO.Dead}( Controllable ): The cargo is dead. The cargo process will be ended.
+--   * @{#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.
 -- 
--- ### 1.2.2) CARGO States:
+-- ## 1.2.2) CARBO_BASE States:
 -- 
 --   * **UnLoaded**: The cargo is unloaded from a carrier.
 --   * **Boarding**: The cargo is currently boarding (= running) into a carrier.
@@ -38,93 +37,144 @@
 --   * **Dead**: The cargo is dead ...
 --   * **End**: The process has come to an end.
 --   
--- ### 1.2.3) CARGO state transition functions:
+-- ## 1.2.3) CARBO_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 functions will be called by the state machine:
+-- There are 2 moments when state transition methods will be called by the state machine:
 -- 
 --   * **Before** the state transition. 
---     The state transition function needs to start with the name **OnBefore + the name of the state**. 
---     If the state transition function returns false, then the processing of the state transition will not be done!
+--     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 function needs to start with the name **OnAfter + the name of the state**. 
---     These state transition functions need to provide a return value, which is specified at the function description.
---     
+--     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.
+-- 
+-- 2) #CARGO_UNIT class
+-- ====================
+-- The CARGO_UNIT class defines a cargo that is represented by a UNIT object within the simulator, and can be transported by a carrier.
+-- Use the event functions as described above to Load, UnLoad, Board, UnBoard the CARGO_UNIT objects to and from carriers.
+-- 
+-- 5) #CARGO_GROUPED class
+-- =======================
+-- The CARGO_GROUPED class defines a cargo that is represented by a group of UNIT objects within the simulator, and can be transported by a carrier.
+-- Use the event functions as described above to Load, UnLoad, Board, UnBoard the CARGO_UNIT objects to and from carriers.
+-- 
+-- This module is still under construction, but is described above works already, and will keep working ...
+-- 
 -- @module Cargo
 
 -- Events
 
---- Event Function. The cargo must be in the **UnLoaded** state.
--- Boards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo to the Carrier.
--- @function [parent=#CARGO] Board
--- @param #CARGO self
+-- Board
+
+--- 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
 -- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
 
---- Event Function. The cargo must be in the **Loaded** state.
--- UnBoards the cargo to a Carrier. The event will create a movement (= running or driving) of the cargo from the Carrier.
--- @function [parent=#CARGO] UnBoard
--- @param #CARGO self
+--- 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
+-- @param #number DelaySeconds The amount of seconds to delay the action.
+-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
+
+
+-- UnBoard
+
+--- 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
 -- @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.
 
---- Event Function. The cargo must be in the **UnLoaded** state.
--- 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.
--- @function [parent=#CARGO] Load
--- @param #CARGO self
+--- 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
+-- @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.
+
+
+-- Load
+
+--- 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
 -- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
 
---- Event Function. The cargo must be in the **Loaded** state.
--- 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.
--- @function [parent=#CARGO] Board
--- @param #CARGO self
+--- 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
+-- @param #number DelaySeconds The amount of seconds to delay the action.
+-- @param Controllable#CONTROLLABLE ToCarrier The Carrier that will hold the cargo.
+
+
+-- UnLoad
+
+--- 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
+-- @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
+-- @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.
 
 -- State Transition Functions
 
 -- UnLoaded
 
---- @function [parent=#CARGO] OnBeforeUnLoaded
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnBeforeUnLoaded
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 -- @return #boolean
 
---- @function [parent=#CARGO] OnAfterUnLoaded
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnAfterUnLoaded
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 
 -- Loaded
 
---- @function [parent=#CARGO] OnBeforeLoaded
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnBeforeLoaded
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 -- @return #boolean
 
---- @function [parent=#CARGO] OnAfterLoaded
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnAfterLoaded
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 
 -- Boarding
 
---- @function [parent=#CARGO] OnBeforeBoarding
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnBeforeBoarding
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 -- @return #boolean
 
---- @function [parent=#CARGO] OnAfterBoarding
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnAfterBoarding
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 
 -- UnBoarding
 
---- @function [parent=#CARGO] OnBeforeUnBoarding
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnBeforeUnBoarding
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 -- @return #boolean
 
---- @function [parent=#CARGO] OnAfterUnBoarding
--- @param #CARGO self
+--- @function [parent=#CARBO_BASE] OnAfterUnBoarding
+-- @param #CARBO_BASE self
 -- @param Controllable#CONTROLLABLE Controllable
 
 
@@ -132,9 +182,9 @@
 
 CARGOS = {}
 
-do -- CARGO
+do -- CARBO_BASE
 
-  --- @type CARGO
+  --- @type CARBO_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.
@@ -147,8 +197,8 @@ do -- CARGO
   -- @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.
-  CARGO = {
-    ClassName = "CARGO",
+  CARBO_BASE = {
+    ClassName = "CARBO_BASE",
     Type = nil,
     Name = nil,
     Weight = nil,
@@ -160,20 +210,19 @@ do -- CARGO
     Containable = false,
   }
 
---- @type CARGO.CargoObjects
+--- @type CARBO_BASE.CargoObjects
 -- @map < #string, Positionable#POSITIONABLE > The alive POSITIONABLE objects representing the the cargo.
 
 
---- CARGO Constructor. This class is an abstract class and should not be instantiated.
--- @param #CARGO self
--- @param Mission#MISSION Mission
+--- CARBO_BASE Constructor. This class is an abstract class and should not be instantiated.
+-- @param #CARBO_BASE self
 -- @param #string Type
 -- @param #string Name
 -- @param #number Weight
 -- @param #number ReportRadius (optional)
 -- @param #number NearRadius (optional)
--- @return #CARGO
-function CARGO:New( Mission, Type, Name, Weight, ReportRadius, NearRadius )
+-- @return #CARBO_BASE
+function CARBO_BASE:New( Type, Name, Weight, ReportRadius, NearRadius )
 
   FSMT = {
     initial = 'UnLoaded',
@@ -189,7 +238,7 @@ function CARGO:New( Mission, Type, Name, Weight, ReportRadius, NearRadius )
     },
   }
 
-  local self = BASE:Inherit( self, STATEMACHINE_PROCESS:New( FSMT ) ) -- #CARGO
+  local self = BASE:Inherit( self, STATEMACHINE_PROCESS:New( FSMT ) ) -- #CARBO_BASE
   self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
 
 
@@ -214,20 +263,20 @@ function CARGO:New( Mission, Type, Name, Weight, ReportRadius, NearRadius )
 end
 
 
---- Template method to spawn a new representation of the CARGO in the simulator.
--- @param #CARGO self
--- @return #CARGO
-function CARGO:Spawn( PointVec2 )
+--- 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 )
   self:F()
 
 end
 
 
 --- Check if CargoCarrier is near the Cargo to be Loaded.
--- @param #CARGO self
+-- @param #CARBO_BASE self
 -- @param Point#POINT_VEC2 PointVec2
 -- @return #boolean
-function CARGO:IsNear( PointVec2 )
+function CARBO_BASE:IsNear( PointVec2 )
   self:F( { PointVec2 } )
 
   local Distance = PointVec2:DistanceFromPointVec2( self.CargoObject:GetPointVec2() )
@@ -245,14 +294,13 @@ end
 do -- CARGO_REPRESENTABLE
 
   --- @type CARGO_REPRESENTABLE
-  -- @extends #CARGO
+  -- @extends #CARBO_BASE
   CARGO_REPRESENTABLE = {
     ClassName = "CARGO_REPRESENTABLE"
   }
 
 --- CARGO_REPRESENTABLE Constructor.
 -- @param #CARGO_REPRESENTABLE self
--- @param Mission#MISSION Mission
 -- @param Controllable#Controllable CargoObject
 -- @param #string Type
 -- @param #string Name
@@ -260,8 +308,8 @@ do -- CARGO_REPRESENTABLE
 -- @param #number ReportRadius (optional)
 -- @param #number NearRadius (optional)
 -- @return #CARGO_REPRESENTABLE
-function CARGO_REPRESENTABLE:New( Mission, CargoObject, Type, Name, Weight, ReportRadius, NearRadius )
-  local self = BASE:Inherit( self, CARGO:New( Mission, Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO
+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
   self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
 
   
@@ -290,7 +338,7 @@ function CARGO_REPRESENTABLE:RouteTo( ToPointVec2, Speed )
   return self  
 end
 
-end -- CARGO
+end -- CARBO_BASE
 
 do -- CARGO_UNIT
 
@@ -302,7 +350,6 @@ do -- CARGO_UNIT
 
 --- CARGO_UNIT Constructor.
 -- @param #CARGO_UNIT self
--- @param Mission#MISSION Mission
 -- @param Unit#UNIT CargoUnit
 -- @param #string Type
 -- @param #string Name
@@ -310,8 +357,8 @@ do -- CARGO_UNIT
 -- @param #number ReportRadius (optional)
 -- @param #number NearRadius (optional)
 -- @return #CARGO_UNIT
-function CARGO_UNIT:New( Mission, CargoUnit, Type, Name, Weight, ReportRadius, NearRadius )
-  local self = BASE:Inherit( self, CARGO_REPRESENTABLE:New( Mission, CargoUnit, Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO_UNIT
+function CARGO_UNIT:New( CargoUnit, Type, Name, Weight, ReportRadius, NearRadius )
+  local self = BASE:Inherit( self, CARGO_REPRESENTABLE:New( CargoUnit, Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO_UNIT
   self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
 
   self:T( CargoUnit )
@@ -555,7 +602,6 @@ do -- CARGO_PACKAGE
 
 --- CARGO_PACKAGE Constructor.
 -- @param #CARGO_PACKAGE self
--- @param Mission#MISSION Mission
 -- @param Unit#UNIT CargoCarrier The UNIT carrying the package.
 -- @param #string Type
 -- @param #string Name
@@ -563,8 +609,8 @@ do -- CARGO_PACKAGE
 -- @param #number ReportRadius (optional)
 -- @param #number NearRadius (optional)
 -- @return #CARGO_PACKAGE
-function CARGO_PACKAGE:New( Mission, CargoCarrier, Type, Name, Weight, ReportRadius, NearRadius )
-  local self = BASE:Inherit( self, CARGO_REPRESENTABLE:New( Mission, CargoCarrier, Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO_PACKAGE
+function CARGO_PACKAGE:New( CargoCarrier, Type, Name, Weight, ReportRadius, NearRadius )
+  local self = BASE:Inherit( self, CARGO_REPRESENTABLE:New( CargoCarrier, Type, Name, Weight, ReportRadius, NearRadius ) ) -- #CARGO_PACKAGE
   self:F( { Type, Name, Weight, ReportRadius, NearRadius } )
 
   self:T( CargoCarrier )
@@ -770,7 +816,7 @@ end
 do -- CARGO_GROUP
 
   --- @type CARGO_GROUP
-  -- @extends Cargo#CARGO
+  -- @extends Cargo#CARBO_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 = {
@@ -787,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, CARGO:New( Type, Name, 0, ReportRadius, NearRadius ) ) -- #CARGO_GROUP
+  local self = BASE:Inherit( self, CARBO_BASE:New( Type, Name, 0, ReportRadius, NearRadius ) ) -- #CARGO_GROUP
   self:F( { Type, Name, ReportRadius, NearRadius } )
 
   self.CargoSet = CargoSet

Moose Development/Moose/Fsm/Patrol.lua

@@ -1,10 +1,10 @@
---- This module contains the PROCESS\_PATROLZONE class.
+--- (AI) (FSM) Make AI patrol routes or zones.
 -- 
 -- ===
 -- 
--- 1) @{#PROCESS_PATROLZONE} class, extends @{StateMachine#STATEMACHINE}
+-- 1) @{#PATROLZONE} class, extends @{StateMachine#STATEMACHINE}
 -- ================================================================
--- The @{#PROCESS_PATROLZONE} class implements the core functions to patrol a @{Zone} by an AIR @{Controllable}.
+-- The @{#PATROLZONE} class implements the core functions to patrol a @{Zone} by an AIR @{Controllable} @{Group}.
 -- The patrol algorithm works that for each airplane patrolling, upon arrival at the patrol zone,
 -- a random point is selected as the route point within the 3D space, within the given boundary limits.
 -- The airplane will fly towards the random 3D point within the patrol zone, using a random speed within the given altitude and speed limits.
@@ -12,47 +12,47 @@
 -- This cycle will continue until a fuel treshold has been reached by the airplane.
 -- When the fuel treshold has been reached, the airplane will fly towards the nearest friendly airbase and will land.
 -- 
--- 1.1) PROCESS\_PATROLZONE constructor:
+-- 1.1) PATROLZONE constructor:
 -- ----------------------------
 --   
---   * @{#PROCESS_PATROLZONE.New}(): Creates a new PROCESS\_PATROLZONE object.
+--   * @{#PATROLZONE.New}(): Creates a new PATROLZONE object.
 -- 
--- 1.2) PROCESS\_PATROLZONE state machine:
+-- 1.2) PATROLZONE state machine:
 -- ----------------------------------
--- The PROCESS\_PATROLZONE is a state machine: it manages the different events and states of the AIControllable it is controlling.
+-- The PATROLZONE is a state machine: it manages the different events and states of the AIControllable it is controlling.
 -- 
--- ### 1.2.1) PROCESS\_PATROLZONE Events:
+-- ### 1.2.1) PATROLZONE Events:
 -- 
---   * @{#PROCESS_PATROLZONE.Route}( AIControllable ):  A new 3D route point is selected and the AIControllable will fly towards that point with the given speed.
---   * @{#PROCESS_PATROLZONE.Patrol}( AIControllable ): The AIControllable reports it is patrolling. This event is called every 30 seconds.
---   * @{#PROCESS_PATROLZONE.RTB}( AIControllable ): The AIControllable will report return to base.
---   * @{#PROCESS_PATROLZONE.End}( AIControllable ): The end of the PROCESS\_PATROLZONE process.
---   * @{#PROCESS_PATROLZONE.Dead}( AIControllable ): The AIControllable is dead. The PROCESS\_PATROLZONE process will be ended.
+--   * @{#PATROLZONE.Route}( AIControllable ):  A new 3D route point is selected and the AIControllable will fly towards that point with the given speed.
+--   * @{#PATROLZONE.Patrol}( AIControllable ): The AIControllable reports it is patrolling. This event is called every 30 seconds.
+--   * @{#PATROLZONE.RTB}( AIControllable ): The AIControllable will report return to base.
+--   * @{#PATROLZONE.End}( AIControllable ): The end of the PATROLZONE process.
+--   * @{#PATROLZONE.Dead}( AIControllable ): The AIControllable is dead. The PATROLZONE process will be ended.
 -- 
--- ### 1.2.2) PROCESS\_PATROLZONE States:
+-- ### 1.2.2) PATROLZONE States:
 -- 
 --   * **Route**: A new 3D route point is selected and the AIControllable will fly towards that point with the given speed.
---   * **Patrol**: The AIControllable is patrolling. This state is set every 30 seconds, so every 30 seconds, a state transition function can be used.
+--   * **Patrol**: The AIControllable is patrolling. This state is set every 30 seconds, so every 30 seconds, a state transition method can be used.
 --   * **RTB**: The AIControllable reports it wants to return to the base.
 --   * **Dead**: The AIControllable is dead ...
 --   * **End**: The process has come to an end.
 --   
--- ### 1.2.3) PROCESS\_PATROLZONE state transition functions:
+-- ### 1.2.3) PATROLZONE 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 functions will be called by the state machine:
+-- There are 2 moments when state transition methods will be called by the state machine:
 -- 
 --   * **Before** the state transition. 
---     The state transition function needs to start with the name **OnBefore + the name of the state**. 
---     If the state transition function returns false, then the processing of the state transition will not be done!
+--     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 function needs to start with the name **OnAfter + the name of the state**. 
---     These state transition functions need to provide a return value, which is specified at the function description.
+--     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.
 --
--- An example how to manage a state transition for an PROCESS\_PATROLZONE object **Patrol** for the state **RTB**:
+-- An example how to manage a state transition for an PATROLZONE object **Patrol** for the state **RTB**:
 -- 
 --      local PatrolZoneGroup = GROUP:FindByName( "Patrol Zone" )
 --      local PatrolZone = ZONE_POLYGON:New( "PatrolZone", PatrolZoneGroup )
@@ -60,46 +60,46 @@
 --      local PatrolSpawn = SPAWN:New( "Patrol Group" )
 --      local PatrolGroup = PatrolSpawn:Spawn()
 --
---      local Patrol = PROCESS_PATROLZONE:New( PatrolZone, 3000, 6000, 300, 600 )
+--      local Patrol = PATROLZONE:New( PatrolZone, 3000, 6000, 300, 600 )
 --      Patrol:SetControllable( PatrolGroup )
 --      Patrol:ManageFuel( 0.2, 60 )
 --
--- **OnBefore**RTB( AIGroup ) will be called by the PROCESS\_PATROLZONE object when the AIGroup reports RTB, but **before** the RTB default action is processed by the PROCESS_PATROLZONE object.
+-- **OnBefore**RTB( AIGroup ) will be called by the PATROLZONE object when the AIGroup reports RTB, but **before** the RTB default action is processed by the PATROLZONE object.
 --
---      --- State transition function for the PROCESS\_PATROLZONE **Patrol** object
---      -- @param #PROCESS_PATROLZONE self 
+--      --- State transition function for the PATROLZONE **Patrol** object
+--      -- @param #PATROLZONE self 
 --      -- @param Controllable#CONTROLLABLE AIGroup
---      -- @return #boolean If false is returned, then the OnAfter state transition function will not be called.
+--      -- @return #boolean If false is returned, then the OnAfter state transition method will not be called.
 --      function Patrol:OnBeforeRTB( AIGroup )
 --        AIGroup:MessageToRed( "Returning to base", 20 )
 --      end
 --       
--- **OnAfter**RTB( AIGroup ) will be called by the PROCESS\_PATROLZONE object when the AIGroup reports RTB, but **after** the RTB default action was processed by the PROCESS_PATROLZONE object.
+-- **OnAfter**RTB( AIGroup ) will be called by the PATROLZONE object when the AIGroup reports RTB, but **after** the RTB default action was processed by the PATROLZONE object.
 --
---      --- State transition function for the PROCESS\_PATROLZONE **Patrol** object
---      -- @param #PROCESS_PATROLZONE self 
+--      --- State transition function for the PATROLZONE **Patrol** object
+--      -- @param #PATROLZONE self 
 --      -- @param Controllable#CONTROLLABLE AIGroup
 --      -- @return #Controllable#CONTROLLABLE The new AIGroup object that is set to be patrolling the zone.
 --      function Patrol:OnAfterRTB( AIGroup )
 --        return PatrolSpawn:Spawn()
 --      end 
 --    
--- 1.3) Manage the PROCESS\_PATROLZONE parameters:
+-- 1.3) Manage the PATROLZONE parameters:
 -- ------------------------------------------
--- The following methods are available to modify the parameters of a PROCESS\_PATROLZONE object:
+-- The following methods are available to modify the parameters of a PATROLZONE object:
 -- 
---   * @{#PROCESS_PATROLZONE.SetControllable}(): Set the AIControllable.
---   * @{#PROCESS_PATROLZONE.GetControllable}(): Get the AIControllable.
---   * @{#PROCESS_PATROLZONE.SetSpeed}(): Set the patrol speed of the AI, for the next patrol.
---   * @{#PROCESS_PATROLZONE.SetAltitude}(): Set altitude of the AI, for the next patrol.
+--   * @{#PATROLZONE.SetControllable}(): Set the AIControllable.
+--   * @{#PATROLZONE.GetControllable}(): Get the AIControllable.
+--   * @{#PATROLZONE.SetSpeed}(): Set the patrol speed of the AI, for the next patrol.
+--   * @{#PATROLZONE.SetAltitude}(): Set altitude of the AI, for the next patrol.
 -- 
--- 1.3) Manage the out of fuel in the PROCESS\_PATROLZONE:
+-- 1.3) Manage the out of fuel in the PATROLZONE:
 -- ----------------------------------------------
 -- When the AIControllable is out of fuel, it is required that a new AIControllable is started, before the old AIControllable can return to the home base.
 -- Therefore, with a parameter and a calculation of the distance to the home base, the fuel treshold is calculated.
--- When the fuel treshold is reached, the AIControllable will continue for a given time its patrol task in orbit, while a new AIControllable is targetted to the PROCESS\_PATROLZONE.
+-- When the fuel treshold is reached, the AIControllable will continue for a given time its patrol task in orbit, while a new AIControllable is targetted to the PATROLZONE.
 -- Once the time is finished, the old AIControllable will return to the base.
--- Use the method @{#PROCESS_PATROLZONE.ManageFuel}() to have this proces in place.
+-- Use the method @{#PATROLZONE.ManageFuel}() to have this proces in place.
 -- 
 -- ====
 -- 
@@ -113,9 +113,7 @@
 -- 
 -- Hereby the change log:
 -- 
--- 2016-08-17: PROCESS\_PATROLZONE:New( **PatrolSpawn,** PatrolZone, PatrolFloorAltitude, PatrolCeilingAltitude, PatrolMinSpeed, PatrolMaxSpeed ) replaces PROCESS\_PATROLZONE:New( PatrolZone, PatrolFloorAltitude, PatrolCeilingAltitude, PatrolMinSpeed, PatrolMaxSpeed )
--- 
--- 2016-07-01: Initial class and API.
+-- 2016-09-01: Initial class and API.
 -- 
 -- ===
 -- 
@@ -132,25 +130,25 @@
 --   * **FlightControl**: Design & Programming.
 -- 
 -- 
--- @module Process_PatrolZone
+-- @module Patrol
 
 -- State Transition Functions
 
 --- OnBefore State Transition Function
--- @function [parent=#PROCESS_PATROLZONE] OnBeforeRoute
--- @param #PROCESS_PATROLZONE self
+-- @function [parent=#PATROLZONE] OnBeforeRoute
+-- @param #PATROLZONE self
 -- @param Controllable#CONTROLLABLE Controllable
 -- @return #boolean
 
 --- OnAfter State Transition Function
--- @function [parent=#PROCESS_PATROLZONE] OnAfterRoute
--- @param #PROCESS_PATROLZONE self
+-- @function [parent=#PATROLZONE] OnAfterRoute
+-- @param #PATROLZONE self
 -- @param Controllable#CONTROLLABLE Controllable
 
 
 
---- PROCESS\_PATROLZONE class
--- @type PROCESS_PATROLZONE
+--- PATROLZONE class
+-- @type PATROLZONE
 -- @field Controllable#CONTROLLABLE AIControllable The @{Controllable} patrolling.
 -- @field Zone#ZONE_BASE PatrolZone The @{Zone} where the patrol needs to be executed.
 -- @field DCSTypes#Altitude PatrolFloorAltitude The lowest altitude in meters where to execute the patrol.
@@ -158,26 +156,26 @@
 -- @field DCSTypes#Speed  PatrolMinSpeed The minimum speed of the @{Controllable} in km/h.
 -- @field DCSTypes#Speed  PatrolMaxSpeed The maximum speed of the @{Controllable} in km/h.
 -- @extends StateMachine#STATEMACHINE_CONTROLLABLE
-PROCESS_PATROLZONE = {
-  ClassName = "PROCESS_PATROLZONE",
+PATROLZONE = {
+  ClassName = "PATROLZONE",
 }
 
 
 
---- Creates a new PROCESS\_PATROLZONE object
--- @param #PROCESS_PATROLZONE self
+--- Creates a new PATROLZONE object
+-- @param #PATROLZONE self
 -- @param Zone#ZONE_BASE PatrolZone The @{Zone} where the patrol needs to be executed.
 -- @param DCSTypes#Altitude PatrolFloorAltitude The lowest altitude in meters where to execute the patrol.
 -- @param DCSTypes#Altitude PatrolCeilingAltitude The highest altitude in meters where to execute the patrol.
 -- @param DCSTypes#Speed  PatrolMinSpeed The minimum speed of the @{Controllable} in km/h.
 -- @param DCSTypes#Speed  PatrolMaxSpeed The maximum speed of the @{Controllable} in km/h.
--- @return #PROCESS_PATROLZONE self
+-- @return #PATROLZONE self
 -- @usage
--- -- Define a new PROCESS_PATROLZONE Object. This PatrolArea will patrol an AIControllable within PatrolZone between 3000 and 6000 meters, with a variying speed between 600 and 900 km/h.
+-- -- Define a new PATROLZONE Object. This PatrolArea will patrol an AIControllable within PatrolZone between 3000 and 6000 meters, with a variying speed between 600 and 900 km/h.
 -- PatrolZone = ZONE:New( 'PatrolZone' )
 -- PatrolSpawn = SPAWN:New( 'Patrol Group' )
--- PatrolArea = PROCESS_PATROLZONE:New( PatrolZone, 3000, 6000, 600, 900 )
-function PROCESS_PATROLZONE:New( PatrolZone, PatrolFloorAltitude, PatrolCeilingAltitude, PatrolMinSpeed, PatrolMaxSpeed )
+-- PatrolArea = PATROLZONE:New( PatrolZone, 3000, 6000, 600, 900 )
+function PATROLZONE:New( PatrolZone, PatrolFloorAltitude, PatrolCeilingAltitude, PatrolMinSpeed, PatrolMaxSpeed )
 
   local FSMT = {
     initial = 'None',
@@ -207,11 +205,11 @@ end
 
 
 --- Sets (modifies) the minimum and maximum speed of the patrol.
--- @param #PROCESS_PATROLZONE self
+-- @param #PATROLZONE self
 -- @param DCSTypes#Speed  PatrolMinSpeed The minimum speed of the @{Controllable} in km/h.
 -- @param DCSTypes#Speed  PatrolMaxSpeed The maximum speed of the @{Controllable} in km/h.
--- @return #PROCESS_PATROLZONE self
-function PROCESS_PATROLZONE:SetSpeed( PatrolMinSpeed, PatrolMaxSpeed )
+-- @return #PATROLZONE self
+function PATROLZONE:SetSpeed( PatrolMinSpeed, PatrolMaxSpeed )
   self:F2( { PatrolMinSpeed, PatrolMaxSpeed } )
   
   self.PatrolMinSpeed = PatrolMinSpeed
@@ -221,11 +219,11 @@ end
 
 
 --- Sets the floor and ceiling altitude of the patrol.
--- @param #PROCESS_PATROLZONE self
+-- @param #PATROLZONE self
 -- @param DCSTypes#Altitude PatrolFloorAltitude The lowest altitude in meters where to execute the patrol.
 -- @param DCSTypes#Altitude PatrolCeilingAltitude The highest altitude in meters where to execute the patrol.
--- @return #PROCESS_PATROLZONE self
-function PROCESS_PATROLZONE:SetAltitude( PatrolFloorAltitude, PatrolCeilingAltitude )
+-- @return #PATROLZONE self
+function PATROLZONE:SetAltitude( PatrolFloorAltitude, PatrolCeilingAltitude )
   self:F2( { PatrolFloorAltitude, PatrolCeilingAltitude } )
   
   self.PatrolFloorAltitude = PatrolFloorAltitude
@@ -238,7 +236,7 @@ end
 function _NewPatrolRoute( AIControllable )
 
   AIControllable:T( "NewPatrolRoute" )
-  local PatrolZone = AIControllable:GetState( AIControllable, "PatrolZone" ) -- PatrolZone#PROCESS_PATROLZONE
+  local PatrolZone = AIControllable:GetState( AIControllable, "PatrolZone" ) -- PatrolZone#PATROLZONE
   PatrolZone:__Route( 1 )
 end
 
@@ -247,13 +245,13 @@ end
 
 --- When the AIControllable is out of fuel, it is required that a new AIControllable is started, before the old AIControllable can return to the home base.
 -- Therefore, with a parameter and a calculation of the distance to the home base, the fuel treshold is calculated.
--- When the fuel treshold is reached, the AIControllable will continue for a given time its patrol task in orbit, while a new AIControllable is targetted to the PROCESS\_PATROLZONE.
+-- When the fuel treshold is reached, the AIControllable will continue for a given time its patrol task in orbit, while a new AIControllable is targetted to the PATROLZONE.
 -- Once the time is finished, the old AIControllable will return to the base.
--- @param #PROCESS_PATROLZONE self
+-- @param #PATROLZONE self
 -- @param #number PatrolFuelTresholdPercentage The treshold in percentage (between 0 and 1) when the AIControllable is considered to get out of fuel.
 -- @param #number PatrolOutOfFuelOrbitTime The amount of seconds the out of fuel AIControllable will orbit before returning to the base.
--- @return #PROCESS_PATROLZONE self
-function PROCESS_PATROLZONE:ManageFuel( PatrolFuelTresholdPercentage, PatrolOutOfFuelOrbitTime )
+-- @return #PATROLZONE self
+function PATROLZONE:ManageFuel( PatrolFuelTresholdPercentage, PatrolOutOfFuelOrbitTime )
 
   self.PatrolManageFuel = true
   self.PatrolFuelTresholdPercentage = PatrolFuelTresholdPercentage
@@ -263,9 +261,9 @@ function PROCESS_PATROLZONE:ManageFuel( PatrolFuelTresholdPercentage, PatrolOutO
 end
 
 --- Defines a new patrol route using the @{Process_PatrolZone} parameters and settings.
--- @param #PROCESS_PATROLZONE self
--- @return #PROCESS_PATROLZONE self
-function PROCESS_PATROLZONE:onenterRoute()
+-- @param #PATROLZONE self
+-- @return #PATROLZONE self
+function PATROLZONE:onenterRoute()
 
   self:F2()
 
@@ -360,8 +358,8 @@ function PROCESS_PATROLZONE:onenterRoute()
 end
 
 
---- @param #PROCESS_PATROLZONE self
-function PROCESS_PATROLZONE:onenterPatrol()
+--- @param #PATROLZONE self
+function PATROLZONE:onenterPatrol()
   self:F2()
 
   if self.Controllable and self.Controllable:IsAlive() then

Moose Development/Moose/Fsm/Process.lua

@@ -2,17 +2,13 @@
 
 --- The PROCESS class
 -- @type PROCESS
--- @field Scheduler#SCHEDULER ProcessScheduler
--- @field Unit#UNIT ProcessUnit
 -- @field Group#GROUP ProcessGroup
 -- @field Menu#MENU_GROUP MissionMenu
 -- @field Task#TASK_BASE Task
--- @field StateMachine#STATEMACHINE_TASK Fsm
 -- @field #string ProcessName
--- @extends Base#BASE
+-- @extends StateMachine#STATEMACHINE_CONTROLLABLE
 PROCESS = {
-  ClassName = "TASK",
-  ProcessScheduler = nil,
+  ClassName = "PROCESS",
   NextEvent = nil,
   Scores = {},
 }
@@ -23,66 +19,55 @@ PROCESS = {
 -- @param Task#TASK_BASE Task
 -- @param Unit#UNIT ProcessUnit
 -- @return #PROCESS self
-function PROCESS:New( ProcessName, Task, ProcessUnit )
-  local self = BASE:Inherit( self, BASE:New() )
+function PROCESS:New( FSMT, ProcessUnit, ProcessName )
+  local self = BASE:Inherit( self, STATEMACHINE_CONTROLLABLE:New( FSMT, ProcessUnit ) )
   self:F()
 
-  self.ProcessUnit = ProcessUnit
   self.ProcessGroup = ProcessUnit:GetGroup()
-  self.MissionMenu = Task.Mission:GetMissionMenu( self.ProcessGroup )
-  self.Task = Task
+  --self.MissionMenu = Task.Mission:GetMissionMenu( self.ProcessGroup )
   self.ProcessName = ProcessName
   
-  self.ProcessScheduler = SCHEDULER:New()
-  
   return self
 end
 
---- @param #PROCESS self
-function PROCESS:NextEvent( NextEvent, ... )
-  self:F(self.ProcessName)
-  self.ProcessScheduler:Schedule( self.Fsm, NextEvent, arg, 1 ) -- This schedules the next event, but only if scheduling is activated.
-end
-
---- @param #PROCESS self
-function PROCESS:StopEvents()
-  self:F( { "Stop Process ", self.ProcessName } )
-  self.ProcessScheduler:Stop()
-end
-
 --- Adds a score for the PROCESS to be achieved.
 -- @param #PROCESS self
--- @param #string ProcessStatus is the status of the PROCESS when the score needs to be given.
+-- @param Task#TASK_BASE Task The task for which the process needs to account score.
+-- @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 )
+function PROCESS:AddScore( Task, 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
+  self.Scores[ProcessStatus].Task = Task
+  
   return self
 end
 
 --- StateMachine callback function for a PROCESS
 -- @param #PROCESS self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
+-- @param Controllable#CONTROLLABLE ProcessUnit
 -- @param #string Event
 -- @param #string From
 -- @param #string To
-function PROCESS:OnStateChange( Fsm, Event, From, To )
-  self:E( { self.ProcessName, Event, From, To, self.ProcessUnit.UnitName } )
+function PROCESS:OnStateChange( ProcessUnit, Event, From, To )
+  self:E( { self.ProcessName, Event, From, To, ProcessUnit.UnitName } )
 
   if self:IsTrace() then
     MESSAGE:New( "Process " .. self.ProcessName .. " : " .. Event .. " changed to state " .. To, 15 ):ToAll()
   end
 
+  -- 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 Scoring = self.Task:GetScoring()
+  
+    local Task = self.Scores[To].Task  
+    local Scoring = Task:GetScoring()
     if Scoring then
-      Scoring:_AddMissionTaskScore( self.Task.Mission, self.ProcessUnit, self.Scores[To].ScoreText, self.Scores[To].Score )
+      Scoring:_AddMissionTaskScore( Task.Mission, ProcessUnit, self.Scores[To].ScoreText, self.Scores[To].Score )
     end
   end
 end

Moose Development/Moose/Fsm/Process_Smoke.lua

@@ -21,13 +21,7 @@ do -- PROCESS_SMOKE_TARGETS
   -- @return #PROCESS_SMOKE_TARGETS self
   function PROCESS_SMOKE_TARGETS:New( Task, ProcessUnit, TargetSetUnit, TargetZone )
   
-    -- Inherits from BASE
-    local self = BASE:Inherit( self, PROCESS:New( "ASSIGN_MENU_ACCEPT", Task, ProcessUnit ) ) -- #PROCESS_SMOKE_TARGETS
-    
-    self.TargetSetUnit = TargetSetUnit
-    self.TargetZone = TargetZone
-    
-    self.Fsm = STATEMACHINE_PROCESS:New( self, {
+    local FSMT = {
       initial = 'None',
       events = {
         { name = 'Start',  from = 'None',  to = 'AwaitSmoke' },
@@ -44,49 +38,56 @@ do -- PROCESS_SMOKE_TARGETS
       },
       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 for a TASK2
+  --- StateMachine callback function
   -- @param #PROCESS_SMOKE_TARGETS self
-  -- @param StateMachine#STATEMACHINE_TASK Fsm
+  -- @param Controllable#CONTROLLABLE ProcessUnit
   -- @param #string Event
   -- @param #string From
   -- @param #string To
-  function PROCESS_SMOKE_TARGETS:OnStart( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
+  function PROCESS_SMOKE_TARGETS:OnStart( ProcessUnit, Event, From, To )
+    self:E( { Event, From, To, ProcessUnit.UnitName} )
   
     self:E("Set smoke menu")
   
-    local ProcessGroup = self.ProcessUnit:GetGroup()
-    local MissionMenu = self.Task.Mission:GetMissionMenu( ProcessGroup )
+    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:NextEvent( self.Fsm.Next )
+      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 } )
+    --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 for a TASK2
+  --- StateMachine callback function
   -- @param #PROCESS_SMOKE_TARGETS self
-  -- @param StateMachine#STATEMACHINE_PROCESS Fsm
+  -- @param Controllable#CONTROLLABLE ProcessUnit
   -- @param #string Event
   -- @param #string From
   -- @param #string To
-  function PROCESS_SMOKE_TARGETS:OnSmoking( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
+  function PROCESS_SMOKE_TARGETS:OnSmoking( ProcessUnit, Event, From, To )
+    self:E( { Event, From, To, ProcessUnit.UnitName} )
     
     self.TargetSetUnit:ForEachUnit(
       --- @param Unit#UNIT SmokeUnit

Moose Development/Moose/Fsm/Route.lua

@@ -0,0 +1,233 @@
+--- (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

Moose Development/Moose/Functional/AIBalancer.lua

@@ -10,7 +10,7 @@
 -- of the underlying AI GROUPS.
 -- 
 -- The parent class @{StateMachine#STATEMACHINE_SET} manages the functionality to control the Finite State Machine (FSM) 
--- and calls for each event the state transition functions providing the internal @{StateMachine#STATEMACHINE_SET.Set} object containing the
+-- and calls for each event the state transition methods providing the internal @{StateMachine#STATEMACHINE_SET.Set} object containing the
 -- SET_GROUP and additional event parameters provided during the event.
 -- 
 -- 1.1) AIBALANCER construction method

Moose Development/Moose/Moose.lua

@@ -1,61 +1,60 @@
 --- The main include file for the MOOSE system.
 
 --- Core Routines
-Include.File( "Routines" )
-Include.File( "Utils" )
+Include.File( "Utilities/Routines" )
+Include.File( "Utilities/Utils" )
 
 --- Core Classes
-Include.File( "Base" )
-Include.File( "Object" )
-Include.File( "Identifiable" )
-Include.File( "Positionable" )
-Include.File( "Controllable" )
-Include.File( "Scheduler" )
-Include.File( "Event" )
-Include.File( "Menu" )
-Include.File( "Group" )
-Include.File( "Unit" )
-Include.File( "Zone" )
-Include.File( "Client" )
-Include.File( "Static" )
-Include.File( "Airbase" )
-Include.File( "Database" )
-Include.File( "Set" )
-Include.File( "Point" )
-Include.File( "Scoring" )
+Include.File( "Core/Base" )
+Include.File( "Core/Scheduler" )
+Include.File( "Core/Event" )
+Include.File( "Core/Menu" )
+Include.File( "Core/Zone" )
+Include.File( "Core/Database" )
+Include.File( "Core/Set" )
+Include.File( "Core/Point" )
+Include.File( "Core/Message" )
+Include.File( "Core/StateMachine" )
+
+--- Wrapper Classes
+Include.File( "Wrapper/Object" )
+Include.File( "Wrapper/Identifiable" )
+Include.File( "Wrapper/Positionable" )
+Include.File( "Wrapper/Controllable" )
+Include.File( "Wrapper/Group" )
+Include.File( "Wrapper/Unit" )
+Include.File( "Wrapper/Client" )
+Include.File( "Wrapper/Static" )
+Include.File( "Wrapper/Airbase" )
 
 --- Functional Classes
-Include.File( "Cargo" )
-Include.File( "Message" )
-Include.File( "Mission" )
-Include.File( "CleanUp" )
-Include.File( "Spawn" )
-Include.File( "Movement" )
-Include.File( "Sead" )
-Include.File( "Escort" )
-Include.File( "MissileTrainer" )
-Include.File( "AirbasePolice" )
-Include.File( "Detection" )
+Include.File( "Functional/Scoring" )
+Include.File( "Functional/CleanUp" )
+Include.File( "Functional/Spawn" )
+Include.File( "Functional/Movement" )
+Include.File( "Functional/Sead" )
+Include.File( "Functional/Escort" )
+Include.File( "Functional/MissileTrainer" )
+Include.File( "Functional/AirbasePolice" )
+Include.File( "Functional/Detection" )
+Include.File( "Functional/AIBalancer" )
+
+--- Process Classes
+Include.File( "Fsm/Process" )
+Include.File( "Fsm/Assign" )
+Include.File( "Fsm/Route" )
+Include.File( "Fsm/Process_Smoke" )
+Include.File( "Fsm/Account" )
+Include.File( "Fsm/Process_JTAC" )
+Include.File( "Fsm/Patrol" )
+Include.File( "Fsm/Cargo" )
 
 --- Task Handling Classes
-Include.File( "DetectionManager" )
-
-Include.File( "StateMachine" )
-
-Include.File( "Process" )
-Include.File( "Process_Assign" )
-Include.File( "Process_Route" )
-Include.File( "Process_Smoke" )
-Include.File( "Process_Destroy" )
-Include.File( "Process_JTAC" )
-Include.File( "Process_PatrolZone" )
-
-Include.File( "Task" )
-Include.File( "Task_SEAD" )
-Include.File( "Task_A2G" )
-
---- AI Set Handling Classes
-Include.File( "AIBalancer" )
+Include.File( "Tasking/Mission" )
+Include.File( "Tasking/Task" )
+Include.File( "Tasking/DetectionManager" )
+Include.File( "Tasking/Task_SEAD" )
+Include.File( "Tasking/Task_A2G" )
 
 
 -- The order of the declarations is important here. Don't touch it.

Moose Development/Moose/Process_Assign.lua

@@ -1,185 +0,0 @@
---- This module contains the PROCESS_ASSIGN classes.
--- 
--- ===
--- 
--- 1) @{Task_Assign#TASK_ASSIGN_ACCEPT} class, extends @{Task#TASK_BASE}
--- =====================================================================
--- The @{Task_Assign#TASK_ASSIGN_ACCEPT} class accepts by default a task for a player. No player intervention is allowed to reject the task.
--- 
--- 2) @{Task_Assign#TASK_ASSIGN_MENU_ACCEPT} class, extends @{Task#TASK_BASE}
--- ==========================================================================
--- The @{Task_Assign#TASK_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.
--- 
--- 
--- 
--- 
--- 
--- 
--- @module Task_Assign
--- 
-
-
-do -- PROCESS_ASSIGN_ACCEPT
-
-  --- PROCESS_ASSIGN_ACCEPT class
-  -- @type PROCESS_ASSIGN_ACCEPT
-  -- @field Task#TASK_BASE Task
-  -- @field Unit#UNIT ProcessUnit
-  -- @field Zone#ZONE_BASE TargetZone
-  -- @extends Task2#TASK2
-  PROCESS_ASSIGN_ACCEPT = { 
-    ClassName = "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 Task#TASK Task
-  -- @param Unit#UNIT Unit
-  -- @return #PROCESS_ASSIGN_ACCEPT self
-  function PROCESS_ASSIGN_ACCEPT:New( Task, ProcessUnit, TaskBriefing )
-  
-    -- Inherits from BASE
-    local self = BASE:Inherit( self, PROCESS:New( "ASSIGN_ACCEPT", Task, ProcessUnit ) ) -- #PROCESS_ASSIGN_ACCEPT
-    
-    self.TaskBriefing = TaskBriefing
-    
-    self.Fsm = STATEMACHINE_PROCESS:New( self, {
-      initial = 'UnAssigned',
-      events = {
-        { name = 'Start',  from = 'UnAssigned',  to = 'Assigned' },
-        { name = 'Fail',   from = 'UnAssigned',  to = 'Failed' },
-      },
-      callbacks = {
-        onAssign = self.OnAssign,
-      },
-      endstates = {
-        'Assigned', 'Failed'
-      },
-    } )
-    
-    return self
-  end
-  
-  --- StateMachine callback function for a TASK2
-  -- @param #PROCESS_ASSIGN_ACCEPT self
-  -- @param StateMachine#STATEMACHINE_PROCESS Fsm
-  -- @param #string Event
-  -- @param #string From
-  -- @param #string To
-  function PROCESS_ASSIGN_ACCEPT:OnAssigned( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
-    
-  end
-
-end
-
-
-do -- PROCESS_ASSIGN_MENU_ACCEPT
-
-  --- PROCESS_ASSIGN_MENU_ACCEPT class
-  -- @type PROCESS_ASSIGN_MENU_ACCEPT
-  -- @field Task#TASK_BASE Task
-  -- @field Unit#UNIT ProcessUnit
-  -- @field Zone#ZONE_BASE TargetZone
-  -- @extends Task2#TASK2
-  PROCESS_ASSIGN_MENU_ACCEPT = { 
-    ClassName = "PROCESS_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 #PROCESS_ASSIGN_MENU_ACCEPT self
-  -- @param Task#TASK Task
-  -- @param Unit#UNIT Unit
-  -- @return #PROCESS_ASSIGN_MENU_ACCEPT self
-  function PROCESS_ASSIGN_MENU_ACCEPT:New( Task, ProcessUnit, TaskBriefing )
-  
-    -- Inherits from BASE
-    local self = BASE:Inherit( self, PROCESS:New( "ASSIGN_MENU_ACCEPT", Task, ProcessUnit ) ) -- #PROCESS_ASSIGN_MENU_ACCEPT
-    
-    self.TaskBriefing = TaskBriefing
-    
-    self.Fsm = STATEMACHINE_PROCESS:New( self, {
-      initial = 'UnAssigned',
-      events = {
-        { name = 'Start',  from = 'UnAssigned',  to = 'AwaitAccept' },
-        { name = 'Assign',  from = 'AwaitAccept',  to = 'Assigned' },
-        { name = 'Reject',  from = 'AwaitAccept',  to = 'Rejected' },
-        { name = 'Fail',  from = 'AwaitAccept',  to = 'Rejected' },
-      },
-      callbacks = {
-        onStart = self.OnStart,
-        onAssign = self.OnAssign,
-        onReject = self.OnReject,
-      },
-      endstates = {
-        'Assigned', 'Rejected'
-      },
-    } )
-    
-    return self
-  end
-  
-  --- StateMachine callback function for a TASK2
-  -- @param #PROCESS_ASSIGN_MENU_ACCEPT self
-  -- @param StateMachine#STATEMACHINE_TASK Fsm
-  -- @param #string Event
-  -- @param #string From
-  -- @param #string To
-  function PROCESS_ASSIGN_MENU_ACCEPT:OnStart( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
-  
-    MESSAGE:New( self.TaskBriefing .. "\nAccess the radio menu to accept the task. You have 30 seconds or the assignment will be cancelled.", 30, "Assignment" ):ToGroup( self.ProcessUnit:GetGroup() )
-    self.MenuText = self.Task.TaskName
-   
-    local ProcessGroup = self.ProcessUnit:GetGroup() 
-    self.Menu = MENU_GROUP:New( ProcessGroup, "Task " .. self.MenuText .. " acceptance" )
-    self.MenuAcceptTask = MENU_GROUP_COMMAND:New( ProcessGroup, "Accept task " .. self.MenuText, self.Menu, self.MenuAssign, self )
-    self.MenuRejectTask = MENU_GROUP_COMMAND:New( ProcessGroup, "Reject task " .. self.MenuText, self.Menu, self.MenuReject, self )
-  end
-  
-  --- Menu function.
-  -- @param #PROCESS_ASSIGN_MENU_ACCEPT self
-  function PROCESS_ASSIGN_MENU_ACCEPT:MenuAssign()
-    self:E( )
-  
-    self:NextEvent( self.Fsm.Assign )
-  end
-  
-  --- Menu function.
-  -- @param #PROCESS_ASSIGN_MENU_ACCEPT self
-  function PROCESS_ASSIGN_MENU_ACCEPT:MenuReject()
-    self:E( )
-  
-    self:NextEvent( self.Fsm.Reject )
-  end
-  
-  --- StateMachine callback function for a TASK2
-  -- @param #PROCESS_ASSIGN_MENU_ACCEPT self
-  -- @param StateMachine#STATEMACHINE_PROCESS Fsm
-  -- @param #string Event
-  -- @param #string From
-  -- @param #string To
-  function PROCESS_ASSIGN_MENU_ACCEPT:OnAssign( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
-  
-    self.Menu:Remove()
-  end
-  
-  --- StateMachine callback function for a TASK2
-  -- @param #PROCESS_ASSIGN_MENU_ACCEPT self
-  -- @param StateMachine#STATEMACHINE_PROCESS Fsm
-  -- @param #string Event
-  -- @param #string From
-  -- @param #string To
-  function PROCESS_ASSIGN_MENU_ACCEPT:OnReject( Fsm, Event, From, To )
-    self:E( { Event, From, To, self.ProcessUnit.UnitName} )
-  
-    self.Menu:Remove()
-    self.Task:UnAssignFromUnit( self.ProcessUnit )
-    self.ProcessUnit:Destroy()
-  end
-end

Moose Development/Moose/Process_Destroy.lua

@@ -1,180 +0,0 @@
---- @module Process_Destroy
-
---- PROCESS_DESTROY class
--- @type PROCESS_DESTROY
--- @field Unit#UNIT ProcessUnit
--- @field Set#SET_UNIT TargetSetUnit
--- @extends Process#PROCESS
-PROCESS_DESTROY = { 
-  ClassName = "PROCESS_DESTROY",
-  Fsm = {},
-  TargetSetUnit = nil,
-}
-
-
---- Creates a new DESTROY process.
--- @param #PROCESS_DESTROY self
--- @param Task#TASK Task
--- @param Unit#UNIT ProcessUnit
--- @param Set#SET_UNIT TargetSetUnit
--- @return #PROCESS_DESTROY self
-function PROCESS_DESTROY:New( Task, ProcessName, ProcessUnit, TargetSetUnit )
-
-  -- Inherits from BASE
-  local self = BASE:Inherit( self, PROCESS:New( ProcessName, Task, ProcessUnit ) ) -- #PROCESS_DESTROY
-  
-  self.TargetSetUnit = TargetSetUnit
-
-  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
-
-  self.Fsm = STATEMACHINE_PROCESS:New( self, {
-    initial = 'Assigned',
-    events = {
-      { name = 'Start', from = 'Assigned', to = 'Waiting'    },
-      { name = 'Start', from = 'Waiting', to = 'Waiting'    },
-      { name = 'HitTarget',  from = 'Waiting',    to = 'Destroy' },
-      { name = 'MoreTargets', from = 'Destroy', to = 'Waiting'  },
-      { name = 'Destroyed', from = 'Destroy', to = 'Success' },      
-      { name = 'Fail', from = 'Assigned', to = 'Failed' },
-      { name = 'Fail', from = 'Waiting', to = 'Failed' },
-      { name = 'Fail', from = 'Destroy', to = 'Failed' },
-    },
-    callbacks = {
-      onStart =  self.OnStart,
-      onWaiting = self.OnWaiting,
-      onHitTarget =  self.OnHitTarget,
-      onMoreTargets = self.OnMoreTargets,
-      onDestroyed = self.OnDestroyed,
-      onKilled = self.OnKilled,
-    },
-    endstates = { 'Success', 'Failed' }
-  } )
-
-
-  _EVENTDISPATCHER:OnDead( self.EventDead, self )
-  
-  return self
-end
-
---- Process Events
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_DESTROY:OnStart( Fsm, Event, From, To )
-
-  self:NextEvent( Fsm.Start )
-end
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_DESTROY:OnWaiting( Fsm, Event, From, To )
-
-  local TaskGroup = self.ProcessUnit:GetGroup()
-  if self.DisplayCount >= self.DisplayInterval then
-    MESSAGE:New( "Your group with assigned " .. self.Task:GetName() .. " task has " .. self.TargetSetUnit:GetUnitTypesText() .. " targets left to be destroyed.", 5, "HQ" ):ToGroup( TaskGroup )
-    self.DisplayCount = 1
-  else
-    self.DisplayCount = self.DisplayCount + 1
-  end
-  
-  return true -- Process always the event.
-  
-end
-
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
--- @param Event#EVENTDATA Event
-function PROCESS_DESTROY:OnHitTarget( Fsm, Event, From, To, Event )
-
-
-  self.TargetSetUnit:Flush()
-  
-  if self.TargetSetUnit:FindUnit( Event.IniUnitName ) then
-    self.TargetSetUnit:RemoveUnitsByName( Event.IniUnitName )
-    local TaskGroup = self.ProcessUnit:GetGroup()
-    MESSAGE:New( "You hit a target. Your group with assigned " .. self.Task:GetName() .. " task has " .. self.TargetSetUnit:Count() .. " targets ( " .. self.TargetSetUnit:GetUnitTypesText() .. " ) left to be destroyed.", 15, "HQ" ):ToGroup( TaskGroup )
-  end
-
-  
-  if self.TargetSetUnit:Count() > 0 then
-    self:NextEvent( Fsm.MoreTargets )
-  else
-    self:NextEvent( Fsm.Destroyed )
-  end
-end
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_DESTROY:OnMoreTargets( Fsm, Event, From, To )
-
-
-end
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
--- @param Event#EVENTDATA DCSEvent
-function PROCESS_DESTROY:OnKilled( Fsm, Event, From, To )
-
-  self:NextEvent( Fsm.Restart )
-
-end
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_DESTROY:OnRestart( Fsm, Event, From, To )
-
-  self:NextEvent( Fsm.Menu )
-
-end
-
---- StateMachine callback function for a PROCESS
--- @param #PROCESS_DESTROY self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_DESTROY:OnDestroyed( Fsm, Event, From, To )
-
-end
-
---- DCS Events
-
---- @param #PROCESS_DESTROY self
--- @param Event#EVENTDATA Event
-function PROCESS_DESTROY:EventDead( Event )
-
-  if Event.IniDCSUnit then
-    self:NextEvent( self.Fsm.HitTarget, Event )
-  end
-end
-
-

Moose Development/Moose/Process_Route.lua

@@ -1,86 +0,0 @@
---- @module Task_Route
-
---- PROCESS_ROUTE class
--- @type PROCESS_ROUTE
--- @field Task#TASK TASK
--- @field Unit#UNIT ProcessUnit
--- @field Zone#ZONE_BASE TargetZone
--- @extends Task2#TASK2
-PROCESS_ROUTE = { 
-  ClassName = "PROCESS_ROUTE",
-}
-
-
---- Creates a new routing state machine. The task will route a CLIENT to a ZONE until the CLIENT is within that ZONE.
--- @param #PROCESS_ROUTE self
--- @param Task#TASK Task
--- @param Unit#UNIT Unit
--- @return #PROCESS_ROUTE self
-function PROCESS_ROUTE:New( Task, ProcessUnit, TargetZone )
-
-  -- Inherits from BASE
-  local self = BASE:Inherit( self, PROCESS:New( "ROUTE", Task, ProcessUnit ) ) -- #PROCESS_ROUTE
-  
-  self.TargetZone = TargetZone
-  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
-  
-  self.Fsm = STATEMACHINE_PROCESS:New( self, {
-    initial = 'UnArrived',
-    events = {
-      { name = 'Start',  from = 'UnArrived',  to = 'UnArrived' },
-      { name = 'Fail',  from = 'UnArrived',  to = 'Failed' },
-    },
-    callbacks = {
-      onleaveUnArrived = self.OnLeaveUnArrived,
-      onFail = self.OnFail,
-    },
-    endstates = {
-      'Arrived', 'Failed'
-    },
-  } )
-  
-  return self
-end
-
---- Task Events
-
---- StateMachine callback function for a TASK2
--- @param #PROCESS_ROUTE self
--- @param StateMachine#STATEMACHINE_PROCESS Fsm
--- @param #string Event
--- @param #string From
--- @param #string To
-function PROCESS_ROUTE:OnLeaveUnArrived( Fsm, Event, From, To )
-
-  if self.ProcessUnit:IsAlive() then
-    local IsInZone = self.ProcessUnit:IsInZone( self.TargetZone )
-  
-    if self.DisplayCount >= self.DisplayInterval then
-      if not IsInZone then
-        local ZoneVec2 = self.TargetZone:GetVec2()
-        local ZonePointVec2 = POINT_VEC2:New( ZoneVec2.x, ZoneVec2.y )
-        local TaskUnitVec2 = self.ProcessUnit:GetVec2()
-        local TaskUnitPointVec2 = POINT_VEC2:New( TaskUnitVec2.x, TaskUnitVec2.y )
-        local RouteText = self.ProcessUnit:GetCallsign() .. ": Route to " .. TaskUnitPointVec2:GetBRText( ZonePointVec2 ) .. " km to target."
-        MESSAGE:New( RouteText, self.DisplayTime, self.DisplayCategory  ):ToGroup( self.ProcessUnit:GetGroup() )
-      end
-      self.DisplayCount = 1
-    else
-      self.DisplayCount = self.DisplayCount + 1
-    end
-    
-    --if not IsInZone then
-      self:NextEvent( Fsm.Start )
-    --end
-  
-    return IsInZone -- if false, then the event will not be executed...
-  end
-  
-  return false
-  
-end
-

Moose Development/Moose/Tasking/Task.lua

@@ -59,14 +59,14 @@
 TASK_BASE = {
   ClassName = "TASK_BASE",
   TaskScheduler = nil,
-  Processes = {},
+  ProcessClasses = {}, -- The container of the Process classes that will be used to create and assign new processes for the task to ProcessUnits.
+  Processes = {}, -- The container of actual process objects instantiated and assigned to ProcessUnits.
   Players = nil,
   Scores = {},
   Menu = {},
   SetGroup = nil,
 }
 
-
 --- Instantiates a new TASK_BASE. Should never be used. Interface Class.
 -- @param #TASK_BASE self
 -- @param Mission#MISSION The mission wherein the Task is registered.
@@ -113,6 +113,7 @@ end
 --- Assign the @{Task}to a @{Group}.
 -- @param #TASK_BASE self
 -- @param Group#GROUP TaskGroup
+-- @return #TASK_BASE
 function TASK_BASE:AssignToGroup( TaskGroup )
   self:F2( TaskGroup:GetName() )
   
@@ -131,6 +132,8 @@ function TASK_BASE:AssignToGroup( TaskGroup )
       self:AssignToUnit( TaskUnit )
     end
   end
+  
+  return self
 end
 
 --- Send the briefng message of the @{Task} to the assigned @{Group}s.
@@ -401,19 +404,61 @@ function TASK_BASE:GetTaskName()
 end
 
 
---- Add Process to @{Task} with key @{Unit}.
+--- This is the key worker function for the class. Instantiate a new Process based on the ProcessName to @{Task} and assign it to the ProcessUnit.
 -- @param #TASK_BASE self
--- @param Unit#UNIT TaskUnit
--- @return #TASK_BASE self
-function TASK_BASE:AddProcess( TaskUnit, Process )
-  local TaskUnitName = TaskUnit:GetName()
+-- @param Unit#UNIT ProcessUnit The unit to which the process should be assigned.
+-- @param #string ProcessName The name of the Process.
+-- @return Process#PROCESS The Process that was added.
+function TASK_BASE:AssignProcess( ProcessUnit, ProcessName )
+  self:F( { ProcessName } )
+  local ProcessUnitName = ProcessUnit:GetName()
+  
+  -- Create the Process instance base on the ProcessClasses collection assigned to the Task
+  local ProcessClass, ProcessArguments 
+  ProcessClass, ProcessArguments = self:GetProcessClass( ProcessName )
+  
+  local Process = ProcessClass:New( unpack( ProcessArguments ) ) -- Process#PROCESS
+  Process:SetControllable( ProcessUnit )
+  
   self.Processes = self.Processes or {}
-  self.Processes[TaskUnitName] = self.Processes[TaskUnitName] or {}
-  self.Processes[TaskUnitName][#self.Processes[TaskUnitName]+1] = Process
+  self.Processes[ProcessUnitName] = self.Processes[ProcessUnitName] or {}
+    
+  self.Processes[ProcessUnitName][ProcessName] = Process
+  
   return Process
 end
 
 
+--- Get the default or currently assigned @{Process} class with key ProcessName.
+-- @param #TASK_BASE self
+-- @param #string ProcessName
+-- @return Process#PROCESS
+-- @return #table
+function TASK_BASE:GetProcessClass( ProcessName )
+
+  local ProcessClass = self.ProcessClasses[ProcessName].Class
+  local ProcessArguments = self.ProcessClasses[ProcessName].Arguments
+  
+  return ProcessClass, ProcessArguments
+end
+
+
+--- Set the Process default class with key ProcessName providing the ProcessClass and the constructor initialization parameters when it is assigned to a Unit by the task.
+-- @param #TASK_BASE self
+-- @param #string ProcessName
+-- @param Process#PROCESS ProcessClass
+-- @param #table ... The parameters for the New() constructor of the ProcessClass, when the Task is assigning a new Process to the Unit.
+-- @return Process#PROCESS
+function TASK_BASE:SetProcessClass( ProcessName, ProcessClass, ... )
+
+  self.ProcessClasses[ProcessName] = self.ProcessClasses[ProcessName] or {}
+  self.ProcessClasses[ProcessName].Class = ProcessClass
+  self.ProcessClasses[ProcessName].Arguments = ...
+  
+  return ProcessClass
+end
+
+
 --- Remove Processes from @{Task} with key @{Unit}
 -- @param #TASK_BASE self
 -- @param #string TaskUnitName
@@ -749,6 +794,7 @@ function TASK_BASE:AddScore( TaskStatus, ScoreText, Score )
   return self
 end
 
+
 --- StateMachine callback function for a TASK
 -- @param #TASK_BASE self
 -- @param Unit#UNIT TaskUnit

Moose Development/Moose/Tasking/Task_A2G.lua

@@ -1,4 +1,4 @@
---- This module contains the TASK_A2G classes.
+--- (AI) (SP) (MP) Tasking for Air to Ground Processes.
 -- 
 -- 1) @{#TASK_A2G} class, extends @{Task#TASK_BASE}
 -- =================================================

Moose Development/Moose/Tasking/Task_SEAD.lua

@@ -19,6 +19,7 @@
 -- @module Task_SEAD
 
 
+
 do -- TASK_SEAD
 
   --- The TASK_SEAD class
@@ -43,6 +44,18 @@ do -- TASK_SEAD
   
     self.TargetSetUnit = TargetSetUnit
     self.TargetZone = TargetZone
+    
+    -- ASSIGN_ACCEPT:New(TaskBriefing)
+    self:SetProcessClass( "ASSIGN", ASSIGN_ACCEPT, self.TaskBriefing )
+    
+    -- ROUTE_ZONE:New(TargetZone)
+    self:SetProcessClass( "ROUTE", ROUTE_ZONE, self.TargetZone )
+    
+    -- ACCOUNT_DEADS:New(TargetSetUnit,TaskName)
+    self:SetProcessClass( "ACCOUNT", ACCOUNT_DEADS, self.TargetSetUnit, "SEAD" )
+    
+    -- SMOKE_TARGETS_ZONE:New( self.TargetSetUnit, self.TargetZone )
+    --self:SetProcessClass( "SMOKE", SMOKE_TARGETS_ZONE, self.TargetSetUnit, self.TargetZone )
 
     _EVENTDISPATCHER:OnPlayerLeaveUnit( self._EventPlayerLeaveUnit, self )
     _EVENTDISPATCHER:OnDead( self._EventDead, self )
@@ -71,38 +84,31 @@ do -- TASK_SEAD
   function TASK_SEAD:AssignToUnit( TaskUnit )
     self:F( TaskUnit:GetName() )
     
-    local ProcessAssign = self:AddProcess( TaskUnit, PROCESS_ASSIGN_ACCEPT:New( self, TaskUnit, self.TaskBriefing ) )
-    local ProcessRoute = self:AddProcess( TaskUnit, PROCESS_ROUTE:New( self, TaskUnit, self.TargetZone ) )
-    local ProcessSEAD = self:AddProcess( TaskUnit, PROCESS_DESTROY:New( self, "SEAD", TaskUnit, self.TargetSetUnit ) )
-    local ProcessSmoke = self:AddProcess( TaskUnit, PROCESS_SMOKE_TARGETS:New( self, TaskUnit, self.TargetSetUnit, self.TargetZone ) )
+    local ProcessAssign = self:AssignProcess( TaskUnit, "ASSIGN" )
+    local ProcessRoute = self:AssignProcess( TaskUnit, "ROUTE" )
+    local ProcessSEAD = self:AssignProcess( TaskUnit, "ACCOUNT" )
+    --local ProcessSmoke = self:AssignProcess( TaskUnit, "SMOKE" )
     
-    local Process = self:AddStateMachine( TaskUnit, STATEMACHINE_TASK:New( self, TaskUnit, {
+    local FSMT = {
         initial = 'None',
         events = {
-          { name = 'Next',   from = 'None',           to = 'Planned' },
+          { name = 'Next',    from = 'None',          to = 'Planned' },
           { name = 'Next',    from = 'Planned',       to = 'Assigned' },
           { name = 'Reject',  from = 'Planned',       to = 'Rejected' }, 
           { name = 'Next',    from = 'Assigned',      to = 'Success' },
           { name = 'Fail',    from = 'Assigned',      to = 'Failed' }, 
           { name = 'Fail',    from = 'Arrived',       to = 'Failed' }     
         },
-        callbacks = {
-          onNext = self.OnNext,
-          onRemove = self.OnRemove,
-        },
         subs = {
-          Assign = {  onstateparent = 'Planned',          oneventparent = 'Next',        fsm = ProcessAssign.Fsm,         event = 'Start',      returnevents = { 'Next', 'Reject' } },
-          Route = {   onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessRoute.Fsm,         event = 'Start'       },
-          Sead = {    onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessSEAD.Fsm,          event = 'Start',      returnevents = { 'Next' } },
-          Smoke = {   onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessSmoke.Fsm,         event = 'Start',      }
+          Assign = {  onstateparent = 'Planned',          oneventparent = 'Next',         fsm = ProcessAssign,        event = 'Start',      returnevents = { 'Next', 'Reject' } },
+          Route = {   onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessRoute,         event = 'Start'       },
+          Sead = {    onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessSEAD,          event = 'Start',      returnevents = { 'Next' } },
+          --Smoke = {   onstateparent = 'Assigned',         oneventparent = 'Next',         fsm = ProcessSmoke,         event = 'Start',      }
         }
-      } ) )
-    
-    ProcessRoute:AddScore( "Failed", "failed to destroy a radar", -100 )
-    ProcessSEAD:AddScore( "Destroy", "destroyed a radar", 25 )
-    ProcessSEAD:AddScore( "Failed", "failed to destroy a radar", -100 )
-    self:AddScore( "Success", "Destroyed all target radars", 250 )
+      }
     
+    local Process = self:AddStateMachine( TaskUnit, STATEMACHINE_TASK:New( FSMT, self, TaskUnit ) )
+
     Process:Next()
   
     return self
@@ -115,32 +121,15 @@ do -- TASK_SEAD
   -- @param #string From
   -- @param #string To
   -- @param Event#EVENTDATA Event
-  function TASK_SEAD:OnNext( Fsm, Event, From, To )
+  function TASK_SEAD:onafterNext( Fsm, Event, From, To )
   
     self:SetState( self, "State", To )
   
   end
   
-  
   --- @param #TASK_SEAD self
   function TASK_SEAD:GetPlannedMenuText()
     return self:GetStateString() .. " - " .. self:GetTaskName() .. " ( " .. self.TargetSetUnit:GetUnitTypesText() .. " )"
   end
   
-  --- @param #TASK_SEAD self
-  function TASK_SEAD:_Schedule()
-    self:F2()
-  
-    self.TaskScheduler = SCHEDULER:New( self, _Scheduler, {}, 15, 15 )
-    return self
-  end
-  
-  
-  --- @param #TASK_SEAD self
-  function TASK_SEAD._Scheduler()
-    self:F2()
-  
-    return true
-  end
-
 end