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

Added lots of new GROUP functions

Browse Source
This commit is contained in:
FlightControl 2016-06-02 14:47:05 +02:00
parent ac1d9485cd
commit 8b01579a42
64 changed files with 5548 additions and 1632 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

290
Moose Development/Moose/Airbase.lua Normal file
View File

@ -0,0 +1,290 @@
--- AIRBASE Class
--
-- @{AIRBASE} class
-- ==============
-- The @{AIRBASE} class is a wrapper class to handle the DCS Airbase objects:
--
-- * Support all DCS Airbase APIs.
-- * Enhance with Airbase specific APIs not in the DCS Airbase API set.
--
--
-- AIRBASE reference methods
-- ======================
-- For each DCS Airbase object alive within a running mission, a AIRBASE wrapper object (instance) will be created within the _@{DATABASE} object.
-- This is done at the beginning of the mission (when the mission starts).
--
-- The AIRBASE class **does not contain a :New()** method, rather it provides **:Find()** methods to retrieve the object reference
-- using the DCS Airbase or the DCS AirbaseName.
--
-- Another thing to know is that AIRBASE objects do not "contain" the DCS Airbase object.
-- The AIRBASE methods will reference the DCS Airbase object by name when it is needed during API execution.
-- If the DCS Airbase object does not exist or is nil, the AIRBASE methods will return nil and log an exception in the DCS.log file.
--
-- The AIRBASE class provides the following functions to retrieve quickly the relevant AIRBASE instance:
--
-- * @{#AIRBASE.Find}(): Find a AIRBASE instance from the _DATABASE object using a DCS Airbase object.
-- * @{#AIRBASE.FindByName}(): Find a AIRBASE instance from the _DATABASE object using a DCS Airbase name.
--
-- IMPORTANT: ONE SHOULD NEVER SANATIZE these AIRBASE OBJECT REFERENCES! (make the AIRBASE object references nil).
--
-- DCS AIRBASE APIs
-- =============
-- The DCS Airbase APIs are used extensively within MOOSE. The AIRBASE class has for each DCS Airbase API a corresponding method.
-- To be able to distinguish easily in your code the difference between a AIRBASE API call and a DCS Airbase API call,
-- the first letter of the method is also capitalized. So, by example, the DCS Airbase method @{DCSAirbase#Airbase.getName}()
-- is implemented in the AIRBASE class as @{#AIRBASE.GetName}().
--
-- More functions will be added
-- ----------------------------
-- During the MOOSE development, more functions will be added.
--
-- @module Airbase
-- @author FlightControl
Include.File( "Routines" )
Include.File( "Base" )
Include.File( "Message" )
--- The AIRBASE class
-- @type AIRBASE
-- @extends Base#BASE
AIRBASE = {
ClassName="AIRBASE",
CategoryName = {
[Airbase.Category.AIRDROME] = "Airdrome",
[Airbase.Category.HELIPAD] = "Helipad",
[Airbase.Category.SHIP] = "Ship",
},
}
-- Registration.
--- Create a new AIRBASE from DCSAirbase.
-- @param #AIRBASE self
-- @param DCSAirbase#Airbase DCSAirbase
-- @param Database#DATABASE Database
-- @return Airbase#AIRBASE
function AIRBASE:Register( AirbaseName )
local self = BASE:Inherit( self, BASE:New() )
self:F2( AirbaseName )
self.AirbaseName = AirbaseName
return self
end
-- Reference methods.
--- Finds a AIRBASE from the _DATABASE using a DCSAirbase object.
-- @param #AIRBASE self
-- @param DCSAirbase#Airbase DCSAirbase An existing DCS Airbase object reference.
-- @return Airbase#AIRBASE self
function AIRBASE:Find( DCSAirbase )
local AirbaseName = DCSAirbase:getName()
local AirbaseFound = _DATABASE:FindAirbase( AirbaseName )
return AirbaseFound
end
--- Find a AIRBASE in the _DATABASE using the name of an existing DCS Airbase.
-- @param #AIRBASE self
-- @param #string AirbaseName The Airbase Name.
-- @return Airbase#AIRBASE self
function AIRBASE:FindByName( AirbaseName )
local AirbaseFound = _DATABASE:FindAirbase( AirbaseName )
return AirbaseFound
end
function AIRBASE:GetDCSAirbase()
local DCSAirbase = Airbase.getByName( self.AirbaseName )
if DCSAirbase then
return DCSAirbase
end
return nil
end
--- Returns coalition of the Airbase.
-- @param Airbase#AIRBASE self
-- @return DCSCoalitionObject#coalition.side The side of the coalition.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetCoalition()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseCoalition = DCSAirbase:getCoalition()
self:T3( AirbaseCoalition )
return AirbaseCoalition
end
return nil
end
--- Returns country of the Airbase.
-- @param Airbase#AIRBASE self
-- @return DCScountry#country.id The country identifier.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetCountry()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseCountry = DCSAirbase:getCountry()
self:T3( AirbaseCountry )
return AirbaseCountry
end
return nil
end
--- Returns DCS Airbase object name.
-- The function provides access to non-activated units too.
-- @param Airbase#AIRBASE self
-- @return #string The name of the DCS Airbase.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetName()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseName = self.AirbaseName
return AirbaseName
end
return nil
end
--- Returns if the airbase is alive.
-- @param Airbase#AIRBASE self
-- @return #boolean true if Airbase is alive.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:IsAlive()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseIsAlive = DCSAirbase:isExist()
return AirbaseIsAlive
end
return false
end
--- Returns the unit's unique identifier.
-- @param Airbase#AIRBASE self
-- @return DCSAirbase#Airbase.ID Airbase ID
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetID()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseID = DCSAirbase:getID()
return AirbaseID
end
return nil
end
--- Returns the Airbase's callsign - the localized string.
-- @param Airbase#AIRBASE self
-- @return #string The Callsign of the Airbase.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetCallSign()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseCallSign = DCSAirbase:getCallsign()
return AirbaseCallSign
end
return nil
end
--- Returns unit descriptor. Descriptor type depends on unit category.
-- @param Airbase#AIRBASE self
-- @return DCSAirbase#Airbase.Desc The Airbase descriptor.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetDesc()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseDesc = DCSAirbase:getDesc()
return AirbaseDesc
end
return nil
end
--- Returns the type name of the DCS Airbase.
-- @param Airbase#AIRBASE self
-- @return #string The type name of the DCS Airbase.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetTypeName()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseTypeName = DCSAirbase:getTypeName()
self:T3( AirbaseTypeName )
return AirbaseTypeName
end
return nil
end
--- Returns the @{DCSTypes#Vec2} vector indicating the point in 2D of the DCS Airbase within the mission.
-- @param Airbase#AIRBASE self
-- @return DCSTypes#Vec2 The 2D point vector of the DCS Airbase.
-- @return #nil The DCS Airbase is not existing or alive.
function AIRBASE:GetPointVec2()
self:F2( self.AirbaseName )
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbasePointVec3 = DCSAirbase:getPosition().p
local AirbasePointVec2 = {}
AirbasePointVec2.x = AirbasePointVec3.x
AirbasePointVec2.y = AirbasePointVec3.z
self:T3( AirbasePointVec2 )
return AirbasePointVec2
end
return nil
end
--- Returns the DCS Airbase category name as defined within the DCS Airbase Descriptor.
-- @param Airbase#AIRBASE self
-- @return #string The DCS Airbase Category Name
function AIRBASE:GetCategoryName()
local DCSAirbase = self:GetDCSAirbase()
if DCSAirbase then
local AirbaseCategoryName = self.CategoryName[ self:GetDesc().category ]
return AirbaseCategoryName
end
return nil
end

847
Moose Development/Moose/Group.lua
View File

@ -48,7 +48,7 @@ GROUP = {
Controller = nil,
DCSGroup = nil,
WayPointFunctions = {},
}
}
--- A DCSGroup
-- @type DCSGroup
@ -887,7 +887,152 @@ function GROUP:CommandSwitchWayPoint( FromWayPoint, ToWayPoint, Index )
end
--- Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- TASKS FOR AIR GROUPS
--- (AIR) Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The unit.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon at the point on the ground.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point to deliver weapon at.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) Desired quantity of passes. The parameter is not the same in AttackGroup and AttackUnit tasks.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombing( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- Bombing = {
-- id = 'Bombing',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'Bombing',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point to hold the position.
-- @param #number Altitude The altitude to hold the position.
@ -896,11 +1041,11 @@ end
function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
self:F2( { self.GroupName, Point, Altitude, Speed } )
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
local LandHeight = land.getHeight( Point )
@ -915,24 +1060,24 @@ function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
}
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
return DCSTask
end
--- Orbit at the current position of the first unit of the group at a specified alititude
--- (AIR) Orbit at the current position of the first unit of the group at a specified alititude
-- @param #GROUP self
-- @param #number Altitude The altitude to hold the position.
-- @param #number Speed The speed flying when holding the position.
@ -952,7 +1097,7 @@ end
--- Hold position at the current position of the first unit of the group.
--- (AIR) Hold position at the current position of the first unit of the group.
-- @param #GROUP self
-- @param #number Duration The maximum duration in seconds to hold the position.
-- @return #GROUP self
@ -963,7 +1108,113 @@ function GROUP:TaskHoldPosition()
end
--- Land the group at a Vec2Point.
--- (AIR) Attacking the map object (building, structure, e.t.c).
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point the map object is closest to. The distance between the point and the map object must not be greater than 2000 meters. Object id is not used here because Mission Editor doesn't support map object identificators.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackMapObject( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- AttackMapObject = {
-- id = 'AttackMapObject',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackMapObject',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon on the runway.
-- @param #GROUP self
-- @param Airbase#AIRBASE Airbase Airbase to attack.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombingRunway( Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- BombingRunway = {
-- id = 'BombingRunway',
-- params = {
-- runwayId = AirdromeId,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'BombingRunway',
params = {
point = Airbase:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Refueling from the nearest tanker. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskRefueling()
self:F2( { self.GroupName } )
-- Refueling = {
-- id = 'Refueling',
-- params = {}
-- }
local DCSTask
DCSTask = { id = 'Refueling',
params = {
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR HELICOPTER) Landing at the ground. For helicopters only.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -971,19 +1222,38 @@ end
function GROUP:TaskLandAtVec2( Point, Duration )
self:F2( { self.GroupName, Point, Duration } )
local DCSTask
-- Land = {
-- id= 'Land',
-- params = {
-- point = Vec2,
-- durationFlag = boolean,
-- duration = Time
-- }
-- }
local DCSTask
if Duration and Duration > 0 then
DCSTask = { id = 'Land', params = { point = Point, durationFlag = true, duration = Duration } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = true,
duration = Duration,
},
}
else
DCSTask = { id = 'Land', params = { point = Point, durationFlag = false } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = false,
},
}
end
self:T3( DCSTask )
return DCSTask
end
--- Land the group at a @{Zone#ZONE).
--- (AIR) Land the group at a @{Zone#ZONE).
-- @param #GROUP self
-- @param Zone#ZONE Zone The zone where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -1004,65 +1274,39 @@ function GROUP:TaskLandAtZone( Zone, Duration, RandomPoint )
return DCSTask
end
--- Attack the Unit.
--- (AIR) Following another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- If another group is on land the unit / group will orbit around.
-- @param #GROUP self
-- @param Unit#UNIT The unit.
-- @param Group#GROUP FollowGroup The group to be followed.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit )
self:F2( { self.GroupName, AttackUnit } )
function GROUP:TaskFollow( FollowGroup, PointVec3, LastWaypointIndex )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = { unitId = AttackUnit:GetID(),
expend = AI.Task.WeaponExpend.TWO,
groupAttack = true,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup )
self:F2( { self.GroupName, AttackGroup } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- Follow = {
-- id = 'Follow',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = { groupId = AttackGroup:GetID(),
expend = AI.Task.WeaponExpend.TWO,
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
},
},
@ -1070,7 +1314,57 @@ function GROUP:TaskAttackGroup( AttackGroup )
return DCSTask
end
--- Fires at a VEC2 point.
--- (AIR) Escort another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- The unit / group will also protect that group from threats of specified types.
-- @param #GROUP self
-- @param Group#GROUP EscortGroup The group to be escorted.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @param #number EngagementDistanceMax Maximal distance from escorted group to threat. If the threat is already engaged by escort escort will disengage if the distance becomes greater than 1.5 * engagementDistMax.
-- @param #list<DCSTypes#AttributeName> TargetTypes Array of AttributeName that is contains threat categories allowed to engage.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskEscort( FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes } )
-- Escort = {
-- id = 'Escort',
-- params = {
-- groupId = Group.ID,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number,
-- engagementDistMax = Distance,
-- targetTypes = array of AttributeName,
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
engagementDistMax = EngagementDistance,
targetTypes = TargetTypes,
},
},
self:T3( { DCSTask } )
return DCSTask
end
-- GROUND TASKS
--- (GROUND) Fire at a VEC2 point until ammunition is finished.
-- @param #GROUP self
-- @param DCSTypes#Vec2 The point to fire at.
-- @param DCSTypes#Distance Radius The radius of the zone to deploy the fire at.
@ -1078,17 +1372,18 @@ end
function GROUP:TaskFireAtPoint( PointVec2, Radius )
self:F2( { self.GroupName, PointVec2, Radius } )
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
local DCSTask
DCSTask = { id = 'FireAtPoint',
params = { point = PointVec2,
params = {
point = PointVec2,
radius = Radius,
}
}
@ -1097,6 +1392,386 @@ function GROUP:TaskFireAtPoint( PointVec2, Radius )
return DCSTask
end
--- (GROUND) Hold ground group from moving.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskHold()
self:F2( { self.GroupName } )
-- Hold = {
-- id = 'Hold',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Hold',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- TASKS FOR AIRBORNE AND GROUND UNITS/GROUPS
--- (AIR + GROUND) The task makes the group/unit a FAC and orders the FAC to control the target (enemy ground group) destruction.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskFAC_AttackGroup( AttackGroup, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Designation, Datalink } )
-- FAC_AttackGroup = {
-- id = 'FAC_AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- EN-ROUTE TASKS FOR AIRBORNE GROUPS
--- (AIR) Engaging targets of defined types.
-- @param #GROUP self
-- @param DCSTypes#Distance Distance Maximal distance from the target to a route leg. If the target is on a greater distance it will be ignored.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All enroute tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( Distance, TargetTypes, Priority )
self:F2( { self.GroupName, Distance, TargetTypes, Priority } )
-- EngageTargets ={
-- id = 'EngageTargets',
-- params = {
-- maxDist = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargets',
params = {
maxDist = Distance,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a targets of defined types at circle-shaped zone.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the zone.
-- @param DCSTypes#Distance Radius Radius of the zone.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( PointVec2, Radius, TargetTypes, Priority )
self:F2( { self.GroupName, PointVec2, Radius, TargetTypes, Priority } )
-- EngageTargetsInZone = {
-- id = 'EngageTargetsInZone',
-- params = {
-- point = Vec2,
-- zoneRadius = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargetsInZone',
params = {
point = PointVec2,
zoneRadius = Radius,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a group. The task does not assign the target group to the unit/group to attack now; it just allows the unit/group to engage the target group as well as other assigned targets.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageGroup( AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- EngageGroup = {
-- id = 'EngageGroup ',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- priority = number,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The UNIT.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageUnit( AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- EngageUnit = {
-- id = 'EngageUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as an AWACS for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskAWACS( )
self:F2( { self.GroupName } )
-- AWACS = {
-- id = 'AWACS',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'AWACS',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as a tanker for friendly units. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskTanker( )
self:F2( { self.GroupName } )
-- Tanker = {
-- id = 'Tanker',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Tanker',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for ground units/groups
--- (GROUND) Ground unit (EW-radar) will act as an EWR for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEWR( )
self:F2( { self.GroupName } )
-- EWR = {
-- id = 'EWR',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'EWR',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for airborne and ground units/groups
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose the target (enemy ground group) as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC_EngageGroup( AttackGroup, Priority, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Priority, Designation, Datalink } )
-- FAC_EngageGroup = {
-- id = 'FAC_EngageGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
priority = Priority,
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose a targets (enemy ground group) around as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param DCSTypes#Distance Radius The maximal distance from the FAC to a target.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC( Radius, Priority )
self:F2( { self.GroupName, Radius, Priority } )
-- FAC = {
-- id = 'FAC',
-- params = {
-- radius = Distance,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC',
params = {
radius = Radius,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- Move the group to a Vec2 Point, wait for a defined duration and embark a group.

849
Moose Mission Setup/Moose Mission Update/l10n/DEFAULT/Moose.lua
View File

@ -1,5 +1,5 @@
env.info( '*** MOOSE STATIC INCLUDE START *** ' )
env.info( 'Moose Generation Timestamp: 20160527_1422' )
env.info( 'Moose Generation Timestamp: 20160602_1446' )
local base = _G
env.info("Loading MOOSE " .. base.timer.getAbsTime() )
@ -4121,7 +4121,7 @@ GROUP = {
Controller = nil,
DCSGroup = nil,
WayPointFunctions = {},
}
}
--- A DCSGroup
-- @type DCSGroup
@ -4960,7 +4960,152 @@ function GROUP:CommandSwitchWayPoint( FromWayPoint, ToWayPoint, Index )
end
--- Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- TASKS FOR AIR GROUPS
--- (AIR) Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The unit.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon at the point on the ground.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point to deliver weapon at.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) Desired quantity of passes. The parameter is not the same in AttackGroup and AttackUnit tasks.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombing( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- Bombing = {
-- id = 'Bombing',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'Bombing',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point to hold the position.
-- @param #number Altitude The altitude to hold the position.
@ -4969,11 +5114,11 @@ end
function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
self:F2( { self.GroupName, Point, Altitude, Speed } )
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
local LandHeight = land.getHeight( Point )
@ -4988,24 +5133,24 @@ function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
}
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
return DCSTask
end
--- Orbit at the current position of the first unit of the group at a specified alititude
--- (AIR) Orbit at the current position of the first unit of the group at a specified alititude
-- @param #GROUP self
-- @param #number Altitude The altitude to hold the position.
-- @param #number Speed The speed flying when holding the position.
@ -5025,7 +5170,7 @@ end
--- Hold position at the current position of the first unit of the group.
--- (AIR) Hold position at the current position of the first unit of the group.
-- @param #GROUP self
-- @param #number Duration The maximum duration in seconds to hold the position.
-- @return #GROUP self
@ -5036,7 +5181,113 @@ function GROUP:TaskHoldPosition()
end
--- Land the group at a Vec2Point.
--- (AIR) Attacking the map object (building, structure, e.t.c).
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point the map object is closest to. The distance between the point and the map object must not be greater than 2000 meters. Object id is not used here because Mission Editor doesn't support map object identificators.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackMapObject( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- AttackMapObject = {
-- id = 'AttackMapObject',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackMapObject',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon on the runway.
-- @param #GROUP self
-- @param Airbase#AIRBASE Airbase Airbase to attack.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombingRunway( Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- BombingRunway = {
-- id = 'BombingRunway',
-- params = {
-- runwayId = AirdromeId,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'BombingRunway',
params = {
point = Airbase:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Refueling from the nearest tanker. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskRefueling()
self:F2( { self.GroupName } )
-- Refueling = {
-- id = 'Refueling',
-- params = {}
-- }
local DCSTask
DCSTask = { id = 'Refueling',
params = {
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR HELICOPTER) Landing at the ground. For helicopters only.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -5044,19 +5295,38 @@ end
function GROUP:TaskLandAtVec2( Point, Duration )
self:F2( { self.GroupName, Point, Duration } )
local DCSTask
-- Land = {
-- id= 'Land',
-- params = {
-- point = Vec2,
-- durationFlag = boolean,
-- duration = Time
-- }
-- }
local DCSTask
if Duration and Duration > 0 then
DCSTask = { id = 'Land', params = { point = Point, durationFlag = true, duration = Duration } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = true,
duration = Duration,
},
}
else
DCSTask = { id = 'Land', params = { point = Point, durationFlag = false } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = false,
},
}
end
self:T3( DCSTask )
return DCSTask
end
--- Land the group at a @{Zone#ZONE).
--- (AIR) Land the group at a @{Zone#ZONE).
-- @param #GROUP self
-- @param Zone#ZONE Zone The zone where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -5077,65 +5347,39 @@ function GROUP:TaskLandAtZone( Zone, Duration, RandomPoint )
return DCSTask
end
--- Attack the Unit.
--- (AIR) Following another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- If another group is on land the unit / group will orbit around.
-- @param #GROUP self
-- @param Unit#UNIT The unit.
-- @param Group#GROUP FollowGroup The group to be followed.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit )
self:F2( { self.GroupName, AttackUnit } )
function GROUP:TaskFollow( FollowGroup, PointVec3, LastWaypointIndex )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = { unitId = AttackUnit:GetID(),
expend = AI.Task.WeaponExpend.TWO,
groupAttack = true,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup )
self:F2( { self.GroupName, AttackGroup } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- Follow = {
-- id = 'Follow',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = { groupId = AttackGroup:GetID(),
expend = AI.Task.WeaponExpend.TWO,
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
},
},
@ -5143,7 +5387,57 @@ function GROUP:TaskAttackGroup( AttackGroup )
return DCSTask
end
--- Fires at a VEC2 point.
--- (AIR) Escort another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- The unit / group will also protect that group from threats of specified types.
-- @param #GROUP self
-- @param Group#GROUP EscortGroup The group to be escorted.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @param #number EngagementDistanceMax Maximal distance from escorted group to threat. If the threat is already engaged by escort escort will disengage if the distance becomes greater than 1.5 * engagementDistMax.
-- @param #list<DCSTypes#AttributeName> TargetTypes Array of AttributeName that is contains threat categories allowed to engage.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskEscort( FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes } )
-- Escort = {
-- id = 'Escort',
-- params = {
-- groupId = Group.ID,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number,
-- engagementDistMax = Distance,
-- targetTypes = array of AttributeName,
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
engagementDistMax = EngagementDistance,
targetTypes = TargetTypes,
},
},
self:T3( { DCSTask } )
return DCSTask
end
-- GROUND TASKS
--- (GROUND) Fire at a VEC2 point until ammunition is finished.
-- @param #GROUP self
-- @param DCSTypes#Vec2 The point to fire at.
-- @param DCSTypes#Distance Radius The radius of the zone to deploy the fire at.
@ -5151,17 +5445,18 @@ end
function GROUP:TaskFireAtPoint( PointVec2, Radius )
self:F2( { self.GroupName, PointVec2, Radius } )
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
local DCSTask
DCSTask = { id = 'FireAtPoint',
params = { point = PointVec2,
params = {
point = PointVec2,
radius = Radius,
}
}
@ -5170,6 +5465,386 @@ function GROUP:TaskFireAtPoint( PointVec2, Radius )
return DCSTask
end
--- (GROUND) Hold ground group from moving.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskHold()
self:F2( { self.GroupName } )
-- Hold = {
-- id = 'Hold',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Hold',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- TASKS FOR AIRBORNE AND GROUND UNITS/GROUPS
--- (AIR + GROUND) The task makes the group/unit a FAC and orders the FAC to control the target (enemy ground group) destruction.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskFAC_AttackGroup( AttackGroup, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Designation, Datalink } )
-- FAC_AttackGroup = {
-- id = 'FAC_AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- EN-ROUTE TASKS FOR AIRBORNE GROUPS
--- (AIR) Engaging targets of defined types.
-- @param #GROUP self
-- @param DCSTypes#Distance Distance Maximal distance from the target to a route leg. If the target is on a greater distance it will be ignored.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All enroute tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( Distance, TargetTypes, Priority )
self:F2( { self.GroupName, Distance, TargetTypes, Priority } )
-- EngageTargets ={
-- id = 'EngageTargets',
-- params = {
-- maxDist = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargets',
params = {
maxDist = Distance,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a targets of defined types at circle-shaped zone.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the zone.
-- @param DCSTypes#Distance Radius Radius of the zone.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( PointVec2, Radius, TargetTypes, Priority )
self:F2( { self.GroupName, PointVec2, Radius, TargetTypes, Priority } )
-- EngageTargetsInZone = {
-- id = 'EngageTargetsInZone',
-- params = {
-- point = Vec2,
-- zoneRadius = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargetsInZone',
params = {
point = PointVec2,
zoneRadius = Radius,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a group. The task does not assign the target group to the unit/group to attack now; it just allows the unit/group to engage the target group as well as other assigned targets.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageGroup( AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- EngageGroup = {
-- id = 'EngageGroup ',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- priority = number,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The UNIT.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageUnit( AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- EngageUnit = {
-- id = 'EngageUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as an AWACS for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskAWACS( )
self:F2( { self.GroupName } )
-- AWACS = {
-- id = 'AWACS',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'AWACS',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as a tanker for friendly units. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskTanker( )
self:F2( { self.GroupName } )
-- Tanker = {
-- id = 'Tanker',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Tanker',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for ground units/groups
--- (GROUND) Ground unit (EW-radar) will act as an EWR for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEWR( )
self:F2( { self.GroupName } )
-- EWR = {
-- id = 'EWR',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'EWR',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for airborne and ground units/groups
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose the target (enemy ground group) as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC_EngageGroup( AttackGroup, Priority, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Priority, Designation, Datalink } )
-- FAC_EngageGroup = {
-- id = 'FAC_EngageGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
priority = Priority,
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose a targets (enemy ground group) around as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param DCSTypes#Distance Radius The maximal distance from the FAC to a target.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC( Radius, Priority )
self:F2( { self.GroupName, Radius, Priority } )
-- FAC = {
-- id = 'FAC',
-- params = {
-- radius = Distance,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC',
params = {
radius = Radius,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- Move the group to a Vec2 Point, wait for a defined duration and embark a group.

849
Moose Mission Setup/Moose.lua
View File

@ -1,5 +1,5 @@
env.info( '*** MOOSE STATIC INCLUDE START *** ' )
env.info( 'Moose Generation Timestamp: 20160527_1422' )
env.info( 'Moose Generation Timestamp: 20160602_1446' )
local base = _G
env.info("Loading MOOSE " .. base.timer.getAbsTime() )
@ -4121,7 +4121,7 @@ GROUP = {
Controller = nil,
DCSGroup = nil,
WayPointFunctions = {},
}
}
--- A DCSGroup
-- @type DCSGroup
@ -4960,7 +4960,152 @@ function GROUP:CommandSwitchWayPoint( FromWayPoint, ToWayPoint, Index )
end
--- Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- TASKS FOR AIR GROUPS
--- (AIR) Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The unit.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon at the point on the ground.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point to deliver weapon at.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) Desired quantity of passes. The parameter is not the same in AttackGroup and AttackUnit tasks.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombing( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- Bombing = {
-- id = 'Bombing',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'Bombing',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Orbit at a specified position at a specified alititude during a specified duration with a specified speed.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point to hold the position.
-- @param #number Altitude The altitude to hold the position.
@ -4969,11 +5114,11 @@ end
function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
self:F2( { self.GroupName, Point, Altitude, Speed } )
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
-- pattern = enum AI.Task.OribtPattern,
-- point = Vec2,
-- point2 = Vec2,
-- speed = Distance,
-- altitude = Distance
local LandHeight = land.getHeight( Point )
@ -4988,24 +5133,24 @@ function GROUP:TaskOrbitCircleAtVec2( Point, Altitude, Speed )
}
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
-- local AITask = { id = 'ControlledTask',
-- params = { task = { id = 'Orbit',
-- params = { pattern = AI.Task.OrbitPattern.CIRCLE,
-- point = Point,
-- speed = Speed,
-- altitude = Altitude + LandHeight
-- }
-- },
-- stopCondition = { duration = Duration
-- }
-- }
-- }
-- )
return DCSTask
end
--- Orbit at the current position of the first unit of the group at a specified alititude
--- (AIR) Orbit at the current position of the first unit of the group at a specified alititude
-- @param #GROUP self
-- @param #number Altitude The altitude to hold the position.
-- @param #number Speed The speed flying when holding the position.
@ -5025,7 +5170,7 @@ end
--- Hold position at the current position of the first unit of the group.
--- (AIR) Hold position at the current position of the first unit of the group.
-- @param #GROUP self
-- @param #number Duration The maximum duration in seconds to hold the position.
-- @return #GROUP self
@ -5036,7 +5181,113 @@ function GROUP:TaskHoldPosition()
end
--- Land the group at a Vec2Point.
--- (AIR) Attacking the map object (building, structure, e.t.c).
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the point the map object is closest to. The distance between the point and the map object must not be greater than 2000 meters. Object id is not used here because Mission Editor doesn't support map object identificators.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackMapObject( PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, PointVec2, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- AttackMapObject = {
-- id = 'AttackMapObject',
-- params = {
-- point = Vec2,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackMapObject',
params = {
point = PointVec2,
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Delivering weapon on the runway.
-- @param #GROUP self
-- @param Airbase#AIRBASE Airbase Airbase to attack.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskBombingRunway( Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack )
self:F2( { self.GroupName, Airbase, WeaponType, WeaponExpend, AttackQty, Direction, GroupAttack } )
-- BombingRunway = {
-- id = 'BombingRunway',
-- params = {
-- runwayId = AirdromeId,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- direction = Azimuth,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'BombingRunway',
params = {
point = Airbase:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
groupAttack = GroupAttack,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Refueling from the nearest tanker. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskRefueling()
self:F2( { self.GroupName } )
-- Refueling = {
-- id = 'Refueling',
-- params = {}
-- }
local DCSTask
DCSTask = { id = 'Refueling',
params = {
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR HELICOPTER) Landing at the ground. For helicopters only.
-- @param #GROUP self
-- @param DCSTypes#Vec2 Point The point where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -5044,19 +5295,38 @@ end
function GROUP:TaskLandAtVec2( Point, Duration )
self:F2( { self.GroupName, Point, Duration } )
local DCSTask
-- Land = {
-- id= 'Land',
-- params = {
-- point = Vec2,
-- durationFlag = boolean,
-- duration = Time
-- }
-- }
local DCSTask
if Duration and Duration > 0 then
DCSTask = { id = 'Land', params = { point = Point, durationFlag = true, duration = Duration } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = true,
duration = Duration,
},
}
else
DCSTask = { id = 'Land', params = { point = Point, durationFlag = false } }
DCSTask = { id = 'Land',
params = {
point = Point,
durationFlag = false,
},
}
end
self:T3( DCSTask )
return DCSTask
end
--- Land the group at a @{Zone#ZONE).
--- (AIR) Land the group at a @{Zone#ZONE).
-- @param #GROUP self
-- @param Zone#ZONE Zone The zone where to land.
-- @param #number Duration The duration in seconds to stay on the ground.
@ -5077,65 +5347,39 @@ function GROUP:TaskLandAtZone( Zone, Duration, RandomPoint )
return DCSTask
end
--- Attack the Unit.
--- (AIR) Following another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- If another group is on land the unit / group will orbit around.
-- @param #GROUP self
-- @param Unit#UNIT The unit.
-- @param Group#GROUP FollowGroup The group to be followed.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackUnit( AttackUnit )
self:F2( { self.GroupName, AttackUnit } )
function GROUP:TaskFollow( FollowGroup, PointVec3, LastWaypointIndex )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex } )
-- AttackUnit = {
-- id = 'AttackUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- }
-- }
local DCSTask
DCSTask = { id = 'AttackUnit',
params = { unitId = AttackUnit:GetID(),
expend = AI.Task.WeaponExpend.TWO,
groupAttack = true,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- Attack a Group.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskAttackGroup( AttackGroup )
self:F2( { self.GroupName, AttackGroup } )
-- AttackGroup = {
-- id = 'AttackGroup',
-- Follow = {
-- id = 'Follow',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'AttackGroup',
params = { groupId = AttackGroup:GetID(),
expend = AI.Task.WeaponExpend.TWO,
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
},
},
@ -5143,7 +5387,57 @@ function GROUP:TaskAttackGroup( AttackGroup )
return DCSTask
end
--- Fires at a VEC2 point.
--- (AIR) Escort another airborne group.
-- The unit / group will follow lead unit of another group, wingmens of both groups will continue following their leaders.
-- The unit / group will also protect that group from threats of specified types.
-- @param #GROUP self
-- @param Group#GROUP EscortGroup The group to be escorted.
-- @param DCSTypes#Vec3 PointVec3 Position of the unit / lead unit of the group relative lead unit of another group in frame reference oriented by course of lead unit of another group. If another group is on land the unit / group will orbit around.
-- @param #number LastWaypointIndex Detach waypoint of another group. Once reached the unit / group Follow task is finished.
-- @param #number EngagementDistanceMax Maximal distance from escorted group to threat. If the threat is already engaged by escort escort will disengage if the distance becomes greater than 1.5 * engagementDistMax.
-- @param #list<DCSTypes#AttributeName> TargetTypes Array of AttributeName that is contains threat categories allowed to engage.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskEscort( FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes )
self:F2( { self.GroupName, FollowGroup, PointVec3, LastWaypointIndex, EngagementDistance, TargetTypes } )
-- Escort = {
-- id = 'Escort',
-- params = {
-- groupId = Group.ID,
-- pos = Vec3,
-- lastWptIndexFlag = boolean,
-- lastWptIndex = number,
-- engagementDistMax = Distance,
-- targetTypes = array of AttributeName,
-- }
-- }
local LastWaypointIndexFlag = nil
if LastWaypointIndex then
LastWaypointIndexFlag = true
end
local DCSTask
DCSTask = { id = 'Follow',
params = {
groupId = FollowGroup:GetID(),
pos = PointVec3,
lastWptIndexFlag = LastWaypointIndexFlag,
lastWptIndex = LastWaypointIndex,
engagementDistMax = EngagementDistance,
targetTypes = TargetTypes,
},
},
self:T3( { DCSTask } )
return DCSTask
end
-- GROUND TASKS
--- (GROUND) Fire at a VEC2 point until ammunition is finished.
-- @param #GROUP self
-- @param DCSTypes#Vec2 The point to fire at.
-- @param DCSTypes#Distance Radius The radius of the zone to deploy the fire at.
@ -5151,17 +5445,18 @@ end
function GROUP:TaskFireAtPoint( PointVec2, Radius )
self:F2( { self.GroupName, PointVec2, Radius } )
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
-- FireAtPoint = {
-- id = 'FireAtPoint',
-- params = {
-- point = Vec2,
-- radius = Distance,
-- }
-- }
local DCSTask
DCSTask = { id = 'FireAtPoint',
params = { point = PointVec2,
params = {
point = PointVec2,
radius = Radius,
}
}
@ -5170,6 +5465,386 @@ function GROUP:TaskFireAtPoint( PointVec2, Radius )
return DCSTask
end
--- (GROUND) Hold ground group from moving.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskHold()
self:F2( { self.GroupName } )
-- Hold = {
-- id = 'Hold',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Hold',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- TASKS FOR AIRBORNE AND GROUND UNITS/GROUPS
--- (AIR + GROUND) The task makes the group/unit a FAC and orders the FAC to control the target (enemy ground group) destruction.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:TaskFAC_AttackGroup( AttackGroup, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Designation, Datalink } )
-- FAC_AttackGroup = {
-- id = 'FAC_AttackGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_AttackGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- EN-ROUTE TASKS FOR AIRBORNE GROUPS
--- (AIR) Engaging targets of defined types.
-- @param #GROUP self
-- @param DCSTypes#Distance Distance Maximal distance from the target to a route leg. If the target is on a greater distance it will be ignored.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All enroute tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( Distance, TargetTypes, Priority )
self:F2( { self.GroupName, Distance, TargetTypes, Priority } )
-- EngageTargets ={
-- id = 'EngageTargets',
-- params = {
-- maxDist = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargets',
params = {
maxDist = Distance,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a targets of defined types at circle-shaped zone.
-- @param #GROUP self
-- @param DCSTypes#Vec2 PointVec2 2D-coordinates of the zone.
-- @param DCSTypes#Distance Radius Radius of the zone.
-- @param #list<#DCSTypes#AttributeName> TargetTypes Array of target categories allowed to engage.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageTargets( PointVec2, Radius, TargetTypes, Priority )
self:F2( { self.GroupName, PointVec2, Radius, TargetTypes, Priority } )
-- EngageTargetsInZone = {
-- id = 'EngageTargetsInZone',
-- params = {
-- point = Vec2,
-- zoneRadius = Distance,
-- targetTypes = array of AttributeName,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageTargetsInZone',
params = {
point = PointVec2,
zoneRadius = Radius,
targetTypes = TargetTypes,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Engaging a group. The task does not assign the target group to the unit/group to attack now; it just allows the unit/group to engage the target group as well as other assigned targets.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup The Group to be attacked.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param DCSTypes#Distance Altitude (optional) Desired attack start altitude. Group/aircraft will make its attacks from the altitude. If the altitude is too low or too high to use weapon aircraft/group will choose closest altitude to the desired attack start altitude. If the desired altitude is defined group/aircraft will not attack from safe altitude.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageGroup( AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit )
self:F2( { self.GroupName, AttackGroup, Priority, WeaponType, WeaponExpend, AttackQty, Direction, Altitude, AttackQtyLimit } )
-- EngageGroup = {
-- id = 'EngageGroup ',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend,
-- attackQty = number,
-- directionEnabled = boolean,
-- direction = Azimuth,
-- altitudeEnabled = boolean,
-- altitude = Distance,
-- attackQtyLimit = boolean,
-- priority = number,
-- }
-- }
local DirectionEnabled = nil
if Direction then
DirectionEnabled = true
end
local AltitudeEnabled = nil
if Altitude then
AltitudeEnabled = true
end
local DCSTask
DCSTask = { id = 'EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
directionEnabled = DirectionEnabled,
direction = Direction,
altitudeEnabled = AltitudeEnabled,
altitude = Altitude,
attackQtyLimit = AttackQtyLimit,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Attack the Unit.
-- @param #GROUP self
-- @param Unit#UNIT AttackUnit The UNIT.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType (optional) Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.WeaponExpend WeaponExpend (optional) Determines how much weapon will be released at each attack. If parameter is not defined the unit / group will choose expend on its own discretion.
-- @param #number AttackQty (optional) This parameter limits maximal quantity of attack. The aicraft/group will not make more attack than allowed even if the target group not destroyed and the aicraft/group still have ammo. If not defined the aircraft/group will attack target until it will be destroyed or until the aircraft/group will run out of ammo.
-- @param DCSTypes#Azimuth Direction (optional) Desired ingress direction from the target to the attacking aircraft. Group/aircraft will make its attacks from the direction. Of course if there is no way to attack from the direction due the terrain group/aircraft will choose another direction.
-- @param #boolean AttackQtyLimit (optional) The flag determines how to interpret attackQty parameter. If the flag is true then attackQty is a limit on maximal attack quantity for "AttackGroup" and "AttackUnit" tasks. If the flag is false then attackQty is a desired attack quantity for "Bombing" and "BombingRunway" tasks.
-- @param #boolean GroupAttack (optional) Flag indicates that the target must be engaged by all aircrafts of the group. Has effect only if the task is assigned to a group, not to a single aircraft.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEngageUnit( AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack )
self:F2( { self.GroupName, AttackUnit, Priority, WeaponType, WeaponExpend, AttackQty, Direction, AttackQtyLimit, GroupAttack } )
-- EngageUnit = {
-- id = 'EngageUnit',
-- params = {
-- unitId = Unit.ID,
-- weaponType = number,
-- expend = enum AI.Task.WeaponExpend
-- attackQty = number,
-- direction = Azimuth,
-- attackQtyLimit = boolean,
-- groupAttack = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'EngageUnit',
params = {
unitId = AttackUnit:GetID(),
weaponType = WeaponType,
expend = WeaponExpend,
attackQty = AttackQty,
direction = Direction,
attackQtyLimit = AttackQtyLimit,
groupAttack = GroupAttack,
priority = Priority,
},
},
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as an AWACS for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskAWACS( )
self:F2( { self.GroupName } )
-- AWACS = {
-- id = 'AWACS',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'AWACS',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR) Aircraft will act as a tanker for friendly units. No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskTanker( )
self:F2( { self.GroupName } )
-- Tanker = {
-- id = 'Tanker',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'Tanker',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for ground units/groups
--- (GROUND) Ground unit (EW-radar) will act as an EWR for friendly units (will provide them with information about contacts). No parameters.
-- @param #GROUP self
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskEWR( )
self:F2( { self.GroupName } )
-- EWR = {
-- id = 'EWR',
-- params = {
-- }
-- }
local DCSTask
DCSTask = { id = 'EWR',
params = {
}
}
self:T3( { DCSTask } )
return DCSTask
end
-- En-route tasks for airborne and ground units/groups
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose the target (enemy ground group) as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param Group#GROUP AttackGroup Target GROUP.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @param #number WeaponType Bitmask of weapon types those allowed to use. If parameter is not defined that means no limits on weapon usage.
-- @param DCSTypes#AI.Task.Designation Designation (optional) Designation type.
-- @param #boolean Datalink (optional) Allows to use datalink to send the target information to attack aircraft. Enabled by default.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC_EngageGroup( AttackGroup, Priority, WeaponType, Designation, Datalink )
self:F2( { self.GroupName, AttackGroup, WeaponType, Priority, Designation, Datalink } )
-- FAC_EngageGroup = {
-- id = 'FAC_EngageGroup',
-- params = {
-- groupId = Group.ID,
-- weaponType = number,
-- designation = enum AI.Task.Designation,
-- datalink = boolean,
-- priority = number,
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC_EngageGroup',
params = {
groupId = AttackGroup:GetID(),
weaponType = WeaponType,
designation = Designation,
datalink = Datalink,
priority = Priority,
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- (AIR + GROUND) The task makes the group/unit a FAC and lets the FAC to choose a targets (enemy ground group) around as well as other assigned targets.
-- The killer is player-controlled allied CAS-aircraft that is in contact with the FAC.
-- If the task is assigned to the group lead unit will be a FAC.
-- @param #GROUP self
-- @param DCSTypes#Distance Radius The maximal distance from the FAC to a target.
-- @param #number Priority All en-route tasks have the priority parameter. This is a number (less value - higher priority) that determines actions related to what task will be performed first.
-- @return DCSTask#Task The DCS task structure.
function GROUP:EnRouteTaskFAC( Radius, Priority )
self:F2( { self.GroupName, Radius, Priority } )
-- FAC = {
-- id = 'FAC',
-- params = {
-- radius = Distance,
-- priority = number
-- }
-- }
local DCSTask
DCSTask = { id = 'FAC',
params = {
radius = Radius,
priority = Priority
}
}
self:T3( { DCSTask } )
return DCSTask
end
--- Move the group to a Vec2 Point, wait for a defined duration and embark a group.

BIN
Moose Test Missions/Moose_Test_CLEANUP/Moose_Test_CLEANUP.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_DATABASE/Moose_Test_DATABASE.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_DESTROY/MOOSE_Test_DESTROY.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_ESCORT/MOOSE_Test_ESCORT.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_MISSILETRAINER/Moose_Test_MISSILETRAINER.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_SEAD/MOOSE_Test_SEAD.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_SPAWN/MOOSE_Test_SPAWN.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_SPAWN_Repeat/MOOSE_Test_SPAWN_Repeat.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_TASK_Pickup_and_Deploy/MOOSE_Test_TASK_Pickup_and_Deploy.miz
View File

Binary file not shown.

BIN
Moose Test Missions/Moose_Test_WRAPPER/Moose_Test_WRAPPER.miz
View File

Binary file not shown.

662
Moose Training/Documentation/Airbase.html Normal file
View File

@ -0,0 +1,662 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<link rel="stylesheet" href="stylesheet.css" type="text/css"/>
</head>
<body>
<div id="container">
<div id="product">
<div id="product_logo"></div>
<div id="product_name"><big><b></b></big></div>
<div id="product_description"></div>
</div>
<div id="main">
<div id="navigation">
<h2>Modules</h2>
<ul><li>
<a href="index.html">index</a>
</li></ul>
<ul>
<li>Airbase</li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>
<li><a href="Client.html">Client</a></li>
<li><a href="DCSAirbase.html">DCSAirbase</a></li>
<li><a href="DCSCoalitionObject.html">DCSCoalitionObject</a></li>
<li><a href="DCSCommand.html">DCSCommand</a></li>
<li><a href="DCSController.html">DCSController</a></li>
<li><a href="DCSGroup.html">DCSGroup</a></li>
<li><a href="DCSObject.html">DCSObject</a></li>
<li><a href="DCSTask.html">DCSTask</a></li>
<li><a href="DCSTypes.html">DCSTypes</a></li>
<li><a href="DCSUnit.html">DCSUnit</a></li>
<li><a href="DCSWorld.html">DCSWorld</a></li>
<li><a href="DCStimer.html">DCStimer</a></li>
<li><a href="DEPLOYTASK.html">DEPLOYTASK</a></li>
<li><a href="DESTROYBASETASK.html">DESTROYBASETASK</a></li>
<li><a href="DESTROYGROUPSTASK.html">DESTROYGROUPSTASK</a></li>
<li><a href="DESTROYRADARSTASK.html">DESTROYRADARSTASK</a></li>
<li><a href="DESTROYUNITTYPESTASK.html">DESTROYUNITTYPESTASK</a></li>
<li><a href="Database.html">Database</a></li>
<li><a href="Escort.html">Escort</a></li>
<li><a href="Event.html">Event</a></li>
<li><a href="GOHOMETASK.html">GOHOMETASK</a></li>
<li><a href="Group.html">Group</a></li>
<li><a href="GroupSet.html">GroupSet</a></li>
<li><a href="MOVEMENT.html">MOVEMENT</a></li>
<li><a href="Menu.html">Menu</a></li>
<li><a href="Message.html">Message</a></li>
<li><a href="MissileTrainer.html">MissileTrainer</a></li>
<li><a href="Mission.html">Mission</a></li>
<li><a href="NOTASK.html">NOTASK</a></li>
<li><a href="PICKUPTASK.html">PICKUPTASK</a></li>
<li><a href="ROUTETASK.html">ROUTETASK</a></li>
<li><a href="STAGE.html">STAGE</a></li>
<li><a href="Scheduler.html">Scheduler</a></li>
<li><a href="Scoring.html">Scoring</a></li>
<li><a href="Sead.html">Sead</a></li>
<li><a href="Set.html">Set</a></li>
<li><a href="Spawn.html">Spawn</a></li>
<li><a href="StaticObject.html">StaticObject</a></li>
<li><a href="TASK.html">TASK</a></li>
<li><a href="Unit.html">Unit</a></li>
<li><a href="UnitSet.html">UnitSet</a></li>
<li><a href="Zone.html">Zone</a></li>
<li><a href="env.html">env</a></li>
<li><a href="land.html">land</a></li>
<li><a href="routines.html">routines</a></li>
</ul>
</div>
<div id="content">
<h1>Module <code>Airbase</code></h1>
<p>AIRBASE Class</p>
<h1><a href="AIRBASE.html">AIRBASE</a> class</h1>
<p>The <a href="AIRBASE.html">AIRBASE</a> class is a wrapper class to handle the DCS Airbase objects:</p>
<ul>
<li>Support all DCS Airbase APIs.</li>
</ul>
<ul>
<li>Enhance with Airbase specific APIs not in the DCS Airbase API set.</li>
</ul>
<h1>AIRBASE reference methods</h1>
<p>For each DCS Airbase object alive within a running mission, a AIRBASE wrapper object (instance) will be created within the _<a href="DATABASE.html">DATABASE</a> object.
This is done at the beginning of the mission (when the mission starts).</p>
<p>The AIRBASE class <strong>does not contain a :New()</strong> method, rather it provides <strong>:Find()</strong> methods to retrieve the object reference
using the DCS Airbase or the DCS AirbaseName.</p>
<p>Another thing to know is that AIRBASE objects do not "contain" the DCS Airbase object.
The AIRBASE methods will reference the DCS Airbase object by name when it is needed during API execution.
If the DCS Airbase object does not exist or is nil, the AIRBASE methods will return nil and log an exception in the DCS.log file.</p>
<p>The AIRBASE class provides the following functions to retrieve quickly the relevant AIRBASE instance:</p>
<ul>
<li><a href="##(AIRBASE).Find">AIRBASE.Find</a>(): Find a AIRBASE instance from the _DATABASE object using a DCS Airbase object.</li>
<li><a href="##(AIRBASE).FindByName">AIRBASE.FindByName</a>(): Find a AIRBASE instance from the _DATABASE object using a DCS Airbase name.</li>
</ul>
<p>IMPORTANT: ONE SHOULD NEVER SANATIZE these AIRBASE OBJECT REFERENCES! (make the AIRBASE object references nil).</p>
<h1>DCS AIRBASE APIs</h1>
<p>The DCS Airbase APIs are used extensively within MOOSE. The AIRBASE class has for each DCS Airbase API a corresponding method.
To be able to distinguish easily in your code the difference between a AIRBASE API call and a DCS Airbase API call,
the first letter of the method is also capitalized. So, by example, the DCS Airbase method <a href="DCSAirbase.html##(Airbase).getName">DCSAirbase#Airbase.getName</a>()
is implemented in the AIRBASE class as <a href="##(AIRBASE).GetName">AIRBASE.GetName</a>().</p>
<h2>More functions will be added</h2>
<p>During the MOOSE development, more functions will be added. </p>
<h2>Global(s)</h2>
<table class="function_list">
<tr>
<td class="name" nowrap="nowrap"><a href="#AIRBASE">AIRBASE</a></td>
<td class="summary">
</td>
</tr>
</table>
<h2><a id="#(AIRBASE)">Type <code>AIRBASE</code></a></h2>
<table class="function_list">
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).CategoryName">AIRBASE.CategoryName</a></td>
<td class="summary">
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).ClassName">AIRBASE.ClassName</a></td>
<td class="summary">
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).Find">AIRBASE:Find(DCSAirbase)</a></td>
<td class="summary">
<p>Finds a AIRBASE from the _DATABASE using a DCSAirbase object.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).FindByName">AIRBASE:FindByName(AirbaseName)</a></td>
<td class="summary">
<p>Find a AIRBASE in the _DATABASE using the name of an existing DCS Airbase.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetCallSign">AIRBASE:GetCallSign()</a></td>
<td class="summary">
<p>Returns the Airbase's callsign - the localized string.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetCategoryName">AIRBASE:GetCategoryName()</a></td>
<td class="summary">
<p>Returns the DCS Airbase category name as defined within the DCS Airbase Descriptor.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetCoalition">AIRBASE:GetCoalition()</a></td>
<td class="summary">
<p>Returns coalition of the Airbase.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetCountry">AIRBASE:GetCountry()</a></td>
<td class="summary">
<p>Returns country of the Airbase.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetDCSAirbase">AIRBASE:GetDCSAirbase()</a></td>
<td class="summary">
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetDesc">AIRBASE:GetDesc()</a></td>
<td class="summary">
<p>Returns unit descriptor.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetID">AIRBASE:GetID()</a></td>
<td class="summary">
<p>Returns the unit's unique identifier.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetName">AIRBASE:GetName()</a></td>
<td class="summary">
<p>Returns DCS Airbase object name.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetPointVec2">AIRBASE:GetPointVec2()</a></td>
<td class="summary">
<p>Returns the <a href="DCSTypes.html##(Vec2)">DCSTypes#Vec2</a> vector indicating the point in 2D of the DCS Airbase within the mission.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).GetTypeName">AIRBASE:GetTypeName()</a></td>
<td class="summary">
<p>Returns the type name of the DCS Airbase.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).IsAlive">AIRBASE:IsAlive()</a></td>
<td class="summary">
<p>Returns if the airbase is alive.</p>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="##(AIRBASE).Register">AIRBASE:Register(DCSAirbase, Database, AirbaseName)</a></td>
<td class="summary">
<p>Create a new AIRBASE from DCSAirbase.</p>
</td>
</tr>
</table>
<h2>Global(s)</h2>
<dl class="function">
<dt>
<em><a href="##(AIRBASE)">#AIRBASE</a></em>
<a id="AIRBASE" >
<strong>AIRBASE</strong>
</a>
</dt>
<dd>
</dd>
</dl>
<h2><a id="#(Airbase)" >Type <code>Airbase</code></a></h2>
<h2><a id="#(AIRBASE)" >Type <code>AIRBASE</code></a></h2>
<p>The AIRBASE class</p>
<h3>Field(s)</h3>
<dl class="function">
<dt>
<em></em>
<a id="#(AIRBASE).CategoryName" >
<strong>AIRBASE.CategoryName</strong>
</a>
</dt>
<dd>
</dd>
</dl>
<dl class="function">
<dt>
<em>#string</em>
<a id="#(AIRBASE).ClassName" >
<strong>AIRBASE.ClassName</strong>
</a>
</dt>
<dd>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).Find" >
<strong>AIRBASE:Find(DCSAirbase)</strong>
</a>
</dt>
<dd>
<p>Finds a AIRBASE from the _DATABASE using a DCSAirbase object.</p>
<h3>Parameter</h3>
<ul>
<li>
<p><code><em><a href="DCSAirbase.html##(Airbase)">DCSAirbase#Airbase</a> DCSAirbase </em></code>:
An existing DCS Airbase object reference.</p>
</li>
</ul>
<h3>Return value</h3>
<p><em><a href="Airbase.html##(AIRBASE)">Airbase#AIRBASE</a>:</em>
self</p>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).FindByName" >
<strong>AIRBASE:FindByName(AirbaseName)</strong>
</a>
</dt>
<dd>
<p>Find a AIRBASE in the _DATABASE using the name of an existing DCS Airbase.</p>
<h3>Parameter</h3>
<ul>
<li>
<p><code><em>#string AirbaseName </em></code>:
The Airbase Name.</p>
</li>
</ul>
<h3>Return value</h3>
<p><em><a href="Airbase.html##(AIRBASE)">Airbase#AIRBASE</a>:</em>
self</p>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetCallSign" >
<strong>AIRBASE:GetCallSign()</strong>
</a>
</dt>
<dd>
<p>Returns the Airbase's callsign - the localized string.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em>#string:</em>
The Callsign of the Airbase.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetCategoryName" >
<strong>AIRBASE:GetCategoryName()</strong>
</a>
</dt>
<dd>
<p>Returns the DCS Airbase category name as defined within the DCS Airbase Descriptor.</p>
<h3>Return value</h3>
<p><em>#string:</em>
The DCS Airbase Category Name</p>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetCoalition" >
<strong>AIRBASE:GetCoalition()</strong>
</a>
</dt>
<dd>
<p>Returns coalition of the Airbase.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em><a href="DCSCoalitionObject.html##(coalition.side)">DCSCoalitionObject#coalition.side</a>:</em>
The side of the coalition.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetCountry" >
<strong>AIRBASE:GetCountry()</strong>
</a>
</dt>
<dd>
<p>Returns country of the Airbase.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em><a href="DCScountry.html##(country.id)">DCScountry#country.id</a>:</em>
The country identifier.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetDCSAirbase" >
<strong>AIRBASE:GetDCSAirbase()</strong>
</a>
</dt>
<dd>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetDesc" >
<strong>AIRBASE:GetDesc()</strong>
</a>
</dt>
<dd>
<p>Returns unit descriptor.</p>
<p>Descriptor type depends on unit category.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em><a href="DCSAirbase.html##(Airbase.Desc)">DCSAirbase#Airbase.Desc</a>:</em>
The Airbase descriptor.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetID" >
<strong>AIRBASE:GetID()</strong>
</a>
</dt>
<dd>
<p>Returns the unit's unique identifier.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em><a href="DCSAirbase.html##(Airbase.ID)">DCSAirbase#Airbase.ID</a>:</em>
Airbase ID</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetName" >
<strong>AIRBASE:GetName()</strong>
</a>
</dt>
<dd>
<p>Returns DCS Airbase object name.</p>
<p>The function provides access to non-activated units too.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em>#string:</em>
The name of the DCS Airbase.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetPointVec2" >
<strong>AIRBASE:GetPointVec2()</strong>
</a>
</dt>
<dd>
<p>Returns the <a href="DCSTypes.html##(Vec2)">DCSTypes#Vec2</a> vector indicating the point in 2D of the DCS Airbase within the mission.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em><a href="DCSTypes.html##(Vec2)">DCSTypes#Vec2</a>:</em>
The 2D point vector of the DCS Airbase.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).GetTypeName" >
<strong>AIRBASE:GetTypeName()</strong>
</a>
</dt>
<dd>
<p>Returns the type name of the DCS Airbase.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em>#string:</em>
The type name of the DCS Airbase.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).IsAlive" >
<strong>AIRBASE:IsAlive()</strong>
</a>
</dt>
<dd>
<p>Returns if the airbase is alive.</p>
<h3>Return values</h3>
<ol>
<li>
<p><em>#boolean:</em>
true if Airbase is alive.</p>
</li>
<li>
<p><em>#nil:</em>
The DCS Airbase is not existing or alive. </p>
</li>
</ol>
</dd>
</dl>
<dl class="function">
<dt>
<a id="#(AIRBASE).Register" >
<strong>AIRBASE:Register(DCSAirbase, Database, AirbaseName)</strong>
</a>
</dt>
<dd>
<p>Create a new AIRBASE from DCSAirbase.</p>
<h3>Parameters</h3>
<ul>
<li>
<p><code><em><a href="DCSAirbase.html##(Airbase)">DCSAirbase#Airbase</a> DCSAirbase </em></code>: </p>
</li>
<li>
<p><code><em><a href="Database.html##(DATABASE)">Database#DATABASE</a> Database </em></code>: </p>
</li>
<li>
<p><code><em> AirbaseName </em></code>: </p>
</li>
</ul>
<h3>Return value</h3>
<p><em><a href="Airbase.html##(AIRBASE)">Airbase#AIRBASE</a>:</em></p>
</dd>
</dl>
</div>
</div>
</body>
</html>

1
Moose Training/Documentation/Base.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li>Base</li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/CARGO.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li>CARGO</li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/CleanUp.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li>CleanUp</li>

1
Moose Training/Documentation/Client.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSAirbase.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSCoalitionObject.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSCommand.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSController.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSGroup.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSObject.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSTask.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSTypes.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSUnit.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCSWorld.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DCStimer.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DEPLOYTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DESTROYBASETASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DESTROYGROUPSTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DESTROYRADARSTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/DESTROYUNITTYPESTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Database.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Escort.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Event.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/GOHOMETASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

950
Moose Training/Documentation/Group.html
View File

File diff suppressed because it is too large Load Diff

1
Moose Training/Documentation/GroupSet.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/MISSION.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/MOVEMENT.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Menu.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Message.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/MissileTrainer.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/NOTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/PICKUPTASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/ROUTETASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/STAGE.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Scheduler.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Scoring.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Sead.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Set.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Spawn.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/StaticObject.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/TASK.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Unit.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/UnitSet.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/Zone.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/env.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

14
Moose Training/Documentation/index.html
View File

@ -17,6 +17,7 @@
index
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>
@ -70,6 +71,19 @@
<div id="content">
<h2>Module</h2>
<table class="module_list">
<tr>
<td class="name" nowrap="nowrap"><a href="Airbase.html">Airbase</a></td>
<td class="summary">
<p>AIRBASE Class</p>
<h1><a href="AIRBASE.html">AIRBASE</a> class</h1>
<p>The <a href="AIRBASE.html">AIRBASE</a> class is a wrapper class to handle the DCS Airbase objects:</p>
<ul>
<li>Support all DCS Airbase APIs.</li>
</ul>
</td>
</tr>
<tr>
<td class="name" nowrap="nowrap"><a href="Base.html">Base</a></td>
<td class="summary">

1
Moose Training/Documentation/land.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>

1
Moose Training/Documentation/routines.html
View File

@ -17,6 +17,7 @@
<a href="index.html">index</a>
</li></ul>
<ul>
<li><a href="Airbase.html">Airbase</a></li>
<li><a href="Base.html">Base</a></li>
<li><a href="CARGO.html">CARGO</a></li>
<li><a href="CleanUp.html">CleanUp</a></li>