v1.6.1 - ASC C-130

* Indicate obligation to use MIST delivered with CTLD

* update ctld.dynamicCargoUnits table

* Indicate obligation to use MIST delivered with CTLD

* MIST madatory in red

* MIST mandatory in red

* fix mist.utils.getHeadingPoints calls

* commit

* fix #164 Issue-wrong12oclock msg

* commit ctld.tools.getRelativeBearing()

* commit

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "Lua.diagnostics.globals": [
+        "ctld"
+    ]
+}

CTLD.lua

@@ -1,4 +1,5 @@
---[[
+--[[ ! IMPORTANT : You must must use the version of MIST supplied in the CTLD pack to correctly manage dynamic spwans
+
         Combat Troop and Logistics Drop
 
         Allows Huey, Mi-8 and C130 to transport troops internally and Helicopters to transport Logistic / Vehicle units to the field via sling-loads
@@ -11,6 +12,9 @@
         See https://github.com/ciribob/DCS-CTLD for a user manual and the latest version
 
         Contributors:
+                - FullGas1 - https://github.com/FullGas1 (i18n concept, FR and SP translations)
+                - Rex (VEAF) - https://github.com/RexAttaque (code, testing, JTAC)
+                - Zip (VEAF) - https://github.com/davidp57 (project management, code, testing)
                 - Steggles - https://github.com/Bob7heBuilder
                 - mvee - https://github.com/mvee
                 - jmontleon - https://github.com/jmontleon
@@ -20,7 +24,6 @@
                 - Proxy404 - https://github.com/Proxy404
                 - atcz - https://github.com/atcz
                 - marcos2221- https://github.com/marcos2221
-                - FullGas1 - https://github.com/FullGas1 (i18n concept, FR and SP translations)
 
         Add [issues](https://github.com/ciribob/DCS-CTLD/issues) to the GitHub repository if you want to report a bug or suggest a new feature.
 
@@ -40,7 +43,7 @@ end
 ctld.Id = "CTLD - "
 
 --- Version.
-ctld.Version = "1.5.1"
+ctld.Version = "1.6.1"
 
 -- To add debugging messages to dcs.log, change the following log levels to `true`; `Debug` is less detailed than `Trace`
 ctld.Debug = false
@@ -611,6 +614,7 @@ ctld.aircraftTypeTable = {
     --"Mirage-F1DDA",
     --"Su-25T",
     --"Yak-52",
+    "C-130J-30",
 
     --%%%%% WARBIRDS %%%%%
     --"Bf-109K-4",
@@ -808,6 +812,7 @@ ctld.logisticUnits = {
 ctld.vehicleTransportEnabled = {
     "76MD",     -- the il-76 mod doesnt use a normal - sign so il-76md wont match... !!!! GRR
     "Hercules",
+    "C-130J-30",
     --"CH-47Fbl1",
 }
 
@@ -817,7 +822,10 @@ ctld.vehicleTransportEnabled = {
 -- We will also use this to make modifications to the menu and other checks and messages
 ctld.dynamicCargoUnits = {
    "CH-47Fbl1",
-   --"UH-1H",
+   "UH-1H",
+   "Mi-8MT",
+   "Mi-24P",
+   "C-130J-30"
 }
 
 -- ************** Maximum Units SETUP for UNITS ******************
@@ -866,6 +874,7 @@ ctld.unitLoadLimits = {
     --["Mirage-F1DDA"] = 1,
     --["Su-25T"] = 1,
     --["Yak-52"] = 1,
+    ["C-130J-30"] = 80
 
     --%%%%% WARBIRDS %%%%%
     --["Bf-109K-4"] = 1,
@@ -888,6 +897,7 @@ ctld.internalCargoLimits = {
     -- Remove the -- below to turn on options
     ["Mi-8MT"] = 2,
     ["CH-47Fbl1"] = 8,
+    ["C-130J-30"] = 20
 }
 
 
@@ -916,6 +926,7 @@ ctld.unitActions = {
     ["Hercules"] = { crates = true, troops = true },
     ["SK-60"] = { crates = true, troops = true },
     ["UH-60L"] = { crates = true, troops = true },
+    ["C-130J-30"] = { crates = true, troops = true },
     --["T-45"] = {crates=true, troops=true},
 
     --%%%%% CHOPPERS %%%%%
@@ -1924,19 +1935,24 @@ function ctld.spawnCrateAtPoint(_side, _weight, _point, _hdg)
 end
 
 -- ***************************************************************
-function ctld.getSecureDistanceFromUnit(_unitName)	-- return a distance between the center of unitName, to be sure not touch the unitName
+function ctld.getSecureDistanceFromUnit(_unitOrName)	-- return a distance between the center of unitName, to be sure not touch the unitName
-    local rotorDiameter = 0 --19    -- meters  -- õk for UH & CH47
+    local rotorDiameter = 19    -- meters  -- ok for UH & CH47
-    if Unit.getByName(_unitName) then
+    local unit = _unitOrName
-        local unitUserBox = Unit.getByName(_unitName):getDesc().box
+    if type(unit) == "string" then
-        local SecureDistanceFromUnit = 0
+        unit = Unit.getByName(_unitOrName)
+    end
+    local secureDistanceFromUnit = rotorDiameter
+    if unit then
+        local unitUserBox = unit:getDesc().box
+        if unitUserBox then
         if math.abs(unitUserBox.max.x) >= math.abs(unitUserBox.min.x) then
-            SecureDistanceFromUnit = math.abs(unitUserBox.max.x) + (rotorDiameter/2)
+                secureDistanceFromUnit = math.abs(unitUserBox.max.x) + (rotorDiameter/2)
         else
-            SecureDistanceFromUnit = math.abs(unitUserBox.min.x) + (rotorDiameter/2)
+                secureDistanceFromUnit = math.abs(unitUserBox.min.x) + (rotorDiameter/2)
         end
-		return SecureDistanceFromUnit
 	end
-	return nil
+	end
+    return secureDistanceFromUnit
 end
 
 -- ***************************************************************
@@ -1977,7 +1993,7 @@ function ctld.getUnitsInRepackRadius(_PlayerTransportUnitName, _radius)
     end
 
     local unitsNamesList  = ctld.getNearbyUnits(unit:getPoint(), _radius, unit:getCoalition())
-    
+
     local repackableUnits = {}
     for i = 1, #unitsNamesList do
         local unitObject     = Unit.getByName(unitsNamesList[i])
@@ -1998,11 +2014,13 @@ function ctld.getNearbyUnits(_point, _radius, _coalition)
     local unitsByDistance = {}
     local cpt = 1
     local _units = {}
-    local _unitList = mist.DBs.unitsByName
+    for _unitName, _ in pairs(mist.DBs.unitsByName) do
-    for _unitName, _unit in pairs(mist.DBs.unitsByName) do
         local u = Unit.getByName(_unitName)
-        if u and u:isExist() and (_coalition == 4 or u:getCoalition() == _coalition) then
+        local e = (u and u:isExist()) or false
-            --local _dist = ctld.getDistance(u:getPoint(), _point)
+        -- pcall is needed because getCoalition() fails if the unit is an object without coalition (like a smoke effect)
+        local c = nil
+        pcall(function() c = (u and e and u:getCoalition()) or nil end)
+            if u and e and (_coalition == 4 or c == _coalition) then
             local _dist = mist.utils.get2DDist(u:getPoint(), _point)
             if _dist <= _radius then
                 unitsByDistance[cpt] = {id =cpt, dist = _dist, unit = _unitName, typeName = u:getTypeName()}
@@ -2010,7 +2028,7 @@ function ctld.getNearbyUnits(_point, _radius, _coalition)
             end
         end
     end
-    
+
     --table.sort(unitsByDistance, function(a,b) return a.dist < b.dist end)       -- sort the table by distance (the nearest first)
     table.sort(unitsByDistance, function(a,b) return a.typeName < b.typeName end)   -- sort the table by typeNAme
     for i, v in ipairs(unitsByDistance) do
@@ -2092,7 +2110,7 @@ function ctld.repackVehicle(_params, t) -- scan rrs table 'repackRequestsStack'
                     local _name          = string.format("%s_%i", v.desc, _unitId)
                     local secureDistance = ctld.getSecureDistanceFromUnit(playerUnitName) or 10
                     local relativePoint  = ctld.getRelativePoint(playerPoint, secureDistance + (i * offset), randomHeading) -- 7 meters from the transport unit
-                        
+
                     if ctld.unitDynamicCargoCapable(PlayerTransportUnit) == false then
                         ctld.spawnCrateStatic(refCountry, _unitId, relativePoint, _name, crateWeight, playerCoa, playerHeading, nil)
                     else
@@ -2105,8 +2123,8 @@ function ctld.repackVehicle(_params, t) -- scan rrs table 'repackRequestsStack'
         ctld.repackRequestsStack[ii] = nil                -- remove the processed request from the stacking table
     end
 
-    
+
-        
+
     if ctld.enableRepackingVehicles == true then
         return t + 3         -- reschedule the function in 3 seconds
     else
@@ -2601,7 +2619,7 @@ function ctld.spawnCrate(_arguments, bypassCrateWaitTime)
 
             if ctld.unitDynamicCargoCapable(_heli) then
                 _model_type = "dynamic"
-                _point = ctld.getPointAt6Oclock(_heli, 15)
+                _point = ctld.getPointAt6Oclock(_heli, ctld.getSecureDistanceFromUnit(_heli))
                 _position = "6"
             end
 
@@ -2615,10 +2633,19 @@ function ctld.spawnCrate(_arguments, bypassCrateWaitTime)
 
             -- add to move table
             ctld.crateMove[_name] = _name
+                
+            local refPoint = _heli:getPoint()
+            local refLat, refLon = coord.LOtoLL(refPoint)
+            local unitPos = _heli:getPosition()
+   			local refHeading = math.deg(math.atan2(unitPos.x.z, unitPos.x.x))
+ 
+            local destLat, destLon, destAlt = coord.LOtoLL(_point)	
 
+            local relativePos, forma = ctld.tools.getRelativeBearing(refLat, refLon, refHeading, destLat, destLon, 'clock')
+                
             ctld.displayMessageToGroup(_heli,
                 ctld.i18n_translate("A %1 crate weighing %2 kg has been brought out and is at your %3 o'clock ",
-                    _crateType.desc, _crateType.weight, _position), 20)
+                    _crateType.desc, _crateType.weight, relativePos), 20)
         else
             env.info("Couldn't find crate item to spawn")
         end
@@ -3169,7 +3196,7 @@ function ctld.updateTroopsInGame(params, t)		-- return count of troops in game b
 			for index, unitObj in pairs(v:getUnits()) do		-- for each unit in group
                 if unitObj:getDesc().attributes.Infantry then
                     ctld.InfantryInGameCount[coalitionId] = ctld.InfantryInGameCount[coalitionId] + 1
-                end 
+                end
             end
         end
     end
@@ -3227,7 +3254,7 @@ function ctld.loadTroopsFromZone(_args)
         ctld.logTrace("FG_ ctld.InfantryInGameCount[heloCoa] =  %s", ctld.p(ctld.InfantryInGameCount[heloCoa]))
         ctld.logTrace("FG_ _groupTemplate.total =  %s", ctld.p(_groupTemplate.total))
         ctld.logTrace("FG_ ctld.nbLimitSpawnedTroops[%s].total =  %s", ctld.p(heloCoa), ctld.p(ctld.nbLimitSpawnedTroops[heloCoa]))
-        
+
         local limitReached = true
         if (ctld.nbLimitSpawnedTroops[1]~=0 or ctld.nbLimitSpawnedTroops[2]~=0) and (ctld.InfantryInGameCount[heloCoa] + _groupTemplate.total > ctld.nbLimitSpawnedTroops[heloCoa]) then  -- load troops only if Coa limit not reached
             ctld.displayMessageToGroup(_heli, ctld.i18n_translate("Count Infantries limit in the mission reached, you can't load more troops"), 10)
@@ -3892,7 +3919,7 @@ function ctld.getClosestCrate(_heli, _crates, _type)
     local _shortestDistance = -1
     local _distance = 0
     local _minimumDistance = 5     -- prevents dynamic cargo crates from unpacking while in cargo hold
-    local _maxDistance     = 20    -- prevents onboard dynamic cargo crates from unpacking requested by other helo
+    local _maxDistance     = 75    -- prevents onboard dynamic cargo crates from unpacking requested by other helo
     for _, _crate in pairs(_crates) do
         if (_crate.details.unit == _type or _type == nil) then
             _distance = _crate.dist
@@ -3960,7 +3987,7 @@ function ctld.unpackCrates(_arguments)
             local _crates = ctld.getCratesAndDistance(_heli)
             local _crate = ctld.getClosestCrate(_heli, _crates)
             ctld.logTrace("FG_ ctld.unpackCrates._crate =  %s", ctld.p(_crate))
-    
+
             if ctld.inLogisticsZone(_heli) == true or ctld.farEnoughFromLogisticZone(_heli) == false then
                 ctld.displayMessageToGroup(_heli,
                     ctld.i18n_translate("You can't unpack that here! Take it to where it's needed!"), 20)
@@ -4015,7 +4042,7 @@ function ctld.unpackCrates(_arguments)
                     ctld.logTrace("_crate =  %s", ctld.p(_crate))
                     local _spawnedGroups = ctld.spawnCrateGroup(_heli, { _point }, { _crate.details.unit }, { _crateHdg })
                     ctld.logTrace("_spawnedGroups =  %s", ctld.p(_spawnedGroups))
-                    
+
                     if _heli:getCoalition() == 1 then
                         ctld.spawnedCratesRED[_crateName] = nil
                     else
@@ -4217,12 +4244,11 @@ function ctld.dropSlingCrate(_args)
                 local _position = "12"
                 if ctld.unitDynamicCargoCapable(_heli) then
                     _model_type = "dynamic"
-                    _point = ctld.getPointAt6Oclock(_heli, 15)
+                    _point = ctld.getPointAt6Oclock(_heli, ctld.getSecureDistanceFromUnit(_heli))
                     _position = "6"
                 end
                 ctld.displayMessageToGroup(_heli,
-                    ctld.i18n_translate("%1 crate has been safely unhooked and is at your %2 o'clock", _crate.desc,
+                    ctld.i18n_translate("%1 crate has been safely unhooked and is at your %2 o'clock", _crate.desc, _position), 10)
-                        _position), 10)
             elseif _heightDiff > 7.5 and _heightDiff <= 40.0 then
                 ctld.displayMessageToGroup(_heli,
                     ctld.i18n_translate("%1 crate has been safely dropped below you", _crate.desc), 10)
@@ -5026,7 +5052,7 @@ function ctld.unpackMultiCrate(_heli, _nearestCrate, _nearbyCrates)
         if ctld.unitDynamicCargoCapable(_heli) == true then
             _point = ctld.getPointInRearSector(_heli, ctld.getSecureDistanceFromUnit(_heli:getName()))
         end
-        
+
         local _crateHdg = mist.getHeading(_nearestCrate.crateUnit, true)
 
         -- destroy crates
@@ -5744,7 +5770,7 @@ function ctld.unitDynamicCargoCapable(_unit)
         --ctld.logDebug("ctld.unitDynamicCargoCapable(_type=[%s])", ctld.p(_type))
         for _, _name in ipairs(ctld.dynamicCargoUnits) do
             local _nameLower = string.lower(_name)
-            if string.find(_type, _nameLower, 1, true) then             --string.match does not work with patterns containing '-' as it is a magic character
+            if string.find(_type, _nameLower, 1, true) then    --string.match does not work with patterns containing '-' as it is a magic character
                 result = true
                 break
             end
@@ -5864,208 +5890,201 @@ end
 -- Adds menuitem to a human unit
 function ctld.addTransportF10MenuOptions(_unitName)
     ctld.logDebug("ctld.addTransportF10MenuOptions(_unitName=[%s])", ctld.p(_unitName))
-    local status, error = pcall(function()
+    local _unit = ctld.getTransportUnit(_unitName)
-        local _unit = ctld.getTransportUnit(_unitName)
+    ctld.logTrace("_unit = %s", ctld.p(_unit))
-        ctld.logTrace("_unit = %s", ctld.p(_unit))
 
-        if _unit then
+    if _unit then
-            local _unitTypename = _unit:getTypeName()
+        local _unitTypename = _unit:getTypeName()
-            local _groupId = ctld.getGroupId(_unit)
+        local _groupId = ctld.getGroupId(_unit)
-            if _groupId then
+        if _groupId then
-                -- ctld.logTrace("_groupId = %s", ctld.p(_groupId))
+            -- ctld.logTrace("_groupId = %s", ctld.p(_groupId))
-                -- ctld.logTrace("ctld.addedTo = %s", ctld.p(ctld.addedTo[tostring(_groupId)]))
+            -- ctld.logTrace("ctld.addedTo = %s", ctld.p(ctld.addedTo[tostring(_groupId)]))
-                if ctld.addedTo[tostring(_groupId)] == nil then
+            if ctld.addedTo[tostring(_groupId)] == nil then
-                    ctld.logTrace("adding CTLD menu for _groupId = %s", ctld.p(_groupId))
+                ctld.logTrace("adding CTLD menu for _groupId = %s", ctld.p(_groupId))
-                    local _rootPath = missionCommands.addSubMenuForGroup(_groupId, ctld.i18n_translate("CTLD"))
+                local _rootPath = missionCommands.addSubMenuForGroup(_groupId, ctld.i18n_translate("CTLD"))
-                    local _unitActions = ctld.getUnitActions(_unitTypename)
+                local _unitActions = ctld.getUnitActions(_unitTypename)
-                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Check Cargo"), _rootPath, ctld.checkTroopStatus, { _unitName })
+                missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Check Cargo"), _rootPath, ctld.checkTroopStatus, { _unitName })
-                    if _unitActions.troops then
+                if _unitActions.troops then
-                        local _troopCommandsPath = missionCommands.addSubMenuForGroup(_groupId,ctld.i18n_translate("Troop Transport"), _rootPath)
+                    local _troopCommandsPath = missionCommands.addSubMenuForGroup(_groupId,ctld.i18n_translate("Troop Transport"), _rootPath)
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unload / Extract Troops"),
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unload / Extract Troops"),
-                            _troopCommandsPath, ctld.unloadExtractTroops, { _unitName })
+                        _troopCommandsPath, ctld.unloadExtractTroops, { _unitName })
 
-                        -- local _loadPath = missionCommands.addSubMenuForGroup(_groupId, "Load From Zone", _troopCommandsPath)
+                    -- local _loadPath = missionCommands.addSubMenuForGroup(_groupId, "Load From Zone", _troopCommandsPath)
-                        local _transportLimit = ctld.getTransportLimit(_unitTypename)
+                    local _transportLimit = ctld.getTransportLimit(_unitTypename)
-                        local itemNb = 0
+                    local itemNb = 0
-                        local menuEntries = {}
+                    local menuEntries = {}
-                        local menuPath = _troopCommandsPath
+                    local menuPath = _troopCommandsPath
-                        for _, _loadGroup in pairs(ctld.loadableGroups) do
+                    for _, _loadGroup in pairs(ctld.loadableGroups) do
-                            if not _loadGroup.side or _loadGroup.side == _unit:getCoalition() then
+                        if not _loadGroup.side or _loadGroup.side == _unit:getCoalition() then
-                                -- check size & unit
+                            -- check size & unit
-                                if _transportLimit >= _loadGroup.total then
+                            if _transportLimit >= _loadGroup.total then
-                                    table.insert(menuEntries,
+                                table.insert(menuEntries,
-                                        { text = ctld.i18n_translate("Load ") .. _loadGroup.name, group = _loadGroup })
+                                    { text = ctld.i18n_translate("Load ") .. _loadGroup.name, group = _loadGroup })
-                                end
                             end
                         end
-                        for _i, _menu in ipairs(menuEntries) do
-                            -- add the menu item
-                            itemNb = itemNb + 1
-                            if itemNb == 9 and _i < #menuEntries then                                     -- page limit reached (first item is "unload")
-                                menuPath = missionCommands.addSubMenuForGroup(_groupId, ctld.i18n_translate("Next page"),
-                                    menuPath)
-                                itemNb = 1
-                            end
-                            missionCommands.addCommandForGroup(_groupId, _menu.text, menuPath, ctld.loadTroopsFromZone,
-                                { _unitName, true, _menu.group, false })
-                        end
-                        if ctld.unitCanCarryVehicles(_unit) then
-                            local _vehicleCommandsPath = missionCommands.addSubMenuForGroup(_groupId,
-                                ctld.i18n_translate("Vehicle / FOB Transport"), _rootPath)
-                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unload Vehicles"),
-                                _vehicleCommandsPath, ctld.unloadTroops, { _unitName, false })
-                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Load / Extract Vehicles"),
-                                _vehicleCommandsPath, ctld.loadTroopsFromZone, { _unitName, false, "", true })
-
-                            if ctld.enabledFOBBuilding and ctld.staticBugWorkaround == false then
-                                missionCommands.addCommandForGroup(_groupId,
-                                    ctld.i18n_translate("Load / Unload FOB Crate"), _vehicleCommandsPath,
-                                    ctld.loadUnloadFOBCrate, { _unitName, false })
-                            end
-                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Check Cargo"),
-                                _vehicleCommandsPath, ctld.checkTroopStatus, { _unitName })
-                        end
                     end
+                    for _i, _menu in ipairs(menuEntries) do
+                        -- add the menu item
+                        itemNb = itemNb + 1
+                        if itemNb == 9 and _i < #menuEntries then                                     -- page limit reached (first item is "unload")
+                            menuPath = missionCommands.addSubMenuForGroup(_groupId, ctld.i18n_translate("Next page"),
+                                menuPath)
+                            itemNb = 1
+                        end
+                        missionCommands.addCommandForGroup(_groupId, _menu.text, menuPath, ctld.loadTroopsFromZone,
+                            { _unitName, true, _menu.group, false })
+                    end
+                    if ctld.unitCanCarryVehicles(_unit) then
+                        local _vehicleCommandsPath = missionCommands.addSubMenuForGroup(_groupId,
+                            ctld.i18n_translate("Vehicle / FOB Transport"), _rootPath)
+                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unload Vehicles"),
+                            _vehicleCommandsPath, ctld.unloadTroops, { _unitName, false })
+                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Load / Extract Vehicles"),
+                            _vehicleCommandsPath, ctld.loadTroopsFromZone, { _unitName, false, "", true })
 
-                    if ctld.enableCrates and _unitActions.crates then
+                        if ctld.enabledFOBBuilding and ctld.staticBugWorkaround == false then
-                        if ctld.unitCanCarryVehicles(_unit) == false then
+                            missionCommands.addCommandForGroup(_groupId,
-                            -- sort the crate categories alphabetically
+                                ctld.i18n_translate("Load / Unload FOB Crate"), _vehicleCommandsPath,
-                            local crateCategories = {}
+                                ctld.loadUnloadFOBCrate, { _unitName, false })
-                            for category, _ in pairs(ctld.spawnableCrates) do
+                        end
-                                table.insert(crateCategories, category)
+                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Check Cargo"),
+                            _vehicleCommandsPath, ctld.checkTroopStatus, { _unitName })
+                    end
+                end
+
+                if ctld.enableCrates and _unitActions.crates then
+                        -- sort the crate categories alphabetically
+                        local crateCategories = {}
+                        for category, _ in pairs(ctld.spawnableCrates) do
+                            table.insert(crateCategories, category)
+                        end
+                        table.sort(crateCategories)
+                        --ctld.logTrace("crateCategories = [%s]", ctld.p(crateCategories))
+
+                        -- add menu for spawning crates
+                        local itemNbMain = 0
+                        local _cratesMenuPath = missionCommands.addSubMenuForGroup(_groupId,
+                            ctld.i18n_translate("Crates: Vehicle / FOB / Drone"), _rootPath)
+
+                        for _i, _category in ipairs(crateCategories) do
+                            local _subMenuName = _category
+                            local _crates = ctld.spawnableCrates[_subMenuName]
+
+                            -- add the submenu item
+                            itemNbMain = itemNbMain + 1
+                            if itemNbMain == 10 and _i < #crateCategories then    -- page limit reached
+                                _cratesMenuPath = missionCommands.addSubMenuForGroup(_groupId,
+                                    ctld.i18n_translate("Next page"), _cratesMenuPath)
+                                itemNbMain = 1
                             end
-                            table.sort(crateCategories)
+                            local itemNbSubmenu = 0
-                            --ctld.logTrace("crateCategories = [%s]", ctld.p(crateCategories))
+                            local menuEntries = {}
-
+                            local _subMenuPath = missionCommands.addSubMenuForGroup(_groupId, _subMenuName, _cratesMenuPath)
-                            -- add menu for spawning crates
+                            for _, _crate in pairs(_crates) do
-                            local itemNbMain = 0
+                                --ctld.logTrace("_crate = [%s]", ctld.p(_crate))
-                            local _cratesMenuPath = missionCommands.addSubMenuForGroup(_groupId,
+                                if not (_crate.multiple) or ctld.enableAllCrates then
-                                ctld.i18n_translate("Crates: Vehicle / FOB / Drone"), _rootPath)
+                                    local isJTAC = ctld.isJTACUnitType(_crate.unit)
-
+                                    --ctld.logTrace("isJTAC = [%s]", ctld.p(isJTAC))
-                            for _i, _category in ipairs(crateCategories) do
+                                    if not isJTAC or (isJTAC and ctld.JTAC_dropEnabled) then
-                                local _subMenuName = _category
+                                        if _crate.side == nil or (_crate.side == _unit:getCoalition()) then
-                                local _crates = ctld.spawnableCrates[_subMenuName]
+                                            local _crateRadioMsg = _crate.desc
-
+                                            --add in the number of crates required to build something
-                                -- add the submenu item
+                                            if _crate.cratesRequired ~= nil and _crate.cratesRequired > 1 then
-                                itemNbMain = itemNbMain + 1
+                                                _crateRadioMsg = _crateRadioMsg .. " (" .. _crate.cratesRequired ..
-                                if itemNbMain == 10 and _i < #crateCategories then    -- page limit reached
+                                                ")"
-                                    _cratesMenuPath = missionCommands.addSubMenuForGroup(_groupId,
-                                        ctld.i18n_translate("Next page"), _cratesMenuPath)
-                                    itemNbMain = 1
-                                end
-                                local itemNbSubmenu = 0
-                                local menuEntries = {}
-                                local _subMenuPath = missionCommands.addSubMenuForGroup(_groupId, _subMenuName, _cratesMenuPath)
-                                for _, _crate in pairs(_crates) do
-                                    --ctld.logTrace("_crate = [%s]", ctld.p(_crate))
-                                    if not (_crate.multiple) or ctld.enableAllCrates then
-                                        local isJTAC = ctld.isJTACUnitType(_crate.unit)
-                                        --ctld.logTrace("isJTAC = [%s]", ctld.p(isJTAC))
-                                        if not isJTAC or (isJTAC and ctld.JTAC_dropEnabled) then
-                                            if _crate.side == nil or (_crate.side == _unit:getCoalition()) then
-                                                local _crateRadioMsg = _crate.desc
-                                                --add in the number of crates required to build something
-                                                if _crate.cratesRequired ~= nil and _crate.cratesRequired > 1 then
-                                                    _crateRadioMsg = _crateRadioMsg .. " (" .. _crate.cratesRequired ..
-                                                    ")"
-                                                end
-                                                if _crate.multiple then
-                                                    _crateRadioMsg = "* " .. _crateRadioMsg
-                                                end
-                                                local _menuEntry = { text = _crateRadioMsg, crate = _crate }
-                                                --ctld.logTrace("_menuEntry = [%s]", ctld.p(_menuEntry))
-                                                table.insert(menuEntries, _menuEntry)
                                             end
+                                            if _crate.multiple then
+                                                _crateRadioMsg = "* " .. _crateRadioMsg
+                                            end
+                                            local _menuEntry = { text = _crateRadioMsg, crate = _crate }
+                                            --ctld.logTrace("_menuEntry = [%s]", ctld.p(_menuEntry))
+                                            table.insert(menuEntries, _menuEntry)
                                         end
                                     end
                                 end
-                                for _i, _menu in ipairs(menuEntries) do
+                            end
-                                    --ctld.logTrace("_menu = [%s]", ctld.p(_menu))
+                            for _i, _menu in ipairs(menuEntries) do
-                                    -- add the submenu item
+                                --ctld.logTrace("_menu = [%s]", ctld.p(_menu))
-                                    itemNbSubmenu = itemNbSubmenu + 1
+                                -- add the submenu item
-                                    if itemNbSubmenu == 10 and _i < #menuEntries then     -- page limit reached
+                                itemNbSubmenu = itemNbSubmenu + 1
-                                        _subMenuPath = missionCommands.addSubMenuForGroup(_groupId,
+                                if itemNbSubmenu == 10 and _i < #menuEntries then     -- page limit reached
-                                            ctld.i18n_translate("Next page"), _subMenuPath)
+                                    _subMenuPath = missionCommands.addSubMenuForGroup(_groupId,
-                                        itemNbSubmenu = 1
+                                        ctld.i18n_translate("Next page"), _subMenuPath)
-                                    end
+                                    itemNbSubmenu = 1
-                                    missionCommands.addCommandForGroup(_groupId, _menu.text, _subMenuPath,
-                                        ctld.spawnCrate, { _unitName, _menu.crate.weight })
                                 end
-                            end
+                                missionCommands.addCommandForGroup(_groupId, _menu.text, _subMenuPath,
+                                    ctld.spawnCrate, { _unitName, _menu.crate.weight })
                         end
                     end
-                    
-                    if (ctld.enabledFOBBuilding or ctld.enableCrates) and _unitActions.crates then
-                        local _crateCommands = missionCommands.addSubMenuForGroup(_groupId,
-                            ctld.i18n_translate("CTLD Commands"), _rootPath)
-                        if ctld.vehicleCommandsPath[_unitName] == nil then
-                            ctld.vehicleCommandsPath[_unitName] = mist.utils.deepCopy(_crateCommands)
-                        end
-                        if ctld.hoverPickup == false or ctld.loadCrateFromMenu == true then
-                            if ctld.loadCrateFromMenu then
-                                missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Load Nearby Crate(s)"),
-                                    _crateCommands, ctld.loadNearbyCrate, _unitName)
-                            end
-                        end
-
-                        if ctld.loadCrateFromMenu or ctld.hoverPickup then
-                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Crate(s)"),
-                                _crateCommands, ctld.dropSlingCrate, { _unitName })
-                        end
-
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unpack Any Crate"),
-                            _crateCommands, ctld.unpackCrates, { _unitName })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Nearby Crates"),
-                            _crateCommands, ctld.listNearbyCrates, { _unitName })
-
-                        if ctld.enabledFOBBuilding then
-                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List FOBs"), _crateCommands,
-                                ctld.listFOBS, { _unitName })
-                        end
-
-                        if  ctld.enableRepackingVehicles == true then
-                            ctld.updateRepackMenu( _unitName )        -- add repack menu
-                        end
-                    end
-
-                    if ctld.enableSmokeDrop then
-                        local _smokeMenu = missionCommands.addSubMenuForGroup(_groupId,
-                            ctld.i18n_translate("Smoke Markers"), _rootPath)
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Red Smoke"), _smokeMenu,
-                            ctld.dropSmoke, { _unitName, trigger.smokeColor.Red })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Blue Smoke"), _smokeMenu,
-                            ctld.dropSmoke, { _unitName, trigger.smokeColor.Blue })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Orange Smoke"), _smokeMenu,
-                            ctld.dropSmoke, { _unitName, trigger.smokeColor.Orange })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Green Smoke"), _smokeMenu,
-                            ctld.dropSmoke, { _unitName, trigger.smokeColor.Green })
-                    end
-
-                    if ctld.enabledRadioBeaconDrop then
-                        local _radioCommands = missionCommands.addSubMenuForGroup(_groupId,
-                            ctld.i18n_translate("Radio Beacons"), _rootPath)
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Beacons"), _radioCommands,
-                            ctld.listRadioBeacons, { _unitName })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Beacon"), _radioCommands,
-                            ctld.dropRadioBeacon, { _unitName })
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Remove Closest Beacon"),
-                            _radioCommands, ctld.removeRadioBeacon, { _unitName })
-                    elseif ctld.deployedRadioBeacons ~= {} then
-                        local _radioCommands = missionCommands.addSubMenuForGroup(_groupId,
-                            ctld.i18n_translate("Radio Beacons"), _rootPath)
-                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Beacons"), _radioCommands,
-                            ctld.listRadioBeacons, { _unitName })
-                    end
-
-                    ctld.addedTo[tostring(_groupId)] = true
-                    ctld.logTrace("ctld.addedTo = %s", ctld.p(ctld.addedTo))
-                    ctld.logTrace("done adding CTLD menu for _groupId = %s", ctld.p(_groupId))
                 end
+
+                if (ctld.enabledFOBBuilding or ctld.enableCrates) and _unitActions.crates then
+                    local _crateCommands = missionCommands.addSubMenuForGroup(_groupId,
+                        ctld.i18n_translate("CTLD Commands"), _rootPath)
+                    if ctld.vehicleCommandsPath[_unitName] == nil then
+                        ctld.vehicleCommandsPath[_unitName] = mist.utils.deepCopy(_crateCommands)
+                    end
+                    if ctld.hoverPickup == false or ctld.loadCrateFromMenu == true then
+                        if ctld.loadCrateFromMenu then
+                            missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Load Nearby Crate(s)"),
+                                _crateCommands, ctld.loadNearbyCrate, _unitName)
+                        end
+                    end
+
+                    if ctld.loadCrateFromMenu or ctld.hoverPickup then
+                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Crate(s)"),
+                            _crateCommands, ctld.dropSlingCrate, { _unitName })
+                    end
+
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Unpack Any Crate"),
+                        _crateCommands, ctld.unpackCrates, { _unitName })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Nearby Crates"),
+                        _crateCommands, ctld.listNearbyCrates, { _unitName })
+
+                    if ctld.enabledFOBBuilding then
+                        missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List FOBs"), _crateCommands,
+                            ctld.listFOBS, { _unitName })
+                    end
+
+                    if  ctld.enableRepackingVehicles == true then
+                        ctld.updateRepackMenu( _unitName )        -- add repack menu
+                    end
+                end
+
+                if ctld.enableSmokeDrop then
+                    local _smokeMenu = missionCommands.addSubMenuForGroup(_groupId,
+                        ctld.i18n_translate("Smoke Markers"), _rootPath)
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Red Smoke"), _smokeMenu,
+                        ctld.dropSmoke, { _unitName, trigger.smokeColor.Red })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Blue Smoke"), _smokeMenu,
+                        ctld.dropSmoke, { _unitName, trigger.smokeColor.Blue })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Orange Smoke"), _smokeMenu,
+                        ctld.dropSmoke, { _unitName, trigger.smokeColor.Orange })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Green Smoke"), _smokeMenu,
+                        ctld.dropSmoke, { _unitName, trigger.smokeColor.Green })
+                end
+
+                if ctld.enabledRadioBeaconDrop then
+                    local _radioCommands = missionCommands.addSubMenuForGroup(_groupId,
+                        ctld.i18n_translate("Radio Beacons"), _rootPath)
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Beacons"), _radioCommands,
+                        ctld.listRadioBeacons, { _unitName })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Drop Beacon"), _radioCommands,
+                        ctld.dropRadioBeacon, { _unitName })
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("Remove Closest Beacon"),
+                        _radioCommands, ctld.removeRadioBeacon, { _unitName })
+                elseif ctld.deployedRadioBeacons ~= {} then
+                    local _radioCommands = missionCommands.addSubMenuForGroup(_groupId,
+                        ctld.i18n_translate("Radio Beacons"), _rootPath)
+                    missionCommands.addCommandForGroup(_groupId, ctld.i18n_translate("List Beacons"), _radioCommands,
+                        ctld.listRadioBeacons, { _unitName })
+                end
+
+                ctld.addedTo[tostring(_groupId)] = true
+                ctld.logTrace("ctld.addedTo = %s", ctld.p(ctld.addedTo))
+                ctld.logTrace("done adding CTLD menu for _groupId = %s", ctld.p(_groupId))
             end
         end
-    end)
-    if (not status) then
-        ctld.logError(string.format("Error adding f10 to transport: %s", error))
     end
 end
 
@@ -7773,7 +7792,7 @@ function ctld.TreatOrbitJTAC(params, t)
             if ctld.JTACInRoute[k] == nil and  ctld.OrbitInUse[k] == nil then		-- if JTAC is in route
                 ctld.JTACInRoute[k] = timer.getTime()		-- update time of the last run
             end
-            
+
             if ctld.jtacCurrentTargets[k] ~= nil then		       -- if target lased by JTAC
                 local droneAlti = Unit.getByName(k):getPoint().y
                 if ctld.OrbitInUse[k] == nil then		-- if JTAC is not in orbit => start orbiting and update start time
@@ -7784,7 +7803,7 @@ function ctld.TreatOrbitJTAC(params, t)
                     if timer.getTime() > (ctld.OrbitInUse[k] + 60) then   	                     -- each 60" update orbit coord 
                         ctld.StartOrbitGroup(k, ctld.jtacCurrentTargets[k].name, droneAlti, 100) -- do orbit JTAC
                         ctld.OrbitInUse[k] = timer.getTime()			          -- update time of the last orbit run 
-                    end 
+                    end
                 end
             else                                                   -- if JTAC have no target
                 if ctld.InOrbitList(k) == true then				   -- JTAC orbiting, without target => stop orbit
@@ -7802,12 +7821,12 @@ end
 -- Make orbit the group "_grpName", on target "_unitTargetName".  _alti in meters, speed in km/h
 function ctld.StartOrbitGroup(_jtacUnitName, _unitTargetName, _alti, _speed)
 	if (Unit.getByName(_unitTargetName) ~= nil) and (Unit.getByName(_jtacUnitName) ~= nil) then			-- si target unit and JTAC group exist
-		local orbit = { id     = 'Orbit', 
+		local orbit = { id     = 'Orbit',
                         params = {pattern = 'Circle',
                                   point = mist.utils.makeVec2(mist.getAvgPos(mist.makeUnitTable({_unitTargetName}))),
                                   speed = _speed,
                                   altitude = _alti
-                                 } 
+                                 }
                       }
         local jtacGroupName = Unit.getByName(_jtacUnitName):getGroup():getName()
         Unit.getByName(_jtacUnitName):getController():popTask()	                      -- stop current Task
@@ -7818,10 +7837,10 @@ end
 -- test if one unitName already is targeted by a JTAC
 function ctld.InOrbitList(_grpName)
     for k, v in pairs(ctld.OrbitInUse) do			-- for each orbit in use
-		if k == _grpName then 
+		if k == _grpName then
 			return true
 		end
-	end 
+	end
 	return false
 end
 -------------------------------------------------------------------------------------------
@@ -7853,10 +7872,10 @@ function ctld.backToRoute(_jtacUnitName)
     local jtacGroupName = Unit.getByName(_jtacUnitName):getGroup():getName()
     --local JTACRoute     = mist.getGroupRoute(jtacGroupName, true)   -- get the initial editor route of the current group
     local JTACRoute     = mist.utils.deepCopy(mist.getGroupRoute(jtacGroupName, true))   -- get the initial editor route of the current group
-    local newJTACRoute  = ctld.adjustRoute(JTACRoute, ctld.getNearestWP(_jtacUnitName)) 
+    local newJTACRoute  = ctld.adjustRoute(JTACRoute, ctld.getNearestWP(_jtacUnitName))
 
-    local Mission       = {} 	
+    local Mission       = {}
-    Mission = { id = 'Mission', params = {route = {points = newJTACRoute}}} 
+    Mission = { id = 'Mission', params = {route = {points = newJTACRoute}}}
 
     -- unactive orbit mode if it's on
     if ctld.InOrbitList(_jtacUnitName) == true then					-- if JTAC orbiting => stop it
@@ -7910,11 +7929,11 @@ function ctld.adjustRoute(_initialRouteTable, _firstWpOfNewRoute)  -- create a r
                                 if idx2 == #adjustedRoute then
                                     lastWpAsAlreadySwitchWaypoint = true
                                 end
-                            
+
                             end
-                        
+
                         end
-                    
+
                     else	-- for "ControlledTask"
                         if adjustedRoute[idx2].task.params.tasks[j].params and
                            adjustedRoute[idx2].task.params.tasks[j].params.task and
@@ -8495,7 +8514,7 @@ end
 --- Handle world events.
 ctld.eventHandler = {}
 function ctld.eventHandler:onEvent(event)
-    ctld.logTrace("ctld.eventHandler:onEvent()")
+    --ctld.logTrace("ctld.eventHandler:onEvent()")
     if event == nil then
         ctld.logError("Event handler was called with a nil event!")
         return
@@ -8508,7 +8527,7 @@ function ctld.eventHandler:onEvent(event)
     elseif event.id == world.event.S_EVENT_BIRTH then
         eventName = "S_EVENT_BIRTH"
     else
-        ctld.logTrace("Ignoring event %s", ctld.p(event))
+        --ctld.logTrace("Ignoring event %s", ctld.p(event))
         return
     end
     ctld.logDebug("caught event %s: %s", ctld.p(eventName), ctld.p(event))
@@ -8543,7 +8562,7 @@ function ctld.eventHandler:onEvent(event)
                     for _, aircraftType in pairs(ctld.aircraftTypeTable) do
                         if aircraftType == playerTypeName then
                             ctld.logTrace("adding by aircraft type, unitName = %s", ctld.p(unitName))
-                            if ctld.isValueInIpairTable(ctld.transportPilotNames, unitName) == false then
+                            if ctld.tools.isValueInIpairTable(ctld.transportPilotNames, unitName) == false then
                                 table.insert(ctld.transportPilotNames, unitName)  -- add transport unit to the list
                             end
                             if ctld.addedTo[tostring(_groupId)] == nil then  -- only if menu not already set up
@@ -8621,7 +8640,8 @@ function ctld.RandomReal(mini, maxi)
 end
 
 -- Tools
-function ctld.isValueInIpairTable(tab, value)
+ctld.tools = {}
+function ctld.tools.isValueInIpairTable(tab, value)
     for i, v in ipairs(tab) do
       if v == value then
         return true -- La valeur existe
@@ -8629,6 +8649,58 @@ function ctld.isValueInIpairTable(tab, value)
     end
     return false -- La valeur n'existe pas
   end
+------------------------------------------------------------------------------------
+--- Calculates the orientation of an end point relative to a reference point.
+--- The calculation takes into account the current orientation of the reference point.
+---
+--- @param refLat number Latitude of the reference point in degrees.
+--- @param refLon number Longitude of the reference point in degrees.
+--- @param refHeading number Current orientation of the reference point in degrees (0 = North, 90 = East).
+--- @param destLat number Latitude of the arrival point in degrees.
+--- @param destLon number Longitude of the arrival point in degrees.
+--- @param resultFormat string The desired output format: "radian", "degree" or "clock".
+--- @return number The relative orientation in the specified resultFormat.
+function ctld.tools.getRelativeBearing(refLat, refLon, refHeading, destLat, destLon, resultFormat)
+  -- Converting degrees to radians for geometric calculations
+  local radrefLat = math.rad(refLat)
+  local raddestLat = math.rad(destLat)
+  local radrefLon = math.rad(refLon)
+  local raddestLon = math.rad(destLon)
+  local radrefHeading = math.rad(refHeading)
+
+  -- Calculating the longitude difference between the two points
+  local deltaLon = raddestLon - radrefLon
+
+  -- Using the great circle formula for azimuth (bearing)
+  -- This formula is based on spherical trigonometry and uses atan2
+  -- to correctly handle all quadrants.
+  local y = math.sin(deltaLon) * math.cos(raddestLat)
+  local x = math.cos(radrefLat) * math.sin(raddestLat) - math.sin(radrefLat) * math.cos(raddestLat) * math.cos(deltaLon)
+  local absoluteBearingRad = math.atan2(y, x)
+
+  -- Calculate relative orientation by subtracting the reference refHeading
+  local relativeBearingRad = absoluteBearingRad - radrefHeading
+
+  -- Normalizes the angle to be in the range [-pi, pi]
+  -- This ensures a consistent angle, whether positive or negative.
+  local normalizedRad = (relativeBearingRad + math.pi) % (2 * math.pi) - math.pi
+
+  -- Returns the value in the requested resultFormat
+  if resultFormat == "radian" then
+    return normalizedRad, resultFormat
+  elseif resultFormat == "clock" then
+    -- Convert to clock position (12h = front, 3h = right, 6h = back, etc..)
+    local bearingDeg = math.deg(normalizedRad)
+    local clockPosition = ((bearingDeg + 360) % 360) / 30
+    clockPosition =  clockPosition >= 0 and math.floor(clockPosition + 0.5) or math.ceil(clockPosition - 0.5), resultFormat		-- rounded clockPosition
+    if clockPosition == 0 then clockPosition = 12 end
+    return clockPosition, resultFormat
+  else -- By default, the resultFormat is "degree"
+    resultFormat = "degree"
+    local bearingDeg = math.deg(normalizedRad)
+    return (bearingDeg + 360) % 360, resultFormat
+  end
+end
 
 --- Enable/Disable error boxes displayed on screen.
 env.setErrorMessageBoxEnabled(false)

README.md

@@ -11,6 +11,8 @@ It's open-source and free as in free beer (you don't have to pay to use it), and
 
 We're always looking for help, please reach out to [Zip on Discord](https://discordapp.com/users/421317390807203850) if you want to participate in maintenance or development.
 
+And if you'd like to support our work, you can [buy me a coffee](https://coff.ee/veaf_zip)!
+
 ## Contents
 
 This script is a rewrite of some of the functionality of the original Complete Combat Troop Transport Script (CTTS) by Geloxo (http://forums.eagle.ru/showthread.php?t=108523), as well as adding new features.
@@ -130,7 +132,7 @@ Optionaly, you can disable the STTS (text to speech over SRS) feature (4).
 ![dynamic_loading]
 
 ### Script Setup
-**This script requires MIST version 4.0.57 or above: https://github.com/mrSkortch/MissionScriptingTools**
+🔴IMPORTANT: This script requires MIST supplied in the CTLD zipped pack to correctly manage dynamic spwans.
 
 First make sure MIST is loaded, either as an Initialization Script  for the mission or the first DO SCRIPT with a "TIME MORE" of 1. "TIME MORE" means run the actions after X seconds into the mission.
 

mist.lua

@@ -35,7 +35,7 @@ mist = {}
 -- don't change these
 mist.majorVersion = 4
 mist.minorVersion = 5
-mist.build = "128-DYNSLOTS-01"
+mist.build = "128-DYNSLOTS-02"
 
 -- forward declaration of log shorthand
 local log
@@ -826,11 +826,11 @@ do -- the main scope
 							if zone.verticies then
 								local offset = {}
 								for i = 1, #zone.verticies do
-									table.insert(offset, {dist = mist.utils.get2DDist(uRef.point, zone.verticies[i]), heading = mist.getHeadingPoints(uRef.point, zone.verticies[i]) + uRef.heading})
+									table.insert(offset, {dist = mist.utils.get2DDist(uRef.point, zone.verticies[i]), heading = mist.utils.getHeadingPoints(uRef.point, zone.verticies[i]) + uRef.heading})
 								end
 								zone.offset = offset
 							else
-								zone.offset = {dist = mist.utils.get2DDist(uRef.point, zone.point), heading = mist.getHeadingPoints(uRef.point, zone.point) + uRef.heading}
+								zone.offset = {dist = mist.utils.get2DDist(uRef.point, zone.point), heading = mist.utils.getHeadingPoints(uRef.point, zone.point) + uRef.heading}
 							end
 						end
 					end
@@ -1481,19 +1481,27 @@ do -- the main scope
 		-- dont need to add units spawned in at the start of the mission if mist is loaded in init line
 		if event.id == world.event.S_EVENT_BIRTH and timer.getTime0() < timer.getAbsTime() then
 
-			if Object.getCategory(event.initiator) == 1  then 
+			if Object.getCategory(event.initiator) == 1  then
 				--log:info('Object is a Unit')
 				local g =  Unit.getGroup(event.initiator)
-				if g and event.initiator:getPlayerName() ~= "" and not mist.DBs.MEunitsByName[event.initiator:getName()] then
+				if not g then
+					log:error('groupSpawned event handler: cannot get hold of Group via Unit. This is a DCS bug')
+					return
+				end
+				if event.initiator:getPlayerName() == "" then
+					log:error('groupSpawned event handler: cannot get initiator playerName. This is a DCS bug')
+					return
+				end
+				if not mist.DBs.MEunitsByName[event.initiator:getName()] then
+					log:error('groupSpawned event handler: cannot find initiator unit in MiST tables. This is a DCS bug')
+					return
+				end
 				--	log:info(Unit.getGroup(event.initiator):getName())
-					local gName = g:getName()
+				local gName = g:getName()
-					if not tempSpawnedGroups[gName] then
+				if not tempSpawnedGroups[gName] then
-						--log:warn('addedTo tempSpawnedGroups: $1', gName)
+					--log:warn('addedTo tempSpawnedGroups: $1', gName)
-						tempSpawnedGroups[gName] = {type = 'group', gp = g}
+					tempSpawnedGroups[gName] = {type = 'group', gp = g}
-						tempSpawnGroupsCounter = tempSpawnGroupsCounter + 1
+					tempSpawnGroupsCounter = tempSpawnGroupsCounter + 1
-					end
-				else
-					log:error('Group not accessible by unit in event handler. This is a DCS bug')
 				end
 			elseif Object.getCategory(event.initiator) == 3 or Object.getCategory(event.initiator) == 6 then
 				--log:info('staticSpawnEvent')