Merge branch 'develop' of https://github.com/FlightControl-Master/MOOSE into develop

Moose Development/Moose/Core/Database.lua

@@ -66,6 +66,7 @@ local _DATABASECoalition =
   {
     [1] = "Red",
     [2] = "Blue",
+    [3] = "Neutral",
   }
 
 local _DATABASECategory =
@@ -116,7 +117,7 @@ function DATABASE:New()
   --- @param #DATABASE self
   local function CheckPlayers( self )
   
-    local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ) }
+    local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ), AlivePlayersNeutral = coalition.getPlayers( coalition.side.NEUTRAL )}
     for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
       --self:E( { "CoalitionData:", CoalitionData } )
       for UnitId, UnitData in pairs( CoalitionData ) do
@@ -741,7 +742,7 @@ end
 -- @return #DATABASE self
 function DATABASE:_RegisterPlayers()
 
-  local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ) }
+  local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ), AlivePlayersNeutral = coalition.getPlayers( coalition.side.NEUTRAL ) }
   for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
     for UnitId, UnitData in pairs( CoalitionData ) do
       self:T3( { "UnitData:", UnitData } )
@@ -765,7 +766,7 @@ end
 -- @return #DATABASE self
 function DATABASE:_RegisterGroupsAndUnits()
 
-  local CoalitionsData = { GroupsRed = coalition.getGroups( coalition.side.RED ), GroupsBlue = coalition.getGroups( coalition.side.BLUE ) }
+  local CoalitionsData = { GroupsRed = coalition.getGroups( coalition.side.RED ), GroupsBlue = coalition.getGroups( coalition.side.BLUE ),  GroupsNeutral = coalition.getGroups( coalition.side.NEUTRAL ) }
   for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
     for DCSGroupId, DCSGroup in pairs( CoalitionData ) do
 
@@ -1176,11 +1177,19 @@ function DATABASE:_RegisterTemplates()
   self.UNITS = {}
   --Build routines.db.units and self.Navpoints
   for CoalitionName, coa_data in pairs(env.mission.coalition) do
+    self:T({CoalitionName=CoalitionName})
 
-    if (CoalitionName == 'red' or CoalitionName == 'blue') and type(coa_data) == 'table' then
+    if (CoalitionName == 'red' or CoalitionName == 'blue' or CoalitionName == 'neutrals') and type(coa_data) == 'table' then
       --self.Units[coa_name] = {}
       
       local CoalitionSide = coalition.side[string.upper(CoalitionName)]
+      if CoalitionName=="red" then
+        CoalitionSide=coalition.side.NEUTRAL
+      elseif CoalitionName=="blue" then
+        CoalitionSide=coalition.side.BLUE
+      else
+        CoalitionSide=coalition.side.NEUTRAL
+      end
 
       -- build nav points DB
       self.Navpoints[CoalitionName] = {}

Moose Development/Moose/Core/Point.lua

@@ -342,8 +342,108 @@ do -- COORDINATE
     return x - Precision <= self.x and x + Precision >= self.x and z - Precision <= self.z and z + Precision >= self.z   
   end
   
-  
+  --- Returns if the 2 coordinates are at the same 2D position.
+  -- @param #COORDINATE self
+  -- @param #number radius (Optional) Scan radius in meters. Default 100 m.
+  -- @param #boolean scanunits (Optional) If true scan for units. Default true.
+  -- @param #boolean scanstatics (Optional) If true scan for static objects. Default true.
+  -- @param #boolean scanscenery (Optional) If true scan for scenery objects. Default false.
+  -- @return True if units were found.
+  -- @return True if statics were found.
+  -- @return True if scenery objects were found.
+  -- @return Unit objects found.
+  -- @return Static objects found.
+  -- @return Scenery objects found.
+  function COORDINATE:ScanObjects(radius, scanunits, scanstatics, scanscenery)
+    self:F(string.format("Scanning in radius %.1f m.", radius))
 
+    local SphereSearch = {
+      id = world.VolumeType.SPHERE,
+        params = {
+        point = self:GetVec3(),
+        radius = radius,
+        }
+      }
+
+    -- Defaults
+    radius=radius or 100
+    if scanunits==nil then
+      scanunits=true
+    end
+    if scanstatics==nil then
+      scanstatics=true
+    end
+    if scanscenery==nil then
+      scanscenery=false
+    end
+    
+    --{Object.Category.UNIT, Object.Category.STATIC, Object.Category.SCENERY}
+    local scanobjects={}
+    if scanunits then
+      table.insert(scanobjects, Object.Category.UNIT)
+    end
+    if scanstatics then
+      table.insert(scanobjects, Object.Category.STATIC)
+    end
+    if scanscenery then
+      table.insert(scanobjects, Object.Category.SCENERY)
+    end
+    
+    -- Found stuff.
+    local Units = {}
+    local Statics = {}
+    local Scenery = {}
+    local gotstatics=false
+    local gotunits=false
+    local gotscenery=false
+    
+    local function EvaluateZone( ZoneObject )
+    
+      if ZoneObject then
+      
+        -- Get category of scanned object.
+        local ObjectCategory = ZoneObject:getCategory()
+        
+        -- Check for unit or static objects
+        --if (ObjectCategory == Object.Category.UNIT and ZoneObject:isExist() and ZoneObject:isActive()) then
+        if (ObjectCategory == Object.Category.UNIT and ZoneObject:isExist()) then
+        
+          table.insert(Units, ZoneObject)
+          gotunits=true
+          
+        elseif (ObjectCategory == Object.Category.STATIC and ZoneObject:isExist()) then
+        
+          table.insert(Statics, ZoneObject)
+          gotstatics=true
+          
+        elseif ObjectCategory == Object.Category.SCENERY then
+        
+          table.insert(Scenery, ZoneObject)
+          gotscenery=true
+          
+        end
+        
+      end
+      
+      return true
+    end
+  
+    -- Search the world.
+    world.searchObjects(scanobjects, SphereSearch, EvaluateZone)
+    
+    for _,unit in pairs(Units) do
+      self:T(string.format("Scan found unit %s", unit:getName()))
+    end
+    for _,static in pairs(Statics) do
+      self:T(string.format("Scan found static %s", static:getName()))
+    end
+    for _,scenery in pairs(Scenery) do
+      self:T(string.format("Scan found scenery %s", scenery:getTypeName()))
+    end
+    
+    return gotunits, gotstatics, gotscenery, Units, Statics, Scenery
+  end
+ 
   --- Calculate the distance from a reference @{#COORDINATE}.
   -- @param #COORDINATE self
   -- @param #COORDINATE PointVec2Reference The reference @{#COORDINATE}.
@@ -996,6 +1096,84 @@ do -- COORDINATE
     return RoutePoint
   end
   
+  --- Gets the nearest parking spot.
+  -- @param #COORDINATE self
+  -- @param Wrapper.Airbase#AIRBASE airbase (Optional) Search only parking spots at this airbase.
+  -- @param Wrapper.Airbase#Terminaltype terminaltype (Optional) Type of the terminal. Default any execpt valid spawn points on runway.
+  -- @param #boolean free (Optional) If true, returns the closest free spot. If false, returns the closest occupied spot. If nil, returns the closest spot regardless of free or occupied.
+  -- @return Core.Point#COORDINATE Coordinate of the nearest parking spot.
+  -- @return #number Terminal ID.
+  -- @return #number Distance to closest parking spot in meters.
+  function COORDINATE:GetClosestParkingSpot(airbase, terminaltype, free)
+    
+    -- Get airbase table.
+    local airbases={}
+    if airbase then
+      table.insert(airbases,airbase)
+    else
+      airbases=AIRBASE.GetAllAirbases()
+    end
+    
+    -- Init.
+    local _closest=nil --Core.Point#COORDINATE
+    local _termID=nil
+    local _distmin=nil
+
+    -- Loop over all airbases.
+    for _,_airbase in pairs(airbases) do
+    
+      local mybase=_airbase --Wrapper.Airbase#AIRBASE
+      local parkingdata=mybase:GetParkingSpotsTable(terminaltype)
+      
+      for _,_spot in pairs(parkingdata) do
+        
+        -- Check for parameters.        
+        if (free==true and _spot.Free==true) or (free==false and _spot.Free==false) or free==nil then
+          
+          local _coord=_spot.Coordinate --Core.Point#COORDINATE
+            
+          local _dist=self:Get2DDistance(_coord)
+          if _distmin==nil then
+            _closest=_coord
+            _distmin=_dist
+            _termID=_spot.TerminalID
+          else    
+            if _dist<_distmin then
+              _distmin=_dist
+              _closest=_coord
+              _termID=_spot.TerminalID
+            end
+          end
+                          
+        end         
+      end
+    end
+   
+    return _closest, _termID, _distmin
+  end
+
+  --- Gets the nearest free parking spot.
+  -- @param #COORDINATE self
+  -- @param Wrapper.Airbase#AIRBASE airbase (Optional) Search only parking spots at that airbase.
+  -- @param Wrapper.Airbase#Terminaltype terminaltype (Optional) Type of the terminal.
+  -- @return #COORDINATE Coordinate of the nearest free parking spot.
+  -- @return #number Terminal ID.
+  -- @return #number Distance to closest free parking spot in meters.
+  function COORDINATE:GetClosestFreeParkingSpot(airbase, terminaltype)
+    return self:GetClosestParkingSpot(airbase, terminaltype, true)
+  end
+
+  --- Gets the nearest occupied parking spot.
+  -- @param #COORDINATE self
+  -- @param Wrapper.Airbase#AIRBASE airbase (Optional) Search only parking spots at that airbase.
+  -- @param Wrapper.Airbase#Terminaltype terminaltype (Optional) Type of the terminal.
+  -- @return #COORDINATE Coordinate of the nearest occupied parking spot.
+  -- @return #number Terminal ID.
+  -- @return #number Distance to closest occupied parking spot in meters.
+  function COORDINATE:GetClosestOccupiedParkingSpot(airbase, terminaltype)
+    return self:GetClosestParkingSpot(airbase, terminaltype, false)
+  end
+    
   --- Gets the nearest coordinate to a road.
   -- @param #COORDINATE self
   -- @return #COORDINATE Coordinate of the nearest road.

Moose Development/Moose/Core/Spawn.lua

@@ -1218,8 +1218,9 @@ end
 -- @param Wrapper.Airbase#AIRBASE SpawnAirbase The @{Wrapper.Airbase} where to spawn the group.
 -- @param #SPAWN.Takeoff Takeoff (optional) The location and takeoff method. Default is Hot.
 -- @param #number TakeoffAltitude (optional) The altitude above the ground.
--- @return Wrapper.Group#GROUP that was spawned.
--- @return #nil Nothing was spawned.
+-- @param Wrapper.Airbase#AIRBASE.TerminalType TerminalType (optional) The terminal type the aircraft should be spawned at. See @{Wrapper.Airbase#AIRBASE.TerminalType}.
+-- @param #boolean EmergencyAirSpawn (optional) If true (default), groups are spawned in air if there is no parking spot at the airbase. If false, nothing is spawned if no parking spot is available.
+-- @return Wrapper.Group#GROUP that was spawned or nil when nothing was spawned.
 -- @usage
 --   Spawn_Plane = SPAWN:New( "Plane" )
 --   Spawn_Plane:SpawnAtAirbase( AIRBASE:FindByName( AIRBASE.Caucasus.Krymsk ), SPAWN.Takeoff.Cold )
@@ -1236,34 +1237,56 @@ end
 --   Spawn_Heli:SpawnAtAirbase( AIRBASE:FindByName( "FARP Air" ), SPAWN.Takeoff.Air )
 --   
 --   Spawn_Heli:SpawnAtAirbase( AIRBASE:FindByName( "Carrier" ), SPAWN.Takeoff.Cold )
+--   
+--   Spawn_Plane:SpawnAtAirbase( AIRBASE:FindByName( AIRBASE.Caucasus.Krymsk ), SPAWN.Takeoff.Cold, nil, AIRBASE.TerminalType.OpenBig )
 -- 
-function SPAWN:SpawnAtAirbase( SpawnAirbase, Takeoff, TakeoffAltitude ) -- R2.2
-  self:F( { self.SpawnTemplatePrefix, SpawnAirbase, Takeoff, TakeoffAltitude } )
+function SPAWN:SpawnAtAirbase( SpawnAirbase, Takeoff, TakeoffAltitude, TerminalType, EmergencyAirSpawn ) -- R2.2, R2.4
+  self:F( { self.SpawnTemplatePrefix, SpawnAirbase, Takeoff, TakeoffAltitude, TerminalType } )
 
-  local PointVec3 = SpawnAirbase:GetPointVec3()
+  -- Get position of airbase.
+  local PointVec3 = SpawnAirbase:GetCoordinate()
   self:T2(PointVec3)
 
+  -- Set take off type. Default is hot.
   Takeoff = Takeoff or SPAWN.Takeoff.Hot
   
+  -- By default, groups are spawned in air if no parking spot is available.
+  if EmergencyAirSpawn==nil then
+    EmergencyAirSpawn=true
+  end
+  
   if self:_GetSpawnIndex( self.SpawnIndex + 1 ) then
     
+    -- Get group template.
     local SpawnTemplate = self.SpawnGroups[self.SpawnIndex].SpawnTemplate
   
     if SpawnTemplate then
 
+      -- Debug output
       self:T( { "Current point of ", self.SpawnTemplatePrefix, SpawnAirbase } )
+      
+      -- Template group, unit and its attributes.
+      local TemplateGroup = GROUP:FindByName(self.SpawnTemplatePrefix)
+      local TemplateUnit=TemplateGroup:GetUnit(1)
+      local ishelo=TemplateUnit:HasAttribute("Helicopters")
+      local isbomber=TemplateUnit:HasAttribute("Bombers")
+      local istransport=TemplateUnit:HasAttribute("Transports")
+      local isfighter=TemplateUnit:HasAttribute("Battleplanes")
 
+      -- First waypoint of the group.
       local SpawnPoint = SpawnTemplate.route.points[1] 
 
-      -- These are only for ships.
+      -- These are only for ships and FARPS.
       SpawnPoint.linkUnit = nil
       SpawnPoint.helipadId = nil
       SpawnPoint.airdromeId = nil
 
+      -- Get airbase ID and category.
       local AirbaseID = SpawnAirbase:GetID()
       local AirbaseCategory = SpawnAirbase:GetDesc().category
       self:F( { AirbaseCategory = AirbaseCategory } )
       
+      -- Set airdromeId.
       if AirbaseCategory == Airbase.Category.SHIP then
         SpawnPoint.linkUnit = AirbaseID
         SpawnPoint.helipadId = AirbaseID
@@ -1274,72 +1297,253 @@ function SPAWN:SpawnAtAirbase( SpawnAirbase, Takeoff, TakeoffAltitude ) -- R2.2
         SpawnPoint.airdromeId = AirbaseID
       end
 
-      SpawnPoint.alt = 0
-              
-      SpawnPoint.type = GROUPTEMPLATE.Takeoff[Takeoff][1] -- type
+      -- Set waypoint type/action.
+      SpawnPoint.alt    = 0
+      SpawnPoint.type   = GROUPTEMPLATE.Takeoff[Takeoff][1] -- type
       SpawnPoint.action = GROUPTEMPLATE.Takeoff[Takeoff][2] -- action
       
+      -- Check if we spawn on ground. 
+      local spawnonground=not (Takeoff==SPAWN.Takeoff.Air)
+      self:T({spawnonground=spawnonground, TOtype=Takeoff, TOair=Takeoff==SPAWN.Takeoff.Air})
+      
+      -- Check where we actually spawn if we spawn on ground.
+      local spawnonship=false
+      local spawnonfarp=false
+      local spawnonrunway=false
+      local spawnonairport=false
+      if spawnonground then      
+        if AirbaseCategory == Airbase.Category.SHIP then
+          spawnonship=true
+        elseif AirbaseCategory == Airbase.Category.HELIPAD then
+          spawnonfarp=true
+        elseif AirbaseCategory == Airbase.Category.AIRDROME then
+          spawnonairport=true
+        end
+        spawnonrunway=Takeoff==SPAWN.Takeoff.Runway
+      end
+      
+      -- Array with parking spots coordinates.
+      local parkingspots={}
+      local parkingindex={}
+      local spots
+      
+      -- Spawn happens on ground, i.e. at an airbase, a FARP or a ship.
+      if spawnonground then
+        
+        -- Number of free parking spots.
+        local nfree=0
+        
+        -- Set terminal type.
+        local termtype=TerminalType
+        if spawnonrunway then
+          termtype=AIRBASE.TerminalType.Runway
+        end
+        
+        -- Scan options. Might make that input somehow.
+        local scanradius=50
+        local scanunits=true
+        local scanstatics=true
+        local scanscenery=false
+        local verysafe=false
+        
+        -- Number of free parking spots at the airbase.
+        if spawnonship or spawnonfarp or spawnonrunway then
+          -- These places work procedural and have some kind of build in queue ==> Less effort.
+          self:T(string.format("Group %s is spawned on farp/ship/runway %s.", self.SpawnTemplatePrefix, SpawnAirbase:GetName()))
+          nfree=SpawnAirbase:GetFreeParkingSpotsNumber(termtype, spawnonship or spawnonfarp or spawnonrunway)
+          spots=SpawnAirbase:GetFreeParkingSpotsTable(termtype, spawnonship or spawnonfarp or spawnonrunway)
+        else
+          if ishelo then
+            if termtype==nil then
+              -- Helo is spawned. Try exclusive helo spots first.
+              self:T(string.format("Helo group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), AIRBASE.TerminalType.HelicopterOnly))
+              spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, AIRBASE.TerminalType.HelicopterOnly, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+              nfree=#spots
+              if nfree<#SpawnTemplate.units then
+                -- Not enough helo ports. Let's try also other terminal types.
+                self:T(string.format("Helo group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), AIRBASE.TerminalType.HelicopterUsable))
+                spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, AIRBASE.TerminalType.HelicopterUsable, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+                nfree=#spots
+              end
+            else
+              -- No terminal type specified. We try all spots except shelters.
+              self:T(string.format("Helo group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), termtype))
+              spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, termtype, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+              nfree=#spots              
+            end
+          else
+            -- Fixed wing aircraft is spawned.
+            if termtype==nil then
+            --TODO: Add some default cases for transport, bombers etc. if no explicit terminal type is provided.
+            --TODO: We don't want Bombers to spawn in shelters. But I don't know a good attribute for just fighers.
+            --TODO: Some attributes are "Helicopters", "Bombers", "Transports", "Battleplanes". Need to check it out.
+              if isbomber or istransport then
+                -- First we fill the potentially bigger spots.
+                self:T(string.format("Transport/bomber group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), AIRBASE.TerminalType.OpenBig))
+                spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, AIRBASE.TerminalType.OpenBig, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+                nfree=#spots
+                if nfree<#SpawnTemplate.units then
+                  -- Now we try the smaller ones.
+                  self:T(string.format("Transport/bomber group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), AIRBASE.TerminalType.OpenMedOrBig))         
+                  spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, AIRBASE.TerminalType.OpenMedOrBig, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+                  nfree=#spots
+                end
+              else
+                self:T(string.format("Fighter group %s is at %s using terminal type %d.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), AIRBASE.TerminalType.FighterAircraft))
+                spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, AIRBASE.TerminalType.FighterAircraft, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+                nfree=#spots              
+              end            
+            else
+              -- Terminal type explicitly given.
+              self:T(string.format("Plane group %s is at %s using terminal type %s.", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), tostring(termtype)))
+              spots=SpawnAirbase:FindFreeParkingSpotForAircraft(TemplateGroup, termtype, scanradius, scanunits, scanstatics, scanscenery, verysafe)
+              nfree=#spots
+            end
+          end
+        end
+      
+        -- Get parking data.
+        local parkingdata=SpawnAirbase:GetParkingSpotsTable(termtype)
+        self:T2(string.format("Parking at %s, terminal type %s:", SpawnAirbase:GetName(), tostring(termtype)))
+        for _,_spot in pairs(parkingdata) do        
+          self:T2(string.format("%s, Termin Index = %3d, Term Type = %03d, Free = %5s, TOAC = %5s, Term ID0 = %3d, Dist2Rwy = %4d", 
+          SpawnAirbase:GetName(), _spot.TerminalID, _spot.TerminalType,tostring(_spot.Free),tostring(_spot.TOAC),_spot.TerminalID0,_spot.DistToRwy))
+        end
+        self:T(string.format("%s at %s: free parking spots = %d - number of units = %d", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), nfree, #SpawnTemplate.units))
+        
+        -- Put parking spots in table. These spots are only used if spawing at an airbase. 
+        if nfree >= #SpawnTemplate.units or (spawnonrunway and nfree>0) then
+          
+          for i=1,#SpawnTemplate.units do
+            table.insert(parkingspots, spots[i].Coordinate)
+            table.insert(parkingindex, spots[i].TerminalID)
+          end
+          
+        else
+          if EmergencyAirSpawn and not self.SpawnUnControlled then 
+            self:E(string.format("WARNING: Group %s has no parking spots at %s ==> air start!", self.SpawnTemplatePrefix, SpawnAirbase:GetName()))
+          
+            -- Not enough parking spots at the airport ==> Spawn in air.
+            spawnonground=false
+            spawnonship=false
+            spawnonfarp=false
+            spawnonrunway=false
+            
+            -- Set waypoint type/action to turning point.
+            SpawnPoint.type   = GROUPTEMPLATE.Takeoff[GROUP.Takeoff.Air][1] -- type   = Turning Point
+            SpawnPoint.action = GROUPTEMPLATE.Takeoff[GROUP.Takeoff.Air][2] -- action = Turning Point
+            
+            -- Adjust altitude to be 500-1000 m above the airbase.
+            PointVec3.x=PointVec3.x+math.random(-500,500)
+            PointVec3.z=PointVec3.z+math.random(-500,500)            
+            if ishelo then
+              PointVec3.y=PointVec3:GetLandHeight()+math.random(100,1000)
+            else
+              -- Randomize position so that multiple AC wont be spawned on top even in air.
+              PointVec3.y=PointVec3:GetLandHeight()+math.random(500,2500)
+            end
+            
+            Takeoff=GROUP.Takeoff.Air
+          else
+            self:E(string.format("WARNING: Group %s has no parking spots at %s ==> No emergency air start or uncontrolled spawning ==> No spawn!", self.SpawnTemplatePrefix, SpawnAirbase:GetName()))
+            return nil
+          end
+        end
+        
+      end
 
       -- Translate the position of the Group Template to the Vec3.
       for UnitID = 1, #SpawnTemplate.units do
-        self:T( 'Before Translation SpawnTemplate.units['..UnitID..'].x = ' .. SpawnTemplate.units[UnitID].x .. ', SpawnTemplate.units['..UnitID..'].y = ' .. SpawnTemplate.units[UnitID].y )
-
-        -- These cause a lot of confusion.
+        self:T2('Before Translation SpawnTemplate.units['..UnitID..'].x = '..SpawnTemplate.units[UnitID].x..', SpawnTemplate.units['..UnitID..'].y = '..SpawnTemplate.units[UnitID].y)
+        
+        -- Template of the current unit.
         local UnitTemplate = SpawnTemplate.units[UnitID]
-
-        UnitTemplate.parking = nil
-        UnitTemplate.parking_id = nil
-        UnitTemplate.alt = 0
-
+        
+        -- Tranlate position and preserve the relative position/formation of all aircraft.  
         local SX = UnitTemplate.x
         local SY = UnitTemplate.y 
-        local BX = SpawnPoint.x
-        local BY = SpawnPoint.y
-        local TX = PointVec3.x + ( SX - BX )
-        local TY = PointVec3.z + ( SY - BY )
-        
-        UnitTemplate.x = TX
-        UnitTemplate.y = TY
-        
-        if Takeoff == GROUP.Takeoff.Air then
-          UnitTemplate.alt = PointVec3.y + ( TakeoffAltitude or 200 )
-        --else
-        --  UnitTemplate.alt = PointVec3.y + 10
-        end
-        self:T( 'After Translation SpawnTemplate.units['..UnitID..'].x = ' .. UnitTemplate.x .. ', SpawnTemplate.units['..UnitID..'].y = ' .. UnitTemplate.y )
-      end
-      
-      SpawnPoint.x = PointVec3.x
-      SpawnPoint.y = PointVec3.z
-      
-      if Takeoff == GROUP.Takeoff.Air then
-        SpawnPoint.alt = PointVec3.y + ( TakeoffAltitude or 200 )
-      --else
-      --  SpawnPoint.alt = PointVec3.y + 10
-      end
+        local BX = SpawnTemplate.route.points[1].x
+        local BY = SpawnTemplate.route.points[1].y
+        local TX = PointVec3.x + (SX-BX)
+        local TY = PointVec3.z + (SY-BY)
+               
+        if spawnonground then
+          
+          -- Ships and FARPS seem to have a build in queue.
+          if spawnonship or spawnonfarp or spawnonrunway then
+          
+            self:T(string.format("Group %s spawning at farp, ship or runway %s.", self.SpawnTemplatePrefix, SpawnAirbase:GetName()))
 
+            -- Spawn on ship. We take only the position of the ship.
+            SpawnTemplate.units[UnitID].x   = PointVec3.x --TX
+            SpawnTemplate.units[UnitID].y   = PointVec3.z --TY
+            SpawnTemplate.units[UnitID].alt = PointVec3.y
+          
+          else
+
+            self:T(string.format("Group %s spawning at airbase %s on parking spot id %d", self.SpawnTemplatePrefix, SpawnAirbase:GetName(), parkingindex[UnitID]))
+            
+            -- Get coordinates of parking spot.
+            SpawnTemplate.units[UnitID].x   = parkingspots[UnitID].x
+            SpawnTemplate.units[UnitID].y   = parkingspots[UnitID].z
+            SpawnTemplate.units[UnitID].alt = parkingspots[UnitID].y
+            
+          end
+                 
+        else
+        
+          self:T(string.format("Group %s spawning in air at %s.", self.SpawnTemplatePrefix, SpawnAirbase:GetName()))
+          
+          -- Spawn in air as requested initially. Original template orientation is perserved, altitude is already correctly set.
+          SpawnTemplate.units[UnitID].x   = TX
+          SpawnTemplate.units[UnitID].y   = TY
+          SpawnTemplate.units[UnitID].alt = PointVec3.y
+          
+        end
+             
+        -- Parking spot id.
+        UnitTemplate.parking = nil
+        UnitTemplate.parking_id = nil
+        if parkingindex[UnitID] then
+          UnitTemplate.parking = parkingindex[UnitID]
+        end
+        
+        -- Debug output.
+        self:T2(string.format("Group %s unit number %d: Parking    = %s",self.SpawnTemplatePrefix, UnitID, tostring(UnitTemplate.parking)))
+        self:T2(string.format("Group %s unit number %d: Parking ID = %s",self.SpawnTemplatePrefix, UnitID, tostring(UnitTemplate.parking_id)))        
+        self:T2('After Translation SpawnTemplate.units['..UnitID..'].x = '..SpawnTemplate.units[UnitID].x..', SpawnTemplate.units['..UnitID..'].y = '..SpawnTemplate.units[UnitID].y)
+      end
+      
+      -- Set gereral spawnpoint position.
+      SpawnPoint.x   = PointVec3.x
+      SpawnPoint.y   = PointVec3.z
+      SpawnPoint.alt = PointVec3.y
+      
       SpawnTemplate.x = PointVec3.x
       SpawnTemplate.y = PointVec3.z
       
+      -- Spawn group.
       local GroupSpawned = self:SpawnWithIndex( self.SpawnIndex )
-      
-      -- When spawned in the air, we need to generate a Takeoff Event
-      
+            
+      -- When spawned in the air, we need to generate a Takeoff Event.
       if Takeoff == GROUP.Takeoff.Air then
         for UnitID, UnitSpawned in pairs( GroupSpawned:GetUnits() ) do
           SCHEDULER:New( nil, BASE.CreateEventTakeoff, { GroupSpawned, timer.getTime(), UnitSpawned:GetDCSObject() } , 1 )
         end
       end
-
-      return GroupSpawned
+        
+      -- Check if we accidentally spawned on the runway. Needs to be schedules, because group is not immidiately alive.
+      if Takeoff~=SPAWN.Takeoff.Runway and Takeoff~=SPAWN.Takeoff.Air and spawnonairport then
+        SCHEDULER:New(nil, AIRBASE.CheckOnRunWay, {SpawnAirbase, GroupSpawned, 75, true} , 1.0)
+      end
+      
+      return GroupSpawned      
     end
   end
   
   return nil
 end
 
-
-
 --- Will spawn a group from a Vec3 in 3D space. 
 -- This method is mostly advisable to be used if you want to simulate spawning units in the air, like helicopters or airplanes.
 -- Note that each point in the route assigned to the spawning group is reset to the point of the spawn.
@@ -1801,7 +2005,7 @@ end
 --- Get the index from a given group.
 -- The function will search the name of the group for a #, and will return the number behind the #-mark.
 function SPAWN:GetSpawnIndexFromGroup( SpawnGroup )
-	self:F( { self.SpawnTemplatePrefix, self.SpawnAliasPrefix, SpawnGroup } )
+	self:F2( { self.SpawnTemplatePrefix, self.SpawnAliasPrefix, SpawnGroup } )
 	
 	local IndexString = string.match( SpawnGroup:GetName(), "#(%d*)$" ):sub( 2 )
 	local Index = tonumber( IndexString )