VECTOR

- Added excludelist to GetClosestBeacon function

Moose Development/Moose/Core/Point.lua

@@ -1637,7 +1637,6 @@ do -- COORDINATE
       if AirbaseCategory == Airbase.Category.SHIP or AirbaseCategory == Airbase.Category.HELIPAD then
         RoutePoint.linkUnit = AirbaseID
         RoutePoint.helipadId = AirbaseID
-        RoutePoint.airdromeId = airbase:IsAirdrome() and AirbaseID or nil
       elseif AirbaseCategory == Airbase.Category.AIRDROME then
         RoutePoint.airdromeId = AirbaseID
       else

Moose Development/Moose/Functional/Scoring.lua

@@ -320,8 +320,8 @@ function SCORING:New( GameName, SavePath, AutoSave )
 
   -- Create the CSV file.
   self.AutoSavePath = SavePath
-  self.AutoSave = (AutoSave == nil or AutoSave == true) and true or false
-  if self.AutoSavePath and self.AutoSave == true then
+  self.AutoSave = AutoSave or true
+  if self.AutoSave == true then
     self:OpenCSV( GameName )
   end
 

Moose Development/Moose/Globals.lua

@@ -20,6 +20,13 @@ _DATABASE:_RegisterCargos()
 _DATABASE:_RegisterZones()
 _DATABASE:_RegisterAirbases()
 
+--- Function that writes to DCS log file
+-- @param #string text Formatted text.
+-- @param ... Format passed to string.format().
+function printf(text, ...)
+  env.info(string.format(text, ...))
+end
+
 --- Check if os etc is available.
 BASE:I("Checking de-sanitization of os, io and lfs:")
 local __na = false

Moose Development/Moose/Modules.lua

@@ -32,6 +32,7 @@ __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Core/MarkerOps_Base.lua' )
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Core/TextAndSound.lua' )
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Core/Pathline.lua' )
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Core/ClientMenu.lua')
+__Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Core/Vector.lua')
 
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Wrapper/Object.lua' )
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Wrapper/Identifiable.lua' )
@@ -186,4 +187,9 @@ __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Tasking/Task_Cargo_Dispatcher
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Tasking/Task_Capture_Zone.lua' )
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Tasking/Task_Capture_Dispatcher.lua' )
 
+__Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Navigation/Point.lua' )
+__Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Navigation/Beacons.lua' )
+__Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Navigation/Radios.lua' )
+__Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Navigation/Towns.lua' )
+
 __Moose.Include( MOOSE_DEVELOPMENT_FOLDER..'/Moose/Globals.lua' )

Moose Development/Moose/Modules_local.lua

@@ -32,6 +32,7 @@ __Moose.Include( 'Core\\MarkerOps_Base.lua' )
 __Moose.Include( 'Core\\TextAndSound.lua' )
 __Moose.Include( 'Core\\Condition.lua' )
 __Moose.Include( 'Core\\ClientMenu.lua' )
+__Moose.Include( 'Core\\Vector.lua' )
 
 __Moose.Include( 'Wrapper\\Object.lua' )
 __Moose.Include( 'Wrapper\\Identifiable.lua' )
@@ -177,4 +178,9 @@ __Moose.Include( 'Tasking\\Task_Cargo_Dispatcher.lua' )
 __Moose.Include( 'Tasking\\Task_Capture_Zone.lua' )
 __Moose.Include( 'Tasking\\Task_Capture_Dispatcher.lua' )
 
+__Moose.Include( 'Navigation\\Point.lua' )
+__Moose.Include( 'Navigation\\Beacons.lua' )
+__Moose.Include( 'Navigation\\Radios.lua' )
+__Moose.Include( 'Navigation\\Towns.lua' )
+
 __Moose.Include( 'Globals.lua' )

Moose Development/Moose/Navigation/Beacons.lua

@@ -0,0 +1,395 @@
+--- **NAVIGATION** - Beacons of the map/theatre.
+--
+-- **Main Features:**
+--
+--    * Access beacons of the map
+--    * Find closest beacon
+--    * Get frequencies and channels
+-- 
+-- ===
+--
+-- ## Example Missions:
+--
+-- Demo missions can be found on [github](https://github.com/FlightControl-Master/MOOSE_MISSIONS/tree/develop/Navigation%20-%20Beacons).
+-- 
+-- ===
+--
+-- ### Author: **funkyfranky**
+-- 
+-- ===
+-- @module Navigation.Beacons
+-- @image NAVIGATION_Beacons.png
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- BEACONS class.
+-- @type BEACONS
+-- 
+-- @field #string ClassName Name of the class.
+-- @field #number verbose Verbosity of output.
+-- @field #table beacons Beacons.
+-- 
+-- @extends Core.Base#BASE
+
+--- *Hope is the beacon that guides lost ships back to the shore.*
+--
+-- ===
+--
+-- # The BEACONS Concept
+--
+-- This class is desinged to make information about beacons of a map/theatre easier accessible. The information contains location, type and frequencies of all or specific beacons of the map.
+-- 
+-- **Note** that try to avoid hard coding stuff in Moose since DCS is updated frequently and things change. Therefore, the main source of information is either a file `beacons.lua` that can be
+-- found in the installation directory of DCS for each map or a table that the user needs to provide.
+-- 
+-- # Basic Setup
+-- 
+-- A new `BEACONS` object can be created with the @{#BEACONS.NewFromFile}(*beacons_lua_file*) function.
+-- 
+--     local beacons=BEACONS:NewFromFile("<DCS_Install_Directory>\Mods\terrains\<Map_Name>\beacons.lua")
+--     beacons:MarkerShow()
+-- 
+-- This will load the beacons from the `<DCS_Install_Directory>` for the specific map and place markers on the F10 map. This is the first step you should do to ensure that the file
+-- you provided is correct and all relevant beacons are present.
+-- 
+-- # User Functions
+-- 
+-- ## F10 Map Markers
+-- 
+-- ## Position
+-- 
+-- ## Get Closest Beacon
+-- 
+--
+-- @field #BEACONS
+BEACONS = {
+  ClassName  = "BEACONS",
+  verbose    =         1,
+  beacons    =        {},
+}
+
+--- Mission capability.
+-- @type BEACONS.Beacon
+-- @field #function display_name Function that returns the localized name.
+-- @field #number type Beacon type.
+-- @field #string beaconId Beacon ID.
+-- @field #string callsign Call sign.
+-- @field #number frequency Frequency in Hz.
+-- @field #number channel TACAN, RSBN or PRMG channel depending on type.
+-- @field #table position Position table.
+-- @field #number direction Direction in degrees.
+-- @field #table positionGeo Table with latitude and longitude.
+-- @field #table sceneObjects Table with scenery objects, e.g. `{t:393396742}`.
+-- @field #number chartOffsetX No idea what this offset is?!
+-- @field DCS#Vec3 vec3 Position vector 3D.
+-- @field #number markerID ID for the F10 marker.
+-- @field #string typeName Name of becon type.
+-- @field Wrapper.Scenery#SCENERY scenery The scenery object.
+
+--- BEACONS class version.
+-- @field #string version
+BEACONS.version="0.0.4"
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- ToDo list
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- TODO: A lot...
+-- DONE: TACAN channel from frequency (was already in beacon.lua as channel)
+-- DONE: Scenery object
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Constructor(s)
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Create a new BECAONS class instance from a given table.
+-- @param #BEACONS self
+-- @param #table BeaconTable Table with beacon info.
+-- @return #BEACONS self
+function BEACONS:NewFromTable(BeaconTable)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #BEACONS
+  
+  for _,_beacon in pairs(BeaconTable) do
+    local beacon=_beacon --#BEACONS.Beacon
+    
+    -- Get 3D vector
+    beacon.vec3={x=beacon.position[1], y=beacon.position[2], z=beacon.position[3]}
+    
+    -- Get coordinate
+    beacon.coordinate=COORDINATE:NewFromVec3(beacon.vec3)
+    
+    -- Get type name
+    beacon.typeName=self:_GetTypeName(beacon.type)
+    
+    -- Find closest scenery object from scan
+    beacon.scenery=beacon.coordinate:FindClosestScenery(20)
+    
+    -- Debug stuff for scenery object
+    if false then
+      if beacon.scenery then
+        env.info(string.format("FF Beacon %s %s %s got scenery object %s, %s", beacon.callsign, beacon.beaconId, beacon.typeName, beacon.scenery:GetName(), beacon.scenery:GetTypeName() ))
+        UTILS.PrintTableToLog(beacon.scenery.SceneryObject)
+        UTILS.PrintTableToLog(beacon.sceneObjects)
+      else
+        env.info(string.format("FF NO scenery object  %s %s %s ", beacon.callsign, beacon.beaconId, beacon.typeName))
+      end
+    end
+    
+    -- Add to table
+    table.insert(self.beacons, beacon)
+  end
+  
+  -- Debug output
+  self:I(string.format("Added %d beacons", #self.beacons))
+  
+  if self.verbose > 0 then
+    local text="Beacon types:"
+    for typeName,typeID in pairs(BEACON.Type) do
+      local n=self:CountBeacons(typeID)
+      text=text..string.format("\n%s = %d", typeName, n)      
+    end
+    self:I(text)
+  end
+  
+  return self
+end
+
+
+--- Create a new BECAONS class instance from a given file.
+-- @param #BEACONS self
+-- @param #string FileName Full path to the file containing the map beacons.
+-- @return #BEACONS self
+function BEACONS:NewFromFile(FileName)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #BEACONS
+  
+  local exists=UTILS.FileExists(FileName)
+  
+  if exists==false then
+    self:E(string.format("ERROR: file with beacon info does not exist!"))
+    return nil
+  end
+
+  -- This will create a global table `beacons`  
+  dofile(FileName)
+
+  -- Get beacons from table.
+  self=self:NewFromTable(beacons)
+  
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- User Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get 3D position vector of a specific beacon.
+-- @param #BEACONS self
+-- @param #BEACONS.Beacon beacon The beacon data structure.
+-- @return DCS#Vec3 Position vector.
+function BEACONS:GetVec3(beacon)
+  return beacon.vec3
+end
+
+--- Get COORDINATE of a specific beacon.
+-- @param #BEACONS self
+-- @param #BEACONS.Beacon beacon The beacon data structure.
+-- @return Core.Point#COORDINATE The coordinate.
+function BEACONS:GetCoordinate(beacon)
+  local coordinate=COORDINATE:NewFromVec3(beacon.vec3)
+  return coordinate
+end
+
+--- Find closest beacon to a given coordinate.
+-- @param #BEACONS self
+-- @param Core.Point#COORDINATE Coordinate The reference coordinate.
+-- @param #number TypeID (Optional) Only search for specific beacon types, *e.g.* `BEACON.Type.TACAN`.
+-- @param #number DistMax (Optional) Max search distance in meters.
+-- @param #table ExcludeList (Optional) List of beacons to exclude.
+-- @return #BEACONS.Beacon The closest beacon.
+function BEACONS:GetClosestBeacon(Coordinate, TypeID, DistMax, ExcludeList)
+
+  local beacon=nil --#BEACONS.Beacon
+  local distmin=math.huge
+  
+  ExcludeList=ExcludeList or {}
+  
+  for _,_beacon in pairs(self.beacons) do
+    local bc=_beacon --#BEACONS.Beacon
+    
+    if (TypeID==nil or TypeID==bc.type) and (not UTILS.IsInTable(ExcludeList, bc, "beaconId")) then
+    
+      local dist=Coordinate:Get2DDistance(bc.vec3)
+      
+      if dist<distmin and (DistMax==nil or dist<=DistMax) then
+        distmin=dist
+        beacon=bc
+      end
+      
+    end
+    
+  end  
+  
+  return beacon
+end
+
+--- Get table of all beacons, optionally of a given type.
+-- @param #BEACONS self
+-- @param #number TypeID (Optional) Only return specific beacon types, *e.g.* `BEACON.Type.TACAN`.
+-- @return #table Table of beacons. Each element is of type #BEACON.Beacon.
+function BEACONS:GetBeacons(TypeID)
+  
+  local beacons={}
+  
+  for _,_beacon in pairs(self.beacons) do
+    local bc=_beacon --#BEACONS.Beacon
+    
+    if TypeID==nil or TypeID==bc.type then
+      table.insert(beacons, bc)
+    end
+    
+  end  
+
+  return beacons
+end
+
+--- Count beacons, optionally of a given type.
+-- @param #BEACONS self
+-- @param #number TypeID (Optional) Only count specific beacon types, *e.g.* `BEACON.Type.TACAN`.
+-- @return #number Number of beacons.
+function BEACONS:CountBeacons(TypeID)
+
+  local n=0
+  
+  if TypeID then
+    for _,_beacon in pairs(self.beacons) do
+      local bc=_beacon --#BEACONS.Beacon
+      
+      if TypeID==bc.type then
+        n=n+1
+      end 
+    end
+  else
+    n=#self.beacons
+  end
+
+  return n
+end
+
+--- Add markers for all beacons on the F10 map. Optionally, only a specific beacon or a certain beacon type can be marked.
+-- @param #BEACONS self
+-- @param #BEACONS.Beacon Beacon (Optional) Only this specifc beacon.
+-- @param #number TypeID (Optional) Only show specific beacon types, *e.g.* `BEACON.Type.TACAN`.
+-- @return #BEACONS self
+function BEACONS:MarkerShow(Beacon, TypeID)
+
+  for _,_beacon in pairs(self.beacons) do
+    local beacon=_beacon --#BEACONS.Beacon
+    if Beacon==nil or Beacon.beaconId==beacon.beaconId then
+      if TypeID==nil or beacon.type==TypeID then
+        local text=self:_GetMarkerText(beacon)
+        local coord=COORDINATE:NewFromVec3(beacon.vec3)
+        if beacon.markerID then
+          UTILS.RemoveMark(beacon.markerID)
+        end
+        beacon.markerID=coord:MarkToAll(text)
+      end
+    end
+  end
+
+  return self
+end
+
+--- Remove markers of all beacons from the F10 map. Optionally, remove only marker of a specific beacon or a certain beacon type.
+-- @param #BEACONS self
+-- @param #BEACONS.Beacon Beacon (Optional) Only this specifc beacon.
+-- @param #number TypeID (Optional) Only show specific beacon types, *e.g.* `BEACON.Type.TACAN`.
+-- @return #BEACONS self
+function BEACONS:MarkerRemove(Beacon, TypeID)
+
+  for _,_beacon in pairs(self.beacons) do
+    local beacon=_beacon --#BEACONS.Beacon
+    if Beacon==nil or Beacon.beaconId==beacon.beaconId then    
+      if TypeID==nil or beacon.type==TypeID then    
+        if beacon.markerID then
+          UTILS.RemoveMark(beacon.markerID)
+          beacon.markerID=nil
+        end
+      end
+    end
+  end
+
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Private Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get text displayed in the F10 marker.
+-- @param #BEACONS self
+-- @param #BEACONS.Beacon beacon The beacon data structure.
+-- @return #string Marker text.
+function BEACONS:_GetMarkerText(beacon)
+
+  local frequency, funit=self:_GetFrequency(beacon.frequency)
+  local direction=beacon.direction~=nil and beacon.direction or -1
+
+  local text=string.format("Beacon %s [ID=%s]", tostring(beacon.typeName), tostring(beacon.beaconId))  
+  text=text..string.format("\nCallsign: %s", tostring(beacon.callsign))
+  if UTILS.IsInTable({BEACON.Type.TACAN, BEACON.Type.RSBN, BEACON.Type.PRMG_GLIDESLOPE, BEACON.Type.PRMG_LOCALIZER}, beacon.type) then
+    text=text..string.format("\nChannel: %s", tostring(beacon.channel))
+  end
+  text=text..string.format("\nFrequency: %.3f %s", frequency, funit)
+  text=text..string.format("\nDirection: %.1f°", direction)
+  
+  return text
+end
+
+
+--- Get converted frequency.
+-- @param #BEACONS self
+-- @param #number freq Frequency in Hz.
+-- @return #number Frequency in better unit.
+-- @return #string Unit ("Hz", "kHz", "MHz").
+function BEACONS:_GetFrequency(freq)
+
+  freq=freq or 0
+  local unit="Hz"
+  
+  if freq>=1e6 then
+    freq=freq/1e6
+    unit="MHz"
+  elseif freq>=1e3 then
+    freq=freq/1e3
+    unit="kHz"
+  end
+
+  return freq, unit
+end
+
+--- Get name of beacon type.
+-- @param #BEACONS self
+-- @param #number typeID Beacon type number.
+-- @return #string Type name.
+function BEACONS:_GetTypeName(typeID)
+
+  if typeID~=nil then  
+    for typeName,_typeID in pairs(BEACON.Type) do
+      if _typeID==typeID then
+        return typeName
+      end  
+    end
+  end
+
+  return "Unknown"
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Moose Development/Moose/Navigation/Point.lua

@@ -0,0 +1,587 @@
+--- **NAVIGATION** - Navigation Airspace Points, Fixes and Aids.
+--
+-- **Main Features:**
+--
+--    * Stuff
+--    * More Stuff
+-- 
+-- ===
+--
+-- ## Example Missions:
+--
+-- Demo missions can be found on [github](https://github.com/FlightControl-Master/MOOSE_MISSIONS/tree/develop/Navigation%20-%20NavFix).
+-- 
+-- ===
+--
+-- ### Author: **funkyfranky**
+-- 
+-- ===
+-- @module Navigation.Point
+-- @image NAVIGATION_Point.png
+
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- NAVFIX class.
+-- @type NAVFIX
+-- 
+-- @field #string ClassName Name of the class.
+-- @field #number verbose Verbosity of output.
+-- @field #string name Name of the point.
+-- @field #string typePoint Type of the point, *e.g. "Intersection", "VOR", "Airport".
+-- @field Core.Vector#VECTOR vector Position vector of the fix.
+-- @field Wrapper.Marker#MARKER marker Marker on F10 map.
+-- @field #number altMin Minimum altitude in meters.
+-- @field #number altMax Maximum altitude in meters.
+-- @field #number speedMin Minimum speed in knots.
+-- @field #number speedMax Maximum speed in knots.
+-- 
+-- @field #boolean isCompulsory Is this a compulsory fix.
+-- @field #boolean isFlyover Is this a flyover fix (`true`) or turning point otherwise.
+-- @field #boolean isFAF Is this a final approach fix.
+-- @field #boolean isIAF Is this an initial approach fix.
+-- @field #boolean isIF Is this an initial fix.
+-- @field #boolean isMAF Is this an initial fix.
+-- 
+-- @extends Core.Base#BASE
+
+--- *A fleet of British ships at war are the best negotiators.* -- Horatio Nelson
+--
+-- ===
+--
+-- # The NAVFIX Concept
+--
+-- The NAVFIX class has a great concept!
+-- 
+-- A NAVFIX describes a geo position and can, *e.g.*, be part of a FLIGHTPLAN. It has a unique name and is of a certain type, *e.g.* "Intersection", "VOR", "Airbase" etc.
+-- It can also have further properties as min/max altitudes and speeds that aircraft need to obey when they pass the point.
+-- 
+-- # Basic Setup
+-- 
+-- A new `NAVFIX` object can be created with the @{#NAVFIX.New}() function.
+-- 
+--     myNavPoint=NAVFIX:New()
+--     myTemplate:SetXYZ(X, Y, Z)
+--     
+-- This is how it works.
+--
+-- @field #NAVFIX
+NAVFIX = {
+  ClassName       = "NAVFIX",
+  verbose         =          0,
+}
+
+--- Type of point.
+-- @type NAVFIX.Type
+-- @field #string POINT Waypoint.
+-- @field #string INTERSECTION Intersection of airway.
+-- @field #string AIRPORT Airport.
+-- @field #string VOR Very High Frequency Omnidirectional Range Station.
+-- @field #string DME Distance Measuring Equipment.
+-- @field #string NDB Non-Directional Beacon.
+-- @field #string VORDME Combined VHF omnidirectional range (VOR) with a distance-measuring equipment (DME).
+-- @field #string LOC Localizer.
+-- @field #string ILS Instrument Landing System.
+-- @field #string TACAN TACtical Air Navigation System (TACAN).
+NAVFIX.Type={
+  POINT="Point",
+  INTERSECTION="Intersection",
+  AIRPORT="Airport",
+  NDB="NDB",
+  VOR="VOR",
+  DME="DME",
+  VORDME="VOR/DME",
+  LOC="Localizer",
+  ILS="ILS",
+  TACAN="TACAN"
+}
+
+--- NAVFIX class version.
+-- @field #string version
+NAVFIX.version="0.0.1"
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- ToDo list
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- TODO: A lot...
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Constructor(s)
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Create a new NAVFIX class instance from a given VECTOR.
+-- @param #NAVFIX self
+-- @param #string Name Name/ident of the point. Should be unique!
+-- @param #string Type Type of the point. Default `NAVFIX.Type.POINT`.
+-- @param Core.Vector#VECTOR Vector Position vector of the navpoint.
+-- @return #NAVFIX self
+function NAVFIX:NewFromVector(Name, Type, Vector)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #NAVFIX
+  
+  -- Vector of point.
+  self.vector=Vector
+  
+  -- Name of point.
+  self.name=Name
+  
+  -- Type of the point.
+  self.typePoint=Type or NAVFIX.Type.POINT
+  
+  local coord=COORDINATE:NewFromVec3(self.vector)
+  
+  -- Marker on F10.
+  self.marker=MARKER:New(coord, self:_GetMarkerText())
+  
+  -- Log ID string.
+  self.lid=string.format("NAVFIX %s [%s] | ", tostring(self.name), tostring(self.typePoint))
+  
+  -- Debug info.
+  self:I(self.lid..string.format("Created NAVFIX"))
+
+  return self
+end
+
+
+--- Create a new NAVFIX class instance from a given COORDINATE.
+-- @param #NAVFIX self
+-- @param #string Name Name of the fix. Should be unique!
+-- @param #string Type Type of the point. Default `NAVFIX.Type.POINT`.
+-- @param Core.Point#COORDINATE Coordinate Coordinate of the point.
+-- @return #NAVFIX self
+function NAVFIX:NewFromCoordinate(Name, Type, Coordinate)
+
+  -- Create a VECTOR from the coordinate.
+  local Vector=VECTOR:NewFromVec(Coordinate)
+  
+  -- Create NAVFIX.
+  self=NAVFIX:NewFromVector(Name, Type, Vector)
+  
+  return self
+end
+
+
+--- Create a new NAVFIX instance from given latitude and longitude in degrees, minutes and seconds (DMS).
+-- @param #NAVFIX self
+-- @param #string Name Name of the fix. Should be unique!
+-- @param #string Type Type of the point. Default `NAVFIX.Type.POINT`.
+-- @param #string Latitude Latitude in DMS as string.
+-- @param #string Longitude Longitude in DMS as string.
+-- @return #NAVFIX self
+function NAVFIX:NewFromLLDMS(Name, Type, Latitude, Longitude)
+
+  -- Create a VECTOR from the coordinate.
+  local Vector=VECTOR:NewFromLLDMS(Latitude, Longitude)
+
+  -- Create NAVFIX.
+  self=NAVFIX:NewFromVector(Name, Type, Vector)
+  
+  return self  
+end
+
+--- Create a new NAVFIX instance from given latitude and longitude in decimal degrees (DD).
+-- @param #NAVFIX self
+-- @param #string Name Name of the fix. Should be unique!
+-- @param #string Type Type of the point. Default `NAVFIX.Type.POINT`.
+-- @param #number Latitude Latitude in DD.
+-- @param #number Longitude Longitude in DD.
+-- @return #NAVFIX self
+function NAVFIX:NewFromLLDD(Name, Type, Latitude, Longitude)
+
+  -- Create a VECTOR from the coordinate.
+  local Vector=VECTOR:NewFromLLDD(Latitude, Longitude)
+
+  -- Create NAVFIX.
+  self=NAVFIX:NewFromVector(Name, Type, Vector)
+  
+  return self  
+end
+
+
+--- Create a new NAVFIX class instance relative to a given other NAVFIX.
+-- You have to specify the distance and bearing from the new point to the given point. *E.g.*, for a distance of 5 NM and a bearing of 090° (West), the
+-- new nav point is created 5 NM East of the given nav point. The reason is that this corresponts to convention used in most maps.
+-- You can, however, use the `Reciprocal` switch to create the new point in the direction you specify.
+-- @param #NAVFIX self
+-- @param #string Name Name of the fix. Should be unique!
+-- @param #string Type Type of navfix.
+-- @param #NAVFIX NavFix The given/existing navigation fix relative to which the new fix is created.
+-- @param #number Distance Distance from the given to the new point in nautical miles.
+-- @param #number Bearing Bearing [Deg] from the new point to the given one.
+-- @param #boolean Reciprocal If `true` the reciprocal `Bearing` is taken so it specifies the direction from the given point to the new one. 
+-- @return #NAVFIX self
+function NAVFIX:NewFromNavFix(Name, Type, NavFix, Distance, Bearing, Reciprocal)
+
+  -- Convert magnetic to true bearing by adding magnetic declination, e.g. mag. bearing 10°M ==> true bearing 16°M (for 6° variation on Caucasus map)
+  Bearing=Bearing+UTILS.GetMagneticDeclination()
+
+  if Reciprocal then
+    Bearing=Bearing-180
+  end
+  
+  -- Translate.
+  local Vector=NavFix.vector:Translate(UTILS.NMToMeters(Distance), Bearing, true)
+  
+  self=NAVFIX:NewFromVector(Name, Type, Vector)
+  
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- User Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Set whether this is the intermediate fix (IF).
+-- @param #NAVFIX self
+-- @return #NAVFIX self
+function NAVFIX:SetIntermediateFix(IntermediateFix)
+  self.isIF=IntermediateFix
+  return self
+end
+
+--- Set whether this is an initial approach fix (IAF).
+-- The IAF is the point where the initial approach segment of an instrument approach begins.
+-- It is usually a designated intersection, VHF omidirectional range (VOR) non-directional beacon (NDB)
+-- or distance measuring equipment (DME) fix.
+-- The IAF may be collocated with the intermediate fix (IF) of the instrument apprach an in such case they designate the
+-- beginning of the intermediate segment of the approach. When the IAF and the IF are combined, there is no inital approach segment.
+-- @param #NAVFIX self
+-- @param #boolean IntermediateFix If `true`, this is an intermediate fix.
+-- @return #NAVFIX self
+function NAVFIX:SetInitialApproachFix(IntermediateFix)
+  self.isIAF=IntermediateFix
+  return self
+end
+
+
+--- Set whether this is the final approach fix (FAF).
+-- @param #NAVFIX self
+-- @param #boolean FinalApproachFix If `true`, this is a final approach fix.
+-- @return #NAVFIX self
+function NAVFIX:SetFinalApproachFix(FinalApproachFix)
+  self.isFAF=FinalApproachFix
+  return self
+end
+
+--- Set whether this is the final approach fix (FAF).
+-- @param #NAVFIX self
+-- @param #boolean FinalApproachFix If `true`, this is a final approach fix.
+-- @return #NAVFIX self
+function NAVFIX:SetMissedApproachFix(MissedApproachFix)
+  self.isMAF=MissedApproachFix
+  return self
+end
+
+
+--- Set minimum altitude.
+-- @param #NAVFIX self
+-- @param #number Altitude Min altitude in feet.
+-- @return #NAVFIX self
+function NAVFIX:SetAltMin(Altitude)
+
+  self.altMin=Altitude
+
+  return self
+end
+
+--- Set maximum altitude.
+-- @param #NAVFIX self
+-- @param #number Altitude Max altitude in feet.
+-- @return #NAVFIX self
+function NAVFIX:SetAltMax(Altitude)
+
+  self.altMax=Altitude
+
+  return self
+end
+
+--- Set mandatory altitude (min alt = max alt).
+-- @param #NAVFIX self
+-- @param #number Altitude Altitude in feet.
+-- @return #NAVFIX self
+function NAVFIX:SetAltMandatory(Altitude)
+
+  self.altMin=Altitude
+  self.altMax=Altitude
+
+  return self
+end
+
+--- Set minimum allowed speed at this fix.
+-- @param #NAVFIX self
+-- @param #number Speed Min speed in knots.
+-- @return #NAVFIX self
+function NAVFIX:SetSpeedMin(Speed)
+
+  self.speedMin=Speed
+
+  return self
+end
+
+--- Set maximum allowed speed at this fix.
+-- @param #NAVFIX self
+-- @param #number Speed Max speed in knots.
+-- @return #NAVFIX self
+function NAVFIX:SetSpeedMax(Speed)
+
+  self.speedMax=Speed
+
+  return self
+end
+
+--- Set mandatory speed (min speed = max speed) at this fix.
+-- @param #NAVFIX self
+-- @param #number Speed Mandatory speed in knots.
+-- @return #NAVFIX self
+function NAVFIX:SetSpeedMandatory(Speed)
+
+  self.speedMin=Speed
+  self.speedMax=Speed
+
+  return self
+end
+
+
+--- Set whether this fix is compulsory.
+-- @param #NAVFIX self
+-- @param #boolean Compulsory If `true`, this is a compusory fix. If `false` or nil, it is non-compulsory.
+-- @return #NAVFIX self
+function NAVFIX:SetCompulsory(Compulsory)
+  self.isCompulsory=Compulsory
+  return self
+end
+
+--- Set whether this is a fly-over fix fix.
+-- @param #NAVFIX self
+-- @param #boolean FlyOver If `true`, this is a fly over fix. If `false` or nil, it is not.
+-- @return #NAVFIX self
+function NAVFIX:SetFlyOver(FlyOver)
+  self.isFlyover=FlyOver
+  return self
+end
+
+
+--- Get the altitude in feet MSL. If min and max altitudes are set, it will return a random altitude between min and max.
+-- @param #NAVFIX self
+-- @return #number Altitude in feet MSL. Can be `nil`, if neither min nor max altitudes have beeen set. 
+function NAVFIX:GetAltitude()
+
+  local alt=nil
+  if self.altMin and self.altMax and self.altMin~=self.altMax then
+    alt=math.random(self.altMin, self.altMax)
+  elseif self.altMin then
+    alt=self.altMin
+  elseif self.altMax then
+    alt=self.altMax
+  end
+
+  return alt
+end
+
+
+--- Get the speed. If min and max speeds are set, it will return a random speed between min and max.
+-- @param #NAVFIX self
+-- @return #number Speed in knots. Can be `nil`, if neither min nor max speeds have beeen set. 
+function NAVFIX:GetSpeed()
+
+  local speed=nil
+  if self.speedMin and self.speedMax and self.speedMin~=self.speedMax then
+    speed=math.random(self.speedMin, self.speedMax)
+  elseif self.speedMin then
+    speed=self.speedMin
+  elseif self.speedMax then
+    speed=self.speedMax
+  end
+
+  return speed
+end
+
+
+
+--- Add marker the NAVFIX on the F10 map.
+-- @param #NAVFIX self
+-- @return #NAVFIX self
+function NAVFIX:MarkerShow()
+
+  self.marker:ToAll()
+
+  return self
+end
+
+--- Remove marker of the NAVFIX from the F10 map.
+-- @param #NAVFIX self
+-- @return #NAVFIX self
+function NAVFIX:MarkerRemove()
+
+  self.marker:Remove()
+
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Private Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get text displayed in the F10 marker.
+-- @param #NAVFIX self
+-- @return #string Marker text.
+function NAVFIX:_GetMarkerText()
+
+  local altmin=self.altMin and tostring(self.altMin) or ""
+  local altmax=self.altMax and tostring(self.altMax) or ""
+  local speedmin=self.speedMin and tostring(self.speedMin) or ""
+  local speedmax=self.speedMax and tostring(self.speedMax) or ""
+
+
+  local text=string.format("NAVFIX %s", self.name)
+  if self.isIAF then
+    text=text..string.format(" (IAF)")
+  end
+  if self.isIF then
+    text=text..string.format(" (IF)")
+  end
+  text=text..string.format("\nAltitude [ft]: %s - %s", altmin, altmax)
+  text=text..string.format("\nSpeed [knots]: %s - %s", speedmin, speedmax)
+  text=text..string.format("\nCompulsory: %s", tostring(self.isCompulsory))
+  text=text..string.format("\nFly Over: %s", tostring(self.isFlyover))
+  
+  return text
+end
+
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- NAVAID class.
+-- @type NAVAID
+-- @field #string ClassName Name of the class.
+-- @field #number verbose Verbosity of output.
+-- @extends Navigation.Point#NAVFIX
+
+--- *A fleet of British ships at war are the best negotiators.* -- Horatio Nelson
+--
+-- ===
+--
+-- # The NAVAID Concept
+--
+-- A NAVAID consists of one or multiple FLOTILLAs. These flotillas "live" in a WAREHOUSE that has a phyiscal struction (STATIC or UNIT) and can be captured or destroyed.
+-- 
+-- # Basic Setup
+-- 
+-- A new `NAVAID` object can be created with the @{#NAVAID.New}(`WarehouseName`, `FleetName`) function, where `WarehouseName` is the name of the static or unit object hosting the fleet
+-- and `FleetName` is the name you want to give the fleet. This must be *unique*!
+-- 
+--     myFleet=NAVAID:New("myWarehouseName", "1st Fleet")
+--     myFleet:SetPortZone(ZonePort1stFleet)
+--     myFleet:Start()
+--     
+-- A fleet needs a *port zone*, which is set via the @{#NAVAID.SetPortZone}(`PortZone`) function. This is the zone where the naval assets are spawned and return to.
+-- 
+-- Finally, the fleet needs to be started using the @{#NAVAID.Start}() function. If the fleet is not started, it will not process any requests.
+--
+-- @field #NAVAID
+NAVAID = {
+  ClassName       = "NAVAID",
+  verbose         =       0,
+}
+  
+--- NAVAID class version.
+-- @field #string version
+NAVAID.version="0.0.1"
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- ToDo list
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- TODO: Add frequencies. Which unit MHz, kHz, Hz?
+-- TODO: Add radial function
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Constructor
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Create a new NAVAID class instance.
+-- @param #NAVAID self
+-- @param #string Name Name/ident of this navaid.
+-- @param #string Type Type of the point. Default `NAVFIX.Type.POINT`.
+-- @param #string ZoneName Name of the zone to scan the scenery.
+-- @param #string SceneryName Name of the scenery object.
+-- @return #NAVAID self
+function NAVAID:NewFromScenery(Name, Type, ZoneName, SceneryName)
+
+  -- Get the zone.
+  local zone=ZONE:FindByName(ZoneName)
+  
+  -- Get coordinate.
+  local Coordinate=zone:GetCoordinate()
+
+  -- Inherit everything from NAVFIX class.
+  self=BASE:Inherit(self, NAVFIX:NewFromCoordinate(Name, Type, Coordinate)) -- #NAVAID
+
+  -- Set zone.
+  self.zone=ZONE:FindByName(ZoneName)
+
+  -- Try to get the scenery object. Note not all can be found unfortunately.
+  if SceneryName then
+    self.scenery=SCENERY:FindByNameInZone(SceneryName, ZoneName)
+    if not self.scenery then
+      self:E(string.format("ERROR: Could not find scenery object %s in zone %s", SceneryName, ZoneName))
+    end
+  end
+  
+  -- Alias.  
+  self.alias=string.format("%s %s %s", tostring(ZoneName), tostring(SceneryName), tostring(Type))
+  
+  -- Set some string id for output to DCS.log file.
+  self.lid=string.format("NAVAID %s | ", self.alias)
+  
+  -- Debug info.
+  self:I(self.lid..string.format("Created NAVAID!"))
+
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- User Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Set frequency the beacon transmits on.
+-- @param #NAVAID self
+-- @param #number Frequency Frequency in Hz.
+-- @return #NAVAID self
+function NAVAID:SetFrequency(Frequency)
+
+  self.frequency=Frequency
+
+  return self
+end
+
+--- Set channel of, *e.g.*, TACAN beacons.
+-- @param #NAVAID self
+-- @param #number Channel The channel.
+-- @param #string Band The band either `"X"` (default) or `"Y"`. 
+-- @return #NAVAID self
+function NAVAID:SetChannel(Channel, Band)
+
+  self.channel=Channel
+  self.band=Band or "X"
+
+  return self
+end
+
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Private Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- Add private CLASS functions here.
+-- No private NAVAID functions yet.
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Moose Development/Moose/Navigation/Radios.lua

@@ -0,0 +1,330 @@
+--- **NAVIGATION** - Airbase radios.
+--
+-- **Main Features:**
+--
+--    * Get radio frequencies of airbases
+-- 
+-- ===
+--
+-- ## Example Missions:
+--
+-- Demo missions can be found on [github](https://github.com/FlightControl-Master/MOOSE_MISSIONS/tree/develop/Navigation%20-%20Radios).
+-- 
+-- ===
+--
+-- ### Author: **funkyfranky**
+-- 
+-- ===
+-- @module Navigation.Radios
+-- @image NAVIGATION_Radios.png
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- RADIOS class.
+-- @type RADIOS
+-- 
+-- @field #string ClassName Name of the class.
+-- @field #number verbose Verbosity of output.
+-- @field #table radios Radios.
+-- 
+-- @extends Core.Base#BASE
+
+--- *It's not true I had nothing on, I had the radio on.* -- *Marilyn Monroe*
+--
+-- ===
+--
+-- # The RADIOS Concept
+--
+-- This class is desinged to make information about radios of a map/theatre easier accessible. The information contains mostly the frequencies of airbases of the map.
+-- 
+-- **Note** that try to avoid hard coding stuff in Moose since DCS is updated frequently and things change. Therefore, the main source of information is either a file `radio.lua` that can be
+-- found in the installation directory of DCS for each map or a table that the user needs to provide.
+-- 
+-- # Basic Setup
+-- 
+-- A new `RADIOS` object can be created with the @{#RADIOS.NewFromFile}(*radio_lua_file*) function.
+-- 
+--     local radios=RADIOS:NewFromFile("<DCS_Install_Directory>\Mods\terrains\<Map_Name>\radios.lua")
+--     radios:MarkerShow()
+-- 
+-- This will load the radios from the `<DCS_Install_Directory>` for the specific map and place markers on the F10 map. This is the first step you should do to ensure that the file
+-- you provided is correct and all relevant radios are present.
+-- 
+-- # User Functions
+-- 
+-- ## F10 Map Markers
+-- 
+-- ## Position
+-- 
+-- ## Closest Radio
+-- 
+--
+-- @field #RADIOS
+RADIOS = {
+  ClassName  = "RADIOS",
+  verbose    =         0,
+  radios    =        {},
+}
+
+--- Radio item data structure.
+-- @type RADIOS.Radio
+-- @field #string radioId Radio ID.
+-- @field #table role Roles of the radio (usually {"ground", "tower", "approach"}).
+-- @field #table callsign Callsigns of the radio (usually the airbase name).
+-- @field #table frequency Frequencies of the radios.
+-- @field #table position Position table.
+-- @field #table sceneObjects Scenery objects.
+-- @field #string name Name of the airbase.
+-- @field Wrapper.Airbase#AIRBASE airbase Airbase.
+
+--- Radio item data structure.
+-- @type RADIOS.Frequency
+-- @field #number modu Modulation type.
+-- @field #number freq Frequency in Hz.
+
+
+--- RADIOS class version.
+-- @field #string version
+RADIOS.version="0.0.0"
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- ToDo list
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- TODO: A lot...
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Constructor(s)
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Create a new RADIOS class instance from a given table.
+-- @param #RADIOS self
+-- @param #table RadioTable Table with radios info.
+-- @return #RADIOS self
+function RADIOS:NewFromTable(RadioTable)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #RADIOS
+  
+  local airbasenames=AIRBASE.GetAllAirbaseNames()
+  
+  for _,_radio in pairs(RadioTable) do
+    local radio=_radio --#RADIOS.Radio
+    
+    --UTILS.PrintTableToLog(radio)
+    --UTILS.PrintTableToLog(radio.callsign)
+    
+    -- The table structure of callsign is a bit awkward. We need to get the airbase name.
+    local cs=radio.callsign[1]
+    if cs and cs.common then
+      radio.name=cs.common[1]
+    elseif cs and cs.nato then
+      radio.name=cs.nato[1]
+    else
+      radio.name="Unknown"
+    end
+    
+    --UTILS.PrintTableToLog(radio.callsign)
+    
+    radio.name=self:_GetAirbaseName(airbasenames, radio.name)
+    
+    radio.airbase=AIRBASE:FindByName(radio.name)
+    
+    if radio.airbase then
+      radio.coordinate=radio.airbase:GetCoordinate()
+    end
+    
+    -- Add to table
+    table.insert(self.radios, radio)
+  end
+  
+  -- Debug output
+  self:I(string.format("Added %d radios", #self.radios))
+  
+  return self
+end
+
+
+--- Create a new RADIOS class instance from a given file.
+-- @param #RADIOS self
+-- @param #string FileName Full path to the file containing the map radios.
+-- @return #RADIOS self
+function RADIOS:NewFromFile(FileName)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #RADIOS
+  
+  local exists=UTILS.FileExists(FileName)
+  
+  if exists==false then
+    self:E(string.format("ERROR: file with radios info does not exist! File=%s", tostring(FileName)))
+    return nil
+  end
+  
+  -- Backup DCS radio table
+  local radiobak=UTILS.DeepCopy(radio)
+
+  -- This will create a global table `radio`  
+  dofile(FileName)
+
+  -- Get radios from table.
+  self=self:NewFromTable(radio)
+  
+  -- Restore DCS radio table
+  radio=UTILS.DeepCopy(radiobak)
+  
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- User Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get 3D position vector of a specific radio.
+-- @param #RADIOS self
+-- @param #RADIOS.Radio radio The radio data structure.
+-- @return DCS#Vec3 Position vector.
+function RADIOS:GetVec3(radio)
+  return radio.vec3
+end
+
+--- Get COORDINATE of a specific radio.
+-- @param #RADIOS self
+-- @param #RADIOS.Radio radio The radio data structure.
+-- @return Core.Point#COORDINATE The coordinate.
+function RADIOS:GetCoordinate(radio)
+  return radio.coordinate
+end
+
+--- Add markers for all radios on the F10 map.
+-- @param #RADIOS self
+-- @param #RADIOS.Radio Radio (Optional) Only this specifc radio.
+-- @return #RADIOS self
+function RADIOS:MarkerShow(Radio)
+
+  for _,_radio in pairs(self.radios) do
+    local radio=_radio --#RADIOS.Radio
+    if Radio==nil or Radio.radioId==radio.radioId then
+      local coord=self:GetCoordinate(radio)
+      if coord then
+        local text=self:_GetMarkerText(radio)
+        if radio.markerID then
+          UTILS.RemoveMark(radio.markerID)
+        end
+        radio.markerID=coord:MarkToAll(text)
+      end
+    end
+  end
+
+  return self
+end
+
+--- Remove markers of all radios from the F10 map.
+-- @param #RADIOS self
+-- @param #RADIOS.Radio Radio (Optional) Only this specifc radio.
+-- @return #RADIOS self
+function RADIOS:MarkerRemove(Radio)
+
+  for _,_radio in pairs(self.radios) do
+    local radio=_radio --#RADIOS.Radio
+    if Radio==nil or Radio.radioId==radio.radioId then    
+      if radio.markerID then
+        UTILS.RemoveMark(radio.markerID)
+        radio.markerID=nil
+      end
+    end
+  end
+
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Private Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get text displayed in the F10 marker.
+-- @param #RADIOS self
+-- @param #RADIOS.Radio radio The radio data structure.
+-- @return #string Marker text.
+function RADIOS:_GetMarkerText(radio)
+
+  local text=string.format("Radio %s", tostring(radio.name))
+  for b,f in pairs(radio.frequency) do
+    local frequency=f --#RADIOS.Frequency
+    local mod=frequency[1]
+    local fre=frequency[2]
+    local freq, funit=self:_GetFrequency(fre)
+    --UTILS.PrintTableToLog(frequency)
+    local band=self:_GetBandName(b)
+    text=text..string.format("\n%s: %.3f %s", band, freq, funit)
+  end
+    
+  return text
+end
+
+
+--- Get converted frequency.
+-- @param #RADIOS self
+-- @param #number freq Frequency in Hz.
+-- @return #number Frequency in better unit.
+-- @return #string Unit ("Hz", "kHz", "MHz").
+function RADIOS:_GetFrequency(freq)
+
+  freq=freq or 0
+  local unit="Hz"
+  
+  if freq>=1e6 then
+    freq=freq/1e6
+    unit="MHz"
+  elseif freq>=1e3 then
+    freq=freq/1e3
+    unit="kHz"
+  end
+
+  return freq, unit
+end
+
+--- Get name of frequency band.
+-- @param #RADIOS self
+-- @param #number BandNumber Band as number.
+-- @return #string Band name.
+function RADIOS:_GetBandName(BandNumber)
+
+  if BandNumber~=nil then  
+    for bandName,bandNumber in pairs(ENUMS.FrequencyBand) do
+      if bandNumber==BandNumber then
+        return bandName
+      end  
+    end
+  end
+
+  return "Unknown"
+end
+
+--- Get name of frequency band.
+-- @param #RADIOS self
+-- @param #table airbasenames Names of all airbases.
+-- @param #string name Name of airbase.
+-- @return #string Name of airbase
+function RADIOS:_GetAirbaseName(airbasenames, name)
+
+  local airbase=AIRBASE:FindByName(name)
+  
+  if airbase then
+    return name    
+  else
+    for _,airbasename in pairs(airbasenames) do
+      if string.find(airbasename, name) then
+        return airbasename
+      end    
+    end
+  end
+
+  return "Unknown"
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Moose Development/Moose/Navigation/Towns.lua

@@ -0,0 +1,296 @@
+--- **NAVIGATION** - Beacons of the map/theatre.
+--
+-- **Main Features:**
+--
+--    * Find towns of map
+--    * Road and rail connections
+-- 
+-- ===
+--
+-- ## Example Missions:
+--
+-- Demo missions can be found on [github](https://github.com/FlightControl-Master/MOOSE_MISSIONS/tree/develop/Navigation%20-%20Towns).
+-- 
+-- ===
+--
+-- ### Author: **funkyfranky**
+-- 
+-- ===
+-- @module Navigation.Towns
+-- @image NAVIGATION_Towns.png
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- TOWNS class.
+-- @type TOWNS
+-- 
+-- @field #string ClassName Name of the class.
+-- @field #number verbose Verbosity of output.
+-- @field #table towns Towns.
+-- 
+-- @extends Core.Base#BASE
+
+--- *Hope is the beacon that guides lost ships back to the shore.*
+--
+-- ===
+--
+-- # The TOWNS Concept
+--
+-- This class is desinged to make information about towns of a map/theatre easier accessible. The information contains location and road/rail connections of the towns.
+-- 
+-- **Note** that try to avoid hard coding stuff in Moose since DCS is updated frequently and things change. Therefore, the main source of information is either a file `towns.lua` that can be
+-- found in the installation directory of DCS for each map or a table that the user needs to provide.
+-- 
+-- # Basic Setup
+-- 
+-- A new `TOWNS` object can be created with the @{#TOWNS.NewFromFile}(*towns_lua_file*) function.
+-- 
+--     local towns=TOWNS:NewFromFile("<DCS_Install_Directory>\Mods\terrains\<Map_Name>\towns.lua")
+--     towns:MarkerShow()
+-- 
+-- This will load the towns from the `<DCS_Install_Directory>` for the specific map and place markers on the F10 map. This is the first step you should do to ensure that the file
+-- you provided is correct and all relevant towns are present.
+-- 
+-- # User Functions
+-- 
+-- ## F10 Map Markers
+-- 
+-- ## Position
+-- 
+-- ## Get Closest Town
+-- 
+--
+-- @field #TOWNS
+TOWNS = {
+  ClassName  =   "TOWNS",
+  verbose    =         0,
+  towns      =        {},
+}
+
+--- Town data.
+-- @type TOWNS.Town
+-- @field #string display_name Displayed name.
+-- @field #string name Name of the town.
+-- @field #number latitude Latitude.
+-- @field #number longitude Longitude
+-- @field DCS#Vec3 vec3 Position vector 3D.
+-- @field Core.Point#COORDINATE coordinate The coordinate.
+-- @field Core.Point#COORDINATE coordRoad The coordinate of the closest road.
+-- @field Core.Point#COORDINATE coordRail The coordinate of the closest railway.
+-- @field #number markerID ID for the F10 marker.
+
+--- TOWNS class version.
+-- @field #string version
+TOWNS.version="0.0.1"
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- ToDo list
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+-- TODO: A lot...
+-- TODO: Road connection
+-- TODO: Rail connection
+-- TODO: Connection between towns
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Constructor(s)
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Create a new TOWNS class instance from a given table.
+-- @param #TOWNS self
+-- @param #table TownTable Table with all towns data.
+-- @return #TOWNS self
+function TOWNS:NewFromTable(TownTable)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #TOWNS
+  
+  for TownName,_town in pairs(TownTable) do
+    local town=_town --#TOWNS.Town
+    
+    town.name=TownName    
+
+    -- Get coordinate
+    town.coordinate=COORDINATE:NewFromLLDD(town.latitude, town.longitude)
+    
+    -- Get coordinate of closest road
+    town.coordRoad=town.coordinate:GetClosestPointToRoad()
+    
+    -- Get coordinate of closest rail
+    town.coordRail=town.coordinate:GetClosestPointToRoad(true)
+    
+    -- Add to table
+    table.insert(self.towns, town)
+  end
+  
+  -- Debug output
+  self:I(string.format("Added %d towns", #self.towns))
+  
+  return self
+end
+
+
+--- Create a new TOWNS class instance from a given file.
+-- @param #TOWNS self
+-- @param #string FileName Full path to the file containing the towns data.
+-- @return #TOWNS self
+function TOWNS:NewFromFile(FileName)
+
+  -- Inherit everything from BASE class.
+  self=BASE:Inherit(self, BASE:New()) -- #TOWNS
+  
+  local exists=UTILS.FileExists(FileName)
+  
+  if exists==false then
+    self:E(string.format("ERROR: file with towns info does not exist!"))
+    return nil
+  end
+
+  -- This will create a global table `towns`  
+  dofile(FileName)
+
+  -- Get towns from table.
+  self=self:NewFromTable(towns)
+  
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- User Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get 3D position vector of a specific town.
+-- @param #TOWNS self
+-- @param #TOWNS.Town town The town data structure.
+-- @return DCS#Vec3 Position vector.
+function TOWNS:GetVec3(town)
+  return town.vec3
+end
+
+--- Get COORDINATE of a specific town.
+-- @param #TOWNS self
+-- @param #TOWNS.Town town The town data structure.
+-- @return Core.Point#COORDINATE The coordinate.
+function TOWNS:GetCoordinate(town)
+  return town.coordinate
+end
+
+--- Get closest road coordinate of a town.
+-- @param #TOWNS self
+-- @param #TOWNS.Town town The town data structure.
+-- @return Core.Point#COORDINATE The closest road coordinate.
+function TOWNS:GetCoordRoad(town)
+  return town.coordRoad
+end
+
+--- Get closest rail coordinate of a town.
+-- @param #TOWNS self
+-- @param #TOWNS.Town town The town data structure.
+-- @return Core.Point#COORDINATE The closest rail coordinate.
+function TOWNS:GetCoordRail(town)
+  return town.coordRail
+end
+
+--- Get road connection between two towns.
+-- @param #TOWNS self
+-- @param #TOWNS.Town townA The town data structure.
+-- @param #TOWNS.Town townB The town data structure.
+-- @return #table Table containing path coordinates.
+function TOWNS:GetConnectionRoad(townA, townB)
+
+  local path=townA.coordRoad:GetPathOnRoad(townB.coordRoad)
+
+  return path
+end
+
+--- Find closest town to a given coordinate.
+-- @param #TOWNS self
+-- @param Core.Point#COORDINATE Coordinate The reference coordinate.
+-- @return #TOWNS.Town The closest town.
+function TOWNS:GetClosestTown(Coordinate)
+
+  local Town=nil --#TOWNS.Town
+  local distmin=math.huge
+  
+  for _,_town in pairs(self.towns) do
+    local town=_town --#TOWNS.Town
+    
+    local dist=Coordinate:Get2DDistance(town.coordinate)
+    
+    if dist<distmin then
+      distmin=dist
+      Town=town
+    end    
+  end
+  
+  return Town
+end
+
+--- Get table of all towns, optionally of a given type.
+-- @param #TOWNS self
+-- @return #table Table of towns. Each element is of type #TOWN.Town.
+function TOWNS:GetTowns()
+  return self.towns
+end
+
+--- Add markers for all towns on the F10 map.
+-- @param #TOWNS self
+-- @param #TOWNS.Town Town (Optional) Only this specifc town.
+-- @return #TOWNS self
+function TOWNS:MarkerShow(Town)
+
+  for _,_town in pairs(self.towns) do
+    local town=_town --#TOWNS.Town
+    if Town==nil or Town.name==town.name then
+      local text=self:_GetMarkerText(town)
+      local coord=town.coordinate
+      if town.markerID then
+        UTILS.RemoveMark(town.markerID)
+      end
+      town.markerID=coord:MarkToAll(text)
+    end
+  end
+
+  return self
+end
+
+--- Remove markers of all towns from the F10 map.
+-- @param #TOWNS self
+-- @param #TOWNS.Town Town (Optional) Only this specifc town.
+-- @return #TOWNS self
+function TOWNS:MarkerRemove(Town)
+
+  for _,_town in pairs(self.towns) do
+    local town=_town --#TOWNS.Town
+    if Town==nil or Town.name==town.name then    
+      if town.markerID then
+        UTILS.RemoveMark(town.markerID)
+        town.markerID=nil
+      end
+    end
+  end
+
+  return self
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-- Private Functions
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+--- Get text displayed in the F10 marker.
+-- @param #TOWNS self
+-- @param #TOWNS.Town town The town data structure.
+-- @return #string Marker text.
+function TOWNS:_GetMarkerText(town)
+
+  local text=string.format("Town %s", town.name)  
+  --text=text..string.format("\nCallsign: %s", tostring(beacon.callsign))
+  
+  return text
+end
+
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Moose Development/Moose/Ops/Airboss.lua

@@ -12229,8 +12229,8 @@ function AIRBOSS:GetHeadingIntoWind_new( vdeck, magnetic, coord )
   local magvar= magnetic and self.magvar or 0
 
   -- Ship heading so cross wind is min for the given wind.
-  local intowind = (540 + (windto - magvar + math.deg(theta) )) % 360
-
+  -- local intowind = (540 + (windto - magvar + math.deg(theta) )) % 360 -- VNAO Edit: Using old heading into wind algorithm
+  local intowind = self:GetHeadingIntoWind_old(vdeck,magnetic) -- VNAO Edit: Using old heading into wind algorithm
 
   return intowind, v
 end
@@ -12682,8 +12682,7 @@ function AIRBOSS:_LSOgrade( playerData )
   local nL=count(G, '_')/2
   local nS=count(G, '%(')
   local nN=N-nS-nL
-  
-  if TIG=="_OK_" then nL = nL -1 end --Circuit added to prevent grade deduction for perfect groove
+
 
   -- Groove time 15-18.99 sec for a unicorn. Or 60-65 for V/STOL unicorn.
   local Tgroove=playerData.Tgroove
@@ -12713,6 +12712,7 @@ function AIRBOSS:_LSOgrade( playerData )
     else
 
     if vtol then
+
       -- Add AV-8B Harrier devation allowances due to lower groundspeed and 3x conventional groove time, this allows to maintain LSO tolerances while respecting the deviations are not unsafe.--Pene testing
       -- Large devaitions still result in a No Grade, A Unicorn still requires a clean pass with no deviation.
 

Moose Development/Moose/Ops/Brigade.lua

@@ -599,7 +599,80 @@ function BRIGADE:onafterStatus(From, Event, To)
       text=text..string.format("\n* %s: spawned=%s", asset.spawngroupname, tostring(asset.spawned))      
     end
     self:I(self.lid..text)
-  end    
+  end
+
+  if self.verbose>=3 then
+  
+    -- Count numbers
+    local Ntotal=0
+    local Nspawned=0
+    local Nrequested=0
+    local Nreserved=0
+    local Nstock=0
+    
+    local text="\n===========================================\n"
+    text=text.."Assets:"
+    local legion=self --Ops.Legion#LEGION
+
+    for _,_cohort in pairs(legion.cohorts) do
+      local cohort=_cohort --Ops.Cohort#COHORT
+      
+      for _,_asset in pairs(cohort.assets) do
+        local asset=_asset --Functional.Warehouse#WAREHOUSE.Assetitem
+
+        local state="In Stock"
+        if asset.flightgroup then
+          state=asset.flightgroup:GetState()
+          local mission=legion:GetAssetCurrentMission(asset)
+          if mission then
+            state=state..string.format(", Mission \"%s\" [%s]", mission:GetName(), mission:GetType())
+          end
+        else
+          if asset.spawned then
+            env.info("FF ERROR: asset has opsgroup but is NOT spawned!")
+          end
+          if asset.requested and asset.isReserved then
+            env.info("FF ERROR: asset is requested and reserved. Should not be both!")
+            state="Reserved+Requested!"
+          elseif asset.isReserved then
+            state="Reserved"
+          elseif asset.requested then
+            state="Requested"
+          end
+        end
+                    
+        -- Text.
+        text=text..string.format("\n[UID=%03d] %s Legion=%s [%s]: State=%s [RID=%s]", 
+        asset.uid, asset.spawngroupname, legion.alias, cohort.name, state, tostring(asset.rid))
+        
+        
+        if asset.spawned then
+          Nspawned=Nspawned+1
+        end            
+        if asset.requested then
+          Nrequested=Nrequested+1
+        end  
+        if asset.isReserved then
+          Nreserved=Nreserved+1
+        end                      
+        if not (asset.spawned or asset.requested or asset.isReserved) then
+          Nstock=Nstock+1
+        end
+        
+        Ntotal=Ntotal+1
+        
+      end
+  
+    end
+    text=text.."\n-------------------------------------------"
+    text=text..string.format("\nNstock     = %d", Nstock)
+    text=text..string.format("\nNreserved  = %d", Nreserved)
+    text=text..string.format("\nNrequested = %d", Nrequested)
+    text=text..string.format("\nNspawned   = %d", Nspawned)
+    text=text..string.format("\nNtotal     = %d (=%d)", Ntotal, Nstock+Nspawned+Nrequested+Nreserved)
+    text=text.."\n==========================================="
+    self:I(self.lid..text)
+  end  
 
 end
 

Moose Development/Moose/Utilities/Enums.lua

@@ -1386,3 +1386,28 @@ ENUMS.FARPObjectTypeNamesAndShape ={
   [ENUMS.FARPType.PADSINGLE] = { TypeName="FARP_SINGLE_01", ShapeName="FARP_SINGLE_01"},
 }
 
+--- Radio frequency bands (HF, VHF, UHF)
+-- @type ENUMS.FrequencyBand
+-- @field #number HF High frequency
+-- @field #number VHF_LOW Very high frequency
+-- @field #number VHF_HI Very high frequency
+-- @field #number UHF Ultra high frequency
+ENUMS.FrequencyBand = {
+  HF = 0,
+  VHF_LOW = 1,
+  VHF_HI = 2,
+  UHF = 3,
+}
+
+--- Radio modulation types (AM, FM)
+-- @type ENUMS.ModulationType
+-- @field #number AM Amplitude modulation
+-- @field #number FM Frequency modulation
+-- @field #number AMFM Amplitude and frequency modulation
+-- @field #number DISCARD Discard modulation
+ENUMS.ModulationType = {
+  AM = 0,
+  FM = 1,
+  AMFM = 2,
+  DISCARD = -1,
+}

Moose Development/Moose/Utilities/Utils.lua

@@ -3227,6 +3227,22 @@ function UTILS.BearingToCardinal(Heading)
   end
 end
 
+--- Adjust given heading so that is is in [0, 360).
+-- @param #number Heading The heading in degrees.
+-- @return #number Adjust heading in [0,360).
+function UTILS.AdjustHeading360(Heading)
+
+  while Heading>=360 or Heading<0 do
+    if Heading>=360 then
+      Heading=Heading-360
+    elseif Heading<0 then
+      Heading=Heading+360
+    end
+  end
+
+  return Heading
+end
+
 --- Create a BRAA NATO call string BRAA between two GROUP objects
 -- @param Wrapper.Group#GROUP FromGrp GROUP object
 -- @param Wrapper.Group#GROUP ToGrp GROUP object
@@ -4255,56 +4271,18 @@ function UTILS.SpawnFARPAndFunctionalStatics(Name,Coordinate,FARPType,Coalition,
   local FarpVec2 = Coordinate:GetVec2()
   
   if NumberPads > 1 then
-    local Grid = UTILS.GenerateGridPoints(FarpVec2, NumberPads, SpacingX, SpacingY)
-    local groupData = {
-    ["visible"] = true,
-    ["hidden"] = false,
-    ["units"] = {},
-    ["y"] = 0,  -- Group center latitude
-    ["x"] = 0,  -- Group center longitude
-    ["name"] = Name,
-    } 
-    local unitData = {
-            ["category"] = "Heliports",
-            ["type"] = STypeName,  -- FARP type
-            ["y"] = 0,  -- Latitude coordinate (meters)
-            ["x"] = 0,  -- Longitude coordinate (meters)
-            ["name"] = Name,
-            ["heading"] = 0,  -- Heading in radians
-            ["heliport_modulation"] = mod,  -- 0 = AM, 1 = FM
-            ["heliport_frequency"] = freq,  -- Radio frequency in MHz
-            ["heliport_callsign_id"] = callsign,  -- Callsign ID
-            ["dead"] = false,
-            ["shape_name"] = SShapeName,
-            ["dynamicSpawn"] = DynamicSpawns,
-            ["allowHotStart"] = HotStart,
-    }
+    local Grid = UTILS.GenerateGridPoints(FarpVec2, NumberPads, SpacingX, SpacingY) 
     for id,gridpoint in ipairs(Grid) do
       -- Spawn FARP
-      local UnitTemplate = UTILS.DeepCopy(unitData)
-      UnitTemplate.x = gridpoint.x
-      UnitTemplate.y = gridpoint.y
-      if id > 1 then UnitTemplate.name = Name.."-"..id end
-      table.insert(groupData.units,UnitTemplate)
-      if id==1 then
-        groupData.x = gridpoint.x
-        groupData.y = gridpoint.y
-      end   
-    end
-    --BASE:I("Spawning FARP")
-    --UTILS.PrintTableToLog(groupData,1)
-    local Static=coalition.addGroup(Country, -1, groupData)
-    -- Currently DCS >= 2.8 does not trigger birth events if FARPS are spawned!
-    -- We create such an event. The airbase is registered in Core.Event
-    local Event = {
-      id = EVENTS.Birth,
-      time = timer.getTime(),
-      initiator = Static
-      }
-    -- Create BIRTH event.
-    world.onEvent(Event)
-    
-    PopulateStorage(Name.."-1",liquids,equip,airframes)
+      local location = COORDINATE:NewFromVec2(gridpoint)
+      local newfarp = SPAWNSTATIC:NewFromType(STypeName,"Heliports",Country) --  "Invisible FARP" "FARP"
+      newfarp:InitShape(SShapeName) -- "invisiblefarp" "FARPS"
+      newfarp:InitFARP(callsign,freq,mod,DynamicSpawns,HotStart)
+      local spawnedfarp = newfarp:SpawnFromCoordinate(location,0,Name.."-"..id)
+      table.insert(ReturnObjects,spawnedfarp)
+      
+      PopulateStorage(Name.."-"..id,liquids,equip,airframes)   
+    end    
   else
     -- Spawn FARP
     local newfarp = SPAWNSTATIC:NewFromType(STypeName,"Heliports",Country) --  "Invisible FARP" "FARP"

Moose Development/Moose/Wrapper/Group.lua

@@ -1152,6 +1152,23 @@ function GROUP:GetVec3()
   return nil
 end
 
+--- Returns the current {@Core.Vector#VECTOR} of the first Unit in the GROUP.
+-- @param #GROUP self
+-- @return Core.Vector#VECTOR Vector of the first Unit of the GROUP or nil if cannot be found.
+function GROUP:GetVector()
+
+  -- Get first unit.
+  local unit=self:GetUnit(1)
+
+  if unit then
+    local vector=unit:GetVector()
+    return vector
+  end
+
+  self:E("ERROR: Cannot get Vector of group "..tostring(self.GroupName))
+  return nil
+end
+
 --- Returns the average Vec3 vector of the Units in the GROUP.
 -- @param #GROUP self
 -- @return DCS#Vec3 Current Vec3 of the GROUP  or nil if cannot be found.

Moose Development/Moose/Wrapper/Positionable.lua

@@ -219,6 +219,25 @@ function POSITIONABLE:GetOrientationZ()
   end
 end
 
+--- Returns the vectors of the orientation of the object:
+-- X is the orientation parallel to the movement of the object, Z perpendicular and Y vertical orientation.
+-- @param #POSITIONABLE self
+-- @return Core.Vector#VECTOR X orientation, i.e. parallel to the direction of movement.
+-- @return Core.Vector#VECTOR Y orientation, i.e. vertical.
+-- @return Core.Vector#VECTOR Z orientation, i.e. perpendicular to the direction of movement.
+function POSITIONABLE:GetOrientationVectors()
+  local position = self:GetPosition()
+  if position then
+    local vecx=VECTOR:NewFromVec(position.x)
+    local vecy=VECTOR:NewFromVec(position.y)
+    local vecz=VECTOR:NewFromVec(position.z)
+    return vecx, vecy, vecz
+  else
+    BASE:E( { "Cannot GetOrientation", Positionable = self, Alive = self:IsAlive() } )
+    return nil, nil, nil
+  end
+end
+
 --- Returns the @{DCS#Position3} position vectors indicating the point and direction vectors in 3D of the POSITIONABLE within the mission.
 -- @param #POSITIONABLE self
 -- @return DCS#Position The 3D position vectors of the POSITIONABLE.
@@ -286,6 +305,27 @@ function POSITIONABLE:GetVec2()
   return nil
 end
 
+--- Returns the @{Core.Vector#VECTOR} indicating the 3D position of the object on the map.
+-- @param #POSITIONABLE self
+-- @return Core.Vector#VECTOR The 3D vector.
+function POSITIONABLE:GetVector()
+
+  local DCSPositionable = self:GetDCSObject()
+
+  if DCSPositionable then
+
+    local Vec3 = DCSPositionable:getPoint() -- DCS#Vec3
+    
+    local vector=VECTOR:NewFromVec(Vec3)
+
+    return vector
+  end
+
+  self:E( { "Cannot GetVec2", Positionable = self, Alive = self:IsAlive() } )
+
+  return nil
+end
+
 --- Returns a COORDINATE object indicating the point in 2D of the POSITIONABLE within the mission.
 -- @param #POSITIONABLE self
 -- @return Core.Point#COORDINATE The 3D point vector of the POSITIONABLE.
@@ -914,6 +954,24 @@ function POSITIONABLE:GetVelocityVec3()
   return nil
 end
 
+--- Returns the velocity vector.
+-- @param #POSITIONABLE self
+-- @return Core.Vector#VECTOR The velocity vector or `nil` if the object does not exist.
+function POSITIONABLE:GetVelocityVector()
+
+  local DCSPositionable = self:GetDCSObject()
+
+  if DCSPositionable and DCSPositionable:isExist() then
+    local vec3 = DCSPositionable:getVelocity()
+    local vector=VECTOR:NewFromVec(vec3)
+    return vector
+  end
+
+  BASE:E( { "Cannot GetVelocityVector", Positionable = self, Alive = self:IsAlive() } )
+
+  return nil
+end
+
 --- Get relative velocity with respect to another POSITIONABLE.
 -- @param #POSITIONABLE self
 -- @param #POSITIONABLE Positionable Other POSITIONABLE.
@@ -1865,7 +1923,6 @@ do -- Cargo
       ["HL_DSHK"] = 6*POSITIONABLE.DefaultInfantryWeight,
       ["CCKW_353"] = 16*POSITIONABLE.DefaultInfantryWeight, --GMC CCKW 2½-ton 6×6 truck, estimating 16 soldiers,
       ["MaxxPro_MRAP"] = 7*POSITIONABLE.DefaultInfantryWeight,
-      ["Sd_Kfz_251"] = 10*POSITIONABLE.DefaultInfantryWeight,
     }
   }