mission = 
{
    ["trig"] = 
    {
        ["actions"] = 
        {
            [1] = "a_do_script(\"dcsCommon = {}\\\
dcsCommon.version = \\\"2.6.4\\\"\\\
--[[-- VERSION HISTORY\\\
 2.2.6 - compassPositionOfARelativeToB\\\
       - clockPositionOfARelativeToB\\\
 2.2.7 - isTroopCarrier \\\
       - distFlat\\\
 2.2.8 - fixed event2text \\\
 2.2.9 - getUnitAGL\\\
       - getUnitAlt\\\
       - getUnitSpeed \\\
       - getUnitHeading\\\
       - getUnitHeadingDegrees\\\
       - mag\\\
       - clockPositionOfARelativeToB with own heading \\\
 2.3.0 - unitIsInfantry\\\
 2.3.1 - bool2YesNo\\\
       - bool2Text\\\
 2.3.2 - getGroupAvgSpeed\\\
       - getGroupMaxSpeed\\\
 2.3.3 - getSizeOfTable\\\
 2.3.4 - isSceneryObject\\\
         coalition2county\\\
 2.3.5 - smallRandom\\\
         pickRandom uses smallRandom\\\
         airfield handling, parking \\\
         flight waypoint handling\\\
         landing waypoint creation\\\
         take-off waypoint creation\\\
 2.3.6 - createOverheadAirdromeRoutPintData(aerodrome)\\\
 2.3.7 - coalition2county - warning when creating UN \\\
 2.3.8 - improved headingOfBInDegrees, new getClockDirection\\\
 2.3.9 - getClosingVelocity\\\
       - dot product \\\
       - magSquare\\\
       - vMag\\\
 2.4.0 - libCheck\\\
 2.4.1 - grid/square/rect formation \\\
       - arrangeGroupInNColumns formation \\\
       - 2Columns formation deep and wide formation\\\
 2.4.2 - getAirbasesInRangeOfPoint\\\
 2.4.3 - lerp \\\
 2.4.4 - getClosestAirbaseTo\\\
       - fixed bug in containsString when strings equal\\\
 2.4.5 - added cargo and mass options to createStaticObjectData\\\
 2.4.6 - fixed randompercent \\\
 2.4.7 - smokeColor2Num(smokeColor)\\\
 2.4.8 - linkStaticDataToUnit()\\\
 2.4.9 - trim functions \\\
       - createGroundUnitData uses trim function to remove leading/trailing blanks\\\
         so now we can use blanks after comma to separate types \\\
       - dcsCommon.trimArray(\\\
       - createStaticObjectData uses trim for type \\\
       - getEnemyCoalitionFor understands strings, still returns number\\\
       - coalition2county also undertsands 'red' and 'blue'\\\
 2.5.0 - \\\"Line\\\" formation with one unit places unit at center     \\\
 2.5.1 - vNorm(a)  \\\
 2.5.1 - added SA-18 Igla manpad to unitIsInfantry()\\\
 2.5.2 - added copyArray method\\\
       - corrected heading in createStaticObjectData\\\
 2.5.3 - corrected rotateGroupData bug for cz \\\
       - removed forced error in failed pickRandom\\\
 2.5.4 - rotateUnitData()\\\
       - randomBetween()\\\
 2.5.5 - stringStartsWithDigit()\\\
       - stringStartsWithLetter()\\\
       - stringIsPositiveNumber()\\\
 2.5.6 - corrected stringEndsWith() bug with str\\\
 2.5.7 - point2text(p) \\\
 2.5.8 - string2GroupCat()\\\
 2.5.9 - string2ObjectCat()\\\
 2.6.0 - unified uuid, removed uuIdent\\\
 2.6.1 - removed bug in rotateUnitData: cy --> cz param passing  \\\
 2.6.2 - new combineTables()\\\
 2.6.3 - new tacan2freq()\\\
 2.6.4 - new processHMS()\\\
 2.6.5 - new bearing2compass()\\\
       - new bearingdegrees2compass()\\\
       - new latLon2Text() - based on mist \\\
       \\\
--]]--\\\
\\\
    -- dcsCommon is a library of common lua functions \\\
    -- for easy access and simple mission programming\\\
    -- (c) 2021, 2022 by Chritian Franz and cf/x AG\\\
\\\
    dcsCommon.verbose = false -- set to true to see debug messages. Lots of them\\\
    dcsCommon.uuidStr = \\\"uuid-\\\"\\\
    dcsCommon.simpleUUID = 76543 -- a number to start. as good as any\\\
    \\\
    -- globals\\\
    dcsCommon.cbID = 0 -- callback id for simple callback scheduling\\\
    dcsCommon.troopCarriers = {\\\"Mi-8MT\\\", \\\"UH-1H\\\", \\\"Mi-24P\\\"} -- Ka-50 and Gazelle can't carry troops\\\
\\\
    -- verify that a module is loaded. obviously not required\\\
    -- for dcsCommon, but all higher-order modules\\\
    function dcsCommon.libCheck(testingFor, requiredLibs)\\\
        local canRun = true \\\
        for idx, libName in pairs(requiredLibs) do \\\
            if not _G[libName] then \\\
                trigger.action.outText(\\\"*** \\\" .. testingFor .. \\\" requires \\\" .. libName, 30)\\\
                canRun = false \\\
            end\\\
        end\\\
        return canRun\\\
    end\\\
\\\
    -- returns only positive values, lo must be >0 and <= hi \\\
    function dcsCommon.randomBetween(loBound, hiBound)\\\
        if not loBound then loBound = 1 end \\\
        if not hiBound then hiBound = 1 end \\\
        if loBound == hiBound then return loBound end \\\
\\\
        local delayMin = loBound\\\
        local delayMax = hiBound \\\
        local delay = delayMax \\\
    \\\
        if delayMin ~= delayMax then \\\
            -- pick random in range , say 3-7 --> 5 s!\\\
            local delayDiff = (delayMax - delayMin) + 1 -- 7-3 + 1\\\
            delay = dcsCommon.smallRandom(delayDiff) - 1 --> 0-4\\\
            delay = delay + delayMin \\\
            if delay > delayMax then delay = delayMax end \\\
            if delay < 1 then delay = 1 end \\\
        \\\
            if dcsCommon.verbose then \\\
                trigger.action.outText(\\\"+++dcsC: delay range \\\" .. delayMin .. \\\"-\\\" .. delayMax .. \\\": selected \\\" .. delay, 30)\\\
            end\\\
        end\\\
        \\\
        return delay\\\
    end\\\
    \\\
\\\
    -- taken inspiration from mist, as dcs lua has issues with\\\
    -- random numbers smaller than 50. Given a range of x numbers 1..x, it is \\\
    -- repeated a number of times until it fills an array of at least \\\
    -- 50 items (usually some more), and only then one itemis picked from \\\
    -- that array with a random number that is from a greater range (0..50+)\\\
    function dcsCommon.smallRandom(theNum) -- adapted from mist, only support ints\\\
        if theNum >= 50 then return math.random(theNum) end\\\
        \\\
        -- for small randoms (<50) \\\
        local lowNum, highNum\\\
        highNum = theNum\\\
        lowNum = 1\\\
        local total = 1\\\
        if math.abs(highNum - lowNum + 1) < 50 then -- if total values is less than 50\\\
            total = math.modf(50/math.abs(highNum - lowNum + 1)) -- number of times to repeat whole range to get above 50. e.g. 11 would be 5 times 1 .. 11, giving us 55 items total \\\
        end\\\
        local choices = {}\\\
        for i = 1, total do -- iterate required number of times\\\
            for x = lowNum, highNum do -- iterate between the range\\\
                choices[#choices +1] = x -- add each entry to a table\\\
            end\\\
        end\\\
        local rtnVal; -- = math.random(#choices) -- will now do a math.random of at least 50 choices\\\
        for i = 1, 15 do\\\
            rtnVal = math.random(#choices) -- iterate 15 times for randomization\\\
        end\\\
        return choices[rtnVal] -- return indexed\\\
    end\\\
    \\\
\\\
    function dcsCommon.getSizeOfTable(theTable)\\\
        local count = 0\\\
        for _ in pairs(theTable) do count = count + 1 end\\\
        return count\\\
    end\\\
\\\
    function dcsCommon.findAndRemoveFromTable(theTable, theElement) -- assumes array \\\
        if not theElement then return false end \\\
        if not theTable then return false end \\\
        for i=1, #theTable do \\\
            if theTable[i] == theElement then \\\
                -- this element found. remove from table \\\
                table.remove(theTable, i)\\\
                return true \\\
            end\\\
        end\\\
    end\\\
\\\
    function dcsCommon.pickRandom(theTable)\\\
        if not theTable then \\\
            trigger.action.outText(\\\"*** warning: nil table in pick random\\\", 30)\\\
        end\\\
        \\\
        if #theTable < 1 then \\\
            trigger.action.outText(\\\"*** warning: zero choice in pick random\\\", 30)\\\
            --local k = i.ll \\\
            return nil\\\
        end\\\
        if #theTable == 1 then return theTable[1] end\\\
        r = dcsCommon.smallRandom(#theTable) --r = math.random(#theTable)\\\
        return theTable[r]\\\
    end\\\
\\\
    -- enumerateTable - make an array out of a table for indexed access\\\
    function dcsCommon.enumerateTable(theTable)\\\
        if not theTable then theTable = {} end\\\
        local array = {}\\\
        for key, value in pairs(theTable) do \\\
            table.insert(array, value)\\\
        end\\\
        return array\\\
    end\\\
\\\
    -- combine table. creates new \\\
    function dcsCommon.combineTables(inOne, inTwo)\\\
        local outTable = {}\\\
        for idx, element in pairs(inOne) do \\\
            table.insert(outTable, element)\\\
        end\\\
        for idx, element in pairs(inTwo) do \\\
            table.insert(outTable, element)\\\
        end\\\
        return outTable\\\
    end\\\
-- \\\
-- A I R F I E L D S  A N D  F A R P S  \\\
--\\\
\\\
    -- airfield management \\\
    function dcsCommon.getAirbaseCat(aBase)\\\
        if not aBase then return nil end \\\
        \\\
        local airDesc = aBase:getDesc()\\\
        if not airDesc then return nil end \\\
        \\\
        local airCat = airDesc.category\\\
        return airCat \\\
    end\\\
\\\
    -- get free parking slot. optional parkingType can be used to \\\
    -- filter for a scpecific type, e.g. 104 = open field\\\
    function dcsCommon.getFirstFreeParkingSlot(aerodrome, parkingType) \\\
        if not aerodrome then return nil end \\\
        local freeSlots = aerodrome:getParking(true)\\\
        \\\
        for idx, theSlot in pairs(freeSlots) do \\\
            if not parkingType then \\\
                -- simply return the first we come across\\\
                return theSlot\\\
            end        \\\
            \\\
            if theSlot.Term_Type == parkingType then \\\
                return theSlot \\\
            end\\\
        end\\\
        \\\
        return nil \\\
    end\\\
\\\
    -- getAirbasesInRangeOfPoint: get airbases that are in range of point \\\
    function dcsCommon.getAirbasesInRangeOfPoint(center, range, filterCat, filterCoalition)\\\
        if not center then return {} end \\\
        if not range then range = 500 end -- 500m default \\\
        local basesInRange = {}\\\
        \\\
        local allAB = dcsCommon.getAirbasesWhoseNameContains(\\\"*\\\", filterCat, filterCoalition)\\\
        for idx, aBase in pairs(allAB) do             \\\
            local delta = dcsCommon.dist(center, aBase:getPoint())\\\
            if delta <= range then \\\
                table.insert(basesInRange, aBase)\\\
            end\\\
        end\\\
        return basesInRange\\\
    end\\\
\\\
    -- getAirbasesInRangeOfAirbase returns all airbases that \\\
    -- are in range of the given airbase \\\
    function dcsCommon.getAirbasesInRangeOfAirbase(airbase, includeCenter, range, filterCat, filterCoalition)\\\
        if not airbase then return {} end\\\
        if not range then range = 150000 end \\\
        local center = airbase:getPoint() \\\
        local centerName = airbase:getName() \\\
        \\\
        local ABinRange = {}\\\
        local allAB = dcsCommon.getAirbasesWhoseNameContains(\\\"*\\\", filterCat, filterCoalition)\\\
        \\\
        for idx, aBase in pairs(allAB) do \\\
            if aBase:getName() ~= centerName then \\\
                local delta = dcsCommon.dist(center, aBase:getPoint())\\\
                if delta <= range then \\\
                    table.insert(ABinRange, aBase)\\\
                end\\\
            end        \\\
        end\\\
        \\\
        if includeCenter then \\\
            table.insert(ABinRange, airbase)\\\
        end\\\
        \\\
        return ABinRange\\\
    end\\\
\\\
    function dcsCommon.getAirbasesInRangeOfAirbaseList(theCenterList, includeList, range, filterCat, filterCoalition)\\\
        local collectorDict = {}\\\
        for idx, aCenter in pairs(theCenterList) do \\\
            -- get all surrounding airbases. returns list of airfields \\\
            local surroundingAB = dcsCommon.getAirbasesInRangeOfAirbase(airbase, includeList, range, filterCat, filterCoalition)\\\
            \\\
            for idx2, theAirField in pairs (surroundingAB) do \\\
                collectorDict[airField] = theAirField \\\
            end\\\
        end\\\
        \\\
        -- make result an array\\\
        local theABList = dcsCommon.enumerateTable(collectorDict)\\\
        return theABList\\\
    end\\\
\\\
    -- getAirbasesWhoseNameContains - get all airbases containing \\\
    -- a name. filterCat is optional and can be aerodrome (0), farp (1), ship (2)\\\
    -- filterCoalition is optional and can be 0 (neutral), 1 (red), 2 (blue) \\\
    -- if no name given or aName = \\\"*\\\", then all bases are returned prior to filtering \\\
    function dcsCommon.getAirbasesWhoseNameContains(aName, filterCat, filterCoalition)\\\
        --trigger.action.outText(\\\"getAB(name): enter with \\\" .. aName, 30)\\\
        if not aName then aName = \\\"*\\\" end \\\
        local allYourBase = world.getAirbases() -- get em all \\\
        local areBelongToUs = {}\\\
        -- now iterate all bases\\\
        for idx, aBase in pairs(allYourBase) do\\\
            local airBaseName = aBase:getName() -- get display name\\\
            if aName == \\\"*\\\" or dcsCommon.containsString(airBaseName, aName) then \\\
                -- containsString is case insesitive unless told otherwise\\\
                --if aName ~= \\\"*\\\" then \\\
                --    trigger.action.outText(\\\"getAB(name): matched \\\" .. airBaseName, 30)\\\
                --end \\\
                local doAdd = true \\\
                if filterCat then \\\
                    -- make sure the airbase is of that category \\\
                    local airCat = dcsCommon.getAirbaseCat(aBase)\\\
                    doAdd = doAdd and airCat == filterCat \\\
                end\\\
                \\\
                if filterCoalition then \\\
                    doAdd = doAdd and filterCoalition == aBase:getCoalition()\\\
                end\\\
                \\\
                if doAdd then \\\
                    -- all good, add to table\\\
                    table.insert(areBelongToUs, aBase)\\\
                end            \\\
            end\\\
        end\\\
        return areBelongToUs\\\
    end\\\
\\\
    function dcsCommon.getFirstAirbaseWhoseNameContains(aName, filterCat, filterCoalition)\\\
        local allBases = dcsCommon.getAirbasesWhoseNameContains(aName, filterCat, filterCoalition)\\\
        for idx, aBase in pairs (allBases) do \\\
            -- simply return first \\\
            return aBase\\\
        end\\\
        return nil \\\
    end    \\\
\\\
    function dcsCommon.getClosestAirbaseTo(thePoint, filterCat, filterCoalition)\\\
        local delta = math.huge\\\
        local allYourBase = dcsCommon.getAirbasesWhoseNameContains(\\\"*\\\", filterCat, filterCoalition) -- get em all and filter\\\
        local closestBase = nil \\\
        for idx, aBase in pairs(allYourBase) do\\\
            -- iterate them all \\\
            local abPoint = aBase:getPoint()\\\
            newDelta = dcsCommon.dist(thePoint, {x=abPoint.x, y = 0, z=abPoint.z})\\\
            if newDelta < delta then \\\
                delta = newDelta\\\
                closestBase = aBase\\\
            end\\\
        end\\\
        return closestBase, delta \\\
    end\\\
\\\
-- \\\
-- U N I T S   M A N A G E M E N T \\\
--\\\
\\\
    -- number of living units in group\\\
    function dcsCommon.livingUnitsInGroup(group)\\\
        local living = 0\\\
        local allUnits = group:getUnits()\\\
        for key, aUnit in pairs(allUnits) do \\\
            if aUnit:isExist() and aUnit:getLife() >= 1 then \\\
                living = living + 1\\\
            end\\\
        end\\\
        return living\\\
    end\\\
\\\
    -- closest living unit in group to a point\\\
    function dcsCommon.getClosestLivingUnitToPoint(group, p)\\\
        if not p then return nil end\\\
        if not group then return nil end\\\
        local closestUnit = nil\\\
        local closestDist = math.huge\\\
        local allUnits = group:getUnits()\\\
        for key, aUnit in pairs(allUnits) do \\\
            if aUnit:isExist() and aUnit:getLife() >= 1 then \\\
                local thisDist = dcsCommon.dist(p, aUnit:getPoint())\\\
                if thisDist < closestDist then \\\
                    closestDist = thisDist\\\
                    closestUnit = aUnit \\\
                end\\\
            end\\\
        end\\\
        return closestUnit, closestDist\\\
    end\\\
    \\\
    -- closest living group to a point - cat can be nil or one of Group.Category = { AIRPLANE = 0, HELICOPTER = 1, GROUND = 2, SHIP = 3, TRAIN = 4}\\\
    function dcsCommon.getClosestLivingGroupToPoint(p, coal, cat) \\\
        if not cat then cat = 2 end -- ground is default \\\
        local closestGroup = nil;\\\
        local closestGroupDist = math.huge\\\
        local allGroups =  coalition.getGroups(coal, cat) -- get all groups from this coalition, perhaps filtered by cat \\\
        for key, grp in pairs(allGroups) do\\\
            local closestUnit, dist = dcsCommon.getClosestLivingUnitToPoint(grp, p)\\\
            if closestUnit then \\\
                if dist < closestGroupDist then \\\
                    closestGroup = grp\\\
                    closestGroupDist = dist\\\
                end\\\
            end            \\\
        end\\\
        return closestGroup, closestGroupDist\\\
    end\\\
\\\
    function dcsCommon.getLivingGroupsAndDistInRangeToPoint(p, range, coal, cat) \\\
        if not cat then cat = 2 end -- ground is default \\\
        local groupsInRange = {};\\\
        local allGroups = coalition.getGroups(coal, cat) -- get all groups from this coalition, perhaps filtered by cat \\\
        for key, grp in pairs(allGroups) do\\\
            local closestUnit, dist = dcsCommon.getClosestLivingUnitToPoint(grp, p)\\\
            if closestUnit then \\\
                if dist < range then \\\
                    table.insert(groupsInRange, {group = grp, dist = dist}) -- array\\\
                end\\\
            end            \\\
        end\\\
        -- sort the groups by distance\\\
        table.sort(groupsInRange, function (left, right) return left.dist < right.dist end )\\\
        return groupsInRange\\\
    end\\\
\\\
    -- distFlat ignores y, input must be xyz points, NOT xy points  \\\
    function dcsCommon.distFlat(p1, p2) \\\
        local point1 = {x = p1.x, y = 0, z=p1.z}\\\
        local point2 = {x = p2.x, y = 0, z=p2.z}\\\
        return dcsCommon.dist(point1, point2)\\\
    end\\\
    \\\
    -- distance between points\\\
    function dcsCommon.dist(point1, point2)     -- returns distance between two points\\\
      -- supports xyz and xy notations\\\
      if not point1 then \\\
        trigger.action.outText(\\\"+++ warning: nil point1 in common:dist\\\", 30)\\\
        point1 = {x=0, y=0, z=0}\\\
      end\\\
\\\
      if not point2 then \\\
        trigger.action.outText(\\\"+++ warning: nil point2 in common:dist\\\", 30)\\\
        point2 = {x=0, y=0, z=0}\\\
        stop.here.now = 1\\\
      end\\\
      \\\
      local p1 = {x = point1.x, y = point1.y}\\\
      if not point1.z then \\\
        p1.z = p1.y\\\
        p1.y = 0\\\
      else \\\
        p1.z = point1.z\\\
      end\\\
      \\\
      local p2 = {x = point2.x, y = point2.y}\\\
      if not point2.z then \\\
        p2.z = p2.y\\\
        p2.y = 0\\\
      else \\\
        p2.z = point2.z\\\
      end\\\
      \\\
      local x = p1.x - p2.x\\\
      local y = p1.y - p2.y \\\
      local z = p1.z - p2.z\\\
      \\\
      return (x*x + y*y + z*z)^0.5\\\
    end\\\
\\\
    function dcsCommon.delta(name1, name2) -- returns distance (in meters) of two named objects\\\
      local n1Pos = Unit.getByName(name1):getPosition().p\\\
      local n2Pos = Unit.getByName(name2):getPosition().p\\\
      return dcsCommon.dist(n1Pos, n2Pos)\\\
    end\\\
\\\
    -- lerp between a and b, x being 0..1 (percentage), clipped to [0..1]\\\
    function dcsCommon.lerp(a, b, x) \\\
        if not a then return 0 end\\\
        if not b then return 0 end\\\
        if not x then return a end\\\
        if x < 0 then x = 0 end \\\
        if x > 1 then x = 1 end \\\
        return a + (b - a ) * x\\\
    end\\\
\\\
    function dcsCommon.bearingFromAtoB(A, B) -- coords in x, z \\\
        dx = B.x - A.x\\\
        dz = B.z - A.z\\\
        bearing = math.atan2(dz, dx) -- in radiants\\\
        return bearing\\\
    end\\\
\\\
    function dcsCommon.bearingInDegreesFromAtoB(A, B)\\\
        local bearing = dcsCommon.bearingFromAtoB(A, B) -- in rads \\\
        bearing = math.floor(bearing / math.pi * 180)\\\
        if bearing < 0 then bearing = bearing + 360 end\\\
        if bearing > 360 then bearing = bearing - 360 end\\\
        return bearing\\\
    end\\\
    \\\
    function dcsCommon.compassPositionOfARelativeToB(A, B)\\\
        -- warning: is REVERSE in order for bearing, returns a string like 'Sorth', 'Southwest'\\\
        if not A then return \\\"***error:A***\\\" end\\\
        if not B then return \\\"***error:B***\\\" end\\\
        local bearing = dcsCommon.bearingInDegreesFromAtoB(B, A) -- returns 0..360\\\
        if bearing < 23 then return \\\"North\\\" end \\\
        if bearing < 68 then return \\\"NE\\\" end\\\
        if bearing < 112 then return \\\"East\\\" end \\\
        if bearing < 158 then return \\\"SE\\\" end \\\
        if bearing < 202 then return \\\"South\\\" end \\\
        if bearing < 248 then return \\\"SW\\\" end \\\
        if bearing < 292 then return \\\"West\\\" end\\\
        if bearing < 338 then return \\\"NW\\\" end \\\
        return \\\"North\\\"\\\
    end\\\
    \\\
    function dcsCommon.bearing2compass(inrad)\\\
        local bearing = math.floor(inrad / math.pi * 180)\\\
        if bearing < 0 then bearing = bearing + 360 end\\\
        if bearing > 360 then bearing = bearing - 360 end\\\
        return dcsCommon.bearingdegrees2compass(bearing)\\\
    end\\\
    \\\
    function dcsCommon.bearingdegrees2compass(bearing)\\\
        if bearing < 23 then return \\\"North\\\" end \\\
        if bearing < 68 then return \\\"NE\\\" end\\\
        if bearing < 112 then return \\\"East\\\" end \\\
        if bearing < 158 then return \\\"SE\\\" end \\\
        if bearing < 202 then return \\\"South\\\" end \\\
        if bearing < 248 then return \\\"SW\\\" end \\\
        if bearing < 292 then return \\\"West\\\" end\\\
        if bearing < 338 then return \\\"NW\\\" end \\\
        return \\\"North\\\"\\\
    end\\\
    \\\
    function dcsCommon.clockPositionOfARelativeToB(A, B, headingOfBInDegrees)\\\
        -- o'clock notation \\\
        if not A then return \\\"***error:A***\\\" end\\\
        if not B then return \\\"***error:B***\\\" end\\\
        if not headingOfBInDegrees then headingOfBInDegrees = 0 end \\\
        \\\
        local bearing = dcsCommon.bearingInDegreesFromAtoB(B, A) -- returns 0..360\\\
--        trigger.action.outText(\\\"+++comm: oclock - bearing = \\\" .. bearing .. \\\" and inHeading = \\\" .. headingOfBInDegrees, 30) \\\
        bearing = bearing - headingOfBInDegrees\\\
        return dcsCommon.getClockDirection(bearing)\\\
        \\\
    end \\\
    \\\
    -- given a heading, return clock with 0 being 12, 180 being 6 etc.\\\
    function dcsCommon.getClockDirection(direction) -- inspired by cws, improvements my own\\\
        if not direction then return 0 end\\\
        direction = math.fmod (direction, 360)\\\
        while direction < 0 do \\\
            direction = direction + 360\\\
        end\\\
        \\\
        if direction < 15 then -- special case 12 o'clock past 12 o'clock\\\
            return 12\\\
        end\\\
    \\\
        direction = direction + 15 -- add offset so we get all other times correct\\\
        return math.floor(direction/30)\\\
    \\\
    end\\\
\\\
    \\\
    function dcsCommon.randomDegrees()\\\
        local degrees = math.random(360) * 3.14152 / 180\\\
        return degrees\\\
    end\\\
\\\
    function dcsCommon.randomPercent()\\\
        local percent = math.random(100)/100\\\
        return percent\\\
    end\\\
\\\
    function dcsCommon.randomPointOnPerimeter(sourceRadius, x, z) \\\
        return dcsCommon.randomPointInCircle(sourceRadius, sourceRadius-1, x, z)\\\
    end\\\
\\\
    function dcsCommon.randomPointInCircle(sourceRadius, innerRadius, x, z)\\\
        if not x then x = 0 end\\\
        --local y = 0\\\
        if not innerRadius then innerRadius = 0 end        \\\
        if innerRadius < 0 then innerRadius = 0 end\\\
        \\\
        local percent = dcsCommon.randomPercent() -- 1 / math.random(100)\\\
        -- now lets get a random degree\\\
        local degrees = dcsCommon.randomDegrees() -- math.random(360) * 3.14152 / 180 -- ok, it's actually radiants. \\\
        local r = (sourceRadius-innerRadius) * percent \\\
        local x = x + (innerRadius + r) * math.cos(degrees)\\\
        local z = z + (innerRadius + r) * math.sin(degrees)\\\
    \\\
        local thePoint = {}\\\
        thePoint.x = x\\\
        thePoint.y = 0\\\
        thePoint.z = z \\\
        \\\
        return thePoint, degrees\\\
    end\\\
\\\
    -- get group location: get the group's location by \\\
    -- accessing the fist existing, alive member of the group that it finds\\\
    function dcsCommon.getGroupLocation(group)\\\
        -- nifty trick from mist: make this work with group and group name\\\
        if type(group) == 'string' then -- group name\\\
            group = Group.getByName(group)\\\
        end\\\
        \\\
        -- get all units\\\
        local allUnits = group:getUnits()\\\
\\\
        -- iterate through all members of group until one is alive and exists\\\
        for index, theUnit in pairs(allUnits) do \\\
            if (theUnit:isExist() and theUnit:getLife() > 0) then \\\
                return theUnit:getPosition().p \\\
            end;\\\
        end\\\
\\\
        -- if we get here, there was no live unit \\\
        --trigger.action.outText(\\\"+++cmn: A group has no live units. returning nil\\\", 10)\\\
        return nil \\\
        \\\
    end\\\
\\\
    -- get the group's first Unit that exists and is \\\
    -- alive \\\
    function dcsCommon.getGroupUnit(group)\\\
        if not group then return nil  end\\\
        \\\
        -- nifty trick from mist: make this work with group and group name\\\
        if type(group) == 'string' then -- group name\\\
            group = Group.getByName(group)\\\
        end\\\
        \\\
        if not group:isExist() then return nil end \\\
        \\\
        -- get all units\\\
        local allUnits = group:getUnits()\\\
\\\
        -- iterate through all members of group until one is alive and exists\\\
        for index, theUnit in pairs(allUnits) do \\\
            if (theUnit:isExist() and theUnit:getLife() > 0) then \\\
                return theUnit\\\
            end;\\\
        end\\\
\\\
        -- if we get here, there was no live unit \\\
        --trigger.action.outText(\\\"+++cmn A group has no live units. returning nil\\\", 10)\\\
        return nil \\\
        \\\
    end\\\
\\\
    -- and here the alias\\\
    function dcsCommon.getFirstLivingUnit(group)\\\
        return dcsCommon.getGroupUnit(group)\\\
    end\\\
    \\\
    -- isGroupAlive returns true if there is at least one unit in the group that isn't dead\\\
    function dcsCommon.isGroupAlive(group)\\\
        return (dcsCommon.getGroupUnit(group) ~= nil) \\\
    end\\\
\\\
    function dcsCommon.getLiveGroupUnits(group)\\\
        -- nifty trick from mist: make this work with group and group name\\\
        if type(group) == 'string' then -- group name\\\
            group = Group.getByName(group)\\\
        end\\\
        \\\
        local liveUnits = {}\\\
        -- get all units\\\
        local allUnits = group:getUnits()\\\
\\\
        -- iterate through all members of group until one is alive and exists\\\
        for index, theUnit in pairs(allUnits) do \\\
            if (theUnit:isExist() and theUnit:getLife() > 0) then \\\
                table.insert(liveUnits, theUnit) \\\
            end;\\\
        end\\\
\\\
        -- if we get here, there was no live unit \\\
        return liveUnits\\\
    end\\\
\\\
    function dcsCommon.getGroupTypeString(group) -- convert into comma separated types \\\
        if not group then \\\
            trigger.action.outText(\\\"+++cmn getGroupTypeString: nil group\\\", 30)\\\
            return \\\"\\\" \\\
        end\\\
        if not dcsCommon.isGroupAlive(group) then \\\
            trigger.action.outText(\\\"+++cmn getGroupTypeString: dead group\\\", 30)\\\
            return \\\"\\\" \\\
        end \\\
        local theTypes = \\\"\\\"\\\
        local liveUnits = dcsCommon.getLiveGroupUnits(group)\\\
        for i=1, #liveUnits do \\\
            if i > 1 then theTypes = theTypes .. \\\",\\\" end\\\
            theTypes = theTypes .. liveUnits[i]:getTypeName()\\\
        end\\\
        return theTypes\\\
    end\\\
\\\
    function dcsCommon.getGroupTypes(group) \\\
        if not group then \\\
            trigger.action.outText(\\\"+++cmn getGroupTypes: nil group\\\", 30)\\\
            return {}\\\
        end\\\
        if not dcsCommon.isGroupAlive(group) then \\\
            trigger.action.outText(\\\"+++cmn getGroupTypes: dead group\\\", 30)\\\
            return {}\\\
        end \\\
        local liveUnits = dcsCommon.getLiveGroupUnits(group)\\\
        local unitTypes = {}\\\
        for i=1, #liveUnits do \\\
            table.insert(unitTypes, liveUnits[i]:getTypeName())\\\
        end\\\
        return unitTypes\\\
    end\\\
\\\
    function dcsCommon.getEnemyCoalitionFor(aCoalition)\\\
        if aCoalition == 1 then return 2 end\\\
        if aCoalition == 2 then return 1 end\\\
        if type(aCoalition) == \\\"string\\\" then \\\
            aCoalition = aCoalition:lower()\\\
            if aCoalition == \\\"red\\\" then return 2 end\\\
            if aCoalition == \\\"blue\\\" then return 1 end\\\
        end\\\
        return nil\\\
    end\\\
\\\
    function dcsCommon.getACountryForCoalition(aCoalition)\\\
        -- scan the table of countries and get the first country that is part of aCoalition\\\
        -- this is useful if you want to create troops for a coalition but don't know the\\\
        -- coalition's countries \\\
        -- we start with id=0 (Russia), go to id=85 (Slovenia), but skip id = 14\\\
        local i = 0\\\
        while i < 86 do \\\
            if i ~= 14 then \\\
                if (coalition.getCountryCoalition(i) == aCoalition) then return i end\\\
            end\\\
            i = i + 1\\\
        end\\\
        \\\
        return nil\\\
    end\\\
--\\\
--\\\
-- C A L L B A C K   H A N D L E R \\\
--\\\
--\\\
\\\
    -- installing callbacks\\\
    -- based on mist, with optional additional hooks for pre- and post-\\\
    -- processing of the event\\\
    -- when filtering occurs in pre, an alternative 'rejected' handler can be called \\\
    function dcsCommon.addEventHandler(f, pre, post, rejected) -- returns ID \\\
        local handler = {} -- build a wrapper and connect the onEvent\\\
        --dcsCommon.cbID = dcsCommon.cbID + 1 -- increment unique count\\\
        handler.id = dcsCommon.uuid(\\\"eventHandler\\\")\\\
        handler.f = f -- the callback itself\\\
        if (rejected) then handler.rejected = rejected end\\\
        -- now set up pre- and post-processors. defaults are set in place\\\
        -- so pre and post are optional. If pre returns false, the callback will\\\
        -- not be invoked\\\
        if (pre) then handler.pre = pre else handler.pre = dcsCommon.preCall end\\\
        if (post) then handler.post = post else handler.post = dcsCommon.postCall end\\\
        function handler:onEvent(event)\\\
            if not self.pre(event) then \\\
                if dcsCommon.verbose then\\\
--                    trigger.action.outText(\\\"event \\\" .. event.id .. \\\" discarded by pre-processor\\\", 10)\\\
                end\\\
                if (self.rejected) then self.rejected(event) end \\\
                return\\\
            end\\\
            self.f(event) -- call the handler\\\
            self.post(event) -- do post-processing\\\
        end\\\
        world.addEventHandler(handler)\\\
        return handler.id\\\
    end\\\
\\\
    function dcsCommon.preCall(e)\\\
        -- we can filter here\\\
        -- if we return false, the call is abortet\\\
        if dcsCommon.verbose then\\\
            trigger.action.outText(\\\"event \\\" .. e.id .. \\\" received: PRE-PROCESSING\\\", 10)\\\
        end\\\
        return true;\\\
    end;\\\
\\\
    function dcsCommon.postCall(e)\\\
        -- we do pos proccing here \\\
        if dcsCommon.verbose then\\\
            trigger.action.outText(\\\"event \\\" .. e.id .. \\\" received: post proc\\\", 10)\\\
        end\\\
    end\\\
    \\\
    -- highly specific eventhandler for one event only\\\
    -- based on above, with direct filtering built in; skips pre\\\
    -- but does post\\\
    function dcsCommon.addEventHandlerForEventTypes(f, evTypes, post, rejected) -- returns ID \\\
        local handler = {} -- build a wrapper and connect the onEvent\\\
        dcsCommon.cbID = dcsCommon.cbID + 1 -- increment unique count\\\
        handler.id = dcsCommon.cbID\\\
        handler.what = evTypes\\\
        if (rejected) then handler.rejected = rejected end \\\
        \\\
        handler.f = f -- set the callback itself\\\
        -- now set up post-processor. pre is hard-coded to match evType\\\
        -- post is optional. If event.id is not in evTypes, the callback will\\\
        -- not be invoked\\\
        if (post) then handler.post = post else handler.post = dcsCommon.postCall end\\\
        function handler:onEvent(event)\\\
            hasMatch = false;\\\
            for key, evType in pairs(self.what) do\\\
                if evType == event.id then\\\
                    hasMatch = true;\\\
                    break;\\\
                end;\\\
            end;\\\
            if not hasMatch then \\\
                if dcsCommon.verbose then\\\
                    trigger.action.outText(\\\"event \\\" .. e.id .. \\\" discarded - not in whitelist evTypes\\\", 10)\\\
                end\\\
                if (self.rejected) then self.rejected(event) end \\\
                return;\\\
            end;\\\
            \\\
            self.f(event) -- call the actual handler as passed to us\\\
            self.post(event) -- do post-processing \\\
        end\\\
        world.addEventHandler(handler) -- add to event handlers\\\
        return handler.id\\\
    end\\\
    \\\
    \\\
    \\\
    -- remove event handler / callback, identical to Mist \\\
    -- note we don't call world.removeEventHandler, but rather directly \\\
    -- access world.eventHandlers directly and remove kvp directly.\\\
    function dcsCommon.removeEventHandler(id)\\\
        for key, handler in pairs(world.eventHandlers) do\\\
            if handler.id and handler.id == id then\\\
                world.eventHandlers[key] = nil\\\
                return true\\\
            end\\\
        end\\\
        return false\\\
    end\\\
\\\
--\\\
--\\\
-- C L O N I N G \\\
--\\\
--\\\
    -- topClone is a shallow clone of orig, only top level is iterated,\\\
    -- all values are ref-copied\\\
    function dcsCommon.topClone(orig)\\\
        local orig_type = type(orig)\\\
        local copy\\\
        if orig_type == 'table' then\\\
            copy = {}\\\
            for orig_key, orig_value in pairs(orig) do\\\
                copy[orig_key] = orig_value\\\
            end\\\
        else -- number, string, boolean, etc\\\
            copy = orig\\\
        end\\\
        return copy\\\
    end\\\
\\\
    -- clone is a recursive clone which will also clone\\\
    -- deeper levels, as used in units \\\
    function dcsCommon.clone(orig)\\\
        local orig_type = type(orig)\\\
        local copy\\\
        if orig_type == 'table' then\\\
            copy = {}\\\
            for orig_key, orig_value in next, orig, nil do\\\
                copy[dcsCommon.clone(orig_key)] = dcsCommon.clone(orig_value)\\\
            end\\\
            setmetatable(copy, dcsCommon.clone(getmetatable(orig)))\\\
        else -- number, string, boolean, etc\\\
            copy = orig\\\
        end\\\
        return copy\\\
    end\\\
\\\
    function dcsCommon.copyArray(inArray)\\\
        -- warning: this is a ref copy!\\\
        local theCopy = {}\\\
        for idx, element in pairs(inArray) do \\\
            table.insert(theCopy, element)\\\
        end\\\
        return theCopy \\\
    end\\\
--\\\
-- \\\
-- S P A W N I N G \\\
-- \\\
-- \\\
\\\
    function dcsCommon.createEmptyGroundGroupData (name)\\\
        local theGroup = {} -- empty group\\\
        theGroup.visible = false\\\
        theGroup.taskSelected = true\\\
        -- theGroup.route = {}\\\
        -- theGroup.groupId = id\\\
        theGroup.tasks = {}\\\
        -- theGroup.hidden = false -- hidden on f10?\\\
\\\
        theGroup.units = { } -- insert units here! -- use addUnitToGroupData\\\
\\\
        theGroup.x = 0\\\
        theGroup.y = 0\\\
        theGroup.name = name\\\
        -- theGroup.start_time = 0\\\
        theGroup.task = \\\"Ground Nothing\\\"\\\
        \\\
        return theGroup\\\
    end;\\\
\\\
    function dcsCommon.createEmptyAircraftGroupData (name)\\\
        local theGroup = dcsCommon.createEmptyGroundGroupData(name)--{} -- empty group\\\
\\\
        theGroup.task = \\\"Nothing\\\" -- can be others, like Transport, CAS, etc\\\
        -- returns with empty route\\\
        theGroup.route = dcsCommon.createEmptyAircraftRouteData() -- we can add points here \\\
        return theGroup\\\
    end;\\\
\\\
    function dcsCommon.createAircraftRoutePointData(x, z, altitudeInFeet, knots, altType, action)\\\
        local rp = {}\\\
        rp.x = x\\\
        rp.y = z\\\
        rp.action = \\\"Turning Point\\\"\\\
        rp.type = \\\"Turning Point\\\"\\\
        if action then rp.action = action; rp.type = action end -- warning: may not be correct, need to verify later\\\
        rp.alt = altitudeInFeet * 0.3048\\\
        rp.speed = knots * 0.514444 -- we use \\\
        rp.alt_type = \\\"BARO\\\"\\\
        if (altType) then rp.alt_type = altType end \\\
        return rp\\\
    end\\\
\\\
    function dcsCommon.addRoutePointDataToRouteData(inRoute, x, z, altitudeInFeet, knots, altType, action)\\\
        local p = dcsCommon.createAircraftRoutePointData(x, z, altitudeInFeet, knots, altType, action)\\\
        local thePoints = inRoute.points \\\
        table.insert(thePoints, p)\\\
    end\\\
    \\\
    function dcsCommon.addRoutePointDataToGroupData(group, x, z, altitudeInFeet, knots, altType, action)\\\
        if not group.route then group.route = dcsCommon.createEmptyAircraftRouteData() end\\\
        local theRoute = group.route \\\
        dcsCommon.addRoutePointDataToRouteData(theRoute, x, z, altitudeInFeet, knots, altType, action)\\\
    end\\\
\\\
    function dcsCommon.addRoutePointForGroupData(theGroup, theRP)\\\
        if not theGroup then return end \\\
        if not theGroup.route then theGroup.route = dcsCommon.createEmptyAircraftRouteData() end\\\
        \\\
        local theRoute = theGroup.route \\\
        local thePoints = theRoute.points \\\
        table.insert(thePoints, theRP)\\\
    end\\\
    \\\
    function dcsCommon.createEmptyAircraftRouteData()\\\
        local route = {}\\\
        route.points = {}\\\
        return route\\\
    end\\\
\\\
    function dcsCommon.createTakeOffFromParkingRoutePointData(aerodrome)\\\
        if not aerodrome then return nil end \\\
            \\\
        local rp = {}    \\\
        local freeParkingSlot = dcsCommon.getFirstFreeParkingSlot(aerodrome, 104) -- get big slot first \\\
        if not freeParkingSlot then \\\
            freeParkingSlot = dcsCommon.getFirstFreeParkingSlot(aerodrome) -- try any size\\\
        end\\\
            \\\
        if not freeParkingSlot then \\\
            trigger.action.outText(\\\"civA: no free parking at \\\" .. aerodrome:getName(), 30)\\\
            return nil \\\
        end\\\
            \\\
        local p = freeParkingSlot.vTerminalPos\\\
            \\\
        rp.airdromeId = aerodrome:getID() \\\
        rp.x = p.x\\\
        rp.y = p.z\\\
        rp.alt = p.y \\\
        rp.action = \\\"From Parking Area\\\"\\\
        rp.type = \\\"TakeOffParking\\\"\\\
            \\\
        rp.speed = 100; -- in m/s? If so, that's 360 km/h \\\
        rp.alt_type = \\\"BARO\\\"\\\
        return rp\\\
    end\\\
\\\
    function dcsCommon.createOverheadAirdromeRoutPintData(aerodrome)\\\
        if not aerodrome then return nil end \\\
        local rp = {}            \\\
        local p = aerodrome:getPoint()\\\
        rp.x = p.x\\\
        rp.y = p.z\\\
        rp.alt = p.y + 2000 -- 6000 ft overhead\\\
        rp.action = \\\"Turning Point\\\"\\\
        rp.type = \\\"Turning Point\\\"\\\
            \\\
        rp.speed = 133; -- in m/s? If so, that's 360 km/h \\\
        rp.alt_type = \\\"BARO\\\"\\\
        return rp\\\
    end\\\
    \\\
\\\
    function dcsCommon.createLandAtAerodromeRoutePointData(aerodrome)\\\
        if not aerodrome then return nil end \\\
            \\\
        local rp = {}            \\\
        local p = aerodrome:getPoint()\\\
        rp.airdromeId = aerodrome:getID() \\\
        rp.x = p.x\\\
        rp.y = p.z\\\
        rp.alt = p.y \\\
        rp.action = \\\"Landing\\\"\\\
        rp.type = \\\"Land\\\"\\\
            \\\
        rp.speed = 100; -- in m/s? If so, that's 360 km/h \\\
        rp.alt_type = \\\"BARO\\\"\\\
        return rp\\\
    end\\\
\\\
    \\\
    function dcsCommon.createRPFormationData(findex) -- must be added as \\\"task\\\" to an RP. use 4 for Echelon right\\\
        local task = {}\\\
        task.id = \\\"ComboTask\\\"\\\
        local params = {}\\\
        task.params = params\\\
        local tasks = {}\\\
        params.tasks = tasks\\\
        local t1 = {}\\\
        tasks[1] = t1\\\
        t1.number = 1\\\
        t1.auto = false \\\
        t1.id = \\\"WrappedAction\\\"\\\
        t1.enabled = true\\\
        local t1p = {}\\\
        t1.params = t1p\\\
        local action = {}\\\
        t1p.action = action \\\
        action.id = \\\"Option\\\"\\\
        local ap = {}\\\
        action.params = ap\\\
        ap.variantIndex = 3\\\
        ap.name = 5 -- AI.Option.Air.ID 5 = Formation \\\
        ap.formationIndex = findex -- 4 is echelon_right\\\
        ap.value = 262147\\\
        \\\
        return task \\\
    end\\\
\\\
    function dcsCommon.addTaskDataToRP(theTask, theGroup, rpIndex)\\\
        local theRoute = theGroup.route\\\
        local thePoints = theRoute.points\\\
        local rp = thePoints[rpIndex]\\\
        rp.task = theTask\\\
    end\\\
    \\\
    -- create a minimal payload table that is compatible with creating \\\
    -- a unit. you may need to alter this before adding the unit to\\\
    -- the mission. all params optional \\\
    function dcsCommon.createPayload(fuel, flare, chaff, gun) \\\
        local payload = {}\\\
        payload.pylons = {}\\\
        if not fuel then fuel = 1000 end -- in kg. check against fuelMassMax in type desc\\\
        if not flare then flare = 0 end\\\
        if not chaff then chaff = 0 end\\\
        if not gun then gun = 0 end\\\
        return payload \\\
        \\\
    end\\\
\\\
    function dcsCommon.createCallsign(cs) \\\
        local callsign = {}\\\
        callsign[1] = 1\\\
        callsign[2] = 1\\\
        callsign[3] = 1\\\
        if not cs then cs = \\\"Enfield11\\\" end\\\
        callsign.name = cs\\\
        return callsign\\\
    end\\\
    \\\
\\\
    -- create the data table required to spawn a unit.\\\
    -- unit types are defined in https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB\\\
    function dcsCommon.createGroundUnitData(name, unitType, transportable)\\\
        local theUnit = {}\\\
        unitType = dcsCommon.trim(unitType)\\\
        theUnit.type = unitType -- e.g. \\\"LAV-25\\\",\\\
        if not transportable then transportable = false end -- elaborate, not requried code\\\
        theUnit.transportable = {[\\\"randomTransportable\\\"] = transportable} \\\
        -- theUnit.unitId = id \\\
        theUnit.skill = \\\"Average\\\" -- always average \\\
        theUnit.x = 0 -- make it zero, zero!\\\
        theUnit.y = 0\\\
        theUnit.name = name\\\
        theUnit.playerCanDrive = false\\\
        theUnit.heading = 0\\\
        return theUnit\\\
    end \\\
\\\
    function dcsCommon.createAircraftUnitData(name, unitType, transportable, altitude, speed, heading)\\\
        local theAirUnit = dcsCommon.createGroundUnitData(name, unitType, transportable)\\\
        theAirUnit.alt = 100 -- make it 100m\\\
        if altitude then theAirUnit.alt = altitude end \\\
        theAirUnit.alt_type = \\\"RADIO\\\" -- AGL\\\
        theAirUnit.speed = 77 -- m/s --> 150 knots\\\
        if speed then theAirUnit.speed = speed end \\\
        if heading then theAirUnit.heading = heading end \\\
        theAirUnit.payload = dcsCommon.createPayload()\\\
        theAirUnit.callsign = dcsCommon.createCallsign()\\\
        return theAirUnit\\\
    end\\\
    \\\
\\\
    function dcsCommon.addUnitToGroupData(theUnit, theGroup, dx, dy, heading)\\\
        -- add a unit to a group, and place it at dx, dy of group's position,\\\
        -- taking into account unit's own current location\\\
        if not dx then dx = 0 end\\\
        if not dy then dy = 0 end\\\
        if not heading then heading = 0 end\\\
        theUnit.x = theUnit.x + dx + theGroup.x\\\
        theUnit.y = theUnit.y + dy + theGroup.y \\\
        theUnit.heading = heading\\\
        table.insert(theGroup.units, theUnit)\\\
    end;\\\
\\\
    function dcsCommon.createSingleUnitGroup(name, theUnitType, x, z, heading) \\\
        -- create the container \\\
        local theNewGroup = dcsCommon.createEmptyGroundGroupData(name)\\\
        local aUnit = {}\\\
        aUnit = dcsCommon.createGroundUnitData(name .. \\\"-1\\\", theUnitType, false)\\\
--        trigger.action.outText(\\\"dcsCommon - unit name retval \\\" .. aUnit.name, 30)\\\
        dcsCommon.addUnitToGroupData(aUnit, theNewGroup, x, z, heading)\\\
        return theNewGroup\\\
    end\\\
    \\\
\\\
    function dcsCommon.arrangeGroupDataIntoFormation(theNewGroup, radius, minDist, formation, innerRadius)\\\
        -- formations:\\\
        --    (default) \\\"line\\\" (left to right along x) -- that is Y direction\\\
        --    \\\"line_v\\\" a line top to bottom -- that is X direction\\\
        --    \\\"chevron\\\" - left to right middle too top\\\
        --    \\\"scattered\\\", \\\"random\\\" -- random, innerRadius used to clear area in center\\\
        --       \\\"circle\\\", \\\"circle_forward\\\" -- circle, forward facing\\\
        --    \\\"circle_in\\\" -- circle, inwarf facing\\\
        --    \\\"circle_out\\\" -- circle, outward facing\\\
        --    \\\"grid\\\", \\\"square\\\", \\\"rect\\\" -- optimal rectangle\\\
        --    \\\"2cols\\\", \\\"2deep\\\" -- 2 columns, n deep \\\
        --    \\\"2wide\\\" -- 2 columns wide, 2 deep \\\
\\\
        local num = #theNewGroup.units \\\
        \\\
        -- now do the formation stuff\\\
        -- make sure that they keep minimum  distance \\\
--        trigger.action.outText(\\\"dcsCommon - processing formation \\\" .. formation .. \\\" with radius = \\\" .. radius, 30)\\\
        if formation == \\\"LINE_V\\\" then \\\
            -- top to bottom in zone (heding 0). -- will run through x-coordinate \\\
            -- use entire radius top to bottom \\\
            local currX = -radius\\\
            local increment = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\\\
            for i=1, num do\\\
            \\\
                local u = theNewGroup.units[i]\\\
--                trigger.action.outText(\\\"formation unit \\\" .. u.name .. \\\" currX = \\\" .. currX, 30)\\\
                u.x = currX\\\
                currX = currX + increment\\\
            end\\\
        \\\
        elseif formation == \\\"LINE\\\" then \\\
            -- left to right in zone. runs through Y\\\
            -- left and right are y because at heading 0, forward is x (not y as expected)\\\
            -- if only one, place in middle of circle and be done \\\
            if num == 1 then \\\
                -- nothing. just stay in the middle \\\
            else \\\
                local currY = -radius\\\
                local increment = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\\\
                for i=1, num do\\\
                    local u = theNewGroup.units[i]\\\
--                    trigger.action.outText(\\\"formation unit \\\" .. u.name .. \\\" currX = \\\" .. currY, 30)\\\
                    u.y = currY\\\
                    currY = currY + increment\\\
                end    \\\
            end \\\
            \\\
        elseif formation == \\\"CHEVRON\\\" then \\\
            -- left to right in zone. runs through Y\\\
            -- left and right are y because at heading 0, forward is x (not y as expected)\\\
            local currY = -radius\\\
            local currX = 0\\\
            local incrementY = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\\\
            local incrementX = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\\\
            for i=1, num do\\\
                local u = theNewGroup.units[i]\\\
--                trigger.action.outText(\\\"formation unit \\\" .. u.name .. \\\" currX = \\\" .. currX .. \\\" currY = \\\" .. currY, 30)\\\
                u.x = currX\\\
                u.y = currY\\\
                -- calc coords for NEXT iteration\\\
                currY = currY + incrementY -- march left to right\\\
                if i < num / 2 then -- march up\\\
                    currX = currX + incrementX \\\
                elseif i == num / 2 then -- even number, keep height\\\
                    currX = currX + 0 \\\
                else \\\
                    currX = currX - incrementX -- march down \\\
                end \\\
                -- note: when unit number even, the wedge is sloped. may need an odd/even test for better looks\\\
            end    \\\
\\\
        elseif formation == \\\"SCATTERED\\\" or formation == \\\"RANDOM\\\" then \\\
            -- use randomPointInCircle and tehn iterate over all vehicles for mindelta\\\
            processedUnits = {}\\\
            for i=1, num do\\\
                local emergencyBreak = 1 -- prevent endless loop\\\
                local lowDist = 10000\\\
                local uPoint = {}\\\
                local thePoint = {}\\\
                repeat     -- get random point intil mindistance to all is kept or emergencybreak\\\
                    for idx, rUnit in pairs(processedUnits) do -- get min dist to all positioned units\\\
                        thePoint = dcsCommon.randomPointInCircle(radius, innerRadius) -- returns x, 0, z\\\
                        uPoint.x = rUnit.x\\\
                        uPoint.y = 0\\\
                        uPoint.z = rUnit.y \\\
                        local dist = dcsCommon.dist(thePoint, uPoint) -- measure distance to unit\\\
                        if (dist < lowDist) then lowDist = dist end\\\
                    end\\\
                    emergencyBreak = emergencyBreak + 1\\\
                until (emergencyBreak > 20) or (lowDist > minDist)\\\
                -- we have random x, y \\\
                local u = theNewGroup.units[i] -- get unit to position\\\
                u.x = thePoint.x\\\
                u.y = thePoint.z -- z --> y mapping! \\\
                -- now add the unit to the 'processed' set \\\
                table.insert(processedUnits, u)\\\
            end    \\\
\\\
        elseif dcsCommon.stringStartsWith(formation, \\\"CIRCLE\\\") then\\\
            -- units are arranged on perimeter of circle defined by radius \\\
--            trigger.action.outText(\\\"formation circle detected\\\", 30)\\\
            local currAngle = 0\\\
            local angleInc = 2 * 3.14157 / num -- increase per spoke \\\
            for i=1, num do\\\
                local u = theNewGroup.units[i] -- get unit \\\
                u.x = radius * math.cos(currAngle)\\\
                u.y = radius * math.sin(currAngle)\\\
                \\\
                -- now baldower out heading \\\
                -- circle, circle_forward no modifier of heading\\\
                if dcsCommon.stringStartsWith(formation, \\\"CIRCLE_IN\\\") then \\\
                    -- make the heading inward faceing - that's angle + pi\\\
                    u.heading = u.heading + currAngle + 3.14157\\\
                elseif dcsCommon.stringStartsWith(formation, \\\"CIRCLE_OUT\\\") then \\\
                    u.heading = u.heading + currAngle + 0\\\
                end\\\
\\\
                currAngle = currAngle + angleInc\\\
            end\\\
        elseif formation == \\\"GRID\\\" or formation == \\\"SQUARE\\\" or formation == \\\"RECT\\\" then \\\
            if num < 2 then return end \\\
            -- arrange units in an w x h grid\\\
            -- e-g- 12 units = 4 x 3. \\\
            -- calculate w \\\
            local w = math.floor(num^(0.5) + 0.5)\\\
            dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\\\
            --[[--\\\
            local h = math.floor(num / w)\\\
            --trigger.action.outText(\\\"AdcsC: num=\\\" .. num .. \\\" w=\\\" .. w .. \\\"h=\\\" .. h .. \\\" -- num%w=\\\" .. num%w, 30)\\\
            if (num % w) > 0 then \\\
                h = h + 1\\\
            end\\\
            \\\
            --trigger.action.outText(\\\"BdcsC: num=\\\" .. num .. \\\" w=\\\" .. w .. \\\"h=\\\" .. h, 30)\\\
            \\\
            -- now w * h always >= num and num items fir in that grid\\\
            -- w is width, h is height, of course :) \\\
            -- now calculat xInc and yInc\\\
            local i = 1\\\
            local xInc = 0 \\\
            if w > 1 then xInc = 2 * radius / (w-1) end\\\
            local yInc = 0\\\
            if h > 1 then yInc = 2 * radius / (h-1) end \\\
            local currY = radius \\\
            if h < 2 then currY = 0 end -- special:_ place in Y middle if only one row)\\\
            while h > 0 do \\\
                local currX = radius \\\
                local wCnt = w \\\
                while wCnt > 0 and (i <= num) do \\\
                    local u = theNewGroup.units[i] -- get unit \\\
                    u.x = currX\\\
                    u.y = currY\\\
                    currX = currX - xInc\\\
                    wCnt = wCnt - 1\\\
                    i = i + 1\\\
                end\\\
                currY = currY - yInc \\\
                h = h - 1\\\
            end\\\
            --]]--\\\
        elseif formation == \\\"2DEEP\\\" or formation == \\\"2COLS\\\" then\\\
            if num < 2 then return end \\\
            -- arrange units in an 2 x h grid\\\
            local w = 2\\\
            dcsCommon.arrangeGroupInNColumnsDeep(theNewGroup, w, radius)\\\
\\\
        elseif formation == \\\"2WIDE\\\" then\\\
            if num < 2 then return end \\\
            -- arrange units in an 2 x h grid\\\
            local w = 2\\\
            dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\\\
        else \\\
            trigger.action.outText(\\\"dcsCommon - unknown formation: \\\" .. formation, 30)\\\
        end\\\
    \\\
    end\\\
    \\\
    function dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\\\
        local num = #theNewGroup.units\\\
        local h = math.floor(num / w)\\\
        if (num % w) > 0 then \\\
            h = h + 1\\\
        end\\\
        local i = 1\\\
        local xInc = 0 \\\
        if w > 1 then xInc = 2 * radius / (w-1) end\\\
        local yInc = 0\\\
        if h > 1 then yInc = 2 * radius / (h-1) end \\\
        local currY = radius \\\
        if h < 2 then currY = 0 end -- special:_ place in Y middle if only one row)\\\
        while h > 0 do \\\
            local currX = radius \\\
            local wCnt = w \\\
            while wCnt > 0 and (i <= num) do \\\
                local u = theNewGroup.units[i] -- get unit \\\
                u.x = currX\\\
                u.y = currY\\\
                currX = currX - xInc\\\
                wCnt = wCnt - 1\\\
                i = i + 1\\\
            end\\\
            currY = currY - yInc \\\
            h = h - 1\\\
        end\\\
    end\\\
    \\\
    function dcsCommon.arrangeGroupInNColumnsDeep(theNewGroup, w, radius)\\\
        local num = #theNewGroup.units\\\
        local h = math.floor(num / w)\\\
        if (num % w) > 0 then \\\
            h = h + 1\\\
        end\\\
        local i = 1\\\
        local yInc = 0 \\\
        if w > 1 then yInc = 2 * radius / (w-1) end\\\
        local xInc = 0\\\
        if h > 1 then xInc = 2 * radius / (h-1) end \\\
        local currX = radius \\\
        if h < 2 then currX = 0 end -- special:_ place in Y middle if only one row)\\\
        while h > 0 do \\\
            local currY = radius \\\
            local wCnt = w \\\
            while wCnt > 0 and (i <= num) do \\\
                local u = theNewGroup.units[i] -- get unit \\\
                u.x = currX\\\
                u.y = currY\\\
                currY = currY - yInc\\\
                wCnt = wCnt - 1\\\
                i = i + 1\\\
            end\\\
            currX = currX - xInc \\\
            h = h - 1\\\
        end\\\
    end\\\
    \\\
    \\\
    function dcsCommon.createGroundGroupWithUnits(name, theUnitTypes, radius, minDist, formation, innerRadius)\\\
        if not minDist then mindist = 4 end -- meters\\\
        if not formation then formation = \\\"line\\\" end \\\
        if not radius then radius = 30 end -- meters \\\
        if not innerRadius then innerRadius = 0 end\\\
        formation = formation:upper()\\\
        -- theUnitTypes can be either a single string or a table of strings\\\
        -- see here for TypeName https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB\\\
        -- formation defines how the units are going to be arranged in the\\\
        -- formation specified. \\\
        -- formations:\\\
        --    (default) \\\"line\\\" (left to right along x) -- that is Y direction\\\
        --    \\\"line_V\\\" a line top to bottom -- that is X direction\\\
        --    \\\"chevron\\\" - left to right middle too top\\\
        --    \\\"scattered\\\", \\\"random\\\" -- random, innerRadius used to clear area in center\\\
        --       \\\"circle\\\", \\\"circle_forward\\\" -- circle, forward facing\\\
        --    \\\"circle_in\\\" -- circle, inwarf facing\\\
        --    \\\"circle_out\\\" -- circle, outward facing\\\
\\\
        -- first, we create a group\\\
        local theNewGroup = dcsCommon.createEmptyGroundGroupData(name)\\\
        \\\
        -- now add a single unit or multiple units\\\
        if type(theUnitTypes) ~= \\\"table\\\" then \\\
--            trigger.action.outText(\\\"dcsCommon - i am here\\\", 30)\\\
--            trigger.action.outText(\\\"dcsCommon - name \\\" .. name, 30)\\\
--            trigger.action.outText(\\\"dcsCommon - unit type \\\" .. theUnitTypes, 30)\\\
            \\\
            local aUnit = {}\\\
            aUnit = dcsCommon.createGroundUnitData(name .. \\\"-1\\\", theUnitTypes, false)\\\
--            trigger.action.outText(\\\"dcsCommon - unit name retval \\\" .. aUnit.name, 30)\\\
            dcsCommon.addUnitToGroupData(aUnit, theNewGroup, 0, 0) -- create with data at location (0,0)\\\
            return theNewGroup\\\
        end \\\
\\\
        -- if we get here, theUnitTypes is a table\\\
        -- now loop and create a unit for each table\\\
        local num = 1\\\
        for key, theType in pairs(theUnitTypes) do \\\
            -- trigger.action.outText(\\\"+++dcsC: creating unit \\\" .. name .. \\\"-\\\" .. num .. \\\": \\\" .. theType, 30)\\\
            local aUnit = dcsCommon.createGroundUnitData(name .. \\\"-\\\"..num, theType, false)\\\
            dcsCommon.addUnitToGroupData(aUnit, theNewGroup, 0, 0)\\\
            num = num + 1\\\
        end\\\
        \\\
        dcsCommon.arrangeGroupDataIntoFormation(theNewGroup, radius, minDist, formation, innerRadius)\\\
        return theNewGroup\\\
\\\
    \\\
    end\\\
\\\
-- create a new group, based on group in mission. Groups coords are 0,0 for group and all\\\
-- x,y and heading\\\
    function dcsCommon.createGroupDataFromLiveGroup(name, newName) \\\
        if not newName then newName = dcsCommon.uuid(\\\"uniqName\\\") end\\\
        -- get access to the group\\\
        local liveGroup = Group.getByName(name)\\\
        if not liveGroup then return nil end\\\
        -- get the categorty\\\
        local cat = liveGroup:getCategory()\\\
        local theNewGroup = {}\\\
        \\\
        -- create a new empty group at (0,0) \\\
        if cat == Group.Category.AIRPLANE or cat == Group.Category.HELICOPTER then \\\
            theNewGroup = dcsCommon.createEmptyAircraftGroupData(newName)\\\
        elseif cat == Group.Category.GROUND then\\\
            theNewGroup = dcsCommon.createEmptyGroudGroupData(newName)\\\
        else \\\
            trigger.action.outText(\\\"dcsCommon - unknown category: \\\" .. cat, 30)\\\
            return nil\\\
        end\\\
        \\\
\\\
        -- now get all units from live group and create data units\\\
        -- note that unit data for group has x=0, y=0\\\
        liveUnits = liveGroup:getUnits()\\\
        \\\
        for index, theUnit in pairs(liveUnits) do \\\
            -- for each unit we get the desc \\\
            local desc = theUnit:getDesc() -- of interest is only typename \\\
            local newUnit = dcsCommon.createGroundUnitData(dcsCommon.uuid(newName),\\\
                                                           desc.typeName,\\\
                                                           false)\\\
            -- we now basically have a ground unit at (0,0) \\\
            -- add mandatory fields by type\\\
            if cat == Group.Category.AIRPLANE or cat == Group.Category.HELICOPTER then \\\
                newUnit.alt = 100 -- make it 100m\\\
                newUnit.alt_type = \\\"RADIO\\\" -- AGL\\\
                newUnit.speed = 77 -- m/s --> 150 knots\\\
                newUnit.payload = dcsCommon.createPayload() -- empty payload\\\
                newUnit.callsign = dcsCommon.createCallsign() -- 'enfield11'\\\
                \\\
            elseif cat == Group.Category.GROUND then\\\
                -- we got all we need\\\
            else \\\
                -- trigger.action.outText(\\\"dcsCommon - unknown category: \\\" .. cat, 30)\\\
                -- return nil\\\
                -- we also got all we need\\\
            end            \\\
            \\\
        end\\\
    \\\
    end;\\\
    \\\
\\\
    function dcsCommon.rotatePointAroundOrigin(inX, inY, angle) -- angle in degrees\\\
        local degrees =  3.14152 / 180 -- ok, it's actually radiants. \\\
        angle = angle * degrees -- turns into rads\\\
        local c = math.cos(angle)\\\
        local s = math.sin(angle)\\\
        local px\\\
        local py \\\
        px = inX * c - inY * s\\\
        py = inX * s + inY * c\\\
        return px, py        \\\
    end\\\
\\\
    function dcsCommon.rotateUnitData(theUnit, degrees, cx, cz)\\\
        if not cx then cx = 0 end\\\
        if not cz then cz = 0 end\\\
        local cy = cz \\\
        --trigger.action.outText(\\\"+++dcsC:rotGrp cy,cy = \\\"..cx .. \\\",\\\" .. cy, 30)\\\
        \\\
        local rads = degrees *  3.14152 / 180\\\
        do\\\
            theUnit.x = theUnit.x - cx -- MOVE TO ORIGIN OF ROTATION\\\
            theUnit.y = theUnit.y - cy                 \\\
            theUnit.x, theUnit.y = dcsCommon.rotatePointAroundOrigin(theUnit.x, theUnit.y, degrees)\\\
            theUnit.x = theUnit.x + cx -- MOVE BACK \\\
            theUnit.y = theUnit.y + cy                 \\\
\\\
            -- may also want to increase heading by degreess\\\
            theUnit.heading = theUnit.heading + rads \\\
        end\\\
    end\\\
    \\\
\\\
    function dcsCommon.rotateGroupData(theGroup, degrees, cx, cz)\\\
        if not cx then cx = 0 end\\\
        if not cz then cz = 0 end\\\
        local cy = cz \\\
        --trigger.action.outText(\\\"+++dcsC:rotGrp cy,cy = \\\"..cx .. \\\",\\\" .. cy, 30)\\\
        \\\
        local rads = degrees *  3.14152 / 180\\\
        -- turns all units in group around the group's center by degrees.\\\
        -- may also need to turn individual units by same amount\\\
        for i, theUnit in pairs (theGroup.units) do\\\
            theUnit.x = theUnit.x - cx -- MOVE TO ORIGIN OF ROTATION\\\
            theUnit.y = theUnit.y - cy                 \\\
            theUnit.x, theUnit.y = dcsCommon.rotatePointAroundOrigin(theUnit.x, theUnit.y, degrees)\\\
            theUnit.x = theUnit.x + cx -- MOVE BACK \\\
            theUnit.y = theUnit.y + cy                 \\\
\\\
            -- may also want to increase heading by degreess\\\
            theUnit.heading = theUnit.heading + rads \\\
        end\\\
    end\\\
\\\
    function dcsCommon.offsetGroupData(theGroup, dx, dy)\\\
        -- add dx and dy to group's and all unit's coords\\\
        for i, theUnit in pairs (theGroup.units) do \\\
            theUnit.x = theUnit.x + dx\\\
            theUnit.y = theUnit.y + dy\\\
        end\\\
        \\\
        theGroup.x = theGroup.x + dx\\\
        theGroup.y = theGroup.y + dy \\\
    end\\\
    \\\
    function dcsCommon.moveGroupDataTo(theGroup, xAbs, yAbs)\\\
        local dx = xAbs-theGroup.x\\\
        local dy = yAbs-theGroup.y\\\
        dcsCommon.offsetGroupData(theGroup, dx, dy)\\\
    end\\\
    \\\
    -- static objectr shapes and types are defined here\\\
    -- https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB/Statics\\\
    \\\
    function dcsCommon.createStaticObjectData(name, objType, heading, dead, cargo, mass)\\\
        local staticObj = {}\\\
        if not heading then heading = 0 end \\\
        if not dead then dead = false end \\\
        if not cargo then cargo = false end \\\
        objType = dcsCommon.trim(objType) \\\
        \\\
        staticObj.heading = heading\\\
        -- staticObj.groupId = 0\\\
        -- staticObj.shape_name = shape -- e.g. H-Windsock_RW\\\
        staticObj.type = objType  -- e.g. Windsock\\\
        -- [\\\"unitId\\\"] = 3,\\\
        staticObj.rate = 1 -- score when killed\\\
        staticObj.name = name\\\
        -- staticObj.category = \\\"Fortifications\\\",\\\
        staticObj.y = 0\\\
        staticObj.x = 0\\\
        staticObj.dead = dead\\\
        staticObj.canCargo = cargo -- to cargo\\\
        if cargo then \\\
            if not mass then mass = 1234 end \\\
            staticObj.mass = mass -- to cargo\\\
        end\\\
        return staticObj\\\
    end\\\
    \\\
    function dcsCommon.createStaticObjectDataAt(loc, name, objType, heading, dead)\\\
        local theData = dcsCommon.createStaticObjectData(name, objType, heading, dead)\\\
        theData.x = loc.x\\\
        theData.y = loc.z \\\
        return theData\\\
    end\\\
    \\\
    function dcsCommon.createStaticObjectForCoalitionAtLocation(theCoalition, loc, name, objType, heading, dead) \\\
        if not heading then heading = math.random(360) * 3.1415 / 180 end\\\
        local theData = dcsCommon.createStaticObjectDataAt(loc, name, objType, heading, dead)\\\
        local theStatic = coalition.addStaticObject(theCoalition, theData)\\\
        return theStatic\\\
    end\\\
    \\\
    function dcsCommon.createStaticObjectForCoalitionInRandomRing(theCoalition, objType, x, z, innerRadius, outerRadius, heading, alive) \\\
        if not outerRadius then outerRadius = innerRadius end\\\
        if not heading then heading = math.random(360) * 3.1415 / 180 end\\\
        local dead = not alive\\\
        local p = dcsCommon.randomPointInCircle(outerRadius, innerRadius, x, z)\\\
        local theData = dcsCommon.createStaticObjectData(dcsCommon.uuid(\\\"static\\\"), objType, heading, dead)\\\
        theData.x = p.x\\\
        theData.y = p.z \\\
        \\\
        local theStatic = coalition.addStaticObject(theCoalition, theData)\\\
        return theStatic\\\
    end\\\
    \\\
    \\\
    \\\
    function dcsCommon.linkStaticDataToUnit(theStatic, theUnit, dx, dy, heading)\\\
        if not theStatic then \\\
            trigger.action.OutText(\\\"+++dcsC: NIL theStatic on linkStatic!\\\", 30)\\\
            return \\\
        end\\\
        -- NOTE: we may get current heading and subtract/add \\\
        -- to original heading \\\
        local rotX, rotY = dcsCommon.rotatePointAroundOrigin(dx, dy, -heading)\\\
        \\\
        if not theUnit then return end\\\
        if not theUnit:isExist() then return end \\\
        theStatic.linkOffset = true \\\
        theStatic.linkUnit = theUnit:getID()\\\
        local unitPos = theUnit:getPoint()\\\
        local offsets = {}\\\
        offsets.x = rotX  \\\
        offsets.y = rotY \\\
        offsets.angle = 0\\\
        theStatic.offsets = offsets\\\
    end\\\
    \\\
    function dcsCommon.offsetStaticData(theStatic, dx, dy)\\\
        theStatic.x = theStatic.x + dx\\\
        theStatic.y = theStatic.y + dy\\\
        -- now check if thre is a route (for linked objects)\\\
        if theStatic.route then \\\
            -- access points[1] x and y and copy from main\\\
            theStatic.route.points[1].x = theStatic.x\\\
            theStatic.route.points[1].y = theStatic.y\\\
        end\\\
    end\\\
    \\\
    function dcsCommon.moveStaticDataTo(theStatic, x, y)\\\
        theStatic.x = x\\\
        theStatic.y = y\\\
        -- now check if thre is a route (for linked objects)\\\
        if theStatic.route then \\\
            -- access points[1] x and y and copy from main\\\
            theStatic.route.points[1].x = theStatic.x\\\
            theStatic.route.points[1].y = theStatic.y\\\
        end\\\
\\\
    end\\\
    \\\
--\\\
--\\\
-- M I S C   M E T H O D S \\\
--\\\
--\\\
\\\
    function dcsCommon.arrayContainsString(theArray, theString) \\\
        if not theArray then return false end\\\
        if not theString then return false end\\\
        for i = 1, #theArray do \\\
            if theArray[i] == theString then return true end \\\
        end\\\
        return false \\\
    end\\\
    \\\
    function dcsCommon.splitString(inputstr, sep) \\\
        if sep == nil then\\\
            sep = \\\"%s\\\"\\\
        end\\\
        if inputstr == nil then \\\
            inputstr = \\\"\\\"\\\
        end\\\
        \\\
        local t={}\\\
        for str in string.gmatch(inputstr, \\\"([^\\\"..sep..\\\"]+)\\\") do\\\
            table.insert(t, str)\\\
        end\\\
        return t\\\
    \\\
    end\\\
    \\\
    function dcsCommon.trimFront(inputstr) \\\
        if not inputstr then return nil end \\\
        local s = inputstr\\\
        while string.len(s) > 1 and string.sub(s, 1, 1) == \\\" \\\" do \\\
            local snew = string.sub(s, 2) -- all except first\\\
            s = snew\\\
        end\\\
        return s\\\
    end\\\
    \\\
    function dcsCommon.trimBack(inputstr)\\\
        if not inputstr then return nil end \\\
        local s = inputstr\\\
        while string.len(s) > 1 and string.sub(s, -1) == \\\" \\\" do \\\
            local snew = string.sub(s, 1, -2) -- all except last\\\
            s = snew\\\
        end\\\
        return s\\\
    end\\\
    \\\
    function dcsCommon.trim(inputstr) \\\
        local t1 = dcsCommon.trimFront(inputstr)\\\
        local t2 = dcsCommon.trimBack(t1)\\\
        return t2\\\
    end\\\
    \\\
    function dcsCommon.trimArray(theArray)\\\
        local trimmedArray = {}\\\
        for idx, element in pairs(theArray) do \\\
            local tel = dcsCommon.trim(element)\\\
            table.insert(trimmedArray, tel)\\\
        end\\\
        return trimmedArray\\\
    end\\\
    \\\
    function dcsCommon.stringIsPositiveNumber(theString)\\\
        -- only full integer positive numbers supported \\\
        if not theString then return false end \\\
--        if theString == \\\"\\\" then return false end \\\
        for i = 1, #theString do \\\
            local c = theString:sub(i,i)\\\
            if c < \\\"0\\\" or c > \\\"9\\\" then return false end \\\
        end\\\
        return true \\\
    end\\\
    \\\
    function dcsCommon.stringStartsWithDigit(theString)\\\
        if #theString < 1 then return false end \\\
        local c = string.sub(theString, 1, 1) \\\
        return c >= \\\"0\\\" and c <= \\\"9\\\" \\\
    end\\\
    \\\
    function dcsCommon.stringStartsWithLetter(theString)\\\
        if #theString < 1 then return false end \\\
        local c = string.sub(theString, 1, 1)\\\
        if c >= \\\"a\\\" and c <= \\\"z\\\" then return true end  \\\
        if c >= \\\"A\\\" and c <= \\\"Z\\\" then return true end \\\
        return false \\\
    end\\\
    \\\
    function dcsCommon.stringStartsWith(theString, thePrefix)\\\
        return theString:find(thePrefix) == 1\\\
    end\\\
    \\\
    function dcsCommon.removePrefix(theString, thePrefix)\\\
        if not dcsCommon.stringStartsWith(theString, thePrefix) then \\\
            return theString\\\
        end;\\\
        return theString:sub(1 + #thePrefix)\\\
    end\\\
    \\\
    function dcsCommon.stringEndsWith(theString, theEnding)\\\
        return theEnding == \\\"\\\" or theString:sub(-#theEnding) == theEnding\\\
    end\\\
    \\\
    function dcsCommon.removeEnding(theString, theEnding) \\\
        if not dcsCommon.stringEndsWith(theString, theEnding) then \\\
            return theString\\\
        end\\\
        return theString:sub(1, #theString - #theEnding)\\\
    end\\\
    \\\
    function dcsCommon.containsString(inString, what, caseSensitive)\\\
        if (not caseSensitive) then \\\
            inString = string.upper(inString)\\\
            what = string.upper(what)\\\
        end\\\
        if inString == what then return true end -- when entire match \\\
        return string.find(inString, what)\\\
    end\\\
    \\\
    function dcsCommon.bool2Text(theBool) \\\
        if not theBool then theBool = false end \\\
        if theBool then return \\\"true\\\" end \\\
        return \\\"false\\\"\\\
    end\\\
    \\\
    function dcsCommon.bool2YesNo(theBool)\\\
        if not theBool then theBool = false end \\\
        if theBool then return \\\"yes\\\" end \\\
        return \\\"no\\\"\\\
    end\\\
\\\
    function dcsCommon.point2text(p) \\\
        if not p then return \\\"<!NIL!>\\\" end \\\
        local t = \\\"[x=\\\"\\\
        if p.x then t = t .. p.x .. \\\", \\\" else t = t .. \\\"<nil>, \\\" end \\\
        if p.y then t = t .. p.y .. \\\", \\\" else t = t .. \\\"<nil>, \\\" end \\\
        if p.z then t = t .. p.z .. \\\"]\\\" else t = t .. \\\"<nil>]\\\" end \\\
        return t \\\
    end\\\
\\\
    function dcsCommon.string2GroupCat(inString)\\\
\\\
        if not inString then return 2 end -- default ground \\\
        inString = inString:lower()\\\
        inString = dcsCommon.trim(inString)\\\
\\\
        local catNum = tonumber(inString)\\\
        if catNum then \\\
            if catNum < 0 then catNum = 0 end \\\
            if catNum > 4 then catNum = 4 end \\\
            return catNum \\\
        end\\\
    \\\
        catNum = 2 -- ground default \\\
        if dcsCommon.stringStartsWith(inString, \\\"grou\\\") then catNum = 2 end \\\
        if dcsCommon.stringStartsWith(inString, \\\"air\\\") then catNum = 0 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"hel\\\") then catNum = 1 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"shi\\\") then catNum = 3 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"trai\\\") then catNum = 4 end\\\
\\\
        return catNum\\\
    end\\\
\\\
    function dcsCommon.string2ObjectCat(inString)\\\
\\\
        if not inString then return 3 end -- default static \\\
        inString = inString:lower()\\\
        inString = dcsCommon.trim(inString)\\\
\\\
        local catNum = tonumber(inString)\\\
        if catNum then \\\
            if catNum < 0 then catNum = 0 end \\\
            if catNum > 6 then catNum = 6 end \\\
            return catNum \\\
        end\\\
    \\\
        catNum = 3 -- static default \\\
        if dcsCommon.stringStartsWith(inString, \\\"uni\\\") then catNum = 1 end \\\
        if dcsCommon.stringStartsWith(inString, \\\"wea\\\") then catNum = 2 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"bas\\\") then catNum = 4 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"sce\\\") then catNum = 5 end\\\
        if dcsCommon.stringStartsWith(inString, \\\"car\\\") then catNum = 6 end\\\
\\\
        return catNum\\\
    end\\\
\\\
    -- recursively show the contents of a variable\\\
    function dcsCommon.dumpVar(key, value, prefix, inrecursion)\\\
        if not inrecursion then \\\
            -- output a marker to find in the log / screen\\\
            env.info(\\\"*** dcsCommon vardump START\\\")\\\
        end\\\
        if not value then value = \\\"nil\\\" end\\\
        if not prefix then prefix = \\\"\\\" end\\\
        prefix = \\\" \\\" .. prefix\\\
        if type(value) == \\\"table\\\" then \\\
            env.info(prefix .. key .. \\\": [ \\\")\\\
            -- iterate through all kvp\\\
            for k,v in pairs (value) do\\\
                dcsCommon.dumpVar(k, v, prefix, true)\\\
            end\\\
            env.info(prefix .. \\\" ] - end \\\" .. key)\\\
            \\\
        elseif type(value) == \\\"boolean\\\" then \\\
            local b = \\\"false\\\"\\\
            if value then b = \\\"true\\\" end\\\
            env.info(prefix .. key .. \\\": \\\" .. b)\\\
            \\\
        else -- simple var, show contents, ends recursion\\\
            env.info(prefix .. key .. \\\": \\\" .. value)\\\
        end\\\
        \\\
        if not inrecursion then \\\
            -- output a marker to find in the log / screen\\\
            trigger.action.outText(\\\"=== dcsCommon vardump END\\\", 30)\\\
            env.info(\\\"=== dcsCommon vardump END\\\")\\\
        end\\\
    end\\\
    \\\
    function dcsCommon.dumpVar2Str(key, value, prefix, inrecursion)\\\
        if not inrecursion then \\\
            -- output a marker to find in the log / screen\\\
            trigger.action.outText(\\\"*** dcsCommon vardump START\\\",30)\\\
        end\\\
        if not value then value = \\\"nil\\\" end\\\
        if not prefix then prefix = \\\"\\\" end\\\
        prefix = \\\" \\\" .. prefix\\\
        if type(value) == \\\"table\\\" then \\\
            trigger.action.outText(prefix .. key .. \\\": [ \\\", 30)\\\
            -- iterate through all kvp\\\
            for k,v in pairs (value) do\\\
                dcsCommon.dumpVar2Str(k, v, prefix, true)\\\
            end\\\
            trigger.action.outText(prefix .. \\\" ] - end \\\" .. key, 30)\\\
            \\\
        elseif type(value) == \\\"boolean\\\" then \\\
            local b = \\\"false\\\"\\\
            if value then b = \\\"true\\\" end\\\
            trigger.action.outText(prefix .. key .. \\\": \\\" .. b, 30)\\\
            \\\
        else -- simple var, show contents, ends recursion\\\
            trigger.action.outText(prefix .. key .. \\\": \\\" .. value, 30)\\\
        end\\\
        \\\
        if not inrecursion then \\\
            -- output a marker to find in the log / screen\\\
            trigger.action.outText(\\\"=== dcsCommon vardump END\\\", 30)\\\
            --env.info(\\\"=== dcsCommon vardump END\\\")\\\
        end\\\
    end\\\
    \\\
\\\
    \\\
    function dcsCommon.numberUUID()\\\
        dcsCommon.simpleUUID = dcsCommon.simpleUUID + 1\\\
        return dcsCommon.simpleUUID\\\
    end\\\
\\\
    function dcsCommon.uuid(prefix)\\\
        --dcsCommon.uuIdent = dcsCommon.uuIdent + 1\\\
        if not prefix then prefix = dcsCommon.uuidStr end\\\
        return prefix .. \\\"-\\\" .. dcsCommon.numberUUID() -- dcsCommon.uuIdent\\\
    end\\\
    \\\
    function dcsCommon.event2text(id) \\\
        if not id then return \\\"error\\\" end\\\
        if id == 0 then return \\\"invalid\\\" end\\\
        -- translate the event id to text\\\
        local events = {\\\"shot\\\", \\\"hit\\\", \\\"takeoff\\\", \\\"land\\\",\\\
                        \\\"crash\\\", \\\"eject\\\", \\\"refuel\\\", \\\"dead\\\",\\\
                        \\\"pilot dead\\\", \\\"base captured\\\", \\\"mission start\\\", \\\"mission end\\\", -- 12\\\
                        \\\"took control\\\", \\\"refuel stop\\\", \\\"birth\\\", \\\"human failure\\\", \\\
                        \\\"det. failure\\\", \\\"engine start\\\", \\\"engine stop\\\", \\\"player enter unit\\\",\\\
                        \\\"player leave unit\\\", \\\"player comment\\\", \\\"start shoot\\\", \\\"end shoot\\\",\\\
                        \\\"mark add\\\", \\\"mark changed\\\", \\\"makr removed\\\", \\\"kill\\\", \\\
                        \\\"score\\\", \\\"unit lost\\\", \\\"land after eject\\\", \\\"Paratrooper land\\\", \\\
                        \\\"chair discard after eject\\\", \\\"weapon add\\\", \\\"trigger zone\\\", \\\"landing quality mark\\\",\\\
                        \\\"BDA\\\", \\\"max\\\"}\\\
        if id > #events then return \\\"Unknown (ID=\\\" .. id .. \\\")\\\" end\\\
        return events[id]\\\
    end\\\
\\\
    function dcsCommon.smokeColor2Text(smokeColor)\\\
        if (smokeColor == 0) then return \\\"Green\\\" end\\\
        if (smokeColor == 1) then return \\\"Red\\\" end\\\
        if (smokeColor == 2) then return \\\"White\\\" end\\\
        if (smokeColor == 3) then return \\\"Orange\\\" end\\\
        if (smokeColor == 4) then return \\\"Blue\\\" end\\\
        \\\
        return (\\\"unknown: \\\" .. smokeColor)\\\
    end\\\
    \\\
    function dcsCommon.smokeColor2Num(smokeColor)\\\
        if not smokeColor then smokeColor = \\\"green\\\" end \\\
        if type(smokeColor) ~= \\\"string\\\" then return 0 end \\\
        smokeColor = smokeColor:lower()\\\
        if (smokeColor == \\\"green\\\") then return 0 end \\\
        if (smokeColor == \\\"red\\\") then return 1 end \\\
        if (smokeColor == \\\"white\\\") then return 2 end \\\
        if (smokeColor == \\\"orange\\\") then return 3 end \\\
        if (smokeColor == \\\"blue\\\") then return 4 end \\\
        return 0\\\
    end\\\
    \\\
    function dcsCommon.markPointWithSmoke(p, smokeColor)\\\
        local x = p.x \\\
        local z = p.z -- do NOT change the point directly\\\
        -- height-correct\\\
        local y = land.getHeight({x = x, y = z})\\\
        local newPoint= {x = x, y = y + 2, z = z}\\\
        trigger.action.smoke(newPoint, smokeColor)\\\
    end\\\
\\\
-- based on buzzer1977's idea, channel is number, eg in 74X, channel is 74, mode is \\\"X\\\"\\\
    function tacan2freq(channel, mode)    \\\
        if not mode then mode = \\\"X\\\" end \\\
        if not channel then channel = 1 end \\\
        if type(mode) ~= \\\"string\\\" then mode = \\\"X\\\" end \\\
        mode = mode:upper()\\\
        local offset = 1000000 * channel\\\
        if channel < 64 then \\\
            if mode == \\\"Y\\\" then\\\
                return 1087000000 + offset\\\
            end\\\
            return 961000000 + offset -- mode x\\\
        end\\\
    \\\
        if mode == \\\"Y\\\" then\\\
            return 961000000 + offset\\\
        end\\\
        return 1087000000 + offset -- mode x\\\
    end\\\
    \\\
    function dcsCommon.processHMS(msg, delta)\\\
        local rS = math.floor(delta)\\\
        local remainS = tostring(rS)\\\
        local rM = math.floor(delta/60)\\\
        local remainM = tostring(rM)\\\
        local rH = math.floor(delta/3600)\\\
        local remainH = tostring(rH)\\\
        local hmsH = remainH \\\
        if rH < 10 then hmsH = \\\"0\\\" .. hmsH end \\\
        \\\
        local hmsCount = delta - (rH * 3600) -- mins left \\\
        local mins = math.floor (hmsCount / 60)\\\
        local hmsM = tostring(mins)\\\
        if mins < 10 then hmsM = \\\"0\\\" .. hmsM end \\\
        \\\
        hmsCount = hmsCount - (mins * 60) \\\
        local secs = math.floor(hmsCount)\\\
        local hmsS = tostring(secs)\\\
        if secs < 10 then hmsS = \\\"0\\\" .. hmsS end \\\
        \\\
        msg = string.gsub(msg, \\\"<s>\\\", remainS)\\\
        msg = string.gsub(msg, \\\"<m>\\\", remainM)\\\
        msg = string.gsub(msg, \\\"<h>\\\", remainH)\\\
        \\\
        msg = string.gsub(msg, \\\"<:s>\\\", hmsS)\\\
        msg = string.gsub(msg, \\\"<:m>\\\", hmsM)\\\
        msg = string.gsub(msg, \\\"<:h>\\\", hmsH)\\\
        \\\
        return msg \\\
    end\\\
    \\\
--\\\
--\\\
-- V E C T O R   M A T H \\\
--\\\
--\\\
\\\
function dcsCommon.vAdd(a, b) \\\
    local r = {}\\\
    if not a then a = {x = 0, y = 0, z = 0} end\\\
    if not b then b = {x = 0, y = 0, z = 0} end\\\
    r.x = a.x + b.x \\\
    r.y = a.y + b.y \\\
    r.z = a.z + b.z \\\
    return r \\\
end\\\
\\\
function dcsCommon.vSub(a, b) \\\
    local r = {}\\\
    if not a then a = {x = 0, y = 0, z = 0} end\\\
    if not b then b = {x = 0, y = 0, z = 0} end\\\
    r.x = a.x - b.x \\\
    r.y = a.y - b.y \\\
    r.z = a.z - b.z \\\
    return r \\\
end\\\
\\\
function dcsCommon.vMultScalar(a, f) \\\
    local r = {}\\\
    if not a then a = {x = 0, y = 0, z = 0} end\\\
    if not f then f = 0 end\\\
    r.x = a.x * f \\\
    r.y = a.y * f \\\
    r.z = a.z * f \\\
    return r \\\
end\\\
\\\
function dcsCommon.vLerp (a, b, t)\\\
    if not a then a = {x = 0, y = 0, z = 0} end\\\
    if not b then b = {x = 0, y = 0, z = 0} end\\\
    \\\
    local d = dcsCommon.vSub(b, a)\\\
    local dt = dcsCommon.vMultScalar(d, t)\\\
    local r = dcsCommon.vAdd(a, dt)\\\
    return r\\\
end\\\
\\\
function dcsCommon.mag(x, y, z) \\\
    if not x then x = 0 end\\\
    if not y then y = 0 end \\\
    if not z then z = 0 end \\\
    \\\
    return (x * x + y * y + z * z)^0.5\\\
end\\\
\\\
function dcsCommon.vMag(a) \\\
    if not a then return 0 end \\\
    if not a.x then a.x = 0 end \\\
    if not a.y then a.y = 0 end \\\
    if not a.z then a.z = 0 end\\\
    return dcsCommon.mag(a.x, a.y, a.z) \\\
end\\\
\\\
function dcsCommon.magSquare(x, y, z) \\\
    if not x then x = 0 end\\\
    if not y then y = 0 end \\\
    if not z then z = 0 end \\\
    \\\
    return (x * x + y * y + z * z)\\\
end\\\
\\\
function dcsCommon.vNorm(a) \\\
    if not a then return {x = 0, y = 0, z = 0} end \\\
    m = dcsCommon.vMag(a)\\\
    if m <= 0 then return {x = 0, y = 0, z = 0} end \\\
    local r = {}\\\
    r.x = a.x / m \\\
    r.y = a.y / m \\\
    r.z = a.z / m\\\
    return r \\\
end\\\
\\\
function dcsCommon.dot (a, b) \\\
    if not a then a = {} end \\\
    if not a.x then a.x = 0 end \\\
    if not a.y then a.y = 0 end \\\
    if not a.z then a.z = 0 end\\\
    if not b then b = {} end \\\
    if not b.x then b.x = 0 end \\\
    if not b.y then b.y = 0 end \\\
    if not b.z then b.z = 0 end \\\
    \\\
    return a.x * b.x + a.y * b.y + a.z * b.z \\\
end\\\
--\\\
-- UNIT MISC\\\
-- \\\
function dcsCommon.isSceneryObject(theUnit)\\\
    if not theUnit then return false end\\\
    return theUnit.getCoalition == nil -- scenery objects do not return a coalition \\\
end\\\
\\\
function dcsCommon.isTroopCarrier(theUnit)\\\
    -- return true if conf can carry troups\\\
    if not theUnit then return false end \\\
    local uType = theUnit:getTypeName()\\\
    if dcsCommon.arrayContainsString(dcsCommon.troopCarriers, uType) then \\\
        -- may add additional tests before returning true\\\
        return true\\\
    end\\\
    return false\\\
end\\\
\\\
function dcsCommon.getUnitAlt(theUnit)\\\
    if not theUnit then return 0 end\\\
    if not theUnit:isExist() then return 0 end \\\
    local p = theUnit:getPoint()\\\
    return p.y \\\
end\\\
\\\
function dcsCommon.getUnitAGL(theUnit)\\\
    if not theUnit then return 0 end\\\
    if not theUnit:isExist() then return 0 end \\\
    local p = theUnit:getPoint()\\\
    local alt = p.y \\\
    local loc = {x = p.x, y = p.z}\\\
    local landElev = land.getHeight(loc)\\\
    return alt - landElev\\\
end \\\
\\\
function dcsCommon.getUnitSpeed(theUnit)\\\
    if not theUnit then return 0 end\\\
    if not theUnit:isExist() then return 0 end \\\
    local v = theUnit:getVelocity()\\\
    return dcsCommon.mag(v.x, v.y, v.z)\\\
end\\\
\\\
-- closing velocity of u1 and u2, seen from u1\\\
function dcsCommon.getClosingVelocity(u1, u2)\\\
    if not u1 then return 0 end \\\
    if not u2 then return 0 end \\\
    if not u1:isExist() then return 0 end \\\
    if not u2:isExist() then return 0 end \\\
    local v1 = u1:getVelocity()\\\
    local v2 = u2:getVelocity()\\\
    local dV = dcsCommon.vSub(v1,v2)\\\
    local a = u1:getPoint()\\\
    local b = u2:getPoint() \\\
    local aMinusB = dcsCommon.vSub(a,b) -- vector from u2 to u1\\\
    local abMag = dcsCommon.vMag(aMinusB) -- distance u1 to u2 \\\
    if abMag < .0001 then return 0 end \\\
    -- project deltaV onto vector from u2 to u1 \\\
    local vClose = dcsCommon.dot(dV, aMinusB) / abMag \\\
    return vClose \\\
end\\\
\\\
function dcsCommon.getGroupAvgSpeed(theGroup)\\\
    if not theGroup then return 0 end \\\
    if not dcsCommon.isGroupAlive(theGroup) then return 0 end \\\
    local totalSpeed = 0\\\
    local cnt = 0 \\\
    local livingUnits = theGroup:getUnits()\\\
    for idx, theUnit in pairs(livingUnits) do \\\
        cnt = cnt + 1\\\
        totalSpeed = totalSpeed + dcsCommon.getUnitSpeed(theUnit)\\\
    end \\\
    if cnt == 0 then return 0 end \\\
    return totalSpeed / cnt \\\
end\\\
 \\\
function dcsCommon.getGroupMaxSpeed(theGroup)\\\
    if not theGroup then return 0 end \\\
    if not dcsCommon.isGroupAlive(theGroup) then return 0 end \\\
    local maxSpeed = 0\\\
    local livingUnits = theGroup:getUnits()\\\
    for idx, theUnit in pairs(livingUnits) do \\\
        currSpeed = dcsCommon.getUnitSpeed(theUnit)\\\
        if currSpeed > maxSpeed then maxSpeed = currSpeed end \\\
    end \\\
    return maxSpeed\\\
end \\\
\\\
function dcsCommon.getUnitHeading(theUnit)\\\
    if not theUnit then return 0 end \\\
    if not theUnit:isExist() then return 0 end \\\
    local pos = theUnit:getPosition() -- returns three vectors, p is location\\\
\\\
    local heading = math.atan2(pos.x.z, pos.x.x)\\\
    -- make sure positive only, add 360 degrees\\\
    if heading < 0 then\\\
        heading = heading + 2 * math.pi    -- put heading in range of 0 to 2*pi\\\
    end\\\
    return heading \\\
end\\\
\\\
function dcsCommon.getUnitHeadingDegrees(theUnit)\\\
    local heading = dcsCommon.getUnitHeading(theUnit)\\\
    return heading * 57.2958 -- 180 / math.pi \\\
end\\\
\\\
function dcsCommon.unitIsInfantry(theUnit)\\\
    if not theUnit then return false end \\\
    if not theUnit:isExist() then return end\\\
    local theType = theUnit:getTypeName()\\\
    local isInfantry =  \\\
                dcsCommon.containsString(theType, \\\"infantry\\\", false) or \\\
                dcsCommon.containsString(theType, \\\"paratrooper\\\", false) or\\\
                dcsCommon.containsString(theType, \\\"stinger\\\", false) or\\\
                dcsCommon.containsString(theType, \\\"manpad\\\", false) or\\\
                dcsCommon.containsString(theType, \\\"soldier\\\", false) or \\\
                dcsCommon.containsString(theType, \\\"SA-18 Igla\\\", false)\\\
    return isInfantry\\\
end\\\
\\\
function dcsCommon.coalition2county(inCoalition)\\\
    -- simply return UN troops for 0 neutral,\\\
    -- joint red for 1  red\\\
    -- joint blue for 2 blue \\\
    if inCoalition == 1 then return 81 end -- cjtf red\\\
    if inCoalition == 2 then return 80 end -- blue \\\
    if type(inCoalition) == \\\"string\\\" then \\\
            inCoalition = inCoalition:lower()\\\
            if inCoalition == \\\"red\\\" then return 81 end\\\
            if inCoalition == \\\"blue\\\" then return 80 end\\\
    end\\\
        \\\
    trigger.action.outText(\\\"+++dcsC: coalition2county in (\\\" .. inCoalition .. \\\") converts to UN (82)!\\\", 30)\\\
    return 82 -- UN \\\
    \\\
end\\\
\\\
function dcsCommon.latLon2Text(lat, lon)\\\
    -- simplified mist version, thanks Grimes!\\\
    -- find hemisphere\\\
    local latHemi, lonHemi\\\
    if lat > 0 then latHemi = 'N' else latHemi = 'S' end\\\
    if lon > 0 then lonHemi = 'E' else lonHemi = 'W' end\\\
\\\
    -- remove sign since we have hemi\\\
    lat = math.abs(lat)\\\
    lon = math.abs(lon)\\\
\\\
    -- calc deg / mins \\\
    local latDeg = math.floor(lat)\\\
    local latMin = (lat - latDeg) * 60\\\
    local lonDeg = math.floor(lon)\\\
    local lonMin = (lon - lonDeg) * 60\\\
\\\
    local rawLatMin = latMin\\\
    latMin = math.floor(latMin)\\\
    local latSec = (rawLatMin - latMin) * 60\\\
\\\
    local rawLonMin = lonMin\\\
    lonMin = math.floor(lonMin)\\\
    local lonSec = (rawLonMin - lonMin) * 60\\\
\\\
    if latSec >= 60 then\\\
        latSec = latSec - 60\\\
        latMin = latMin + 1\\\
    end\\\
\\\
    if lonSec >= 60 then\\\
        lonSec = lonSec - 60\\\
        lonMin = lonMin + 1\\\
    end\\\
\\\
    local secFrmtStr = '%06.3f'\\\
\\\
    local lat = string.format('%02d', latDeg) .. '°' .. string.format('%02d', latMin) .. \\\"'\\\" .. string.format(secFrmtStr, latSec) .. '\\\"' .. latHemi\\\
    local lon = string.format('%02d', lonDeg) .. '°' .. string.format('%02d', lonMin) .. \\\"'\\\" .. string.format(secFrmtStr, lonSec) .. '\\\"' .. lonHemi\\\
    return lat, lon  \\\
end\\\
\\\
--\\\
--\\\
-- INIT\\\
--\\\
--\\\
    -- init any variables the lib requires internally\\\
    function dcsCommon.init()\\\
        cbID = 0\\\
        --dcsCommon.uuIdent = 0\\\
        if (dcsCommon.verbose) or true then\\\
          trigger.action.outText(\\\"dcsCommon v\\\" .. dcsCommon.version .. \\\" loaded\\\", 10)\\\
        end\\\
    end\\\
\\\
    \\\
-- do init. \\\
dcsCommon.init()\\\
\\\
--[[--\\\
\\\
to do: \\\
- formation 2Column\\\
- formation 3Column\\\
\\\
-]]--\\\
\");a_do_script(\"-- cf/x zone management module\\\
-- reads dcs zones and makes them accessible and mutable \\\
-- by scripting.\\\
--\\\
-- Copyright (c) 2021, 2022 by Christian Franz and cf/x AG\\\
--\\\
cfxZones = {}\\\
cfxZones.version = \\\"2.7.9\\\"\\\
--[[-- VERSION HISTORY\\\
 - 2.2.4 - getCoalitionFromZoneProperty\\\
         - getStringFromZoneProperty\\\
 - 2.2.5 - createGroundUnitsInZoneForCoalition corrected coalition --> country \\\
 - 2.2.6 - getVectorFromZoneProperty(theZone, theProperty, defaultVal)\\\
 - 2.2.7 - allow 'yes' as 'true' for boolean attribute \\\
 - 2.2.8 - getBoolFromZoneProperty supports default \\\
         - cfxZones.hasProperty\\\
 - 2.3.0 - property names are case insensitive \\\
 - 2.3.1 - getCoalitionFromZoneProperty allows 0, 1, 2 also\\\
 - 2.4.0 - all zones look for owner attribute, and set it to 0 (neutral) if not present \\\
 - 2.4.1 - getBoolFromZoneProperty upgraded by expected bool \\\
         - markZoneWithSmoke raised by 3 meters\\\
 - 2.4.2 - getClosestZone also returns delta \\\
 - 2.4.3 - getCoalitionFromZoneProperty() accepts 'all' as neutral \\\
           createUniqueZoneName()\\\
           getStringFromZoneProperty returns default if property value = \\\"\\\"\\\
           corrected bug in addZoneToManagedZones\\\
 - 2.4.4 - getPoint(aZone) returns uip-to-date pos for linked and normal zones\\\
         - linkUnit can use \\\"useOffset\\\" property to keep relative position\\\
 - 2.4.5 - updated various methods to support getPoint when referencing \\\
           zone.point  \\\
 - 2.4.6 - corrected spelling in markZoneWithSmoke\\\
 - 2.4.7 - copy reference to dcs zone into cfx zone \\\
 - 2.4.8 - getAllZoneProperties\\\
 - 2.4.9 - createSimpleZone no longer requires location \\\
         - parse dcs adds empty .properties = {} if none tehre \\\
         - createCircleZone adds empty properties \\\
         - createPolyZone adds empty properties \\\
 - 2.4.10 - pickRandomZoneFrom now defaults to all cfxZones.zones\\\
          - getBoolFromZoneProperty also recognizes 0, 1\\\
          - removed autostart\\\
 - 2.4.11 - removed typo in get closest zone \\\
 - 2.4.12 - getStringFromZoneProperty\\\
 - 2.5.0  - harden getZoneProperty and all getPropertyXXXX\\\
 - 2.5.1  - markZoneWithSmoke supports alt attribute \\\
 - 2.5.2  - getPoint also writes through to zone itself for optimization\\\
          - new method getPositiveRangeFromZoneProperty(theZone, theProperty, default)\\\
 - 2.5.3  - new getAllGroupsInZone()\\\
 - 2.5.4  - cleaned up getZoneProperty break on no properties \\\
          - extractPropertyFromDCS trims key and property \\\
 - 2.5.5  - pollFlag() centralized for banging \\\
          - allStaticsInZone\\\
 - 2.5.6  - flag accessor setFlagValue(), getFlagValue()  \\\
          - pollFlag supports theZone as final parameter\\\
          - randomDelayFromPositiveRange\\\
          - isMEFlag\\\
 - 2.5.7  - pollFlag supports dml flags\\\
 - 2.5.8  - flagArrayFromString\\\
          - getFlagNumber invokes tonumber() before returning result \\\
 - 2.5.9  - removed pass-back flag in getPoint() \\\
 - 2.6.0  - testZoneFlag() method based flag testing\\\
 - 2.6.1  - Watchflag parsing of zone condition for number-named flags\\\
          - case insensitive\\\
          - verbose for zone-local accepted (but not acted upon)\\\
          - hasProperty now offers active information when looking for '*?' and '*!'\\\
 - 2.7.0  - doPollFlag - fully support multiple flags per bang!\\\
 - 2.7.1  - setFlagValueMult()\\\
 - 2.7.2  - '261 repair'\\\
 - 2.7.3  - testZoneFlag returns mathodResult, lastVal\\\
          - evalFlagMethodImmediate()\\\
 - 2.7.4  - doPollFlag supports immediate number setting \\\
 - 2.7.5  - more QoL checks when mixing up ? and ! for attributes\\\
 - 2.7.6  - trim for getBoolFromZoneProperty and getStringFromZoneProperty\\\
 - 2.7.7  - randomInRange()\\\
          - show number of zones \\\
 - 2.7.8  - inc method now triggers if curr value > last value \\\
          - dec method noew triggers when curr value < last value \\\
          - testFlagByMethodForZone supports lohi, hilo transitions \\\
          - doPollFlag supports 'pulse'\\\
          - pulseFlag\\\
          - unpulse \\\
- 2.7.9   - getFlagValue QoL for <none>\\\
          - setFlagValue QoL for <none>\\\
          \\\
 \\\
--]]--\\\
cfxZones.verbose = false\\\
cfxZones.caseSensitiveProperties = false -- set to true to make property names case sensitive \\\
cfxZones.ups = 1 -- updates per second. updates moving zones\\\
\\\
cfxZones.zones = {} -- these are the zone as retrieved from the mission.\\\
                    -- ALWAYS USE THESE, NEVER DCS's ZONES!!!!\\\
\\\
-- a zone has the following attributes\\\
-- x, z -- coordinate of center. note they have correct x, 0, z coordinates so no y-->z mapping\\\
-- radius (zero if quad zone)\\\
-- isCircle (true if quad zone)\\\
-- poly the quad coords are in the poly attribute and are a \\\
-- 1..n, wound counter-clockwise as (currently) in DCS:\\\
-- lower left, lower right upper left, upper right, all coords are x, 0, z \\\
-- bounds - contain the AABB coords for the zone: ul (upper left), ur, ll (lower left), lr \\\
--          for both circle and poly, all (x, 0, z)\\\
\\\
-- zones can carry information in their names that can get processed into attributes\\\
-- use \\\
-- zones can also carry information in their 'properties' tag that ME allows to \\\
-- edit. cfxZones provides an easy method to access these properties \\\
--  - getZoneProperty (returns as string)\\\
--  - getMinMaxFromZoneProperty\\\
--  - getBoolFromZoneProperty\\\
--  - getNumberFromZoneProperty\\\
\\\
\\\
-- SUPPORTED PROPERTIES\\\
-- - \\\"linkedUnit\\\" - zone moves with unit of that name. must be exact match\\\
--   can be combined with other attributes that extend (e.g. scar manager and\\\
--   limited pilots/airframes \\\
--\\\
\\\
--\\\
-- readZonesFromDCS is executed exactly once at the beginning\\\
-- from then on, use only the cfxZones.zones table \\\
-- WARNING: cfxZones is NOT case-sensitive. All zone names are \\\
-- indexed by upper case. If you have two zones with same name but \\\
-- different case, one will be replaced\\\
--\\\
\\\
function cfxZones.readFromDCS(clearfirst)\\\
    if (clearfirst) then\\\
        cfxZones.zones = {}\\\
    end\\\
    -- not all missions have triggers or zones\\\
    if not env.mission.triggers then \\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"cf/x zones: no env.triggers defined\\\", 10)\\\
        end\\\
        return\\\
    end\\\
    \\\
    if not env.mission.triggers.zones then \\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"cf/x zones: no zones defined\\\", 10)\\\
        end\\\
        return;\\\
    end\\\
\\\
    -- we only retrieve the data we need. At this point it is name, location and radius\\\
    -- and put this in our own little  structure. we also convert to all upper case name for index\\\
    -- and assume that the name may also carry meaning, e.g. 'LZ:' defines a landing zone\\\
    -- so we can quickly create other sets from this\\\
    -- zone object. DCS 2.7 introduced quads, so this is supported as well\\\
    --   name - name in upper case\\\
    --   isCircle - true if circular zone \\\
    --   isPoly - true if zone is defined by convex polygon, e.g. quad \\\
    --   point - vec3 (x 0 z) - zone's in-world center, used to place the coordinate\\\
    --   radius - number, zero when quad\\\
    --   bounds - aabb with attributes ul, ur, ll, lr (upper left .. lower right) as (x, 0, z)\\\
    --   poly - array 1..n of poly points, wound counter-clockwise \\\
    \\\
    for i, dcsZone in pairs(env.mission.triggers.zones) do\\\
        if type(dcsZone) == 'table' then -- hint taken from MIST: verify type when reading from dcs\\\
                                         -- dcs data is like a box of chocolates...\\\
            local newZone = {}\\\
            -- name, converted to upper is used only for indexing\\\
            -- the original name remains untouched\\\
            newZone.dcsZone = dcsZone\\\
            newZone.name = dcsZone.name\\\
            newZone.isCircle = false\\\
            newZone.isPoly = false\\\
            newZone.radius = 0\\\
            newZone.poly = {}\\\
            newZone.bounds = {}\\\
            newZone.properties = {} -- dcs has this too, copy if present\\\
            if dcsZone.properties then \\\
                newZone.properties = dcsZone.properties \\\
            else\\\
                newZone.properties = {}\\\
            end -- WARNING: REF COPY. May need to clone \\\
            \\\
            local upperName = newZone.name:upper()\\\
            \\\
            -- location as 'point'\\\
            -- WARNING: zones locs are 2D (x,y) pairs, whily y in DCS is altitude.\\\
            --          so we need to change (x,y) into (x, 0, z). Since Zones have no\\\
            --          altitude (they are an infinite cylinder) this works. Remember to \\\
            --          drop y from zone calculations to see if inside. \\\
            newZone.point = cfxZones.createPoint(dcsZone.x, 0, dcsZone.y)\\\
\\\
\\\
            -- start type processing. if zone.type exists, we have a mission \\\
            -- created with 2.7 or above, else earlier \\\
            local zoneType = 0\\\
            if (dcsZone.type) then \\\
                zoneType = dcsZone.type \\\
            end\\\
            \\\
            if zoneType == 0 then \\\
                -- circular zone \\\
                newZone.isCircle = true \\\
                newZone.radius = dcsZone.radius\\\
    \\\
            elseif zoneType == 2 then\\\
                -- polyZone\\\
                newZone.isPoly = true \\\
                newZone.radius = dcsZone.radius -- radius is still written in DCS, may change later\\\
                -- now transfer all point in the poly\\\
                -- note: DCS in 2.7 misspells vertices as 'verticies'\\\
                -- correct vor this \\\
                local verts = {}\\\
                if dcsZone.verticies then verts = dcsZone.verticies \\\
                else \\\
                    -- in later versions, this was corrected\\\
                    verts = dcsZone.vertices -- see if this is ever called\\\
                end\\\
                \\\
                for v=1, #verts do\\\
                    local dcsPoint = verts[v]\\\
                    local polyPoint = cfxZones.createPointFromDCSPoint(dcsPoint) -- (x, y) -- (x, 0, y-->z)\\\
                    newZone.poly[v] = polyPoint\\\
                end\\\
            else \\\
                \\\
                trigger.action.outText(\\\"cf/x zones: malformed zone #\\\" .. i .. \\\" unknown type \\\" .. zoneType, 10)\\\
            end\\\
            \\\
\\\
            -- calculate bounds\\\
            cfxZones.calculateZoneBounds(newZone) \\\
\\\
            -- add to my table\\\
            cfxZones.zones[upperName] = newZone -- WARNING: UPPER ZONE!!!\\\
            --trigger.action.outText(\\\"znd: procced \\\" .. newZone.name .. \\\" with radius \\\" .. newZone.radius, 30)\\\
        else\\\
            if cfxZones.verbose then \\\
                trigger.action.outText(\\\"cf/x zones: malformed zone #\\\" .. i .. \\\" dropped\\\", 10)\\\
            end\\\
        end -- else var not a table\\\
        \\\
    end -- for all zones kvp\\\
end -- readFromDCS\\\
\\\
function cfxZones.calculateZoneBounds(theZone)\\\
    if not (theZone) then return \\\
    end\\\
    \\\
    local bounds = theZone.bounds -- copy ref!\\\
    \\\
    if theZone.isCircle then \\\
        -- aabb are easy: center +/- radius \\\
        local center = theZone.point\\\
        local radius = theZone.radius \\\
        -- dcs uses z+ is down on map\\\
        -- upper left is center - radius \\\
        bounds.ul = cfxZones.createPoint(center.x - radius, 0, center.z - radius)\\\
        bounds.ur = cfxZones.createPoint(center.x + radius, 0, center.z - radius)\\\
        bounds.ll = cfxZones.createPoint(center.x - radius, 0, center.z + radius)\\\
        bounds.lr = cfxZones.createPoint(center.x + radius, 0, center.z + radius)\\\
        \\\
    elseif theZone.isPoly then\\\
        local poly = theZone.poly -- ref copy!\\\
        -- create the four points\\\
        local ll = cfxZones.createPointFromPoint(poly[1])\\\
        local lr = cfxZones.createPointFromPoint(poly[1])\\\
        local ul = cfxZones.createPointFromPoint(poly[1])\\\
        local ur = cfxZones.createPointFromPoint(poly[1])\\\
\\\
        -- now iterate through all points and adjust bounds accordingly \\\
        for v=2, #poly do \\\
             local vertex = poly[v]\\\
             if (vertex.x < ll.x) then ll.x = vertex.x; ul.x = vertex.x end \\\
             if (vertex.x > lr.x) then lr.x = vertex.x; ur.x = vertex.x end \\\
             if (vertex.z < ul.z) then ul.z = vertex.z; ur.z = vertex.z end\\\
             if (vertex.z > ll.z) then ll.z = vertex.z; lr.z = vertex.z end \\\
            \\\
        end\\\
        \\\
        -- now keep the new point references\\\
        -- and store them in the zone's bounds\\\
        bounds.ll = ll\\\
        bounds.lr = lr\\\
        bounds.ul = ul\\\
        bounds.ur = ur \\\
    else \\\
        -- huston, we have a problem\\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"cf/x zones: calc bounds: zone \\\" .. theZone.name .. \\\" has unknown type\\\", 30)\\\
        end\\\
    end\\\
    \\\
end\\\
\\\
function cfxZones.createPoint(x, y, z)\\\
    local newPoint = {}\\\
    newPoint.x = x\\\
    newPoint.y = y\\\
    newPoint.z = z \\\
    return newPoint\\\
end\\\
\\\
function cfxZones.copyPoint(inPoint) \\\
    local newPoint = {}\\\
    newPoint.x = inPoint.x\\\
    newPoint.y = inPoint.y\\\
    newPoint.z = inPoint.z \\\
    return newPoint    \\\
end\\\
\\\
function cfxZones.createHeightCorrectedPoint(inPoint) -- this should be in dcsCommon\\\
    local cP = cfxZones.createPoint(inPoint.x, land.getHeight({x=inPoint.x, y=inPoint.z}),inPoint.z)\\\
    return cP\\\
end\\\
\\\
function cfxZones.getHeightCorrectedZonePoint(theZone)\\\
    return cfxZones.createHeightCorrectedPoint(theZone.point)\\\
end\\\
\\\
function cfxZones.createPointFromPoint(inPoint)\\\
    return cfxZones.copyPoint(inPoint)\\\
end\\\
\\\
function cfxZones.createPointFromDCSPoint(inPoint) \\\
    return cfxZones.createPoint(inPoint.x, 0, inPoint.y)\\\
end\\\
\\\
\\\
function cfxZones.createRandomPointInsideBounds(bounds)\\\
    local x = math.random(bounds.ll.x, ur.x)\\\
    local z = math.random(bounds.ll.z, ur.z)\\\
    return cfxZones.createPoint(x, 0, z)\\\
end\\\
\\\
function cfxZones.addZoneToManagedZones(theZone)\\\
    local upperName = string.upper(theZone.name) -- newZone.name:upper()\\\
    cfxZones.zones[upperName] = theZone\\\
end\\\
\\\
function cfxZones.createUniqueZoneName(inName, searchSet)\\\
    if not inName then return nil end \\\
    if not searchSet then searchSet = cfxZones.zones end \\\
    inName = inName:upper()\\\
    while searchSet[inName] ~= nil do \\\
        inName = inName .. \\\"X\\\"\\\
    end\\\
    return inName\\\
end\\\
\\\
function cfxZones.createSimpleZone(name, location, radius, addToManaged)\\\
    if not radius then radius = 10 end\\\
    if not addToManaged then addToManaged = false end \\\
    if not location then \\\
        location = {}\\\
    end\\\
    if not location.x then location.x = 0 end \\\
    if not location.z then location.z = 0 end \\\
    \\\
    local newZone = cfxZones.createCircleZone(name, location.x, location.z, radius)\\\
    \\\
    if addToManaged then \\\
        cfxZones.addZoneToManagedZones(newZone)\\\
    end\\\
    return newZone\\\
end\\\
\\\
function cfxZones.createCircleZone(name, x, z, radius) \\\
    local newZone = {}\\\
    newZone.isCircle = true\\\
    newZone.isPoly = false\\\
    newZone.poly = {}\\\
    newZone.bounds = {}\\\
            \\\
    newZone.name = name\\\
    newZone.radius = radius\\\
    newZone.point = cfxZones.createPoint(x, 0, z)\\\
 \\\
    -- props \\\
    newZone.properties = {}\\\
    \\\
    -- calculate my bounds\\\
    cfxZones.calculateZoneBounds(newZone)\\\
    \\\
    return newZone\\\
end\\\
\\\
function cfxZones.createPolyZone(name, poly) -- poly must be array of point type\\\
local newZone = {}\\\
    newZone.isCircle = false\\\
    newZone.isPoly = true\\\
    newZone.poly = {}\\\
    newZone.bounds = {}\\\
            \\\
    newZone.name = name\\\
    newZone.radius = 0\\\
    -- copy poly\\\
    for v=1, #poly do \\\
        local theVertex = poly[v] \\\
        newZone.poly[v] = cfxZones.createPointFromPoint(theVertex) \\\
    end\\\
    \\\
    -- properties \\\
    newZone.properties = {}\\\
    \\\
    cfxZones.calculateZoneBounds(newZone)\\\
end\\\
\\\
\\\
\\\
function cfxZones.createRandomZoneInZone(name, inZone, targetRadius, entirelyInside)\\\
    -- create a new circular zone with center placed inside inZone\\\
    -- if entirelyInside is false, only the zone's center is guaranteed to be inside\\\
    -- inZone.\\\
    \\\
--    trigger.action.outText(\\\"Zones: creating rZiZ with tr = \\\" .. targetRadius .. \\\" for \\\" .. inZone.name .. \\\" that as r = \\\" .. inZone.radius, 10)\\\
    \\\
    if inZone.isCircle then \\\
        local sourceRadius = inZone.radius\\\
        if entirelyInside and targetRadius > sourceRadius then targetRadius = sourceRadius end\\\
        if entirelyInside then sourceRadius = sourceRadius - targetRadius end\\\
    \\\
        -- ok, let's first create a random percentage value for the new radius\\\
        local percent = 1 / math.random(100)\\\
        -- now lets get a random degree\\\
        local degrees = math.random(360) * 3.14152 / 180 -- ok, it's actually radiants. \\\
        local r = sourceRadius * percent \\\
        local x = inZone.point.x + r * math.cos(degrees)\\\
        local z = inZone.point.z + r * math.sin(degrees)\\\
        -- construct new zone\\\
        local newZone = cfxZones.createCircleZone(name, x, z, targetRadius)\\\
        return newZone\\\
    \\\
    elseif inZone.isPoly then \\\
        -- we have a poly zone. the way we do this is simple:\\\
        -- generate random x, z with ranges of the bounding box \\\
        -- until the point falls within the polygon.\\\
        local newPoint = {}\\\
        local emergencyBrake = 0\\\
        repeat\\\
            newPoint = cfxZones.createRandomPointInsideBounds(inZone.bounds)\\\
            emergencyBrake = emergencyBrake + 1\\\
            if (emergencyBrake > 100) then \\\
                newPoint = cfxZones.copyPoint(inZone.Point)\\\
                trigger.action.outText(\\\"CreateZoneInZone: mergency brake for inZone\\\" .. inZone.name,  10)\\\
                break\\\
            end\\\
        until cfxZones.isPointInsidePoly(newPoint, inZone.poly)\\\
        \\\
        -- construct new zone\\\
        local newZone = cfxZones.createCircleZone(name, newPoint.x, newPoint.z, targetRadius)\\\
        return newZone\\\
        \\\
    else \\\
        -- zone type unknown\\\
        trigger.action.outText(\\\"CreateZoneInZone: unknown zone type for inZone =\\\" .. inZone.name ,  10)\\\
        return nil \\\
    end\\\
end\\\
\\\
-- polygon inside zone calculations\\\
\\\
\\\
-- isleft returns true if point P is to the left of line AB \\\
-- by determining the sign (up or down) of the normal vector of \\\
-- the two vectors PA and PB in the y coordinate. We arbitrarily define\\\
-- left as being > 0, so right is <= 0. As long as we always use the \\\
-- same comparison, it does not matter what up or down mean.\\\
-- this is important because we don't know if dcs always winds quads\\\
-- the same way, we must simply assume that they are wound as a polygon \\\
function cfxZones.isLeftXZ(A, B, P)\\\
    return ((B.x - A.x)*(P.z - A.z) - (B.z - A.z)*(P.x - A.x)) > 0\\\
end\\\
\\\
-- returns true/false for inside\\\
function cfxZones.isPointInsideQuad(thePoint, A, B, C, D) \\\
    -- Inside test (only convex polygons): \\\
    -- point lies on the same side of each quad's vertex AB, BC, CD, DA\\\
    -- how do we find out which side a point lies on? via the cross product\\\
    -- see isLeft below\\\
    \\\
    -- so all we need to do is make sure all results of isLeft for all\\\
    -- four sides are the same\\\
    mustMatch = isLeftXZ(A, B, thePoint) -- all test results must be the same and we are ok\\\
                                       -- they just must be the same side.\\\
    if (cfxZones.isLeftXZ(B, C, thePoint ~= mustMatch)) then return false end -- on other side than all before\\\
    if (cfxZones.isLeftXZ(C, D, thePoint ~= mustMatch)) then return false end \\\
    if (cfxZones.isLeftXZ(D, A, thePoint ~= mustMatch)) then return false end\\\
    return true\\\
end\\\
\\\
-- generalized version of insideQuad, assumes winding of poly, poly convex, poly closed\\\
function cfxZones.isPointInsidePoly(thePoint, poly)\\\
    local mustMatch = cfxZones.isLeftXZ(poly[1], poly[2], thePoint)\\\
    for v=2, #poly-1 do \\\
        if cfxZones.isLeftXZ(poly[v], poly[v+1], thePoint) ~= mustMatch then return false end\\\
    end\\\
    -- final test\\\
    if cfxZones.isLeftXZ(poly[#poly], poly[1], thePoint) ~= mustMatch then return false end\\\
    \\\
    return true\\\
end;\\\
\\\
function cfxZones.isPointInsideZone(thePoint, theZone)\\\
    local p = {x=thePoint.x, y = 0, z = thePoint.z} -- zones have no altitude\\\
    if (theZone.isCircle) then \\\
        local zp = cfxZones.getPoint(theZone)\\\
        local d = dcsCommon.dist(p, theZone.point)\\\
        return d < theZone.radius\\\
    end \\\
    \\\
    if (theZone.isPoly) then \\\
        --trigger.action.outText(\\\"zne: isPointInside: \\\" .. theZone.name .. \\\" is Polyzone!\\\", 30)\\\
        return (cfxZones.isPointInsidePoly(p, theZone.poly))\\\
    end\\\
\\\
    trigger.action.outText(\\\"isPointInsideZone: Unknown zone type for \\\" .. outerZone.name, 10)\\\
end\\\
\\\
-- isZoneInZone returns true if center of innerZone is inside  outerZone\\\
function cfxZones.isZoneInsideZone(innerZone, outerZone) \\\
    return cfxZones.isPointInsideZone(innerZone.point, outerZone)\\\
\\\
    \\\
end\\\
\\\
function cfxZones.getZonesContainingPoint(thePoint, testZones) -- return array \\\
    if not testZones then \\\
        testZones = cfxZones.zones \\\
    end \\\
    \\\
    local containerZones = {}\\\
    for tName, tData in pairs(testZones) do \\\
        if cfxZones.isPointInsideZone(thePoint, tData) then \\\
            table.insert(containerZones, tData)\\\
        end\\\
    end\\\
\\\
    return containerZones\\\
end\\\
\\\
function cfxZones.getFirstZoneContainingPoint(thePoint, testZones)\\\
    if not testZones then \\\
        testZones = cfxZones.zones \\\
    end \\\
    \\\
    for tName, tData in pairs(testZones) do \\\
        if cfxZones.isPointInsideZone(thePoint, tData) then \\\
            return tData\\\
        end\\\
    end\\\
\\\
    return nil\\\
end\\\
\\\
function cfxZones.getAllZonesInsideZone(superZone, testZones) -- returnes array!\\\
    if not testZones then \\\
        testZones = cfxZones.zones \\\
    end \\\
    \\\
    local containedZones = {}\\\
    for zName, zData in pairs(testZones) do\\\
        if cfxZones.isZoneInsideZone(zData, superZone) then \\\
            if zData ~= superZone then \\\
                -- we filter superzone because superzone usually resides \\\
                -- inside itself \\\
                table.insert(containedZones, zData)\\\
            end\\\
        end\\\
    end\\\
    return containedZones \\\
end\\\
\\\
function cfxZones.getZonesWithAttributeNamed(attributeName, testZones)\\\
    if not testZones then testZones = cfxZones.zones end \\\
\\\
    local attributZones = {}\\\
    for aName,aZone in pairs(testZones) do\\\
        local attr = cfxZones.getZoneProperty(aZone, attributeName)\\\
        if attr then \\\
            -- this zone has the requested attribute\\\
            table.insert(attributZones, aZone)\\\
        end\\\
    end\\\
    return attributZones\\\
end\\\
\\\
--\\\
-- units / groups in zone\\\
--\\\
function cfxZones.allGroupsInZone(theZone, categ) -- categ is optional, must be code \\\
    -- warning: does not check for exiting!\\\
    --trigger.action.outText(\\\"Zone \\\" .. theZone.name .. \\\" radius \\\" .. theZone.radius, 30)\\\
    local inZones = {}\\\
    local coals = {0, 1, 2} -- all coalitions\\\
    for idx, coa in pairs(coals) do \\\
        local allGroups = coalition.getGroups(coa, categ)\\\
        for key, group in pairs(allGroups) do -- iterate all groups\\\
            if cfxZones.isGroupPartiallyInZone(group, theZone) then\\\
                table.insert(inZones, group)\\\
            end\\\
        end\\\
    end\\\
    return inZones\\\
end\\\
\\\
function cfxZones.allStaticsInZone(theZone) -- categ is optional, must be code \\\
    -- warning: does not check for exiting!\\\
    local inZones = {}\\\
    local coals = {0, 1, 2} -- all coalitions\\\
    for idx, coa in pairs(coals) do \\\
        local allStats = coalition.getStaticObjects(coa)\\\
        for key, statO in pairs(allStats) do -- iterate all groups\\\
            local oP = statO:getPoint()\\\
            if cfxZones.pointInZone(oP, theZone) then\\\
                table.insert(inZones, statO)\\\
            end\\\
        end\\\
    end\\\
    return inZones\\\
end\\\
\\\
function cfxZones.groupsOfCoalitionPartiallyInZone(coal, theZone, categ) -- categ is optional\\\
    local groupsInZone = {}\\\
    local allGroups = coalition.getGroups(coal, categ)\\\
    for key, group in pairs(allGroups) do -- iterate all groups\\\
        if group:isExist() then\\\
            if cfxZones.isGroupPartiallyInZone(group, theZone) then\\\
                table.insert(groupsInZone, group)            \\\
            end\\\
        end\\\
    end\\\
    return groupsInZone\\\
end\\\
\\\
function cfxZones.isGroupPartiallyInZone(aGroup, aZone)\\\
    if not aGroup then return false end \\\
    if not aZone then return false end \\\
        \\\
    if not aGroup:isExist() then return false end \\\
    local allUnits = aGroup:getUnits()\\\
    for uk, aUnit in pairs (allUnits) do \\\
        if aUnit:isExist() and aUnit:getLife() > 1 then         \\\
            local p = aUnit:getPoint()\\\
            local inzone, percent, dist = cfxZones.pointInZone(p, aZone)\\\
            if inzone then -- cfxZones.isPointInsideZone(p, aZone) then             \\\
                --trigger.action.outText(\\\"zne: YAY <\\\" .. aUnit:getName() .. \\\"> IS IN \\\" .. aZone.name, 30) \\\
                return true\\\
            end \\\
            --trigger.action.outText(\\\"zne: <\\\" .. aUnit:getName() .. \\\"> not in \\\" .. aZone.name .. \\\", dist = \\\" .. dist .. \\\", rad = \\\", aZone.radius, 30) \\\
        end\\\
    end\\\
    return false\\\
end\\\
\\\
function cfxZones.isEntireGroupInZone(aGroup, aZone)\\\
    if not aGroup then return false end \\\
    if not aZone then return false end \\\
    if not aGroup:isExist() then return false end \\\
    local allUnits = aGroup:getUnits()\\\
    for uk, aUnit in pairs (allUnits) do \\\
        if aUnit:isExist() and aUnit:getLife() > 1 then \\\
            local p = aUnit:getPoint()\\\
            if not cfxZones.isPointInsideZone(p, aZone) then \\\
                return false\\\
            end\\\
        end\\\
    end\\\
    return true\\\
end\\\
\\\
\\\
--\\\
-- Zone Manipulation\\\
--\\\
\\\
function cfxZones.offsetZone(theZone, dx, dz)\\\
    -- first, update center \\\
    theZone.point.x = theZone.point.x + dx\\\
    theZone.point.z = theZone.point.z + dz \\\
    \\\
    -- now process all polygon points - it's empty for circular, so don't worry\\\
    for v=1, #theZone.poly do \\\
        theZone.poly[v].x = theZone.poly[v].x + dx\\\
        theZone.poly[v].z = theZone.poly[v].z + dz \\\
    end\\\
end\\\
\\\
function cfxZones.moveZoneTo(theZone, x, z)\\\
    local dx = x - theZone.point.x\\\
    local dz = z - theZone.point.z \\\
    cfxZones.offsetZone(theZone, dx, dz)\\\
end;\\\
\\\
function cfxZones.centerZoneOnUnit(theZone, theUnit) \\\
    local thePoint = theUnit:getPoint()\\\
    cfxZones.moveZoneTo(theZone, thePoint.x, thePoint.z)\\\
end\\\
\\\
\\\
--[[\\\
-- no longer makes sense with poly zones\\\
function cfxZones.isZoneEntirelyInsideZone(innerZone, outerZone)\\\
    if (innerZone.radius > outerZone.radius) then return false end -- cant fit inside\\\
    local d = dcsCommon.dist(innerZone.point, outerZone.point)\\\
    local reducedR = outerZone.radius - innerZone.radius\\\
    return d < reducedR\\\
end;\\\
--]]\\\
\\\
function cfxZones.dumpZones(zoneTable)\\\
    if not zoneTable then zoneTable = cfxZones.zones end \\\
    \\\
    trigger.action.outText(\\\"Zones START\\\", 10)\\\
    for i, zone in pairs(zoneTable) do \\\
        local myType = \\\"unknown\\\"\\\
        if zone.isCircle then myType = \\\"Circle\\\" end\\\
        if zone.isPoly then myType = \\\"Poly\\\" end \\\
        \\\
        trigger.action.outText(\\\"#\\\".. i .. \\\": \\\" .. zone.name .. \\\" of type \\\" .. myType, 10)\\\
    end\\\
    trigger.action.outText(\\\"Zones END\\\", 10)\\\
end\\\
\\\
function cfxZones.stringStartsWith(theString, thePrefix)\\\
    return theString:find(thePrefix) == 1\\\
end\\\
\\\
function cfxZones.keysForTable(theTable)\\\
    local keyset={}\\\
    local n=0\\\
\\\
    for k,v in pairs(tab) do\\\
        n=n+1\\\
        keyset[n]=k\\\
    end\\\
    return keyset\\\
end\\\
\\\
\\\
--\\\
-- return all zones that have a specific named property\\\
--\\\
function cfxZones.zonesWithProperty(propertyName, searchSet)\\\
    if not searchSet then searchSet = cfxZones.zones end \\\
    local theZones = {}\\\
    for k, aZone in pairs(searchSet) do \\\
        if not aZone then \\\
            trigger.action.outText(\\\"+++zone: nil aZone for \\\" .. k, 30)\\\
        else \\\
            local lU = cfxZones.getZoneProperty(aZone, propertyName)\\\
            if lU then \\\
                table.insert(theZones, aZone)\\\
            end\\\
        end\\\
    end    \\\
    return theZones\\\
end\\\
\\\
--\\\
-- return all zones from the zone table that begin with string prefix\\\
--\\\
function cfxZones.zonesStartingWithName(prefix, searchSet)\\\
    \\\
    if not searchSet then searchSet = cfxZones.zones end \\\
    \\\
--    trigger.action.outText(\\\"Enter: zonesStartingWithName for \\\" .. prefix , 30)\\\
    local prefixZones = {}\\\
    prefix = prefix:upper() -- all zones have UPPERCASE NAMES! THEY SCREAM AT YOU\\\
    for name, zone in pairs(searchSet) do\\\
--        trigger.action.outText(\\\"testing \\\" .. name:upper() .. \\\" starts with \\\" .. prefix , 30)\\\
        if cfxZones.stringStartsWith(name:upper(), prefix) then\\\
            prefixZones[name] = zone -- note: ref copy!\\\
            --trigger.action.outText(\\\"zone with prefix <\\\" .. prefix .. \\\"> found: \\\" .. name, 10)\\\
        end\\\
    end\\\
    \\\
    return prefixZones\\\
end\\\
\\\
--\\\
-- return all zones from the zone table that begin with the string or set of strings passed in prefix \\\
-- if you pass 'true' as second (optional) parameter, it will first look for all zones that begin\\\
-- with '+' and return only those. Use during debugging to force finding a specific zone\\\
--\\\
function cfxZones.zonesStartingWith(prefix, searchSet, debugging)\\\
    -- you can force zones by having their name start with \\\"+\\\"\\\
    -- which will force them to return immediately if debugging is true for this call\\\
\\\
    if (debugging) then \\\
        local debugZones = cfxZones.zonesStartingWithName(\\\"+\\\", searchSet)\\\
        if not (next(debugZones) == nil) then -- # operator only works on array elements \\\
            --trigger.action.outText(\\\"returning zones with prefix <\\\" .. prefix .. \\\">\\\", 10)\\\
            return debugZones \\\
        end \\\
    end\\\
    \\\
    --trigger.action.outText(\\\"#debugZones is  <\\\" .. #debugZones .. \\\">\\\", 10)\\\
\\\
    if (type(prefix) == \\\"string\\\") then \\\
        return cfxZones.zonesStartingWithName(prefix, searchSet)\\\
    end\\\
    \\\
    local allZones = {}\\\
    for i=1, #prefix do \\\
        -- iterate through all names in prefix set\\\
        local theName = prefix[i]\\\
        local newZones = cfxZones.zonesStartingWithName(theName, searchSet)\\\
        -- add them all to current table\\\
        for zName, zInfo in pairs(newZones) do \\\
            allZones[zName] = zInfo -- will also replace doublets\\\
        end\\\
    end\\\
    \\\
    return allZones\\\
end\\\
\\\
function cfxZones.getZoneByName(aName, searchSet) \\\
    if not searchSet then searchSet = cfxZones.zones end \\\
    aName = aName:upper()\\\
    return searchSet[aName] -- the joys of key value pairs\\\
end\\\
\\\
function cfxZones.getZonesContainingString(aString, searchSet) \\\
    if not searchSet then searchSet = cfxZones.zones end\\\
    aString = string.upper(aString)\\\
    resultSet = {}\\\
    for zName, zData in pairs(searchSet) do \\\
        if aString == string.upper(zData.name) then \\\
            resultSet[zName] = zData\\\
        end\\\
    end\\\
    \\\
end;\\\
\\\
-- filter zones by range to a point. returns indexed set\\\
function cfxZones.getZonesInRange(point, range, theZones)\\\
    if not theZones then theZones = cfxZones.zones end\\\
    \\\
    local inRangeSet = {}\\\
    for zName, zData in pairs (theZones) do \\\
        if dcsCommon.dist(point, zData.point) < range then \\\
            table.insert(inRangeSet, zData)\\\
        end\\\
    end\\\
    return inRangeSet \\\
end\\\
\\\
-- get closest zone returns the zone that is closest to point \\\
function cfxZones.getClosestZone(point, theZones)\\\
    if not theZones then theZones = cfxZones.zones end\\\
    local currDelta = math.huge \\\
    local closestZone = nil\\\
    for zName, zData in pairs(theZones) do \\\
        local zPoint = cfxZones.getPoint(zData)\\\
        local delta = dcsCommon.dist(point, zPoint)\\\
        if (delta < currDelta) then \\\
            currDelta = delta\\\
            closestZone = zData\\\
        end\\\
    end\\\
    return closestZone, currDelta \\\
end\\\
\\\
-- return a random zone from the table passed in zones\\\
function cfxZones.pickRandomZoneFrom(zones)\\\
    if not zones then zones = cfxZones.zones end\\\
    local indexedZones = dcsCommon.enumerateTable(zones)\\\
    local r = math.random(#indexedZones)\\\
    return indexedZones[r]\\\
end\\\
\\\
-- return an zone element by index \\\
function cfxZones.getZoneByIndex(theZones, theIndex) \\\
    local enumeratedZones = dcsCommon.enumerateTable(theZones)\\\
    if (theIndex > #enumeratedZones) then\\\
        trigger.action.outText(\\\"WARNING: zone index \\\" .. theIndex .. \\\" out of bounds - max = \\\" .. #enumeratedZones, 30)\\\
        return nil end\\\
    if (theIndex < 1) then return nil end\\\
    \\\
    return enumeratedZones[theIndex]\\\
end\\\
\\\
-- place a smoke marker in center of zone, offset by dx, dy \\\
function cfxZones.markZoneWithSmoke(theZone, dx, dz, smokeColor, alt)\\\
    if not alt then alt = 5 end \\\
    local point = cfxZones.getPoint(theZone) --{} -- theZone.point\\\
    point.x = point.x + dx -- getpoint updates and returns copy \\\
    point.z = point.z + dz \\\
    -- get height at point \\\
    point.y = land.getHeight({x = point.x, y = point.z}) + alt\\\
    -- height-correct\\\
    --local newPoint= {x = point.x, y = land.getHeight({x = point.x, y = point.z}) + 3, z= point.z}\\\
    trigger.action.smoke(point, smokeColor)\\\
end\\\
\\\
-- place a smoke marker in center of zone, offset by radius and degrees \\\
function cfxZones.markZoneWithSmokePolar(theZone, radius, degrees, smokeColor, alt)\\\
    local rads = degrees * math.pi / 180\\\
    local dx = radius * math.sin(rads)\\\
    local dz = radius * math.cos(rads)\\\
    cfxZones.markZoneWithSmoke(theZone, dx, dz, smokeColor, alt)\\\
end\\\
\\\
-- place a smoke marker in center of zone, offset by radius and randomized degrees \\\
function cfxZones.markZoneWithSmokePolarRandom(theZone, radius, smokeColor)\\\
    local degrees = math.random(360)\\\
    cfxZones.markZoneWithSmokePolar(theZone, radius, degrees, smokeColor)\\\
end\\\
\\\
\\\
-- unitInZone returns true if theUnit is inside the zone \\\
-- the second value returned is the percentage of distance\\\
-- from center to rim, with 100% being entirely in center, 0 = outside\\\
-- the third value returned is the distance to center\\\
function cfxZones.pointInZone(thePoint, theZone)\\\
\\\
    if not (theZone) then return false, 0, 0 end\\\
        \\\
    local pflat = {x = thePoint.x, y = 0, z = thePoint.z}\\\
    \\\
    local zpoint = cfxZones.getPoint(theZone) -- updates zone if linked \\\
    local ppoint = thePoint -- xyz\\\
    local pflat = {x = ppoint.x, y = 0, z = ppoint.z}\\\
    local dist = dcsCommon.dist(zpoint, pflat)\\\
    \\\
    if theZone.isCircle then \\\
        if theZone.radius <= 0 then \\\
            return false, 0, 0\\\
        end\\\
\\\
        local success = dist < theZone.radius\\\
        local percentage = 0\\\
        if (success) then \\\
            percentage = 1 - dist / theZone.radius \\\
        end\\\
        return success, percentage, dist \\\
    \\\
    elseif theZone.isPoly then\\\
        local success = cfxZones.isPointInsidePoly(pflat, theZone.poly)\\\
        return success, 0, dist\\\
    else \\\
        trigger.action.outText(\\\"pointInZone: Unknown zone type for \\\" .. theZone.name, 10)\\\
    end\\\
\\\
    return false\\\
end\\\
\\\
function cfxZones.unitInZone(theUnit, theZone)\\\
    if not (theUnit) then return false, 0, 0 end\\\
    if not (theUnit:isExist()) then return false, 0, 0 end\\\
    -- force zone update if it is linked to another zone \\\
    -- pointInZone does update\\\
    local thePoint = theUnit:getPoint()\\\
    return cfxZones.pointInZone(thePoint, theZone)\\\
    \\\
end\\\
\\\
-- returns all units of the input set that are inside the zone \\\
function cfxZones.unitsInZone(theUnits, theZone)\\\
    if not theUnits then return {} end\\\
    if not theZone then return {} end\\\
    \\\
    local zoneUnits = {}\\\
    for index, aUnit in pairs(theUnits) do \\\
        if cfxZones.unitInZone(aUnit, theZone) then \\\
            table.insert( zoneUnits, aUnit)\\\
        end\\\
    end\\\
    return zoneUnits\\\
end\\\
\\\
function cfxZones.closestUnitToZoneCenter(theUnits, theZone)\\\
    -- does not care if they really are in zone. call unitsInZone first\\\
    -- if you need to have them filtered\\\
    -- theUnits MUST BE ARRAY\\\
    if not theUnits then return nil end\\\
    if #theUnits == 0 then return nil end\\\
    local closestUnit = theUnits[1]\\\
    for i=2, #theUnits do\\\
        local aUnit = theUnits[i]\\\
        if dcsCommon.dist(theZone.point, closestUnit:getPoint()) > dcsCommon.dist(theZone.point, aUnit:getPoint()) then \\\
            closestUnit = aUnit\\\
        end\\\
    end\\\
    return closestUnit\\\
end\\\
\\\
function cfxZones.anyPlayerInZone(theZone) -- returns first player it finds\\\
    for pname, pinfo in pairs(cfxPlayer.playerDB) do\\\
        local playerUnit = pinfo.unit\\\
        if (cfxZones.unitInZone(playerUnit, theZone)) then \\\
            return true, playerUnit\\\
        end\\\
    end -- for all players \\\
    return false, nil\\\
end\\\
\\\
\\\
-- grow zone\\\
function cfxZones.growZone()\\\
    -- circular zones simply increase radius\\\
    -- poly zones: not defined \\\
    \\\
end\\\
\\\
\\\
-- creating units in a zone\\\
function cfxZones.createGroundUnitsInZoneForCoalition (theCoalition, groupName, theZone, theUnits, formation, heading) \\\
    -- theUnits can be string or table of string \\\
    if not groupName then groupName = \\\"G_\\\"..theZone.name end \\\
    -- group name will be taken from zone name and prependend with \\\"G_\\\"\\\
    local theGroup = dcsCommon.createGroundGroupWithUnits(groupName, theUnits, theZone.radius, nil, formation)\\\
    \\\
    -- turn the entire formation to heading\\\
    if (not heading) then heading = 0 end\\\
    dcsCommon.rotateGroupData(theGroup, heading) -- currently, group is still at origin, no cx, cy\\\
    \\\
    \\\
    -- now move the group to center of theZone\\\
    dcsCommon.moveGroupDataTo(theGroup, \\\
                          theZone.point.x, \\\
                          theZone.point.z) -- watchit: Z!!!\\\
\\\
\\\
    -- create the group in the world and return it\\\
    -- first we need to translate the coalition to a legal \\\
    -- country. we use UN for neutral, cjtf for red and blue \\\
    local theSideCJTF = dcsCommon.coalition2county(theCoalition)\\\
    return coalition.addGroup(theSideCJTF, Group.Category.GROUND, theGroup)\\\
\\\
end\\\
\\\
-- parsing zone names. The first part of the name until the first blank \\\" \\\" \\\
-- is the prefix and is dropped unless keepPrefix is true. \\\
-- all others are regarded as key:value pairs and are then added \\\
-- to the zone \\\
-- separated by equal sign \\\"=\\\" AND MUST NOT CONTAIN BLANKS\\\
--\\\
-- example usage \\\"followZone unit=rotary-1 dx=30 dy=25 rotateWithHeading=true\\\
--\\\
-- OLD DEPRECATED TECH -- TO BE DECOMMISSIONED SOON, DO NOT USE\\\
-- \\\
--[[--\\\
function cfxZones.parseZoneNameIntoAttributes(theZone, keepPrefix)\\\
--    trigger.action.outText(\\\"Parsing zone:  \\\".. theZone.name, 30)\\\
    if not keepPrefix then keepPrefix = false end -- simply for clarity\\\
    -- now split the name into space-separated strings\\\
    local attributes = dcsCommon.splitString(theZone.name, \\\" \\\")\\\
    if not keepPrefix then table.remove(attributes, 1) end -- pop prefix\\\
\\\
    -- now parse all substrings and add them as attributes to theZone\\\
    for i=1, #attributes do \\\
        local a = attributes[i]\\\
        local kvp = dcsCommon.splitString(a, \\\"=\\\")\\\
        if #kvp == 2 then \\\
            -- we have key value pair\\\
            local theKey = kvp[1]\\\
            local theValue = kvp[2]\\\
            theZone[theKey] = theValue \\\
--            trigger.action.outText(\\\"Zone \\\".. theZone.name .. \\\" parsed: Key = \\\" .. theKey .. \\\", Value = \\\" .. theValue, 30)\\\
        else \\\
--            trigger.action.outText(\\\"Zone \\\".. theZone.name .. \\\": dropped attribute \\\" .. a, 30)\\\
        end\\\
    end \\\
end\\\
--]]--\\\
-- OLD DEPRECATED TECH -- TO BE DECOMMISSIONED SOON, DO NOT USE\\\
--[[--\\\
function cfxZones.processCraterZones ()\\\
    local craters = cfxZones.zonesStartingWith(\\\"crater\\\")\\\
\\\
    \\\
\\\
    -- all these zones need to be processed and their name infor placed into attributes\\\
    for cName, cZone in pairs(craters) do\\\
        cfxZones.parseZoneNameIntoAttributes(cZone)\\\
        \\\
        -- blow stuff up at the location of the zone \\\
        local cPoint = cZone.point\\\
        cPoint.y = land.getHeight({x = cPoint.x, y = cPoint.z})  -- compensate for ground level\\\
        trigger.action.explosion(cPoint, 900)\\\
         \\\
        -- now interpret and act on the crater info \\\
        -- to destroy and place fire. \\\
        \\\
        -- fire has small, medium, large \\\
        -- eg. fire=large\\\
        \\\
    end\\\
end\\\
--]]--\\\
--\\\
-- Flag Pulling \\\
--\\\
function cfxZones.pulseFlag(theFlag, method, theZone)\\\
    local args = {}\\\
    args.theFlag = theFlag\\\
    args.method = method\\\
    args.theZone = theZone \\\
    local delay = 3\\\
    if dcsCommon.containsString(method, \\\",\\\") then \\\
        local parts = dcsCommon.splitString(method, \\\",\\\")\\\
        delay = parts[2]\\\
        if delay then delay = tonumber(delay) end  \\\
    end\\\
    if not delay then delay = 3 end \\\
    if theZone.verbose then \\\
        trigger.action.outText(\\\"+++zne: RAISING pulse t=\\\"..delay..\\\" for flag <\\\" .. theFlag .. \\\"> in zone <\\\" .. theZone.name ..\\\">\\\", 30)\\\
    end \\\
    local newVal = 1\\\
    cfxZones.setFlagValue(theFlag, newVal, theZone)\\\
    \\\
    -- schedule second half of pulse \\\
    timer.scheduleFunction(cfxZones.unPulseFlag, args, timer.getTime() + delay)\\\
end\\\
\\\
function cfxZones.unPulseFlag(args)\\\
    local theZone = args.theZone\\\
    local method = args.method \\\
    local theFlag = args.theFlag \\\
    local newVal = 0\\\
    -- we may later use method to determine pulse direction / newVal\\\
    -- for now, we always go low \\\
    if theZone.verbose then \\\
        trigger.action.outText(\\\"+++zne: DOWNPULSE pulse for flag <\\\" .. theFlag .. \\\"> in zone <\\\" .. theZone.name ..\\\">\\\", 30)\\\
    end\\\
    cfxZones.setFlagValue(theFlag, newVal, theZone)\\\
end\\\
\\\
function cfxZones.doPollFlag(theFlag, method, theZone)\\\
    if cfxZones.verbose then \\\
        trigger.action.outText(\\\"+++zones: polling flag \\\" .. theFlag .. \\\" with \\\" .. method, 30)\\\
    end \\\
    \\\
    if not theZone then \\\
        trigger.action.outText(\\\"+++zones: nil theZone on pollFlag\\\", 30)\\\
    end\\\
    \\\
    method = method:lower()\\\
    method = dcsCommon.trim(method)\\\
    val = tonumber(method)\\\
    if val then \\\
        cfxZones.setFlagValue(theFlag, val, theZone)\\\
        if cfxZones.verbose or theZone.verbose then\\\
            trigger.action.outText(\\\"+++zones: flag <\\\" .. theFlag .. \\\"> changed to #\\\" .. val, 30)\\\
        end \\\
        return \\\
    end \\\
    \\\
    --trigger.action.outText(\\\"+++zones: polling \\\" .. theZone.name .. \\\" method \\\" .. method .. \\\" flag \\\" .. theFlag, 30)\\\
    local currVal = cfxZones.getFlagValue(theFlag, theZone)\\\
    if method == \\\"inc\\\" or method == \\\"f+1\\\" then \\\
        --trigger.action.setUserFlag(theFlag, currVal + 1)\\\
        cfxZones.setFlagValue(theFlag, currVal+1, theZone)\\\
        \\\
    elseif method == \\\"dec\\\" or method == \\\"f-1\\\" then \\\
        -- trigger.action.setUserFlag(theFlag, currVal - 1)\\\
        cfxZones.setFlagValue(theFlag, currVal-1, theZone)\\\
\\\
    elseif method == \\\"off\\\" or method == \\\"f=0\\\" then \\\
        -- trigger.action.setUserFlag(theFlag, 0)\\\
        cfxZones.setFlagValue(theFlag, 0, theZone)\\\
\\\
    elseif method == \\\"flip\\\" or method == \\\"xor\\\" then \\\
        if currVal ~= 0 then \\\
--            trigger.action.setUserFlag(theFlag, 0)\\\
            cfxZones.setFlagValue(theFlag, 0, theZone)\\\
\\\
        else \\\
            --trigger.action.setUserFlag(theFlag, 1)\\\
            cfxZones.setFlagValue(theFlag, 1, theZone)\\\
        end\\\
        \\\
    elseif dcsCommon.stringStartsWith(method, \\\"pulse\\\") then \\\
        cfxZones.pulseFlag(theFlag, method, theZone)\\\
        \\\
    else \\\
        if method ~= \\\"on\\\" and method ~= \\\"f=1\\\" then \\\
            trigger.action.outText(\\\"+++zones: unknown method <\\\" .. method .. \\\"> - using 'on'\\\", 30)\\\
        end\\\
        -- default: on.\\\
--        trigger.action.setUserFlag(theFlag, 1)\\\
        cfxZones.setFlagValue(theFlag, 1, theZone)\\\
    end\\\
    \\\
    if cfxZones.verbose then\\\
        local newVal = cfxZones.getFlagValue(theFlag, theZone)\\\
        trigger.action.outText(\\\"+++zones: flag <\\\" .. theFlag .. \\\"> changed from \\\" .. currVal .. \\\" to \\\" .. newVal, 30)\\\
    end \\\
end\\\
\\\
function cfxZones.pollFlag(theFlag, method, theZone) \\\
    local allFlags = {}\\\
    if dcsCommon.containsString(theFlag, \\\",\\\") then \\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"+++zones: will poll flag set <\\\" .. theFlag .. \\\"> with \\\" .. method, 30)\\\
        end\\\
        allFlags = dcsCommon.splitString(theFlag, \\\",\\\")\\\
    else \\\
        table.insert(allFlags, theFlag)\\\
    end\\\
    \\\
    for idx, aFlag in pairs(allFlags) do \\\
        aFlag = dcsCommon.trim(aFlag)\\\
        -- note: mey require range preprocessing, but that's not\\\
        -- a priority \\\
        cfxZones.doPollFlag(aFlag, method, theZone)\\\
    end \\\
    \\\
end\\\
\\\
function cfxZones.setFlagValueMult(theFlag, theValue, theZone)\\\
    local allFlags = {}\\\
    if dcsCommon.containsString(theFlag, \\\",\\\") then \\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"+++zones: will multi-set flags <\\\" .. theFlag .. \\\"> to \\\" .. theValue, 30)\\\
        end\\\
        allFlags = dcsCommon.splitString(theFlag, \\\",\\\")\\\
    else \\\
        table.insert(allFlags, theFlag)\\\
    end\\\
    \\\
    for idx, aFlag in pairs(allFlags) do \\\
        aFlag = dcsCommon.trim(aFlag)\\\
        -- note: mey require range preprocessing, but that's not\\\
        -- a priority \\\
        cfxZones.setFlagValue(aFlag, theValue, theZone)\\\
    end \\\
end\\\
\\\
function cfxZones.setFlagValue(theFlag, theValue, theZone)\\\
    local zoneName = \\\"<dummy>\\\"\\\
    if not theZone then \\\
        trigger.action.outText(\\\"+++Zne: no zone on setFlagValue\\\")\\\
    else \\\
        zoneName = theZone.name -- for flag wildcards\\\
    end\\\
    \\\
    if type(theFlag) == \\\"number\\\" then \\\
        -- straight set, ME flag \\\
        trigger.action.setUserFlag(theFlag, theValue)\\\
        return \\\
    end\\\
    \\\
    -- we assume it's a string now\\\
    theFlag = dcsCommon.trim(theFlag) -- clear leading/trailing spaces\\\
    local nFlag = tonumber(theFlag) \\\
    if nFlag then \\\
        trigger.action.setUserFlag(theFlag, theValue)\\\
        return \\\
    end\\\
    \\\
    -- some QoL: detect \\\"<none>\\\"\\\
    if dcsCommon.containsString(theFlag, \\\"<none>\\\") then \\\
        trigger.action.outText(\\\"+++Zone: warning - setFlag has '<none>' flag name in zone <\\\" .. zoneName .. \\\">\\\", 30)\\\
    end\\\
    \\\
    -- now do wildcard processing. we have alphanumeric\\\
    if dcsCommon.stringStartsWith(theFlag, \\\"*\\\") then  \\\
        theFlag = zoneName .. theFlag\\\
    end\\\
    trigger.action.setUserFlag(theFlag, theValue)\\\
end \\\
\\\
function cfxZones.getFlagValue(theFlag, theZone)\\\
    local zoneName = \\\"<dummy>\\\"\\\
    if not theZone then \\\
        trigger.action.outText(\\\"+++Zne: no zone on getFlagValue\\\", 30)\\\
    else \\\
        zoneName = theZone.name -- for flag wildcards\\\
    end\\\
    \\\
    if type(theFlag) == \\\"number\\\" then \\\
        -- straight get, ME flag \\\
        return tonumber(trigger.misc.getUserFlag(theFlag))\\\
    end\\\
    \\\
    -- we assume it's a string now\\\
    theFlag = dcsCommon.trim(theFlag) -- clear leading/trailing spaces\\\
    local nFlag = tonumber(theFlag) \\\
    if nFlag then \\\
        return tonumber(trigger.misc.getUserFlag(theFlag))\\\
    end\\\
    \\\
    -- some QoL: detect \\\"<none>\\\"\\\
    if dcsCommon.containsString(theFlag, \\\"<none>\\\") then \\\
        trigger.action.outText(\\\"+++Zone: warning - getFlag has '<none>' flag name in zone <\\\" .. zoneName .. \\\">\\\", 30)\\\
    end\\\
    \\\
    -- now do wildcard processing. we have alphanumeric\\\
    if dcsCommon.stringStartsWith(theFlag, \\\"*\\\") then  \\\
            theFlag = zoneName .. theFlag\\\
    end\\\
    return tonumber(trigger.misc.getUserFlag(theFlag))\\\
end\\\
\\\
function cfxZones.isMEFlag(inFlag)\\\
    -- do NOT use me\\\
    trigger.action.outText(\\\"+++zne: warning: deprecated isMEFlag\\\", 30)\\\
    return true \\\
    -- returns true if inFlag is a pure positive number\\\
--    inFlag = dcsCommon.trim(inFlag)\\\
--    return dcsCommon.stringIsPositiveNumber(inFlag)\\\
end\\\
\\\
-- method-based flag testing \\\
function cfxZones.evalFlagMethodImmediate(currVal, theMethod, theZone)\\\
    -- immediate eval - does not look at last val. \\\
    -- return true/false/value based on theMethod's contraints \\\
    -- simple constraints\\\
    local lMethod = string.lower(theMethod)\\\
    if lMethod == \\\"#\\\" or lMethod == \\\"change\\\" then \\\
        -- ALWAYS RETURNS TRUE for currval <> 0, flase if currval = 0\\\
        return currVal ~= 0  \\\
    end\\\
    \\\
    if lMethod == \\\"0\\\" or lMethod == \\\"no\\\" or lMethod == \\\"false\\\" \\\
       or lMethod == \\\"off\\\" then \\\
        -- WARNING: ALWAYS RETURNS FALSE\\\
        return false  \\\
    end\\\
    \\\
    if lMethod == \\\"1\\\" or lMethod == \\\"yes\\\" or lMethod == \\\"true\\\" \\\
       or lMethod == \\\"on\\\" then \\\
        -- WARNING: ALWAYS RETURNS TRUE\\\
        return true  \\\
    end\\\
    \\\
    if lMethod == \\\"inc\\\" or lMethod == \\\"+1\\\" then \\\
        return currVal+1 -- this may be unexpected\\\
    end\\\
    \\\
    if lMethod == \\\"dec\\\" or lMethod == \\\"-1\\\" then \\\
        return currVal-1 -- this may be unexpectd\\\
    end \\\
    \\\
    -- number constraints\\\
    -- or flag constraints \\\
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \\\
    local op = string.sub(theMethod, 1, 1) \\\
    local remainder = string.sub(theMethod, 2)\\\
    remainder = dcsCommon.trim(remainder) -- remove all leading and trailing spaces\\\
    local rNum = tonumber(remainder)\\\
    if not rNum then \\\
        -- we use remainder as name for flag \\\
        -- PROCESS ESCAPE SEQUENCES\\\
        local esc = string.sub(remainder, 1, 1)\\\
        local last = string.sub(remainder, -1)\\\
        if esc == \\\"@\\\" then \\\
            remainder = string.sub(remainder, 2)\\\
            remainder = dcsCommon.trim(remainder)\\\
        end\\\
        \\\
        if esc == \\\"(\\\" and last == \\\")\\\" and string.len(remainder) > 2 then \\\
            -- note: iisues with startswith(\\\"(\\\") ???\\\
            remainder = string.sub(remainder, 2, -2)\\\
            remainder = dcsCommon.trim(remainder)        \\\
        end\\\
        if esc == \\\"\\\\\\\"\\\" and last == \\\"\\\\\\\"\\\" and string.len(remainder) > 2 then \\\
            remainder = string.sub(remainder, 2, -2)\\\
            remainder = dcsCommon.trim(remainder)        \\\
        end\\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"+++zne: accessing flag <\\\" .. remainder .. \\\">\\\", 30)\\\
        end \\\
        rNum = cfxZones.getFlagValue(remainder, theZone)\\\
    end \\\
    if rNum then \\\
        -- we have a comparison = \\\">\\\", \\\"=\\\", \\\"<\\\" followed by a number  \\\
        if op == \\\"=\\\" then \\\
            return currVal == rNum\\\
        end\\\
        \\\
        if op == \\\"#\\\" or op == \\\"~\\\" then \\\
            return currVal ~= rNum \\\
        end \\\
        \\\
        if op == \\\"<\\\" then \\\
            return currVal < rNum\\\
        end\\\
        \\\
        if op == \\\">\\\" then \\\
            return currVal > rNum\\\
        end\\\
    end\\\
    \\\
    -- if we get here, we have an error \\\
    local zoneName = \\\"<NIL>\\\"\\\
    if theZone then zoneName = theZone.name end \\\
    trigger.action.outText(\\\"+++Zne: illegal |\\\" .. theMethod .. \\\"| in eval for zone \\\" .. zoneName, 30 )\\\
    return false     \\\
end\\\
\\\
function cfxZones.testFlagByMethodForZone(currVal, lastVal, theMethod, theZone)\\\
    -- return true/false based on theMethod's contraints \\\
    -- simple constraints\\\
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \\\
    local lMethod = string.lower(theMethod)\\\
    if lMethod == \\\"#\\\" or lMethod == \\\"change\\\" then \\\
        -- check if currVal different from lastVal\\\
        return currVal ~= lastVal  \\\
    end\\\
    \\\
    if lMethod == \\\"0\\\" or lMethod == \\\"no\\\" or lMethod == \\\"false\\\" \\\
       or lMethod == \\\"off\\\" then \\\
        -- WARNING: ONLY RETURNS TRUE IF FALSE AND lastval not zero!\\\
        return currVal == 0 and currVal ~= lastVal  \\\
    end\\\
    \\\
    if lMethod == \\\"1\\\" or lMethod == \\\"yes\\\" or lMethod == \\\"true\\\" \\\
       or lMethod == \\\"on\\\" then \\\
        -- WARNING: only returns true if lastval was false!!!!\\\
        return (currVal ~= 0 and lastVal == 0)  \\\
    end\\\
    \\\
    if lMethod == \\\"inc\\\" or lMethod == \\\"+1\\\" then \\\
--        return currVal == lastVal+1 -- better: test for greater than \\\
        return currVal > lastVal\\\
    end\\\
    \\\
    if lMethod == \\\"dec\\\" or lMethod == \\\"-1\\\" then \\\
        --return currVal == lastVal-1\\\
        return currVal < lastVal \\\
    end \\\
    \\\
    if lMethod == \\\"lohi\\\" or lMethod == \\\"pulse\\\" then \\\
        return (lastVal <= 0 and currVal > 0)\\\
    end\\\
    \\\
    if lMethod == \\\"hilo\\\" then \\\
        return (lastVal > 0 and currVal <= 0)\\\
    end\\\
    \\\
    -- number constraints\\\
    -- or flag constraints \\\
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \\\
    local op = string.sub(theMethod, 1, 1) \\\
    local remainder = string.sub(theMethod, 2)\\\
    remainder = dcsCommon.trim(remainder) -- remove all leading and trailing spaces\\\
    local rNum = tonumber(remainder)\\\
    if not rNum then \\\
        -- we use remainder as name for flag \\\
        -- PROCESS ESCAPE SEQUENCES\\\
        local esc = string.sub(remainder, 1, 1)\\\
        local last = string.sub(remainder, -1)\\\
        if esc == \\\"@\\\" then \\\
            remainder = string.sub(remainder, 2)\\\
            remainder = dcsCommon.trim(remainder)\\\
        end\\\
        \\\
        if esc == \\\"(\\\" and last == \\\")\\\" and string.len(remainder) > 2 then \\\
            -- note: iisues with startswith(\\\"(\\\") ???\\\
            remainder = string.sub(remainder, 2, -2)\\\
            remainder = dcsCommon.trim(remainder)        \\\
        end\\\
        if esc == \\\"\\\\\\\"\\\" and last == \\\"\\\\\\\"\\\" and string.len(remainder) > 2 then \\\
            remainder = string.sub(remainder, 2, -2)\\\
            remainder = dcsCommon.trim(remainder)        \\\
        end\\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"+++zne: accessing flag <\\\" .. remainder .. \\\">\\\", 30)\\\
        end \\\
        rNum = cfxZones.getFlagValue(remainder, theZone)\\\
    end \\\
    if rNum then \\\
        -- we have a comparison = \\\">\\\", \\\"=\\\", \\\"<\\\" followed by a number \\\
        -- THEY TRIGGER EACH TIME lastVal <> currVal AND condition IS MET  \\\
        if op == \\\"=\\\" then \\\
            return currVal == rNum and lastVal ~= currVal\\\
        end\\\
        \\\
        if op == \\\"#\\\" or op == \\\"~\\\" then \\\
            return currVal ~= rNum and lastVal ~= currVal \\\
        end \\\
        \\\
        if op == \\\"<\\\" then \\\
            return currVal < rNum and lastVal ~= currVal\\\
        end\\\
        \\\
        if op == \\\">\\\" then \\\
            return currVal > rNum and lastVal ~= currVal\\\
        end\\\
    end\\\
    \\\
    -- if we get here, we have an error \\\
    local zoneName = \\\"<NIL>\\\"\\\
    if theZone then zoneName = theZone.name end \\\
    trigger.action.outText(\\\"+++Zne: illegal method constraints |\\\" .. theMethod .. \\\"| for zone \\\" .. zoneName, 30 )\\\
    return false \\\
end\\\
\\\
\\\
function cfxZones.testZoneFlag(theZone, theFlagName, theMethod, latchName)\\\
    -- returns two values: true/false method result, and curr value\\\
    -- returns true if method constraints are met for flag theFlagName\\\
    -- as defined by theMethod \\\
    if not theMethod then \\\
        theMethod = \\\"change\\\"\\\
    end \\\
    \\\
    -- will read and update theZone[latchName] as appropriate \\\
    if not theZone then \\\
        trigger.action.outText(\\\"+++Zne: no zone for testZoneFlag\\\", 30)\\\
        return nil, nil \\\
    end \\\
    if not theFlagName then \\\
        -- this is common, no error, only on verbose \\\
        if cfxZones.verbose then \\\
            trigger.action.outText(\\\"+++Zne: no flagName for zone \\\" .. theZone.name .. \\\" for testZoneFlag\\\", 30)\\\
        end \\\
        return nil, nil\\\
    end\\\
    if not latchName then \\\
        trigger.action.outText(\\\"+++Zne: no latchName for zone \\\" .. theZone.name .. \\\" for testZoneFlag\\\", 30)\\\
        return nil, nil \\\
    end\\\
    -- get current value \\\
    local currVal = cfxZones.getFlagValue(theFlagName, theZone)\\\
    \\\
    -- get last value from latch\\\
    local lastVal = theZone[latchName]\\\
    if not lastVal then \\\
        trigger.action.outText(\\\"+++Zne: latch <\\\" .. latchName .. \\\"> not valid for zone \\\" .. theZone.name, 30)\\\
        return nil, nil\\\
    end\\\
    \\\
    -- now, test by method \\\
    -- we should only test if currVal <> lastVal \\\
    if currVal == lastVal then\\\
        return false, currVal\\\
    end \\\
    \\\
    --trigger.action.outText(\\\"+++Zne: about to test: c = \\\" .. currVal .. \\\", l = \\\" .. lastVal, 30)\\\
    local testResult = cfxZones.testFlagByMethodForZone(currVal, lastVal, theMethod, theZone)\\\
\\\
    -- update latch by method\\\
    theZone[latchName] = currVal \\\
\\\
    -- return result\\\
    return testResult, currVal\\\
end\\\
\\\
\\\
\\\
function cfxZones.flagArrayFromString(inString)\\\
-- original code from RND flag\\\
    if string.len(inString) < 1 then \\\
        trigger.action.outText(\\\"+++zne: empty flags\\\", 30)\\\
        return {} \\\
    end\\\
    if cfxZones.verbose then \\\
        trigger.action.outText(\\\"+++zne: processing <\\\" .. inString .. \\\">\\\", 30)\\\
    end \\\
    \\\
    local flags = {}\\\
    local rawElements = dcsCommon.splitString(inString, \\\",\\\")\\\
    -- go over all elements \\\
    for idx, anElement in pairs(rawElements) do \\\
        if dcsCommon.stringStartsWithDigit(anElement) and  dcsCommon.containsString(anElement, \\\"-\\\") then \\\
            -- interpret this as a range\\\
            local theRange = dcsCommon.splitString(anElement, \\\"-\\\")\\\
            local lowerBound = theRange[1]\\\
            lowerBound = tonumber(lowerBound)\\\
            local upperBound = theRange[2]\\\
            upperBound = tonumber(upperBound)\\\
            if lowerBound and upperBound then\\\
                -- swap if wrong order\\\
                if lowerBound > upperBound then \\\
                    local temp = upperBound\\\
                    upperBound = lowerBound\\\
                    lowerBound = temp \\\
                end\\\
                -- now add add numbers to flags\\\
                for f=lowerBound, upperBound do \\\
                    table.insert(flags, tostring(f))\\\
                end\\\
            else\\\
                -- bounds illegal\\\
                trigger.action.outText(\\\"+++zne: ignored range <\\\" .. anElement .. \\\"> (range)\\\", 30)\\\
            end\\\
        else\\\
            -- single number\\\
            f = dcsCommon.trim(anElement) -- DML flag upgrade: accept strings tonumber(anElement)\\\
            if f then \\\
                table.insert(flags, f)\\\
\\\
            else \\\
                trigger.action.outText(\\\"+++zne: ignored element <\\\" .. anElement .. \\\"> (single)\\\", 30)\\\
            end\\\
        end\\\
    end\\\
    if cfxZones.verbose then \\\
        trigger.action.outText(\\\"+++zne: <\\\" .. #flags .. \\\"> flags total\\\", 30)\\\
    end \\\
    return flags\\\
end\\\
\\\
--\\\
-- PROPERTY PROCESSING \\\
--\\\
\\\
function cfxZones.getAllZoneProperties(theZone, caseInsensitive) -- return as dict \\\
    if not caseInsensitive then caseInsensitive = false end \\\
    if not theZone then return {} end \\\
    \\\
    local dcsProps = theZone.properties -- zone properties in dcs format \\\
    local props = {}\\\
    -- dcs has all properties as array with values .key and .value \\\
    -- so convert them into a dictionary \\\
    for i=1, #dcsProps do \\\
        local theProp = dcsProps[i]\\\
        local theKey = \\\"dummy\\\"\\\
        if string.len(theProp.key) > 0 then theKey = theProp.key end \\\
        if caseInsensitive then theKey = theKey:upper() end \\\
        props[theKey] = theProp.value\\\
    end\\\
    return props \\\
end\\\
\\\
function cfxZones.extractPropertyFromDCS(theKey, theProperties)\\\
-- trim\\\
    theKey = dcsCommon.trim(theKey) \\\
--    make lower case conversion if not case sensitive\\\
    if not cfxZones.caseSensitiveProperties then \\\
        theKey = string.lower(theKey)\\\
    end\\\
\\\
-- iterate all keys and compare to what we are looking for     \\\
    for i=1, #theProperties do\\\
        local theP = theProperties[i]\\\
         \\\
        local existingKey = dcsCommon.trim(theP.key)  \\\
        if not cfxZones.caseSensitiveProperties then \\\
            existingKey = string.lower(existingKey)\\\
        end\\\
        if existingKey == theKey then \\\
            return theP.value\\\
        end\\\
    end\\\
    return nil \\\
end\\\
\\\
function cfxZones.getZoneProperty(cZone, theKey)\\\
    if not cZone then \\\
        trigger.action.outText(\\\"+++zone: no zone in getZoneProperty\\\", 30)\\\
--        breek.here.noew = 1\\\
        return nil\\\
    end \\\
    if not theKey then \\\
        trigger.action.outText(\\\"+++zone: no property key in getZoneProperty for zone \\\" .. cZone.name, 30)\\\
--        breakme.here = 1\\\
        return \\\
    end    \\\
\\\
    local props = cZone.properties\\\
    local theVal = cfxZones.extractPropertyFromDCS(theKey, props)\\\
    return theVal\\\
end\\\
\\\
function cfxZones.getStringFromZoneProperty(theZone, theProperty, default)\\\
    \\\
    if not default then default = \\\"\\\" end\\\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\\\
    if not p then return default end\\\
    if type(p) == \\\"string\\\" then \\\
        p = dcsCommon.trim(p)\\\
        if p == \\\"\\\" then p = default end \\\
        return p\\\
    end\\\
    return default -- warning. what if it was a number first?\\\
end\\\
\\\
function cfxZones.getMinMaxFromZoneProperty(theZone, theProperty)\\\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\\\
    local theNumbers = dcsCommon.splitString(p, \\\" \\\")\\\
\\\
    return tonumber(theNumbers[1]), tonumber(theNumbers[2])\\\
    \\\
end\\\
\\\
function cfxZones.randomInRange(minVal, maxVal)\\\
    if maxVal < minVal then \\\
        local t = minVal\\\
        minVal = maxVal \\\
        maxVal = t\\\
    end\\\
    return cfxZones.randomDelayFromPositiveRange(minVal, maxVal)\\\
end\\\
\\\
function cfxZones.randomDelayFromPositiveRange(minVal, maxVal) \\\
    if not maxVal then return minVal end \\\
    if not minVal then return maxVal end \\\
    local delay = maxVal\\\
    if minVal > 0 and minVal < delay then \\\
        -- we want a randomized from time from minTime .. delay\\\
        local varPart = delay - minVal + 1\\\
        varPart = dcsCommon.smallRandom(varPart) - 1\\\
        delay = minVal + varPart\\\
    end\\\
    return delay \\\
end\\\
\\\
function cfxZones.getPositiveRangeFromZoneProperty(theZone, theProperty, default)\\\
    -- reads property as string, and interprets as range 'a-b'. \\\
    -- if not a range but single number, returns both for upper and lower \\\
    --trigger.action.outText(\\\"***Zne: enter with <\\\" .. theZone.name .. \\\">: range for property <\\\" .. theProperty .. \\\">!\\\", 30)\\\
    if not default then default = 0 end \\\
    local lowerBound = default\\\
    local upperBound = default \\\
    \\\
    local rangeString = cfxZones.getStringFromZoneProperty(theZone, theProperty, \\\"\\\")\\\
    if dcsCommon.containsString(rangeString, \\\"-\\\") then \\\
        local theRange = dcsCommon.splitString(rangeString, \\\"-\\\")\\\
        lowerBound = theRange[1]\\\
        lowerBound = tonumber(lowerBound)\\\
        upperBound = theRange[2]\\\
        upperBound = tonumber(upperBound)\\\
        if lowerBound and upperBound then\\\
            -- swap if wrong order\\\
            if lowerBound > upperBound then \\\
                local temp = upperBound\\\
                upperBound = lowerBound\\\
                lowerBound = temp \\\
            end\\\
--            if rndFlags.verbose then \\\
--            trigger.action.outText(\\\"+++Zne: detected range <\\\" .. lowerBound .. \\\", \\\" .. upperBound .. \\\">\\\", 30)\\\
--            end\\\
        else\\\
            -- bounds illegal\\\
            trigger.action.outText(\\\"+++Zne: illegal range  <\\\" .. rangeString .. \\\">, using \\\" .. default .. \\\"-\\\" .. default, 30)\\\
            lowerBound = default\\\
            upperBound = default \\\
        end\\\
    else \\\
        upperBound = cfxZones.getNumberFromZoneProperty(theZone, theProperty, default) -- between pulses \\\
        lowerBound = upperBound\\\
    end\\\
--    trigger.action.outText(\\\"+++Zne: returning <\\\" .. lowerBound .. \\\", \\\" .. upperBound .. \\\">\\\", 30)\\\
    return lowerBound, upperBound\\\
end\\\
\\\
function cfxZones.hasProperty(theZone, theProperty) \\\
    local foundIt = cfxZones.getZoneProperty(theZone, theProperty)\\\
    if not foundIt then \\\
        -- check for possible forgotten or exchanged IO flags \\\
        if string.sub(theProperty, -1) == \\\"?\\\" then\\\
            local lessOp = theProperty:sub(1,-2)\\\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \\\
                trigger.action.outText(\\\"*** NOTE: \\\" .. theZone.name .. \\\"'s property <\\\" .. lessOp .. \\\"> may be missing a Query ('?') symbol\\\", 30)\\\
            end\\\
            local lessPlus = lessOp .. \\\"!\\\"\\\
            if cfxZones.getZoneProperty(theZone, lessPlus) ~= nil then \\\
                trigger.action.outText(\\\"*** NOTE: \\\" .. theZone.name .. \\\"'s property <\\\" .. lessOp .. \\\"> may be using '!' instead of '?' for input\\\", 30)\\\
            end\\\
            return false \\\
        end\\\
        \\\
        if string.sub(theProperty, -1) == \\\"!\\\" then \\\
            local lessOp = theProperty:sub(1,-2)\\\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \\\
                trigger.action.outText(\\\"*** NOTE: \\\" .. theZone.name .. \\\"'s property <\\\" .. lessOp .. \\\"> may be missing a Bang! ('!') symbol\\\", 30)\\\
            end\\\
            local lessPlus = lessOp .. \\\"?\\\"\\\
            if cfxZones.getZoneProperty(theZone, lessPlus) ~= nil then \\\
                trigger.action.outText(\\\"*** NOTE: \\\" .. theZone.name .. \\\"'s property <\\\" .. lessOp .. \\\"> may be using '!' instead of '?' for input\\\", 30)\\\
            end\\\
            return false \\\
        end\\\
        \\\
        if string.sub(theProperty, -1) == \\\":\\\" then \\\
            local lessOp = theProperty:sub(1,-2)\\\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \\\
                trigger.action.outText(\\\"*** NOTE: \\\" .. theZone.name .. \\\"'s property <\\\" .. lessOp .. \\\"> may be missing a colon (':') at end\\\", 30)\\\
            end\\\
            return false \\\
        end\\\
        \\\
        return false \\\
    end\\\
    return true \\\
--    return foundIt ~= nil \\\
end\\\
\\\
function cfxZones.getBoolFromZoneProperty(theZone, theProperty, defaultVal)\\\
    if not defaultVal then defaultVal = false end \\\
    if type(defaultVal) ~= \\\"boolean\\\" then \\\
        defaultVal = false \\\
    end\\\
\\\
    if not theZone then \\\
        trigger.action.outText(\\\"WARNING: NIL Zone in getBoolFromZoneProperty\\\", 30)\\\
        return defaultVal\\\
    end\\\
\\\
\\\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\\\
    if not p then return defaultVal end\\\
\\\
    -- make sure we compare so default always works when \\\
    -- answer isn't exactly the opposite\\\
    p = p:lower() \\\
    p = dcsCommon.trim(p) \\\
    if defaultVal == false then \\\
        -- only go true if exact match to yes or true \\\
        theBool = false \\\
        theBool = (p == 'true') or (p == 'yes') or p == \\\"1\\\"\\\
        return theBool\\\
    end\\\
    \\\
    local theBool = true \\\
    -- only go false if exactly no or false or \\\"0\\\"\\\
    theBool = (p ~= 'false') and (p ~= 'no') and (p ~= \\\"0\\\") \\\
    return theBool\\\
end\\\
\\\
function cfxZones.getCoalitionFromZoneProperty(theZone, theProperty, default)\\\
    if not default then default = 0 end\\\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\\\
    if not p then return default end  \\\
    if type(p) == \\\"number\\\" then -- can't currently really happen\\\
        if p == 1 then return 1 end \\\
        if p == 2 then return 2 end \\\
        return 0\\\
    end\\\
    \\\
    if type(p) == \\\"string\\\" then \\\
        if p == \\\"1\\\" then return 1 end \\\
        if p == \\\"2\\\" then return 2 end \\\
        if p == \\\"0\\\" then return 0 end \\\
        \\\
        p = p:lower()\\\
        \\\
        if p == \\\"red\\\" then return 1 end \\\
        if p == \\\"blue\\\" then return 2 end \\\
        if p == \\\"neutral\\\" then return 0 end\\\
        if p == \\\"all\\\" then return 0 end \\\
        return default \\\
    end\\\
    \\\
    return default \\\
end\\\
\\\
function cfxZones.getNumberFromZoneProperty(theZone, theProperty, default)\\\
--TODO: trim string \\\
    if not default then default = 0 end\\\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\\\
    p = tonumber(p)\\\
    if not p then return default else return p end\\\
end\\\
\\\
function cfxZones.getVectorFromZoneProperty(theZone, theProperty, minDims, defaultVal)\\\
    if not minDims then minDims = 0 end \\\
    if not defaultVal then defaultVal = 0 end \\\
    local s = cfxZones.getStringFromZoneProperty(theZone, theProperty, \\\"\\\")\\\
    local sVec = dcsCommon.splitString(s, \\\",\\\")\\\
    local nVec = {}\\\
    for idx, numString in pairs (sVec) do \\\
        local n = tonumber(numString)\\\
        if not n then n = defaultVal end\\\
        table.insert(nVec, n)\\\
    end\\\
    -- make sure vector contains at least minDims values \\\
    while #nVec < minDims do \\\
        table.insert(nVec, defaultVal)\\\
    end\\\
    \\\
    return nVec \\\
end\\\
\\\
function cfxZones.getSmokeColorStringFromZoneProperty(theZone, theProperty, default) -- smoke as 'red', 'green', or 1..5\\\
    if not default then default = \\\"red\\\" end \\\
    local s = cfxZones.getStringFromZoneProperty(theZone, theProperty, default)\\\
    s = s:lower()\\\
    s = dcsCommon.trim(s)\\\
    -- check numbers \\\
    if (s == \\\"0\\\") then return \\\"green\\\" end\\\
    if (s == \\\"1\\\") then return \\\"red\\\" end\\\
    if (s == \\\"2\\\") then return \\\"white\\\" end\\\
    if (s == \\\"3\\\") then return \\\"orange\\\" end\\\
    if (s == \\\"4\\\") then return \\\"blue\\\" end\\\
    \\\
    if s == \\\"green\\\" or\\\
       s == \\\"red\\\" or\\\
       s == \\\"white\\\" or\\\
       s == \\\"orange\\\" or\\\
       s == \\\"blue\\\" then return s end\\\
\\\
    return default \\\
end\\\
\\\
--\\\
-- Moving Zones. They contain a link to their unit\\\
-- they are always located at an offset (x,z) or delta, phi \\\
-- to their master unit. delta phi allows adjustment for heading\\\
-- The cool thing about moving zones in cfx is that they do not\\\
-- require special handling, they are always updated \\\
-- and work with 'pointinzone' etc automatically\\\
\\\
-- Always works on cfx Zones, NEVER on DCS zones.\\\
--\\\
-- requires that readFromDCS has been done\\\
--\\\
function cfxZones.getPoint(aZone) -- always works, even linked, point can be reused \\\
    if aZone.linkedUnit then \\\
        local theUnit = aZone.linkedUnit\\\
        -- has a link. is link existing?\\\
        if theUnit:isExist() then \\\
            -- updates zone position \\\
            cfxZones.centerZoneOnUnit(aZone, theUnit)\\\
            cfxZones.offsetZone(aZone, aZone.dx, aZone.dy)\\\
        end\\\
    end\\\
    local thePos = {}\\\
    thePos.x = aZone.point.x\\\
    thePos.y = 0 -- aZone.y \\\
    thePos.z = aZone.point.z\\\
    -- update the zone as well -- that's stupid!\\\
    --[[-- aZone.point = thePos \\\
    local retPoint = {} -- create new copy to pass back \\\
    retPoint.x = thePos.x\\\
    retPoint.y = 0 \\\
    retPoint.z = thePos.z\\\
    --]]--\\\
    return thePos \\\
end\\\
\\\
function cfxZones.linkUnitToZone(theUnit, theZone, dx, dy) -- note: dy is really Z, don't get confused!!!!\\\
    theZone.linkedUnit = theUnit\\\
    if not dx then dx = 0 end\\\
    if not dy then dy = 0 end \\\
    theZone.dx = dx\\\
    theZone.dy = dy \\\
end\\\
\\\
function cfxZones.updateMovingZones()\\\
    cfxZones.updateSchedule = timer.scheduleFunction(cfxZones.updateMovingZones, {}, timer.getTime() + 1/cfxZones.ups)\\\
    -- simply scan all cfx zones for the linkedUnit property and if there\\\
    -- update the zone's points\\\
    for aName,aZone in pairs(cfxZones.zones) do\\\
        if aZone.linkedUnit then \\\
            local theUnit = aZone.linkedUnit\\\
            -- has a link. is link existing?\\\
            if theUnit:isExist() then \\\
                cfxZones.centerZoneOnUnit(aZone, theUnit)\\\
                cfxZones.offsetZone(aZone, aZone.dx, aZone.dy)\\\
                --trigger.action.outText(\\\"cf/x zones update \\\" .. aZone.name, 30)\\\
            end\\\
        end\\\
    end\\\
end\\\
\\\
function cfxZones.startMovingZones()\\\
    -- read all zoness, and look for a property called 'linkedUnit'\\\
    -- which will make them a linked zone if there is a unit that exists\\\
    for aName,aZone in pairs(cfxZones.zones) do\\\
        local lU = cfxZones.getZoneProperty(aZone, \\\"linkedUnit\\\")\\\
        if lU then \\\
            -- this zone is linked to a unit\\\
            theUnit = Unit.getByName(lU)\\\
            local useOffset = cfxZones.getBoolFromZoneProperty(aZone, \\\"useOffset\\\", false)\\\
            if useOffset then aZone.useOffset = true end\\\
            if theUnit then\\\
                local dx = 0\\\
                local dz = 0\\\
                if useOffset then \\\
                    local delta = dcsCommon.vSub(aZone.point,theUnit:getPoint()) -- delta = B - A \\\
                    dx = delta.x \\\
                    dz = delta.z\\\
                end\\\
                cfxZones.linkUnitToZone(theUnit, aZone, dx, dz)\\\
                --trigger.action.outText(\\\"cf/x zones: linked \\\" .. aZone.name .. \\\" to \\\" .. theUnit:getName(), 30)\\\
                if useOffset then \\\
                    --trigger.action.outText(\\\"and dx = \\\" .. dx .. \\\" dz = \\\" .. dz, 30)\\\
                end\\\
            end\\\
        end\\\
        -- support for local verbose flag \\\
        aZone.verbose = cfxZones.getBoolFromZoneProperty(aZone, \\\"verbose\\\", false)\\\
    end\\\
end\\\
\\\
--\\\
-- init\\\
--\\\
\\\
function cfxZones.init()\\\
    -- read all zones into my own db\\\
    cfxZones.readFromDCS(true) -- true: erase old\\\
    \\\
    -- now, pre-read zone owner for all zones\\\
    -- note, all zones with this property are by definition owned zones.\\\
    -- and hence will be read anyway. this will merely ensure that the \\\
    -- ownership is established right away\\\
    -- unless owned zones module is missing, in which case \\\
    -- ownership is still established \\\
    local pZones = cfxZones.zonesWithProperty(\\\"owner\\\")\\\
    for n, aZone in pairs(pZones) do\\\
        aZone.owner = cfxZones.getCoalitionFromZoneProperty(aZone, \\\"owner\\\", 0)\\\
    end\\\
        \\\
    \\\
    -- now initialize moving zones\\\
    cfxZones.startMovingZones()\\\
    cfxZones.updateMovingZones() -- will auto-repeat\\\
    \\\
    trigger.action.outText(\\\"cf/x Zones v\\\".. cfxZones.version .. \\\": loaded, zones:\\\" .. dcsCommon.getSizeOfTable(cfxZones.zones), 30)\\\
\\\
end\\\
\\\
-- get everything rolling\\\
cfxZones.init()\\\
\");a_do_script(\"cfxReconMode = {}\\\
cfxReconMode.version = \\\"2.0.0\\\"\\\
cfxReconMode.verbose = false -- set to true for debug info  \\\
cfxReconMode.reconSound = \\\"UI_SCI-FI_Tone_Bright_Dry_20_stereo.wav\\\" -- to be played when somethiong discovered\\\
\\\
cfxReconMode.prioList = {} -- group names that are high prio and generate special event\\\
cfxReconMode.blackList = {} -- group names that are NEVER detected. Comma separated strings, e.g. {\\\"Always Hidden\\\", \\\"Invisible Group\\\"}\\\
cfxReconMode.dynamics = {} -- if a group name is dynamic\\\
cfxReconMode.zoneInfo = {} -- additional zone info \\\
\\\
cfxReconMode.scoutZones = {} -- zones that define aircraft. used for late eval of players \\\
cfxReconMode.allowedScouts = {} -- when not using autoscouts \\\
cfxReconMode.blindScouts = {} -- to exclude aircraft from being scouts \\\
cfxReconMode.removeWhenDestroyed = true \\\
cfxReconMode.activeMarks = {} -- all marks and their groups, indexed by groupName \\\
\\\
cfxReconMode.requiredLibs = {\\\
    \\\"dcsCommon\\\", -- always\\\
    \\\"cfxZones\\\", -- Zones, of course \\\
}\\\
\\\
--[[--\\\
VERSION HISTORY\\\
 1.0.0 - initial version \\\
 1.0.1 - removeScoutByName()\\\
 1.0.2 - garbage collection \\\
 1.1.0 - autoRecon - any aircraft taking off immediately\\\
         signs up, no message when signing up or closing down\\\
         standalone - copied common procs lerp, agl, dist, distflat\\\
         from dcsCommon\\\
         report numbers \\\
         verbose flag \\\
 1.2.0 - queued recons. One scout per second for more even\\\
         performance\\\
         removed gc since it's now integrated into \\\
         update queue\\\
         removeScout optimization when directly passing name\\\
         playerOnlyRecon for autoRecon \\\
         red, blue, grey side filtering on auto scout\\\
 1.2.1 - parametrized report sound \\\
 1.3.0 - added black list, prio list functionality \\\
 1.3.1 - callbacks now also push name, as group can be dead\\\
       - removed bug when removing dead groups from map\\\
 1.4.0 - import dcsCommon, cfxZones etc \\\
       - added lib check \\\
       - config zone \\\
       - prio+\\\
       - detect+\\\
 1.4.1 - invocation no longer happen twice for prio. \\\
       - recon sound \\\
       - read all flight groups at start to get rid of the \\\
       - late activation work-around \\\
 1.5.0 - removeWhenDestroyed()\\\
       - autoRemove()\\\
       - readConfigZone creates default config zone so we get correct defaulting \\\
 2.0.0 - DML integration prio+-->prio! detect+ --> detect! \\\
         and method\\\
       - changed access to prio and blacklist to hash\\\
       - dynamic option for prio and black \\\
       - trigger zones for designating prio and blacklist \\\
       - reworked stringInList to also include dynamics \\\
       - Report in SALT format: size, action, loc, time.\\\
       - Marks add size, action info\\\
       - LatLon or MGRS\\\
       - MGRS option in config \\\
       - filter onEvent for helo and aircraft \\\
       - allowedScouts and blind \\\
       - stronger scout filtering at startup \\\
       - better filtering on startup when autorecon and playeronly\\\
       - player lazy late checking, zone saving \\\
       - correct checks when not autorecon \\\
       - ability to add special flags to recon prio group \\\
       - event guard in onEvent\\\
       - <t> wildcard \\\
       - <lat>, <lon>, <mgrs> wildcards \\\
 \\\
 cfxReconMode is a script that allows units to perform reconnaissance\\\
 missions and, after detecting units, marks them on the map with \\\
 markers for their coalition and some text \\\
 Also, a callback is initiated for scouts as follows\\\
   signature: (reason, theSide, theSout, theGroup) with  \\\
   reason a string \\\
     'detected' a group was detected\\\
     'removed' a mark for a group timed out\\\
     'priority' a member of prio group was detected \\\
     'start' a scout started scouting\\\
     'end' a scout stopped scouting\\\
     'dead' a scout has died and was removed from pool \\\
   theSide - side of the SCOUT that detected units\\\
   theScout - the scout that detected the group \\\
   theGroup - the group that is detected  \\\
   theName - the group's name    \\\
--]]--\\\
\\\
cfxReconMode.detectionMinRange = 3000 -- meters at ground level\\\
cfxReconMode.detectionMaxRange = 12000 -- meters at max alt (10'000m)\\\
cfxReconMode.maxAlt = 9000 -- alt for maxrange (9km = 27k feet)\\\
\\\
cfxReconMode.autoRecon = true -- add all airborne units, unless \\\
cfxReconMode.redScouts = false -- set to false to prevent red scouts in auto mode\\\
cfxReconMode.blueScouts = true -- set to false to prevent blue scouts in auto-mode\\\
cfxReconMode.greyScouts = false -- set to false to prevent neutral scouts in auto mode\\\
cfxReconMode.playerOnlyRecon = false -- only players can do recon \\\
cfxReconMode.reportNumbers = true -- also add unit count in report \\\
cfxReconMode.prioFlag = nil \\\
cfxReconMode.detectFlag = nil \\\
cfxReconMode.method = \\\"inc\\\"\\\
cfxReconMode.applyMarks = true \\\
cfxReconMode.mgrs = false \\\
\\\
cfxReconMode.ups = 1 -- updates per second.\\\
cfxReconMode.scouts = {} -- units that are performing scouting.\\\
cfxReconMode.processedScouts = {} -- for managing performance: queue\\\
cfxReconMode.detectedGroups = {} -- so we know which have been detected\\\
cfxReconMode.marksFadeAfter = 30*60 -- after detection, marks disappear after\\\
                     -- this amount of seconds. -1 means no fade\\\
                     -- 60 is one minute\\\
\\\
cfxReconMode.callbacks = {} -- sig: cb(reason, side, scout, group)\\\
cfxReconMode.uuidCount = 0 -- for unique marks \\\
\\\
\\\
-- end standalone dcsCommon extract \\\
\\\
function cfxReconMode.uuid()\\\
    cfxReconMode.uuidCount = cfxReconMode.uuidCount + 1\\\
    return cfxReconMode.uuidCount\\\
end\\\
\\\
function cfxReconMode.addCallback(theCB)\\\
    table.insert(cfxReconMode.callbacks, theCB)\\\
end\\\
\\\
function cfxReconMode.invokeCallbacks(reason, theSide, theScout, theGroup, theName)\\\
    for idx, theCB in pairs(cfxReconMode.callbacks) do \\\
        theCB(reason, theSide, theScout, theGroup, theName)\\\
    end\\\
end\\\
\\\
-- add a priority/blackList group name to prio list \\\
function cfxReconMode.addToPrioList(aGroup, dynamic)\\\
    if not dynamic then dynamic = false end \\\
    if not aGroup then return end \\\
    if type(aGroup) == \\\"table\\\" and aGroup.getName then \\\
        aGroup = aGroup:getName()\\\
    end\\\
    if type(aGroup) == \\\"string\\\" then \\\
--        table.insert(cfxReconMode.prioList, aGroup)\\\
        cfxReconMode.prioList[aGroup] = aGroup\\\
        cfxReconMode.dynamics[aGroup] = dynamic \\\
    end\\\
end\\\
\\\
function cfxReconMode.addToBlackList(aGroup, dynamic)\\\
    if not dynamic then dynamic = false end \\\
    if not aGroup then return end \\\
    if type(aGroup) == \\\"table\\\" and aGroup.getName then \\\
        aGroup = aGroup:getName()\\\
    end\\\
    if type(aGroup) == \\\"string\\\" then \\\
        --table.insert(cfxReconMode.blackList, aGroup)\\\
        cfxReconMode.blackList[aGroup] = aGroup\\\
        cfxReconMode.dynamics[aGroup] = dynamic\\\
    end\\\
end\\\
\\\
function cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\\\
    if not dynamic then dynamic = false end \\\
    if not aGroup then return end \\\
    if type(aGroup) == \\\"table\\\" and aGroup.getName then \\\
        aGroup = aGroup:getName()\\\
    end\\\
    if type(aGroup) == \\\"string\\\" then \\\
        cfxReconMode.allowedScouts[aGroup] = aGroup\\\
        cfxReconMode.dynamics[aGroup] = dynamic\\\
    end\\\
end\\\
\\\
function cfxReconMode.addToBlindScoutList(aGroup, dynamic)\\\
    if not dynamic then dynamic = false end \\\
    if not aGroup then return end \\\
    if type(aGroup) == \\\"table\\\" and aGroup.getName then \\\
        aGroup = aGroup:getName()\\\
    end\\\
    if type(aGroup) == \\\"string\\\" then \\\
        cfxReconMode.blindScouts[aGroup] = aGroup\\\
        cfxReconMode.dynamics[aGroup] = dynamic\\\
    end\\\
end\\\
\\\
function cfxReconMode.isStringInList(theString, theList)\\\
    -- returns two values: inList, and original group name (if exist)\\\
    if not theString then return false, nil end \\\
    if type(theString) ~= \\\"string\\\" then return false, nil end\\\
    if not theList then return false, nil end \\\
    \\\
    -- first, try a direct look-up. if this produces a hit\\\
    -- we directly return true \\\
    if theList[theString] then return true, theString end \\\
    \\\
    -- now try the more involved retrieval with string starts with \\\
    for idx, aName in pairs(theList) do \\\
        if dcsCommon.stringStartsWith(theString, aName) then \\\
            -- they start the same. are dynamics allowed?\\\
            if cfxReconMode.dynamics[aName] then \\\
                return true, aName \\\
            end\\\
        end\\\
    end\\\
    \\\
    return false, nil\\\
end\\\
\\\
\\\
-- addScout directly adds a scout unit. Use from external \\\
-- to manually add a unit (e.g. via GUI when autoscout isExist\\\
-- off, or to force a scout unit (e.g. when scouts for a side\\\
-- are not allowed but you still want a unit from that side \\\
-- to scout\\\
-- since we use a queue for scouts, also always check the \\\
-- processed queue before adding to make sure a scout isn't \\\
-- entered multiple times \\\
\\\
function cfxReconMode.addScout(theUnit)\\\
    if not theUnit then \\\
        trigger.action.outText(\\\"+++cfxRecon: WARNING - nil Unit on add\\\", 30)\\\
        return\\\
    end\\\
    \\\
    if type(theUnit) == \\\"string\\\" then \\\
        local u = Unit.getByName(theUnit) \\\
        theUnit = u\\\
    end \\\
    \\\
    if not theUnit then \\\
        trigger.action.outText(\\\"+++cfxRecon: WARNING - did not find unit on add\\\", 30)\\\
        return \\\
    end    \\\
    if not theUnit:isExist() then return end \\\
    -- find out if this an update or a new scout \\\
    local thisID = tonumber(theUnit:getID())\\\
    local theName = theUnit:getName() \\\
    local lastUnit = cfxReconMode.scouts[theName]\\\
    local isProcced = false -- may also be in procced line \\\
    if not lastUnit then \\\
        lastUnit = cfxReconMode.processedScouts[theName]\\\
        if lastUnit then isProcced = true end \\\
    end\\\
\\\
    if lastUnit then \\\
        -- this is merely an overwrite \\\
        if cfxReconMode.verbose then trigger.action.outText(\\\"+++rcn: UPDATE scout \\\" .. theName .. \\\" -- no CB invoke\\\", 30) end \\\
    else \\\
        if cfxReconMode.verbose then trigger.action.outText(\\\"+++rcn: new scout \\\" .. theName .. \\\" with ID \\\" .. thisID, 30) end \\\
        -- a new scout! Invoke callbacks\\\
        local scoutGroup = theUnit:getGroup()\\\
        local theSide = scoutGroup:getCoalition()\\\
        cfxReconMode.invokeCallbacks(\\\"start\\\", theSide, theUnit, nil, \\\"<none>\\\")\\\
    end \\\
    \\\
    if isProcced then \\\
        -- overwrite exiting entry in procced queue\\\
        cfxReconMode.processedScouts[theName] = theUnit\\\
    else \\\
        -- add / overwrite into normal queue \\\
        cfxReconMode.scouts[theName] = theUnit\\\
    end \\\
    \\\
    if cfxReconMode.verbose then\\\
        trigger.action.outText(\\\"+++rcn: addded scout \\\" .. theUnit:getName(), 30)\\\
    end\\\
end\\\
\\\
\\\
function cfxReconMode.removeScout(theUnit)\\\
    if not theUnit then \\\
        trigger.action.outText(\\\"+++rcn: WARNING - nil Unit on remove\\\", 30)\\\
        return \\\
    end\\\
    \\\
    if type(theUnit) == \\\"string\\\" then \\\
        cfxReconMode.removeScoutByName(theUnit)\\\
        return \\\
    end \\\
    \\\
    if not theUnit then return end    \\\
    if not theUnit:isExist() then return end \\\
    cfxReconMode.removeScoutByName(theUnit:getName())\\\
    local scoutGroup = theUnit:getGroup()\\\
    local theSide = scoutGroup:getCoalition()\\\
    cfxReconMode.invokeCallbacks(\\\"end\\\", theSide, theUnit, nil, \\\"<none>\\\")\\\
end\\\
\\\
-- warning: removeScoutByName does NOT invoke callbacks, always\\\
-- use removeScout instead!\\\
function cfxReconMode.removeScoutByName(aName)\\\
    cfxReconMode.scouts[aName] = nil\\\
    cfxReconMode.processedScouts[aName] = nil -- also remove from processed stack \\\
    if cfxReconMode.verbose then\\\
        trigger.action.outText(\\\"+++rcn: removed scout \\\" .. aName, 30)\\\
    end\\\
end\\\
\\\
\\\
function cfxReconMode.canDetect(scoutPos, theGroup, visRange)\\\
    -- determine if a member of theGroup can be seen from \\\
    -- scoutPos at visRange \\\
    -- returns true and pos when detected\\\
    local allUnits = theGroup:getUnits()\\\
    for idx, aUnit in pairs(allUnits) do\\\
        if aUnit:isExist() and aUnit:getLife() >= 1 then \\\
            local uPos = aUnit:getPoint()\\\
            uPos.y = uPos.y + 3 -- raise my 3 meters\\\
            local d = dcsCommon.distFlat(scoutPos, uPos) \\\
            if d < visRange then \\\
                -- is in visual range. do we have LOS?\\\
                if land.isVisible(scoutPos, uPos) then \\\
                    -- group is visible, stop here, return true\\\
                    return true, uPos\\\
                end\\\
            else \\\
                -- OPTIMIZATION: if a unit is outside \\\
                -- detect range, we assume that entire group \\\
                -- is, since they are bunched together\\\
                -- edge cases may get lucky tests\\\
                return false, nil \\\
            end\\\
        end        \\\
    end\\\
    return false, nil -- nothing visible\\\
end\\\
\\\
function cfxReconMode.placeMarkForUnit(location, theSide, theGroup) \\\
    local theID = cfxReconMode.uuid()\\\
    local theDesc = \\\"Contact: \\\"..theGroup:getName()\\\
    if cfxReconMode.reportNumbers then \\\
--        theDesc = theDesc .. \\\" (\\\" .. theGroup:getSize() .. \\\" units)\\\"\\\
        theDesc = theDesc .. \\\" - \\\" .. cfxReconMode.getSit(theGroup) .. \\\", \\\" .. cfxReconMode.getAction(theGroup) .. \\\".\\\"\\\
    end\\\
    trigger.action.markToCoalition(\\\
                    theID, \\\
                    theDesc, \\\
                    location, \\\
                    theSide, \\\
                    false, \\\
                    nil)\\\
    return theID\\\
end\\\
\\\
function cfxReconMode.removeMarkForArgs(args)\\\
    local theSide = args[1]\\\
    local theScout = args[2]\\\
    local theGroup = args[3]\\\
    local theID = args[4]\\\
    local theName = args[5]\\\
    \\\
    -- only remove if it wasn't already removed.\\\
    -- this method is called async *and* sync!\\\
    if cfxReconMode.activeMarks[theName] then \\\
        trigger.action.removeMark(theID)\\\
        -- invoke callbacks\\\
        cfxReconMode.invokeCallbacks(\\\"removed\\\", theSide, theScout, theGroup, theName)\\\
        cfxReconMode.activeMarks[theName] = nil -- also remove from list of groups being checked\\\
    end \\\
    \\\
    cfxReconMode.detectedGroups[theName] = nil -- some housekeeping. \\\
end \\\
\\\
function cfxReconMode.getSit(theGroup)\\\
    local msg = \\\"\\\"\\\
        -- analyse the group we just discovered. We know it's a ground troop, so simply differentiate between vehicles and infantry \\\
        local theUnits = theGroup:getUnits()\\\
        local numInf = 0 \\\
        local numVehicles = 0 \\\
        for idx, aUnit in pairs(theUnits) do \\\
            if dcsCommon.unitIsInfantry(aUnit) then \\\
                numInf = numInf + 1\\\
            else \\\
                numVehicles = numVehicles + 1\\\
            end \\\
        end\\\
        if numInf > 0 and numVehicles > 0 then \\\
            -- mixed infantry and vehicles \\\
            msg = numInf .. \\\" infantry and \\\" .. numVehicles .. \\\" vehicles\\\" \\\
        elseif numInf > 0 then\\\
            -- only infantry\\\
            msg = numInf .. \\\" infantry\\\"\\\
        else \\\
            -- only vehicles\\\
            msg = numVehicles .. \\\" vehicles\\\"\\\
        end \\\
    return msg\\\
end\\\
\\\
function cfxReconMode.getAction(theGroup) \\\
    local msg = \\\"\\\"\\\
    -- simply get the first unit and get velocity vector. \\\
    -- if it's smaller than 1 m/s (= 3.6 kmh), it's \\\"Guarding\\\", if it's faster, it's \\\
    -- moving with direction\\\
    local theUnit = theGroup:getUnit(1)\\\
    local vvel = theUnit:getVelocity()\\\
    local vel = dcsCommon.vMag(vvel)\\\
    if vel < 1 then \\\
        msg = \\\"apparently guarding\\\"\\\
    else\\\
        local speed = \\\"\\\"\\\
        if vel < 3 then speed = \\\"slowly\\\"\\\
        elseif vel < 6 then speed = \\\"deliberately\\\"\\\
        else speed = \\\"briskly\\\" end \\\
        local heading = dcsCommon.getUnitHeading(theUnit) -- in rad \\\
        msg = speed .. \\\" moving \\\" .. dcsCommon.bearing2compass(heading)\\\
    end\\\
    return msg\\\
end\\\
\\\
function cfxReconMode.getLocation(theGroup)\\\
    local msg = \\\"\\\"\\\
    local theUnit = theGroup:getUnit(1)\\\
    local currPoint = theUnit:getPoint()\\\
    if cfxReconMode.mgrs then \\\
        local grid = coord.LLtoMGRS(coord.LOtoLL(currPoint))\\\
        msg = grid.UTMZone .. ' ' .. grid.MGRSDigraph .. ' ' .. grid.Easting .. ' ' .. grid.Northing\\\
    else \\\
        local lat, lon, alt = coord.LOtoLL(currPoint)\\\
        lat, lon = dcsCommon.latLon2Text(lat, lon)\\\
        msg = \\\"Lat \\\" .. lat .. \\\" Lon \\\" .. lon\\\
    end\\\
    return msg\\\
end\\\
\\\
function cfxReconMode.getTimeData()\\\
    local msg = \\\"\\\"\\\
    local absSecs = timer.getAbsTime()-- + env.mission.start_time\\\
    while absSecs > 86400 do \\\
        absSecs = absSecs - 86400 -- subtract out all days \\\
    end\\\
    msg = dcsCommon.processHMS(\\\"<:h>:<:m>:<:s>\\\", absSecs)\\\
    return \\\"at \\\" .. msg\\\
end\\\
\\\
function cfxReconMode.generateSALT(theScout, theGroup)\\\
    local msg = theScout:getName() .. \\\" reports new ground contact \\\" .. theGroup:getName() .. \\\":\\\\n\\\"\\\
    -- SALT: S = Situation or number of units A = action they are doing L = Location T = Time \\\
    msg = msg .. cfxReconMode.getSit(theGroup) .. \\\", \\\"-- S \\\
    msg = msg .. cfxReconMode.getAction(theGroup) .. \\\", \\\" -- A \\\
    msg = msg .. cfxReconMode.getLocation(theGroup) .. \\\", \\\" -- L \\\
    msg = msg .. cfxReconMode.getTimeData() -- T\\\
    \\\
    return msg\\\
end\\\
\\\
function cfxReconMode.processZoneMessage(inMsg, theZone) \\\
    if not inMsg then return \\\"<nil inMsg>\\\" end\\\
    local formerType = type(inMsg)\\\
    if formerType ~= \\\"string\\\" then inMsg = tostring(inMsg) end  \\\
    if not inMsg then inMsg = \\\"<inMsg is incompatible type \\\" .. formerType .. \\\">\\\" end \\\
    local outMsg = \\\"\\\"\\\
    -- replace line feeds \\\
    outMsg = inMsg:gsub(\\\"<n>\\\", \\\"\\\\n\\\")\\\
    if theZone then \\\
        outMsg = outMsg:gsub(\\\"<z>\\\", theZone.name)\\\
    end\\\
    -- replace <t> with current mission time HMS\\\
    local absSecs = timer.getAbsTime()-- + env.mission.start_time\\\
    while absSecs > 86400 do \\\
        absSecs = absSecs - 86400 -- subtract out all days \\\
    end\\\
    local timeString  = dcsCommon.processHMS(\\\"<:h>:<:m>:<:s>\\\", absSecs)\\\
    outMsg = outMsg:gsub(\\\"<t>\\\", timeString)\\\
    \\\
    -- replace <lat> with lat of zone point and <lon> with lon of zone point \\\
    -- and <mgrs> with mgrs coords of zone point \\\
    local currPoint = cfxZones.getPoint(theZone)\\\
    local lat, lon, alt = coord.LOtoLL(currPoint)\\\
    lat, lon = dcsCommon.latLon2Text(lat, lon)\\\
    outMsg = outMsg:gsub(\\\"<lat>\\\", lat)\\\
    outMsg = outMsg:gsub(\\\"<lon>\\\", lon)\\\
    currPoint = cfxZones.getPoint(theZone)\\\
    local grid = coord.LLtoMGRS(coord.LOtoLL(currPoint))\\\
    local mgrs = grid.UTMZone .. ' ' .. grid.MGRSDigraph .. ' ' .. grid.Easting .. ' ' .. grid.Northing\\\
    outMsg = outMsg:gsub(\\\"<mgrs>\\\", mgrs)\\\
    return outMsg\\\
end\\\
\\\
function cfxReconMode.detectedGroup(mySide, theScout, theGroup, theLoc)\\\
    -- put a mark on the map \\\
    if cfxReconMode.applyMarks then \\\
        local theID = cfxReconMode.placeMarkForUnit(theLoc, mySide, theGroup)\\\
        local gName = theGroup:getName()\\\
        local args = {mySide, theScout, theGroup, theID, gName}\\\
        cfxReconMode.activeMarks[gName] = args\\\
        -- schedule removal if desired \\\
        if cfxReconMode.marksFadeAfter > 0 then     \\\
            timer.scheduleFunction(cfxReconMode.removeMarkForArgs, args, timer.getTime() + cfxReconMode.marksFadeAfter)\\\
        end\\\
    end \\\
    \\\
    -- say something\\\
    if cfxReconMode.announcer then \\\
        local msg = cfxReconMode.generateSALT(theScout, theGroup)\\\
        trigger.action.outTextForCoalition(mySide, msg, 30)\\\
--        trigger.action.outTextForCoalition(mySide, theScout:getName() .. \\\" reports new ground contact \\\" .. theGroup:getName(), 30)\\\
        if cfxReconMode.verbose then \\\
            trigger.action.outText(\\\"+++rcn: announced for side \\\" .. mySide, 30)\\\
        end \\\
        -- play a sound \\\
        trigger.action.outSoundForCoalition(mySide, cfxReconMode.reconSound)\\\
    else \\\
    end \\\
    \\\
    -- see if it was a prio target \\\
    local inList, gName = cfxReconMode.isStringInList(theGroup:getName(), cfxReconMode.prioList)\\\
    if inList then \\\
--        if cfxReconMode.announcer then \\\
        if cfxReconMode.verbose then \\\
            trigger.action.outText(\\\"+++rcn: Priority target spotted\\\",    30)\\\
        end \\\
        -- invoke callbacks\\\
        cfxReconMode.invokeCallbacks(\\\"priority\\\", mySide, theScout, theGroup, theGroup:getName())\\\
        \\\
        -- increase prio flag \\\
        if cfxReconMode.prioFlag then \\\
            cfxZones.pollFlag(cfxReconMode.prioFlag, cfxReconMode.method, cfxReconMode.theZone)\\\
        end\\\
        \\\
        -- see if we were passed additional info in zInfo \\\
        if gName and cfxReconMode.zoneInfo[gName] then \\\
            local zInfo = cfxReconMode.zoneInfo[gName]\\\
            if zInfo.prioMessage then \\\
                local msg = zInfo.prioMessage\\\
                msg = cfxReconMode.processZoneMessage(msg, zInfo.theZone) \\\
                trigger.action.outTextForCoalition(mySide, msg, 30)\\\
                if cfxReconMode.verbose or zInfo.theZone.verbose then \\\
                    trigger.action.outText(\\\"+++rcn: prio message sent  for prio target zone <\\\" .. zInfo.theZone.name .. \\\">\\\",30)\\\
                end\\\
            end\\\
            \\\
            if zInfo.theFlag then \\\
                cfxZones.pollFlag(zInfo.theFlag, cfxReconMode.method, zInfo.theZone)\\\
                if cfxReconMode.verbose or zInfo.theZone.verbose then \\\
                    trigger.action.outText(\\\"+++rcn: banging <\\\" .. zInfo.theFlag .. \\\"> for prio target zone <\\\" .. zInfo.theZone.name .. \\\">\\\",30)\\\
                end\\\
            end \\\
        end\\\
    else \\\
        -- invoke callbacks\\\
        cfxReconMode.invokeCallbacks(\\\"detected\\\", mySide, theScout, theGroup, theGroup:getName())\\\
    \\\
        -- increase normal flag \\\
        if cfxReconMode.detectFlag then \\\
            cfxZones.pollFlag(cfxReconMode.detectFlag, cfxReconMode.method, cfxReconMode.theZone)\\\
        end\\\
    end\\\
end\\\
\\\
function cfxReconMode.performReconForUnit(theScout)\\\
    if not theScout then return end \\\
    if not theScout:isExist() then return end -- will be gc'd soon\\\
    -- get altitude above ground to calculate visual range \\\
    local alt = dcsCommon.getUnitAGL(theScout)\\\
    local visRange = dcsCommon.lerp(cfxReconMode.detectionMinRange, cfxReconMode.detectionMaxRange, alt/cfxReconMode.maxAlt)\\\
    local scoutPos = theScout:getPoint()\\\
    -- figure out which groups we are looking for\\\
    local myCoal = theScout:getCoalition()\\\
    local enemyCoal = 1 \\\
    if myCoal == 1 then enemyCoal = 2 end \\\
    \\\
    -- iterate all enemy units until we find one \\\
    -- and then stop this iteration (can only detect one \\\
    -- group per pass)\\\
    local enemyGroups = coalition.getGroups(enemyCoal)\\\
    for idx, theGroup in pairs (enemyGroups) do \\\
        -- make sure it's a ground unit \\\
        local isGround = theGroup:getCategory() == 2\\\
        if theGroup:isExist() and isGround then \\\
            local visible, location = cfxReconMode.canDetect(scoutPos, theGroup, visRange)\\\
            if visible then \\\
                -- see if we already detected this one \\\
                local groupName = theGroup:getName()\\\
                if cfxReconMode.detectedGroups[groupName] == nil then \\\
                    -- only now check against blackList\\\
                    local inList, gName = cfxReconMode.isStringInList(groupName, cfxReconMode.blackList) \\\
                    if not inList then \\\
                        -- visible and not yet seen \\\
                        -- perhaps add some percent chance now \\\
                        -- remember that we know this group \\\
                        cfxReconMode.detectedGroups[groupName] = theGroup\\\
                        cfxReconMode.detectedGroup(myCoal, theScout, theGroup, location)\\\
                        return -- stop, as we only detect one group per pass\\\
                    end \\\
                end\\\
            end\\\
        end\\\
    end\\\
end\\\
\\\
\\\
\\\
function cfxReconMode.updateQueues()\\\
    -- schedule next call \\\
    timer.scheduleFunction(cfxReconMode.updateQueues, {}, timer.getTime() + 1/cfxReconMode.ups)\\\
    \\\
    -- we only process the first aircraft in \\\
    -- the scouts array, move it to processed and then shrink\\\
    -- scouts table until it's empty. When empty, transfer all \\\
    -- back and start cycle anew\\\
\\\
    local theFocusScoutName = nil \\\
    local procCount = 0 -- no iterations done yet\\\
    for name, scout in pairs(cfxReconMode.scouts) do \\\
        theFocusScoutName = name -- remember so we can delete\\\
        if not scout:isExist() then \\\
            -- we ignore the scout, and it's \\\
            -- forgotten since no longer transferred\\\
            -- i.e. built-in GC\\\
            if cfxReconMode.verbose then\\\
                trigger.action.outText(\\\"+++rcn: GC - removing scout \\\" .. name .. \\\" because it no longer exists\\\", 30)\\\
            end\\\
            -- invoke 'end' for this scout  \\\
            cfxReconMode.invokeCallbacks(\\\"dead\\\", -1, nil, nil, name)\\\
        else\\\
            -- scan for this scout\\\
            cfxReconMode.performReconForUnit(scout)\\\
            -- move it to processed table\\\
            cfxReconMode.processedScouts[name] = scout\\\
        end\\\
        procCount = 1 -- remember we went through one iteration\\\
        break -- always end after first iteration\\\
    end\\\
\\\
    -- remove processed scouts from scouts array\\\
    if procCount > 0 then \\\
        -- we processed one scout (even if scout itself did not exist)\\\
        -- remove that scout from active scouts table\\\
        cfxReconMode.scouts[theFocusScoutName] = nil\\\
    else \\\
        -- scouts is empty. copy processed table back to scouts\\\
        -- restart scouts array, contains GC already \\\
        cfxReconMode.scouts = cfxReconMode.processedScouts\\\
        cfxReconMode.processedScouts = {} -- start new empty processed queue\\\
    end \\\
end\\\
\\\
function cfxReconMode.isGroupStillAlive(gName)\\\
        local theGroup = Group.getByName(gName)\\\
        if not theGroup then return false end \\\
        if not theGroup:isExist() then return false end \\\
        local allUnits = theGroup:getUnits()\\\
        for idx, aUnit in pairs (allUnits) do \\\
            if aUnit:getLife() >= 1 then return true end \\\
        end\\\
        return false \\\
end\\\
\\\
function cfxReconMode.autoRemove()\\\
    -- schedule next call \\\
    timer.scheduleFunction(cfxReconMode.autoRemove, {}, timer.getTime() + 1/cfxReconMode.ups)\\\
    \\\
    local toRemove = {}\\\
    -- scan all marked groups, and when they no longer exist, remove them \\\
    for idx, args in pairs (cfxReconMode.activeMarks) do\\\
        -- args = {mySide, theScout, theGroup, theID, gName}\\\
        local gName = args[5]\\\
        if not cfxReconMode.isGroupStillAlive(gName) then \\\
            -- remove mark, remove group from set \\\
            table.insert(toRemove, args)\\\
        end\\\
    end \\\
    \\\
    for idx, args in pairs(toRemove) do \\\
        cfxReconMode.removeMarkForArgs(args)\\\
        trigger.action.outText(\\\"+++recn: removed mark: \\\" .. args[5], 30)\\\
    end\\\
end\\\
\\\
-- late eval player \\\
function cfxReconMode.lateEvalPlayerUnit(theUnit)\\\
    -- check if a player is inside one of the scout zones \\\
    -- first: quick check if the player is already in a list \\\
    local aGroup = theUnit:getGroup() \\\
    local gName = aGroup:getName()\\\
    if cfxReconMode.allowedScouts[gName] then return end \\\
    if cfxReconMode.blindScouts[gName] then return end \\\
\\\
    -- get location \\\
    local p = theUnit:getPoint()\\\
    \\\
    -- iterate all scoutZones\\\
    for idx, theZone in pairs (cfxReconMode.scoutZones) do \\\
        local isScout = theZone.isScout\\\
        local dynamic = theZone.dynamic\\\
        local inZone = cfxZones.pointInZone(p, theZone)\\\
        if inZone then \\\
            if isScout then \\\
                cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\\\
                if cfxReconMode.verbose or theZone.verbose then \\\
                    if dynamic then \\\
                        trigger.action.outText(\\\"+++rcn: added LATE DYNAMIC PLAYER\\\" .. gName .. \\\" to allowed scouts\\\", 30)\\\
                    else \\\
                        trigger.action.outText(\\\"+++rcn: added LATE PLAYER \\\" .. gName .. \\\" to allowed scouts\\\", 30) \\\
                    end\\\
                end \\\
            else \\\
                cfxReconMode.addToBlindScoutList(aGroup, dynamic)\\\
                if cfxReconMode.verbose or theZone.verbose then \\\
                    if dynamic then \\\
                        trigger.action.outText(\\\"+++rcn: added LATE DYNAMIC PLAYER\\\" .. gName .. \\\" to BLIND scouts list\\\", 30)\\\
                    else \\\
                        trigger.action.outText(\\\"+++rcn: added LATE PLAYER \\\" .. gName .. \\\" to BLIND scouts list\\\", 30)\\\
                    end\\\
                end\\\
            end\\\
            return -- we stop after first found \\\
        end\\\
    end\\\
end\\\
\\\
-- event handler \\\
function cfxReconMode:onEvent(event) \\\
    if not event then return end \\\
    if not event.initiator then return end \\\
    if not (event.id == 15 or event.id == 3) then return end \\\
    \\\
    local theUnit = event.initiator \\\
    if not theUnit:isExist() then return end \\\
    local theGroup = theUnit:getGroup() \\\
--    trigger.action.outText(\\\"+++rcn-ENTER onEvent: \\\" .. event.id .. \\\" for <\\\" .. theUnit:getName() .. \\\">\\\", 30)\\\
    if not theGroup then return end \\\
    local gCat = theGroup:getCategory()\\\
    -- only continue if cat = 0 (aircraft) or 1 (helo)\\\
    if gCat > 1 then return end \\\
    \\\
    -- we simply add scouts as they are garbage-collected \\\
    -- every so often when they do not exist \\\
    if event.id == 15 or -- birth\\\
       event.id == 3 -- take-off. should already have been taken \\\
                     -- care of by birth, but you never know \\\
    then\\\
        -- check if a side must not have scouts.\\\
        -- this will prevent player units to auto-\\\
        -- scout when they are on that side. in that case\\\
        -- you must add manually\\\
        local theSide = theUnit:getCoalition()\\\
        \\\
        local isPlayer = theUnit:getPlayerName()\\\
        if isPlayer then  \\\
            -- since players wake up late, we lazy-eval their group\\\
            -- and add it to the blind/scout lists\\\
            cfxReconMode.lateEvalPlayerUnit(theUnit)\\\
            if cfxReconMode.verbose then \\\
                trigger.action.outText(\\\"+++rcn: late player check complete for <\\\" .. theUnit:getName() .. \\\">\\\", 30)\\\
            end\\\
        else \\\
            isPlayer = false -- safer than sorry\\\
        end \\\
        \\\
        if cfxReconMode.autoRecon then \\\
            if theSide == 0 and not cfxReconMode.greyScouts then \\\
                return -- grey scouts are not allowed\\\
            end\\\
            if theSide == 1 and not cfxReconMode.redScouts then \\\
                return -- grey scouts are not allowed\\\
            end\\\
            if theSide == 2 and not cfxReconMode.blueScouts then \\\
                return -- grey scouts are not allowed\\\
            end\\\
        \\\
            if cfxReconMode.playerOnlyRecon then \\\
                if not isPlayer then \\\
                    if cfxReconMode.verbose then \\\
                        trigger.action.outText(\\\"+++rcn: <\\\" .. theUnit:getName() .. \\\"> filtered: no player unit\\\", 30)\\\
                    end \\\
                    return -- only players can do recon. this unit is AI\\\
                end\\\
            end\\\
        end \\\
        \\\
        -- check if cfxReconMode.autoRecon is enabled\\\
        -- otherwise, abort the aircraft is not in \\\
        -- scourlist \\\
        local gName = theGroup:getName()\\\
        if not cfxReconMode.autoRecon then \\\
            -- no auto-recon. plane must be in scouts list \\\
            local inList, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.allowedScouts)\\\
            if not inList then \\\
                if cfxReconMode.verbose then \\\
                    trigger.action.outText(\\\"+++rcn: <\\\" .. theUnit:getName() .. \\\"> filtered: not in scout list\\\", 30)\\\
                end\\\
                return \\\
            end\\\
        end\\\
        \\\
        -- check if aircraft is in blindlist \\\
        -- abort if so \\\
        local inList, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.blindScouts)\\\
        if inList then \\\
            if cfxReconMode.verbose then \\\
                trigger.action.outText(\\\"+++rcn: <\\\" .. theUnit:getName() .. \\\"> filtered: unit cannot scout\\\", 30)\\\
            end\\\
            return \\\
        end\\\
        \\\
        if cfxReconMode.verbose then \\\
            trigger.action.outText(\\\"+++rcn: event \\\" .. event.id .. \\\" for unit \\\" .. theUnit:getName(), 30)\\\
        end \\\
        cfxReconMode.addScout(theUnit)\\\
    end\\\
--    trigger.action.outText(\\\"+++rcn-onEvent: \\\" .. event.id .. \\\" for <\\\" .. theUnit:getName() .. \\\">\\\", 30)\\\
end\\\
\\\
--\\\
-- read all existing planes \\\
-- \\\
function cfxReconMode.processScoutGroups(theGroups)\\\
    for idx, aGroup in pairs(theGroups) do \\\
        -- process all planes in that group \\\
        -- we are very early in the mission, only few groups really \\\
        -- exist now, the rest of the units come in with 15 event\\\
        if aGroup:isExist() then \\\
            -- see if we want to add these aircraft to the \\\
            -- active scout list \\\
            \\\
            local gName = aGroup:getName()\\\
            local isBlind, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.blindScouts)\\\
            local isScout, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.allowedScouts)\\\
            \\\
            local doAdd = cfxReconMode.autoRecon\\\
            if cfxReconMode.autoRecon then \\\
                local theSide = aGroup:getCoalition()\\\
                if theSide == 0 and not cfxReconMode.greyScouts then\\\
                    doAdd = false \\\
                elseif theSide == 1 and not cfxReconMode.redScouts then \\\
                    doAdd = false \\\
                elseif theSide == 2 and not cfxReconMode.blueScouts then \\\
                    doAdd = false \\\
                end \\\
            end\\\
            \\\
            if isBlind then doAdd = false end \\\
            if isScout then doAdd = true end -- overrides all \\\
            \\\
            if doAdd then \\\
                local allUnits = Group.getUnits(aGroup)\\\
                for idy, aUnit in pairs (allUnits) do \\\
                    if aUnit:isExist() then \\\
                        if cfxReconMode.autoRecon and cfxReconMode.playerOnlyRecon and (aUnit:getPlayerName() == nil)\\\
                        then\\\
                            if cfxReconMode.verbose then\\\
                                trigger.action.outText(\\\"+++rcn: skipped unit \\\" ..aUnit:getName() .. \\\" because not player unit\\\", 30)\\\
                            end\\\
                        else\\\
                            cfxReconMode.addScout(aUnit)\\\
                            if cfxReconMode.verbose then\\\
                                trigger.action.outText(\\\"+++rcn: added unit \\\" ..aUnit:getName() .. \\\" to pool at startup\\\", 30)\\\
                            end\\\
                        end\\\
                    end\\\
                end\\\
            else \\\
                if cfxReconMode.verbose then \\\
                    trigger.action.outText(\\\"+++rcn: filtered group \\\" .. gName .. \\\" from being entered into scout pool at startup\\\", 30)\\\
                end\\\
            end \\\
        end\\\
    end\\\
end\\\
\\\
function cfxReconMode.initScouts()\\\
    -- get all groups of aircraft. Unrolled loop 0..2 \\\
    -- added helicopters, removed check for grey/red/bluescouts,\\\
    -- as that happens in processScoutGroups \\\
    local theAirGroups = {}  \\\
    theAirGroups = coalition.getGroups(0, 0) -- 0 = aircraft\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
    theAirGroups = coalition.getGroups(0, 1) -- 1 = helicopter\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
\\\
    theAirGroups = coalition.getGroups(1, 0) -- 0 = aircraft\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
    theAirGroups = coalition.getGroups(1, 1) -- 1 = helicopter\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
\\\
    theAirGroups = coalition.getGroups(2, 0) -- 0 = aircraft\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
    theAirGroups = coalition.getGroups(2, 1) -- 1 = helicopter\\\
    cfxReconMode.processScoutGroups(theAirGroups)\\\
end\\\
\\\
--\\\
-- read config \\\
--\\\
function cfxReconMode.readConfigZone()\\\
    -- note: must match exactly!!!!\\\
    local theZone = cfxZones.getZoneByName(\\\"reconModeConfig\\\") \\\
    if not theZone then \\\
        if cfxReconMode.verbose then\\\
            trigger.action.outText(\\\"+++rcn: no config zone!\\\", 30) \\\
        end \\\
        theZone = cfxZones.createSimpleZone(\\\"reconModeConfig\\\")\\\
    else  \\\
        if cfxReconMode.verbose then \\\
            trigger.action.outText(\\\"+++rcn: found config zone!\\\", 30) \\\
        end \\\
    end \\\
    \\\
    cfxReconMode.verbose = cfxZones.getBoolFromZoneProperty(theZone, \\\"verbose\\\", false)\\\
\\\
    cfxReconMode.autoRecon = cfxZones.getBoolFromZoneProperty(theZone, \\\"autoRecon\\\", true)\\\
    cfxReconMode.redScouts = cfxZones.getBoolFromZoneProperty(theZone, \\\"redScouts\\\", false)\\\
    cfxReconMode.blueScouts = cfxZones.getBoolFromZoneProperty(theZone, \\\"blueScouts\\\", true)    \\\
    cfxReconMode.greyScouts = cfxZones.getBoolFromZoneProperty(theZone, \\\"greyScouts\\\", false)\\\
    cfxReconMode.playerOnlyRecon = cfxZones.getBoolFromZoneProperty(theZone, \\\"playerOnlyRecon\\\", false)\\\
    cfxReconMode.reportNumbers = cfxZones.getBoolFromZoneProperty(theZone, \\\"reportNumbers\\\", true)\\\
        \\\
    cfxReconMode.detectionMinRange = cfxZones.getNumberFromZoneProperty(theZone, \\\"detectionMinRange\\\", 3000)\\\
    cfxReconMode.detectionMaxRange = cfxZones.getNumberFromZoneProperty(theZone, \\\"detectionMaxRange\\\", 12000)\\\
    cfxReconMode.maxAlt = cfxZones.getNumberFromZoneProperty(theZone, \\\"maxAlt\\\", 9000)\\\
    \\\
    if cfxZones.hasProperty(theZone, \\\"prio+\\\") then \\\
        cfxReconMode.prioFlag = cfxZones.getStringFromZoneProperty(theZone, \\\"prio+\\\", \\\"none\\\")\\\
    elseif cfxZones.hasProperty(theZone, \\\"prio!\\\") then \\\
        cfxReconMode.prioFlag = cfxZones.getStringFromZoneProperty(theZone, \\\"prio!\\\", \\\"*<none>\\\")\\\
    end\\\
    \\\
    if cfxZones.hasProperty(theZone, \\\"detect+\\\") then \\\
        cfxReconMode.detectFlag = cfxZones.getStringFromZoneProperty(theZone, \\\"detect+\\\", \\\"none\\\")\\\
    elseif cfxZones.hasProperty(theZone, \\\"detect!\\\") then \\\
        cfxReconMode.detectFlag = cfxZones.getStringFromZoneProperty(theZone, \\\"detect!\\\", \\\"*<none>\\\")\\\
    end\\\
    \\\
    cfxReconMode.method = cfxZones.getStringFromZoneProperty(theZone, \\\"method\\\", \\\"inc\\\")\\\
    if cfxZones.hasProperty(theZone, \\\"reconMethod\\\") then \\\
        cfxReconMode.method = cfxZones.getStringFromZoneProperty(theZone, \\\"reconMethod\\\", \\\"inc\\\")\\\
    end\\\
    \\\
    cfxReconMode.applyMarks = cfxZones.getBoolFromZoneProperty(theZone, \\\"applyMarks\\\", true)\\\
    cfxReconMode.announcer = cfxZones.getBoolFromZoneProperty(theZone, \\\"announcer\\\", true)\\\
    -- trigger.action.outText(\\\"recon: announcer is \\\" .. dcsCommon.bool2Text(cfxReconMode.announcer), 30) -- announced\\\
    if cfxZones.hasProperty(theZone, \\\"reconSound\\\") then \\\
        cfxReconMode.reconSound = cfxZones.getStringFromZoneProperty(theZone, \\\"reconSound\\\", \\\"<nosound>\\\")\\\
    end\\\
    \\\
    cfxReconMode.removeWhenDestroyed = cfxZones.getBoolFromZoneProperty(theZone, \\\"autoRemove\\\", true)\\\
    \\\
    cfxReconMode.mgrs = cfxZones.getBoolFromZoneProperty(theZone, \\\"mgrs\\\", false)\\\
    \\\
    cfxReconMode.theZone = theZone -- save this zone \\\
end\\\
\\\
--\\\
-- read blackList and prio list groups\\\
--\\\
\\\
\\\
function cfxReconMode.processReconZone(theZone) \\\
    local theList = cfxZones.getStringFromZoneProperty(theZone, \\\"recon\\\", \\\"prio\\\")\\\
    theList = string.upper(theList)\\\
    local isBlack = dcsCommon.stringStartsWith(theList, \\\"BLACK\\\")\\\
\\\
    local zInfo = {}\\\
    zInfo.theZone = theZone\\\
    zInfo.isBlack = isBlack    \\\
    if cfxZones.hasProperty(theZone, \\\"spotted!\\\") then \\\
        zInfo.theFlag = cfxZones.getStringFromZoneProperty(theZone, \\\"spotted!\\\", \\\"*<none>\\\")\\\
    end\\\
    \\\
    if cfxZones.hasProperty(theZone, \\\"prioMessage\\\") then \\\
        zInfo.prioMessage = cfxZones.getStringFromZoneProperty(theZone, \\\"prioMessage\\\", \\\"<none>\\\")\\\
    end\\\
    \\\
    local dynamic = cfxZones.getBoolFromZoneProperty(theZone, \\\"dynamic\\\", false)\\\
    zInfo.dynamic = dynamic \\\
    local categ = 2 -- ground troops only\\\
    local allGroups = cfxZones.allGroupsInZone(theZone, categ)\\\
    for idx, aGroup in pairs(allGroups) do \\\
        local gName = aGroup:getName()\\\
        cfxReconMode.zoneInfo[gName] = zInfo \\\
        if isBlack then \\\
            cfxReconMode.addToBlackList(aGroup, dynamic)\\\
            if cfxReconMode.verbose or theZone.verbose then \\\
                if dynamic then trigger.action.outText(\\\"+++rcn: added DYNAMIC \\\" .. aGroup:getName() .. \\\" to blacklist\\\", 30)\\\
                else trigger.action.outText(\\\"+++rcn: added \\\" .. aGroup:getName() .. \\\" to blacklist\\\", 30) \\\
                end\\\
            end \\\
        else \\\
            cfxReconMode.addToPrioList(aGroup, dynamic)\\\
            if cfxReconMode.verbose or theZone.verbose then \\\
                if dynamic then trigger.action.outText(\\\"+++rcn: added DYNAMIC \\\" .. aGroup:getName() .. \\\" to priority target list\\\", 30)\\\
                else trigger.action.outText(\\\"+++rcn: added \\\" .. aGroup:getName() .. \\\" to priority target list\\\", 30)\\\
                end\\\
            end\\\
        end\\\
    end\\\
end\\\
\\\
function cfxReconMode.processScoutZone(theZone) \\\
    local isScout = cfxZones.getBoolFromZoneProperty(theZone, \\\"scout\\\", true)\\\
    local dynamic = cfxZones.getBoolFromZoneProperty(theZone, \\\"dynamic\\\")\\\
    theZone.dynamic = dynamic\\\
    theZone.isScout = isScout\\\
    \\\
    local categ = 0 -- aircraft\\\
    local allFixed = cfxZones.allGroupsInZone(theZone, categ)\\\
    local categ = 1 -- helos\\\
    local allRotor = cfxZones.allGroupsInZone(theZone, categ)\\\
    local allGroups = dcsCommon.combineTables(allFixed, allRotor)\\\
    for idx, aGroup in pairs(allGroups) do \\\
        if isScout then \\\
            cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\\\
            if cfxReconMode.verbose or theZone.verbose then \\\
                if dynamic then trigger.action.outText(\\\"+++rcn: added DYNAMIC \\\" .. aGroup:getName() .. \\\" to allowed scouts\\\", 30)\\\
                else trigger.action.outText(\\\"+++rcn: added \\\" .. aGroup:getName() .. \\\" to allowed scouts\\\", 30) \\\
                end\\\
            end \\\
        else \\\
            cfxReconMode.addToBlindScoutList(aGroup, dynamic)\\\
            if cfxReconMode.verbose or theZone.verbose then \\\
                if dynamic then trigger.action.outText(\\\"+++rcn: added DYNAMIC \\\" .. aGroup:getName() .. \\\" to BLIND scouts list\\\", 30)\\\
                else trigger.action.outText(\\\"+++rcn: added \\\" .. aGroup:getName() .. \\\" to BLIND scouts list\\\", 30)\\\
                end\\\
            end\\\
        end\\\
    end\\\
    \\\
    table.insert(cfxReconMode.scoutZones, theZone)\\\
end\\\
\\\
function cfxReconMode.readReconGroups()\\\
    local attrZones = cfxZones.getZonesWithAttributeNamed(\\\"recon\\\")\\\
    for k, aZone in pairs(attrZones) do \\\
        cfxReconMode.processReconZone(aZone)\\\
    end\\\
end\\\
\\\
function cfxReconMode.readScoutGroups()\\\
    local attrZones = cfxZones.getZonesWithAttributeNamed(\\\"scout\\\")\\\
    for k, aZone in pairs(attrZones) do \\\
        cfxReconMode.processScoutZone(aZone)\\\
    end\\\
end\\\
\\\
--\\\
-- start \\\
--\\\
function cfxReconMode.start()\\\
    -- lib check \\\
    if not dcsCommon.libCheck(\\\"cfx Recon Mode\\\", \\\
        cfxReconMode.requiredLibs) then\\\
        return false \\\
    end\\\
    \\\
    -- read config \\\
    cfxReconMode.readConfigZone()\\\
    \\\
    -- gather prio and blacklist groups \\\
    cfxReconMode.readReconGroups() \\\
    \\\
    -- gather allowed and forbidden scouts \\\
    cfxReconMode.readScoutGroups()\\\
    \\\
    -- gather exiting planes \\\
    cfxReconMode.initScouts()\\\
    \\\
    -- start update cycle\\\
    cfxReconMode.updateQueues()\\\
    \\\
    -- if dead groups are removed from map,\\\
    -- schedule housekeeping \\\
    if cfxReconMode.removeWhenDestroyed then \\\
        cfxReconMode.autoRemove()\\\
    end\\\
    \\\
    if true or cfxReconMode.autoRecon then \\\
        -- install own event handler to detect \\\
        -- when a unit takes off and add it to scout\\\
        -- roster \\\
        world.addEventHandler(cfxReconMode)\\\
    end\\\
    \\\
    trigger.action.outText(\\\"cfx Recon version \\\" .. cfxReconMode.version .. \\\" started.\\\", 30)\\\
    return true\\\
end\\\
\\\
--\\\
-- test callback \\\
--\\\
function cfxReconMode.demoReconCB(reason, theSide, theScout, theGroup, theName)\\\
    trigger.action.outText(\\\"recon CB: \\\" .. reason .. \\\" -- \\\" .. theScout:getName() .. \\\" spotted \\\" .. theName, 30)\\\
end\\\
\\\
if not cfxReconMode.start() then \\\
    cfxReconMode = nil\\\
end\\\
\\\
-- debug: wire up my own callback\\\
-- cfxReconMode.addCallback(cfxReconMode.demoReconCB)\\\
\\\
\\\
--[[--\\\
\\\
ideas:\\\
 \\\
- renew lease. when already sighted, simply renew lease, maybe update location.\\\
- update marks and renew lease \\\
TODO: red+ and blue+ - flags to increase when a plane of the other side is detected\\\
TODO: recon: scout and blind for aircraft in group to add / remove scouts, maybe use scout keyword \\\
 \\\
allow special bangs per priority group \\\
--]]--\\\
\\\
\\\
 \\\
 \");a_do_script(\"cfxArtilleryZones = {}\\\
cfxArtilleryZones.version = \\\"2.2.0\\\" \\\
cfxArtilleryZones.requiredLibs = {\\\
    \\\"dcsCommon\\\", -- always\\\
    \\\"cfxZones\\\", -- Zones, of course \\\
}\\\
cfxArtilleryZones.verbose = false \\\
--[[--\\\
    Version History\\\
 1.0.0 - initial version\\\
 1.0.1 - simSmokeZone\\\
 2.0.0 - zone attributes for shellNum, shellVariance,\\\
         cooldown, addMark, transitionTime\\\
       - doFireAt method\\\
       - simFireAt now calls doFireAt \\\
       - added all params to crteateArtilleryTarget\\\
       - createArtillerTarget replaced createArtilleryZone \\\
       - addMark now used so arty zones can be hidden on map\\\
       - added triggerFlag attribute \\\
       - update now fires every time when flag changes \\\
 2.0.1 - added verbose setting \\\
       - base accuracy now derived from radius \\\
       - added coalition check for ZonesInRange\\\
       - att transition time to zone info mark\\\
       - made compatible with linked zones \\\
       - added silent attribute \\\
       - added transition time to arty command chatter \\\
 2.0.2 - boom?, arty? synonyms \\\
 2.1.0 - DML Flag Support \\\
       - code cleanup\\\
 2.2.0 - DML Watchflag integration \\\
 \\\
    Artillery Target Zones *** EXTENDS ZONES ***\\\
    Target Zones for artillery. Can determine which zones are in range and visible and then handle artillery barrage to this zone \\\
    Copyright (c) 2021, 2022 by Christian Franz and cf/x AG\\\
\\\
    USAGE\\\
    Via ME: Add the relevant attributes to the zone \\\
    Via Script: Use createArtilleryTarget() \\\
\\\
\\\
    Callbacks\\\
    when fire at target is invoked, a callback can be \\\
    invoked so your code knows that fire control has been \\\
    given a command or that projectiles are impacting.\\\
    Signature\\\
    callback(rason, zone, data), with \\\
    reason: 'firing' - fire command given for zone \\\
            'impact' a projectile has hit\\\
    zone:   artilleryZone\\\
    data:   empty on 'fire' \\\
            .point where impact point\\\
            .strength power of explosion \\\
    \\\
--]]--\\\
cfxArtilleryZones.artilleryZones = {}\\\
cfxArtilleryZones.updateDelay = 1 -- every second \\\
\\\
\\\
--\\\
-- C A L L B A C K S \\\
-- \\\
cfxArtilleryZones.callbacks = {}\\\
function cfxArtilleryZones.addCallback(theCallback)\\\
    table.insert(cfxArtilleryZones.callbacks, theCallback)\\\
end\\\
\\\
function cfxArtilleryZones.invokeCallbacksFor(reason, zone, data)\\\
    for idx, theCB in pairs (cfxArtilleryZones.callbacks) do \\\
        theCB(reason, zone, data)\\\
    end\\\
end\\\
\\\
function cfxArtilleryZones.demoCallback(reason, zone, data)\\\
    -- reason: 'fire' or 'impact'\\\
    -- fire has no data, impact has data.point and data.strength \\\
end\\\
\\\
function cfxArtilleryZones.createArtilleryTarget(name, point, coalition, spotRange, transitionTime, baseAccuracy, shellNum, shellStrength, shellVariance, triggerFlag, addMark, cooldown, silent, autoAdd) -- was: createArtilleryZone, changed params list \\\
    if not point then return end \\\
    if not autoAdd then autoAdd = false end \\\
    if not coalition then coalition = 0 end \\\
    if not spotRange then spotRange = 3000 end \\\
    if not shellStrength then shellStrength = 500 end \\\
    if not transitionTime then transitionTime = 20 end \\\
    if not shellNum then shellNum = 17 end \\\
    if not addMark then addMark = false end \\\
    if not name then name = \\\"dftZName\\\" end \\\
    if not shellVariance then shellVariance = 0.2 end \\\
    if not cooldown then cooldown = 120 end \\\
    if not baseAccuracy then baseAccuracy = 100 end \\\
    if not silent then silent = false end \\\
    \\\
    name = cfxZones.createUniqueZoneName(name)\\\
    \\\
    local newZone = cfxZones.createSimpleZone(name,\\\
        point, \\\
        100, \\\
        autoAdd)\\\
    newZone.spotRange = spotRange\\\
    newZone.coalition = coalition\\\
    newZone.landHeight = land.getHeight({x = newZone.point.x, y= newZone.point.z})\\\
    newZone.transitionTime = transitionTime\\\
    newZone.shellNum = shellNum \\\
    newZone.shellStrength = shellStrength\\\
    newZone.triggerFlag = triggerFlag -- can be nil \\\
    if triggerFlag then \\\
        newZone.lastTriggerValue = trigger.misc.getUserFlag(triggerFlag) -- save last value\\\
    end \\\
    newZone.addMark = addMark\\\
    if autoAdd then cfxArtilleryZones.addArtilleryZone(newZone) end \\\
    newZone.shellVariance = shellVariance\\\
    newZone.cooldown = cooldown\\\
    newZone.silent = silent \\\
end\\\
\\\
function cfxArtilleryZones.processArtilleryZone(aZone)\\\
    aZone.artilleryTarget = cfxZones.getStringFromZoneProperty(aZone, \\\"artilleryTarget\\\", aZone.name)\\\
    aZone.coalition = cfxZones.getCoalitionFromZoneProperty(aZone, \\\"coalition\\\", 0) -- side that marks it on map, and who fires arty\\\
    aZone.spotRange = cfxZones.getNumberFromZoneProperty(aZone, \\\"spotRange\\\", 3000) -- FO max range to direct fire\\\
    aZone.shellStrength = cfxZones.getNumberFromZoneProperty(aZone, \\\"shellStrength\\\", 500) -- power of shells (strength)\\\
\\\
    aZone.shellNum = cfxZones.getNumberFromZoneProperty(aZone, \\\"shellNum\\\", 17) -- number of shells in bombardment\\\
    aZone.transitionTime = cfxZones.getNumberFromZoneProperty(aZone, \\\"transitionTime\\\", 20) -- average time of travel for projectiles \\\
    aZone.addMark = cfxZones.getBoolFromZoneProperty(aZone, \\\"addMark\\\", true) -- note: defaults to true \\\
    aZone.shellVariance = cfxZones.getNumberFromZoneProperty(aZone, \\\"shellVariance\\\", 0.2) -- strength of explosion can vary by +/- this amount\\\
    \\\
    -- watchflag:\\\
    -- triggerMethod\\\
    aZone.artyTriggerMethod = cfxZones.getStringFromZoneProperty(aZone, \\\"artyTriggerMethod\\\", \\\"change\\\")\\\
\\\
    if cfxZones.hasProperty(aZone, \\\"triggerMethod\\\") then \\\
        aZone.artyTriggerMethod = cfxZones.getStringFromZoneProperty(aZone, \\\"triggerMethod\\\", \\\"change\\\")\\\
    end\\\
    \\\
    if cfxZones.hasProperty(aZone, \\\"f?\\\") then \\\
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \\\"f?\\\", \\\"none\\\")\\\
    end\\\
    --[[--\\\
    if cfxZones.hasProperty(aZone, \\\"triggerFlag\\\") then \\\
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \\\"triggerFlag\\\", \\\"none\\\")\\\
    end\\\
    --]]--\\\
    if cfxZones.hasProperty(aZone, \\\"artillery?\\\") then \\\
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \\\"artillery?\\\", \\\"none\\\")\\\
    end\\\
    if cfxZones.hasProperty(aZone, \\\"in?\\\") then \\\
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \\\"in?\\\", \\\"none\\\")\\\
    end\\\
    \\\
    if aZone.artyTriggerFlag then \\\
        aZone.lastTriggerValue = trigger.misc.getUserFlag(aZone.artyTriggerFlag) -- save last value\\\
    end\\\
    aZone.cooldown =cfxZones.getNumberFromZoneProperty(aZone, \\\"cooldown\\\", 120) -- seconds \\\
    aZone.baseAccuracy = cfxZones.getNumberFromZoneProperty(aZone, \\\"baseAccuracy\\\", aZone.radius) -- meters from center radius shell impact\\\
    -- use zone radius as mase accuracy for simple placement\\\
    aZone.silent = cfxZones.getBoolFromZoneProperty(aZone, \\\"silent\\\", false)\\\
end\\\
\\\
function cfxArtilleryZones.addArtilleryZone(aZone)\\\
    -- add landHeight to this zone \\\
    aZone.landHeight = land.getHeight({x = aZone.point.x, y= aZone.point.z})\\\
    -- mark it on the map \\\
    aZone.artyCooldownTimer = -1000 \\\
    cfxArtilleryZones.placeMarkForSide(aZone.point, aZone.coalition, aZone.name .. \\\", FO=\\\" .. aZone.spotRange .. \\\"m\\\" .. \\\", tt=\\\" .. aZone.transitionTime)\\\
    table.insert(cfxArtilleryZones.artilleryZones, aZone)\\\
end\\\
\\\
function cfxArtilleryZones.findArtilleryZoneNamed(aName)\\\
    aZone = cfxZones.getZoneByName(aName) \\\
    if not aZone then return nil end \\\
    -- check if it is an arty zone \\\
    if not aZone.artilleryTarget then return nil end \\\
    -- all is well\\\
    return aZone \\\
end\\\
\\\
function cfxArtilleryZones.removeArtilleryZone(aZone)\\\
    if type(aZone) == \\\"string\\\" then \\\
        aZone = cfxArtilleryZones.findArtilleryZoneNamed(aZone) \\\
    end\\\
    if not aZone then return end \\\
    \\\
    -- now create new table \\\
    local filtered = {}\\\
    for idx, theZone in pairs(cfxArtilleryZones.artilleryZones) do \\\
        if theZone ~= aZone then \\\
            table.insert(filtered, theZone)\\\
        end \\\
    end\\\
    cfxArtilleryZones.artilleryZones = filtered \\\
end\\\
\\\
function cfxArtilleryZones.artilleryZonesInRangeOfUnit(theUnit)\\\
    if not theUnit then return {} end \\\
    if not theUnit:isExist() then return {} end\\\
    local myCoalition = theUnit:getCoalition()\\\
    local zonesInRange = {}\\\
    local p = theUnit:getPoint()\\\
    \\\
    for idx, aZone in pairs(cfxArtilleryZones.artilleryZones) do \\\
        -- is it one of mine?\\\
        if aZone.coalition == myCoalition then\\\
            -- is it close enough?\\\
            local zP = cfxZones.getPoint(aZone)\\\
            aZone.landHeight = land.getHeight({x = zP.x, y= zP.z})\\\
            local zonePoint = {x = zP.x, y = aZone.landHeight, z = zP.z}\\\
            local d = dcsCommon.dist(p,zonePoint)\\\
            if d < aZone.spotRange then \\\
                -- LOS check \\\
                if land.isVisible(p, zonePoint) then \\\
                    -- yeah, add to list \\\
                    table.insert(zonesInRange, aZone)\\\
                end\\\
            end\\\
        end \\\
    end\\\
    return zonesInRange\\\
end\\\
\\\
\\\
--\\\
-- MARK ON MAP\\\
--\\\
cfxArtilleryZones.uuidCount = 0\\\
function cfxArtilleryZones.uuid()\\\
    cfxArtilleryZones.uuidCount = cfxArtilleryZones.uuidCount + 1\\\
    return cfxArtilleryZones.uuidCount\\\
end\\\
\\\
function cfxArtilleryZones.placeMarkForSide(location, theSide, theDesc) \\\
    local theID = cfxArtilleryZones.uuid()\\\
    local theDesc = \\\"ARTY: \\\".. theDesc\\\
    trigger.action.markToCoalition(\\\
                    theID, \\\
                    theDesc, \\\
                    location, \\\
                    theSide, \\\
                    false, \\\
                    nil)\\\
    return theID\\\
end\\\
\\\
function cfxArtilleryZones.removeMarkForArgs(args)\\\
    local theID = args[1]    \\\
    trigger.action.removeMark(theID)\\\
end \\\
\\\
--\\\
-- FIRE AT A ZONE\\\
-- \\\
\\\
--\\\
-- BOOM command\\\
--\\\
function cfxArtilleryZones.doBoom(args)\\\
    trigger.action.explosion(args.point, args.strength)\\\
    data = {}\\\
    data.point = args.point \\\
    data.strength = args.strength \\\
    cfxArtilleryZones.invokeCallbacksFor('impact', args.zone, data)\\\
end\\\
\\\
function cfxArtilleryZones.doFireAt(aZone, maxDistFromCenter)\\\
    if type(aZone) == \\\"string\\\" then \\\
        local mZone = cfxArtilleryZones.findArtilleryZoneNamed(aZone)\\\
        aZone = mZone\\\
    end\\\
    if not aZone then return end \\\
\\\
    if not maxDistFromCenter then maxDistFromCenter = aZone.baseAccuracy end \\\
    \\\
    local accuracy = maxDistFromCenter \\\
    local zP = cfxZones.getPoint(aZone)\\\
    aZone.landHeight = land.getHeight({x = zP.x, y= zP.z}) \\\
    local center = {x=zP.x, y=aZone.landHeight, z=zP.z} -- center of where shells hit \\\
    local shellNum = aZone.shellNum\\\
    local shellBaseStrength = aZone.shellStrength\\\
    local shellVariance = aZone.shellVariance  \\\
    local transitionTime = aZone.transitionTime\\\
    \\\
    for i=1, shellNum do\\\
        local thePoint = dcsCommon.randomPointInCircle(accuracy, 0, center.x, center.z)\\\
        thePoint.y = land.getHeight({x=thePoint.x, y=thePoint.z})\\\
        local boomArgs = {}\\\
        local strVar = shellBaseStrength * shellVariance\\\
        strVar = strVar * (2 * dcsCommon.randomPercent() - 1.0) -- go from -1 to 1\\\
        \\\
        boomArgs.strength = shellBaseStrength + strVar\\\
        thePoint.y = land.getHeight({x = thePoint.x, y = thePoint.z}) + 1  -- elevate to ground height + 1\\\
        boomArgs.point = thePoint\\\
        boomArgs.zone = aZone\\\
        local timeVar = 5 * (2 * dcsCommon.randomPercent() - 1.0) -- +/- 1.5 seconds\\\
        if timeVar < 0 then timeVar = -timeVar end \\\
\\\
        timer.scheduleFunction(cfxArtilleryZones.doBoom, boomArgs, timer.getTime() + transitionTime + timeVar)\\\
    end\\\
    \\\
    -- invoke callbacks \\\
    cfxArtilleryZones.invokeCallbacksFor('fire', aZone, {})\\\
end\\\
\\\
function cfxArtilleryZones.simFireAtZone(aZone, aGroup, dist)\\\
    \\\
    if not dist then dist = aZone.spotRange end \\\
    local shellBaseStrength = aZone.shellStrength \\\
\\\
    local maxAccuracy = 100 -- m radius when close\\\
    local minAccuracy = 500 -- m radius whan at max sport dist \\\
    local currAccuracy = minAccuracy \\\
    if dist <= 1000 then \\\
        currAccuracy = maxAccuracy \\\
    else \\\
        local percent = (dist-1000) / (aZone.spotRange-1000)\\\
        currAccuracy = dcsCommon.lerp(maxAccuracy, minAccuracy, percent)\\\
    end\\\
    currAccuracy = math.floor(currAccuracy)\\\
    cfxArtilleryZones.doFireAt(aZone, currAccuracy) \\\
\\\
    aZone.artyCooldownTimer = timer.getTime() + aZone.cooldown -- 120 -- 2 minutes reload\\\
    if not aZone.silent then \\\
        local addInfo = \\\" with d=\\\" .. dist .. \\\", var = \\\" .. currAccuracy .. \\\" pB=\\\" .. shellBaseStrength .. \\\" tt=\\\" .. aZone.transitionTime\\\
    \\\
        trigger.action.outTextForCoalition(aGroup:getCoalition(), \\\"Artillery firing on \\\".. aZone.name .. addInfo, 30)\\\
    end \\\
    --trigger.action.smoke(center, 2) -- mark location visually\\\
end \\\
\\\
function cfxArtilleryZones.simSmokeZone(aZone, aGroup, aColor)\\\
    -- this is simsmoke: transition time is fixed, and we do not\\\
    -- use arty units. all very simple. we merely place smoke on\\\
    -- ground \\\
    if not aColor then aColor = \\\"red\\\" end \\\
    if type(aColor) == \\\"string\\\" then \\\
        aColor = dcsCommon.smokeColor2Num(aColor)\\\
    end\\\
    local zP = cfxZones.getPoint(aZone)\\\
    aZone.landHeight = land.getHeight({x = zP.x, y= zP.z})\\\
    \\\
    local transitionTime = aZone.transitionTime --17 -- seconds until phosphor lands\\\
    local center = {x = zP.x, \\\
                    y =aZone.landHeight + 3, \\\
                    z = zP.z\\\
                   } -- center of where shells hit \\\
    -- we now can 'dirty' the position by something. not yet\\\
    local currAccuracy = 200\\\
\\\
    local thePoint = dcsCommon.randomPointInCircle(currAccuracy, 50, center.x, center.z)\\\
    \\\
    timer.scheduleFunction(cfxArtilleryZones.doSmoke, {thePoint, aColor}, timer.getTime() + transitionTime)\\\
    \\\
    if not aGroup then return end \\\
    if aZone.silent then return end \\\
    \\\
    trigger.action.outTextForCoalition(aGroup:getCoalition(), \\\"Artillery firing single phosphor round at \\\".. aZone.name, 30)\\\
end \\\
\\\
function cfxArtilleryZones.doSmoke(args) \\\
    local thePoint = args[1]\\\
    local aColor = args[2]\\\
    dcsCommon.markPointWithSmoke(thePoint, aColor)\\\
end\\\
\\\
--\\\
-- UPDATE\\\
--\\\
\\\
function cfxArtilleryZones.update()\\\
    -- call me in a couple of minutes to 'rekindle'\\\
    timer.scheduleFunction(cfxArtilleryZones.update, {}, timer.getTime() + cfxArtilleryZones.updateDelay)\\\
    \\\
    -- iterate all zones to see if a trigger has changed \\\
    for idx, aZone in pairs(cfxArtilleryZones.artilleryZones) do \\\
        if cfxZones.testZoneFlag(aZone, aZone.artyTriggerFlag, aZone.artyTriggerMethod, \\\"lastTriggerValue\\\") then\\\
            -- a triggered release!\\\
            cfxArtilleryZones.doFireAt(aZone) -- all from zone vars!    \\\
            if cfxArtilleryZones.verbose then \\\
                local addInfo = \\\" with var = \\\" .. aZone.baseAccuracy .. \\\" pB=\\\" .. aZone.shellStrength\\\
                trigger.action.outText(\\\"Artillery T-Firing on \\\".. aZone.name .. addInfo, 30)\\\
            end \\\
        end\\\
        \\\
    \\\
        -- old code\\\
        if aZone.artyTriggerFlag then \\\
            local currTriggerVal = cfxZones.getFlagValue(aZone.artyTriggerFlag, aZone) -- trigger.misc.getUserFlag(aZone.artyTriggerFlag)\\\
            if currTriggerVal ~= aZone.lastTriggerValue\\\
            then \\\
                -- a triggered release!\\\
                cfxArtilleryZones.doFireAt(aZone) -- all from zone vars!\\\
                \\\
                if cfxArtilleryZones.verbose then \\\
                    local addInfo = \\\" with var = \\\" .. aZone.baseAccuracy .. \\\" pB=\\\" .. aZone.shellStrength\\\
                    trigger.action.outText(\\\"Artillery T-Firing on \\\".. aZone.name .. addInfo, 30)\\\
                end \\\
                aZone.lastTriggerValue = currTriggerVal\\\
            end\\\
\\\
        end\\\
    end\\\
end\\\
\\\
--\\\
-- START \\\
--\\\
\\\
function cfxArtilleryZones.start()\\\
    if not dcsCommon.libCheck(\\\"cfx Artillery Zones\\\", \\\
        cfxArtilleryZones.requiredLibs) then\\\
        return false \\\
    end\\\
    \\\
    -- collect all spawn zones \\\
    local attrZones = cfxZones.getZonesWithAttributeNamed(\\\"artilleryTarget\\\")\\\
    \\\
    -- now create a spawner for all, add them to the spawner updater, and spawn for all zones that are not\\\
    -- paused \\\
    for k, aZone in pairs(attrZones) do \\\
        cfxArtilleryZones.processArtilleryZone(aZone) -- process attribute and add to zone\\\
        cfxArtilleryZones.addArtilleryZone(aZone) -- remember it so we can smoke it\\\
    end\\\
\\\
    -- start update loop\\\
    cfxArtilleryZones.update()\\\
    \\\
    -- say hi\\\
    trigger.action.outText(\\\"cfx Artillery Zones v\\\" .. cfxArtilleryZones.version .. \\\" started.\\\", 30)\\\
    return true \\\
end\\\
\\\
-- let's go \\\
if not cfxArtilleryZones.start() then \\\
    trigger.action.outText(\\\"cf/x Artillery Zones aborted: missing libraries\\\", 30)\\\
    cfxArtilleryZones = nil \\\
end\\\
\\\
\");",
        }, -- end of ["actions"]
        ["events"] = 
        {
        }, -- end of ["events"]
        ["custom"] = 
        {
        }, -- end of ["custom"]
        ["func"] = 
        {
        }, -- end of ["func"]
        ["flag"] = 
        {
            [1] = true,
        }, -- end of ["flag"]
        ["conditions"] = 
        {
            [1] = "return(true)",
        }, -- end of ["conditions"]
        ["customStartup"] = 
        {
        }, -- end of ["customStartup"]
        ["funcStartup"] = 
        {
            [1] = "if mission.trig.conditions[1]() then mission.trig.actions[1]() end",
        }, -- end of ["funcStartup"]
    }, -- end of ["trig"]
    ["requiredModules"] = 
    {
    }, -- end of ["requiredModules"]
    ["date"] = 
    {
        ["Day"] = 21,
        ["Year"] = 2016,
        ["Month"] = 6,
    }, -- end of ["date"]
    ["result"] = 
    {
        ["offline"] = 
        {
            ["conditions"] = 
            {
            }, -- end of ["conditions"]
            ["actions"] = 
            {
            }, -- end of ["actions"]
            ["func"] = 
            {
            }, -- end of ["func"]
        }, -- end of ["offline"]
        ["total"] = 0,
        ["blue"] = 
        {
            ["conditions"] = 
            {
            }, -- end of ["conditions"]
            ["actions"] = 
            {
            }, -- end of ["actions"]
            ["func"] = 
            {
            }, -- end of ["func"]
        }, -- end of ["blue"]
        ["red"] = 
        {
            ["conditions"] = 
            {
            }, -- end of ["conditions"]
            ["actions"] = 
            {
            }, -- end of ["actions"]
            ["func"] = 
            {
            }, -- end of ["func"]
        }, -- end of ["red"]
    }, -- end of ["result"]
    ["groundControl"] = 
    {
        ["passwords"] = 
        {
            ["artillery_commander"] = 
            {
            }, -- end of ["artillery_commander"]
            ["instructor"] = 
            {
            }, -- end of ["instructor"]
            ["observer"] = 
            {
            }, -- end of ["observer"]
            ["forward_observer"] = 
            {
            }, -- end of ["forward_observer"]
        }, -- end of ["passwords"]
        ["roles"] = 
        {
            ["artillery_commander"] = 
            {
                ["neutrals"] = 0,
                ["blue"] = 0,
                ["red"] = 0,
            }, -- end of ["artillery_commander"]
            ["instructor"] = 
            {
                ["neutrals"] = 0,
                ["blue"] = 0,
                ["red"] = 0,
            }, -- end of ["instructor"]
            ["observer"] = 
            {
                ["neutrals"] = 0,
                ["blue"] = 0,
                ["red"] = 0,
            }, -- end of ["observer"]
            ["forward_observer"] = 
            {
                ["neutrals"] = 0,
                ["blue"] = 0,
                ["red"] = 0,
            }, -- end of ["forward_observer"]
        }, -- end of ["roles"]
        ["isPilotControlVehicles"] = false,
    }, -- end of ["groundControl"]
    ["maxDictId"] = 6,
    ["pictureFileNameN"] = 
    {
    }, -- end of ["pictureFileNameN"]
    ["goals"] = 
    {
    }, -- end of ["goals"]
    ["descriptionNeutralsTask"] = "DictKey_descriptionNeutralsTask_4",
    ["weather"] = 
    {
        ["atmosphere_type"] = 0,
        ["groundTurbulence"] = 0,
        ["enable_fog"] = false,
        ["wind"] = 
        {
            ["at8000"] = 
            {
                ["speed"] = 0,
                ["dir"] = 0,
            }, -- end of ["at8000"]
            ["atGround"] = 
            {
                ["speed"] = 0,
                ["dir"] = 0,
            }, -- end of ["atGround"]
            ["at2000"] = 
            {
                ["speed"] = 0,
                ["dir"] = 0,
            }, -- end of ["at2000"]
        }, -- end of ["wind"]
        ["visibility"] = 
        {
            ["distance"] = 80000,
        }, -- end of ["visibility"]
        ["season"] = 
        {
            ["temperature"] = 20,
        }, -- end of ["season"]
        ["type_weather"] = 0,
        ["qnh"] = 760,
        ["cyclones"] = 
        {
        }, -- end of ["cyclones"]
        ["name"] = "Winter, clean sky",
        ["dust_density"] = 0,
        ["fog"] = 
        {
            ["thickness"] = 0,
            ["visibility"] = 0,
        }, -- end of ["fog"]
        ["modifiedTime"] = false,
        ["enable_dust"] = false,
        ["clouds"] = 
        {
            ["thickness"] = 200,
            ["density"] = 0,
            ["preset"] = "Preset2",
            ["base"] = 2500,
            ["iprecptns"] = 0,
        }, -- end of ["clouds"]
    }, -- end of ["weather"]
    ["theatre"] = "Caucasus",
    ["triggers"] = 
    {
        ["zones"] = 
        {
            [1] = 
            {
                ["radius"] = 914.4,
                ["zoneId"] = 165,
                ["color"] = 
                {
                    [1] = 1,
                    [2] = 1,
                    [3] = 0,
                    [4] = 0.14901960784314,
                }, -- end of ["color"]
                ["properties"] = 
                {
                    [1] = 
                    {
                        ["key"] = "playerOnlyRecon",
                        ["value"] = "yes",
                    }, -- end of [1]
                    [2] = 
                    {
                        ["key"] = "detectionMinRange",
                        ["value"] = "2000",
                    }, -- end of [2]
                    [3] = 
                    {
                        ["key"] = "detectionMaxRange",
                        ["value"] = "3000",
                    }, -- end of [3]
                    [4] = 
                    {
                        ["key"] = "maxAlt",
                        ["value"] = "1500",
                    }, -- end of [4]
                    [5] = 
                    {
                        ["key"] = "announcer",
                        ["value"] = "no",
                    }, -- end of [5]
                    [6] = 
                    {
                        ["key"] = "mgrs",
                        ["value"] = "no",
                    }, -- end of [6]
                    [7] = 
                    {
                        ["key"] = "verbose",
                        ["value"] = "no",
                    }, -- end of [7]
                }, -- end of ["properties"]
                ["hidden"] = false,
                ["y"] = 648815.04111688,
                ["x"] = -281079.91177592,
                ["name"] = "reconModeConfig",
                ["type"] = 0,
            }, -- end of [1]
            [2] = 
            {
                ["radius"] = 152.4,
                ["zoneId"] = 166,
                ["color"] = 
                {
                    [1] = 1,
                    [2] = 1,
                    [3] = 1,
                    [4] = 0.15,
                }, -- end of ["color"]
                ["properties"] = 
                {
                    [1] = 
                    {
                        ["key"] = "linkedUnit",
                        ["value"] = "Convoy 1",
                    }, -- end of [1]
                    [2] = 
                    {
                        ["key"] = "recon",
                        ["value"] = "prio",
                    }, -- end of [2]
                    [3] = 
                    {
                        ["key"] = "prioMessage",
                        ["value"] = "Target In sight: <mgrs> - fire, fire, fire!",
                    }, -- end of [3]
                    [4] = 
                    {
                        ["key"] = "spotted!",
                        ["value"] = "*fireArty",
                    }, -- end of [4]
                    [5] = 
                    {
                        ["key"] = "artillery?",
                        ["value"] = "*fireArty",
                    }, -- end of [5]
                    [6] = 
                    {
                        ["key"] = "artilleryTarget",
                        ["value"] = "",
                    }, -- end of [6]
                }, -- end of ["properties"]
                ["hidden"] = false,
                ["y"] = 644816.26844201,
                ["x"] = -282478.67015391,
                ["name"] = "Convoy Artillery Recon Target",
                ["type"] = 0,
            }, -- end of [2]
        }, -- end of ["zones"]
    }, -- end of ["triggers"]
    ["map"] = 
    {
        ["centerY"] = 650833.37639741,
        ["zoom"] = 70173.739247355,
        ["centerX"] = -282810.90211251,
    }, -- end of ["map"]
    ["coalitions"] = 
    {
        ["neutrals"] = 
        {
            [1] = 70,
            [2] = 83,
            [3] = 23,
            [4] = 65,
            [5] = 86,
            [6] = 64,
            [7] = 25,
            [8] = 63,
            [9] = 76,
            [10] = 84,
            [11] = 29,
            [12] = 62,
            [13] = 30,
            [14] = 78,
            [15] = 87,
            [16] = 31,
            [17] = 61,
            [18] = 32,
            [19] = 33,
            [20] = 60,
            [21] = 17,
            [22] = 35,
            [23] = 69,
            [24] = 36,
            [25] = 59,
            [26] = 71,
            [27] = 79,
            [28] = 58,
            [29] = 57,
            [30] = 56,
            [31] = 55,
            [32] = 88,
            [33] = 73,
            [34] = 39,
            [35] = 89,
            [36] = 54,
            [37] = 77,
            [38] = 72,
            [39] = 41,
            [40] = 42,
            [41] = 44,
            [42] = 85,
            [43] = 75,
            [44] = 53,
            [45] = 22,
            [46] = 52,
            [47] = 66,
            [48] = 51,
            [49] = 74,
            [50] = 82,
            [51] = 7,
            [52] = 68,
            [53] = 50,
            [54] = 49,
            [55] = 48,
            [56] = 67,
        }, -- end of ["neutrals"]
        ["blue"] = 
        {
            [1] = 21,
            [2] = 11,
            [3] = 8,
            [4] = 80,
            [5] = 28,
            [6] = 26,
            [7] = 13,
            [8] = 5,
            [9] = 16,
            [10] = 6,
            [11] = 15,
            [12] = 20,
            [13] = 12,
            [14] = 40,
            [15] = 45,
            [16] = 9,
            [17] = 46,
            [18] = 10,
            [19] = 3,
            [20] = 4,
            [21] = 1,
            [22] = 2,
        }, -- end of ["blue"]
        ["red"] = 
        {
            [1] = 18,
            [2] = 24,
            [3] = 27,
            [4] = 81,
            [5] = 34,
            [6] = 37,
            [7] = 38,
            [8] = 0,
            [9] = 43,
            [10] = 19,
            [11] = 47,
        }, -- end of ["red"]
    }, -- end of ["coalitions"]
    ["descriptionText"] = "DictKey_descriptionText_1",
    ["pictureFileNameR"] = 
    {
    }, -- end of ["pictureFileNameR"]
    ["descriptionBlueTask"] = "DictKey_descriptionBlueTask_3",
    ["descriptionRedTask"] = "DictKey_descriptionRedTask_2",
    ["pictureFileNameB"] = 
    {
    }, -- end of ["pictureFileNameB"]
    ["coalition"] = 
    {
        ["neutrals"] = 
        {
            ["bullseye"] = 
            {
                ["y"] = 0,
                ["x"] = 0,
            }, -- end of ["bullseye"]
            ["nav_points"] = 
            {
            }, -- end of ["nav_points"]
            ["name"] = "neutrals",
            ["country"] = 
            {
            }, -- end of ["country"]
        }, -- end of ["neutrals"]
        ["blue"] = 
        {
            ["bullseye"] = 
            {
                ["y"] = 617414,
                ["x"] = -291014,
            }, -- end of ["bullseye"]
            ["nav_points"] = 
            {
            }, -- end of ["nav_points"]
            ["name"] = "blue",
            ["country"] = 
            {
                [1] = 
                {
                    ["id"] = 80,
                    ["name"] = "CJTF Blue",
                    ["plane"] = 
                    {
                        ["group"] = 
                        {
                            [1] = 
                            {
                                ["modulation"] = 0,
                                ["tasks"] = 
                                {
                                }, -- end of ["tasks"]
                                ["radioSet"] = false,
                                ["task"] = "CAS",
                                ["uncontrolled"] = false,
                                ["route"] = 
                                {
                                    ["points"] = 
                                    {
                                        [1] = 
                                        {
                                            ["alt"] = 2000,
                                            ["action"] = "Turning Point",
                                            ["alt_type"] = "BARO",
                                            ["properties"] = 
                                            {
                                                ["addopt"] = 
                                                {
                                                }, -- end of ["addopt"]
                                            }, -- end of ["properties"]
                                            ["speed"] = 179.86111111111,
                                            ["task"] = 
                                            {
                                                ["id"] = "ComboTask",
                                                ["params"] = 
                                                {
                                                    ["tasks"] = 
                                                    {
                                                        [1] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["key"] = "CAS",
                                                            ["id"] = "EngageTargets",
                                                            ["number"] = 1,
                                                            ["auto"] = true,
                                                            ["params"] = 
                                                            {
                                                                ["targetTypes"] = 
                                                                {
                                                                    [1] = "Helicopters",
                                                                    [2] = "Ground Units",
                                                                    [3] = "Light armed ships",
                                                                }, -- end of ["targetTypes"]
                                                                ["priority"] = 0,
                                                            }, -- end of ["params"]
                                                        }, -- end of [1]
                                                        [2] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 2,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["value"] = 2,
                                                                        ["name"] = 1,
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [2]
                                                        [3] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 3,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["value"] = 1,
                                                                        ["name"] = 3,
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [3]
                                                        [4] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 4,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["variantIndex"] = 2,
                                                                        ["name"] = 5,
                                                                        ["formationIndex"] = 2,
                                                                        ["value"] = 131074,
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [4]
                                                        [5] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 5,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["value"] = true,
                                                                        ["name"] = 15,
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [5]
                                                        [6] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 6,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["targetTypes"] = 
                                                                        {
                                                                        }, -- end of ["targetTypes"]
                                                                        ["name"] = 21,
                                                                        ["value"] = "none;",
                                                                        ["noTargetTypes"] = 
                                                                        {
                                                                            [1] = "Fighters",
                                                                            [2] = "Multirole fighters",
                                                                            [3] = "Bombers",
                                                                            [4] = "Helicopters",
                                                                            [5] = "Infantry",
                                                                            [6] = "Fortifications",
                                                                            [7] = "Tanks",
                                                                            [8] = "IFV",
                                                                            [9] = "APC",
                                                                            [10] = "Artillery",
                                                                            [11] = "Unarmed vehicles",
                                                                            [12] = "AAA",
                                                                            [13] = "SR SAM",
                                                                            [14] = "MR SAM",
                                                                            [15] = "LR SAM",
                                                                            [16] = "Aircraft Carriers",
                                                                            [17] = "Cruisers",
                                                                            [18] = "Destroyers",
                                                                            [19] = "Frigates",
                                                                            [20] = "Corvettes",
                                                                            [21] = "Light armed ships",
                                                                            [22] = "Unarmed ships",
                                                                            [23] = "Submarines",
                                                                            [24] = "Cruise missiles",
                                                                            [25] = "Antiship Missiles",
                                                                            [26] = "AA Missiles",
                                                                            [27] = "AG Missiles",
                                                                            [28] = "SA Missiles",
                                                                        }, -- end of ["noTargetTypes"]
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [6]
                                                        [7] = 
                                                        {
                                                            ["enabled"] = true,
                                                            ["auto"] = true,
                                                            ["id"] = "WrappedAction",
                                                            ["number"] = 7,
                                                            ["params"] = 
                                                            {
                                                                ["action"] = 
                                                                {
                                                                    ["id"] = "Option",
                                                                    ["params"] = 
                                                                    {
                                                                        ["value"] = true,
                                                                        ["name"] = 19,
                                                                    }, -- end of ["params"]
                                                                }, -- end of ["action"]
                                                            }, -- end of ["params"]
                                                        }, -- end of [7]
                                                    }, -- end of ["tasks"]
                                                }, -- end of ["params"]
                                            }, -- end of ["task"]
                                            ["type"] = "Turning Point",
                                            ["ETA"] = 0,
                                            ["ETA_locked"] = true,
                                            ["y"] = 650016.33812847,
                                            ["x"] = -279275.02306504,
                                            ["formation_template"] = "",
                                            ["speed_locked"] = true,
                                        }, -- end of [1]
                                        [2] = 
                                        {
                                            ["alt"] = 2000,
                                            ["action"] = "Turning Point",
                                            ["alt_type"] = "BARO",
                                            ["properties"] = 
                                            {
                                                ["addopt"] = 
                                                {
                                                }, -- end of ["addopt"]
                                            }, -- end of ["properties"]
                                            ["speed"] = 179.86111111111,
                                            ["task"] = 
                                            {
                                                ["id"] = "ComboTask",
                                                ["params"] = 
                                                {
                                                    ["tasks"] = 
                                                    {
                                                    }, -- end of ["tasks"]
                                                }, -- end of ["params"]
                                            }, -- end of ["task"]
                                            ["type"] = "Turning Point",
                                            ["ETA"] = 26.698487546873,
                                            ["ETA_locked"] = false,
                                            ["y"] = 641753.52331639,
                                            ["x"] = -284328.74907126,
                                            ["formation_template"] = "",
                                            ["speed_locked"] = true,
                                        }, -- end of [2]
                                    }, -- end of ["points"]
                                }, -- end of ["route"]
                                ["groupId"] = 2,
                                ["hidden"] = false,
                                ["units"] = 
                                {
                                    [1] = 
                                    {
                                        ["alt"] = 2000,
                                        ["alt_type"] = "BARO",
                                        ["livery_id"] = "algerian af desert ku-03",
                                        ["skill"] = "Player",
                                        ["speed"] = 179.86111111111,
                                        ["type"] = "Su-25T",
                                        ["unitId"] = 9,
                                        ["psi"] = 2.1197182065358,
                                        ["y"] = 650016.33812847,
                                        ["x"] = -279275.02306504,
                                        ["name"] = "Aerial-1-1",
                                        ["payload"] = 
                                        {
                                            ["pylons"] = 
                                            {
                                            }, -- end of ["pylons"]
                                            ["fuel"] = "3790",
                                            ["flare"] = 128,
                                            ["chaff"] = 128,
                                            ["gun"] = 100,
                                        }, -- end of ["payload"]
                                        ["heading"] = -2.1197182065358,
                                        ["callsign"] = 
                                        {
                                            [1] = 1,
                                            [2] = 1,
                                            [3] = 1,
                                            ["name"] = "Enfield11",
                                        }, -- end of ["callsign"]
                                        ["onboard_num"] = "010",
                                    }, -- end of [1]
                                }, -- end of ["units"]
                                ["y"] = 650016.33812847,
                                ["x"] = -279275.02306504,
                                ["name"] = "detector",
                                ["communication"] = true,
                                ["start_time"] = 0,
                                ["uncontrollable"] = false,
                                ["frequency"] = 124,
                            }, -- end of [1]
                        }, -- end of ["group"]
                    }, -- end of ["plane"]
                }, -- end of [1]
            }, -- end of ["country"]
        }, -- end of ["blue"]
        ["red"] = 
        {
            ["bullseye"] = 
            {
                ["y"] = 371700,
                ["x"] = 11557,
            }, -- end of ["bullseye"]
            ["nav_points"] = 
            {
            }, -- end of ["nav_points"]
            ["name"] = "red",
            ["country"] = 
            {
                [1] = 
                {
                    ["id"] = 81,
                    ["vehicle"] = 
                    {
                        ["group"] = 
                        {
                            [1] = 
                            {
                                ["visible"] = false,
                                ["tasks"] = 
                                {
                                }, -- end of ["tasks"]
                                ["uncontrollable"] = false,
                                ["task"] = "Ground Nothing",
                                ["taskSelected"] = true,
                                ["route"] = 
                                {
                                    ["spans"] = 
                                    {
                                        [1] = 
                                        {
                                            [1] = 
                                            {
                                                ["y"] = 644776.36063442,
                                                ["x"] = -282484.13388779,
                                            }, -- end of [1]
                                            [2] = 
                                            {
                                                ["y"] = 644339.79461821,
                                                ["x"] = -282766.60056807,
                                            }, -- end of [2]
                                            [4] = 
                                            {
                                                ["y"] = 644312.52042012,
                                                ["x"] = -282788.50766459,
                                            }, -- end of [4]
                                            [8] = 
                                            {
                                                ["y"] = 644282.65565266,
                                                ["x"] = -282822.05122749,
                                            }, -- end of [8]
                                            [16] = 
                                            {
                                                ["y"] = 644181.94365377,
                                                ["x"] = -283140.17911521,
                                            }, -- end of [16]
                                            [17] = 
                                            {
                                                ["y"] = 644090.12167198,
                                                ["x"] = -283409.88512248,
                                            }, -- end of [17]
                                            [9] = 
                                            {
                                                ["y"] = 644277.0614765,
                                                ["x"] = -282830.33884343,
                                            }, -- end of [9]
                                            [18] = 
                                            {
                                                ["y"] = 643698.85478354,
                                                ["x"] = -284916.13004873,
                                            }, -- end of [18]
                                            [5] = 
                                            {
                                                ["y"] = 644301.76507751,
                                                ["x"] = -282798.95899054,
                                            }, -- end of [5]
                                            [10] = 
                                            {
                                                ["y"] = 644271.90304783,
                                                ["x"] = -282838.90398366,
                                            }, -- end of [10]
                                            [11] = 
                                            {
                                                ["y"] = 644264.8567719,
                                                ["x"] = -282852.14343553,
                                            }, -- end of [11]
                                            [3] = 
                                            {
                                                ["y"] = 644323.91294839,
                                                ["x"] = -282778.75311709,
                                            }, -- end of [3]
                                            [6] = 
                                            {
                                                ["y"] = 644295.02490075,
                                                ["x"] = -282806.34480635,
                                            }, -- end of [6]
                                            [12] = 
                                            {
                                                ["y"] = 644260.7191408,
                                                ["x"] = -282861.24638212,
                                            }, -- end of [12]
                                            [13] = 
                                            {
                                                ["y"] = 644255.21036908,
                                                ["x"] = -282875.19625958,
                                            }, -- end of [13]
                                            [7] = 
                                            {
                                                ["y"] = 644288.65068696,
                                                ["x"] = -282814.04869758,
                                            }, -- end of [7]
                                            [14] = 
                                            {
                                                ["y"] = 644247.30806418,
                                                ["x"] = -282898.9116126,
                                            }, -- end of [14]
                                            [15] = 
                                            {
                                                ["y"] = 644214.04668294,
                                                ["x"] = -283019.39548245,
                                            }, -- end of [15]
                                        }, -- end of [1]
                                        [2] = 
                                        {
                                            [1] = 
                                            {
                                                ["y"] = 643697.00471521,
                                                ["x"] = -284915.6504684,
                                            }, -- end of [1]
                                            [2] = 
                                            {
                                                ["y"] = 643697.00471521,
                                                ["x"] = -284915.6504684,
                                            }, -- end of [2]
                                        }, -- end of [2]
                                    }, -- end of ["spans"]
                                    ["points"] = 
                                    {
                                        [1] = 
                                        {
                                            ["alt"] = 23,
                                            ["type"] = "Turning Point",
                                            ["ETA"] = 0,
                                            ["alt_type"] = "BARO",
                                            ["formation_template"] = "",
                                            ["y"] = 644777.17226673,
                                            ["x"] = -282485.39418066,
                                            ["ETA_locked"] = true,
                                            ["speed"] = 0.51388888888889,
                                            ["action"] = "On Road",
                                            ["task"] = 
                                            {
                                                ["id"] = "ComboTask",
                                                ["params"] = 
                                                {
                                                    ["tasks"] = 
                                                    {
                                                    }, -- end of ["tasks"]
                                                }, -- end of ["params"]
                                            }, -- end of ["task"]
                                            ["speed_locked"] = true,
                                        }, -- end of [1]
                                        [2] = 
                                        {
                                            ["alt"] = 12,
                                            ["type"] = "Turning Point",
                                            ["ETA"] = 5402.0776708074,
                                            ["alt_type"] = "BARO",
                                            ["formation_template"] = "",
                                            ["y"] = 643700.16121036,
                                            ["x"] = -284916.46907438,
                                            ["ETA_locked"] = false,
                                            ["speed"] = 0.51388888888889,
                                            ["action"] = "On Road",
                                            ["task"] = 
                                            {
                                                ["id"] = "ComboTask",
                                                ["params"] = 
                                                {
                                                    ["tasks"] = 
                                                    {
                                                    }, -- end of ["tasks"]
                                                }, -- end of ["params"]
                                            }, -- end of ["task"]
                                            ["speed_locked"] = true,
                                        }, -- end of [2]
                                    }, -- end of ["points"]
                                }, -- end of ["route"]
                                ["groupId"] = 1,
                                ["hidden"] = false,
                                ["units"] = 
                                {
                                    [1] = 
                                    {
                                        ["type"] = "Tigr_233036",
                                        ["unitId"] = 8,
                                        ["skill"] = "Average",
                                        ["y"] = 644777.17226673,
                                        ["x"] = -282485.39418066,
                                        ["name"] = "Convoy 1",
                                        ["heading"] = 4.1409948124228,
                                        ["playerCanDrive"] = false,
                                    }, -- end of [1]
                                    [2] = 
                                    {
                                        ["type"] = "M978 HEMTT Tanker",
                                        ["unitId"] = 7,
                                        ["skill"] = "Average",
                                        ["y"] = 644802.3886245,
                                        ["x"] = -282469.14200982,
                                        ["name"] = "Ground-1-4",
                                        ["heading"] = 4.1398835191345,
                                        ["playerCanDrive"] = false,
                                    }, -- end of [2]
                                    [3] = 
                                    {
                                        ["type"] = "M978 HEMTT Tanker",
                                        ["unitId"] = 6,
                                        ["skill"] = "Average",
                                        ["y"] = 644827.58489729,
                                        ["x"] = -282452.85874514,
                                        ["name"] = "Ground-1-3",
                                        ["heading"] = 4.1386496282219,
                                        ["playerCanDrive"] = false,
                                    }, -- end of [3]
                                    [4] = 
                                    {
                                        ["type"] = "M978 HEMTT Tanker",
                                        ["unitId"] = 2,
                                        ["skill"] = "Average",
                                        ["y"] = 644852.75397094,
                                        ["x"] = -282436.53350385,
                                        ["name"] = "Ground-1-2",
                                        ["heading"] = 4.1369823485559,
                                        ["playerCanDrive"] = false,
                                    }, -- end of [4]
                                    [5] = 
                                    {
                                        ["type"] = "Tigr_233036",
                                        ["unitId"] = 1,
                                        ["skill"] = "Average",
                                        ["y"] = 644877.90828596,
                                        ["x"] = -282420.18543915,
                                        ["name"] = "Ground-1-1",
                                        ["heading"] = 4.1360763652664,
                                        ["playerCanDrive"] = false,
                                    }, -- end of [5]
                                }, -- end of ["units"]
                                ["y"] = 644777.17226673,
                                ["x"] = -282485.39418066,
                                ["name"] = "Convoy 1",
                                ["start_time"] = 0,
                            }, -- end of [1]
                        }, -- end of ["group"]
                    }, -- end of ["vehicle"]
                    ["name"] = "CJTF Red",
                }, -- end of [1]
            }, -- end of ["country"]
        }, -- end of ["red"]
    }, -- end of ["coalition"]
    ["sortie"] = "DictKey_sortie_5",
    ["version"] = 20,
    ["trigrules"] = 
    {
        [1] = 
        {
            ["rules"] = 
            {
            }, -- end of ["rules"]
            ["eventlist"] = "",
            ["predicate"] = "triggerStart",
            ["actions"] = 
            {
                [1] = 
                {
                    ["text"] = "dcsCommon = {}\
dcsCommon.version = \"2.6.4\"\
--[[-- VERSION HISTORY\
 2.2.6 - compassPositionOfARelativeToB\
       - clockPositionOfARelativeToB\
 2.2.7 - isTroopCarrier \
       - distFlat\
 2.2.8 - fixed event2text \
 2.2.9 - getUnitAGL\
       - getUnitAlt\
       - getUnitSpeed \
       - getUnitHeading\
       - getUnitHeadingDegrees\
       - mag\
       - clockPositionOfARelativeToB with own heading \
 2.3.0 - unitIsInfantry\
 2.3.1 - bool2YesNo\
       - bool2Text\
 2.3.2 - getGroupAvgSpeed\
       - getGroupMaxSpeed\
 2.3.3 - getSizeOfTable\
 2.3.4 - isSceneryObject\
         coalition2county\
 2.3.5 - smallRandom\
         pickRandom uses smallRandom\
         airfield handling, parking \
         flight waypoint handling\
         landing waypoint creation\
         take-off waypoint creation\
 2.3.6 - createOverheadAirdromeRoutPintData(aerodrome)\
 2.3.7 - coalition2county - warning when creating UN \
 2.3.8 - improved headingOfBInDegrees, new getClockDirection\
 2.3.9 - getClosingVelocity\
       - dot product \
       - magSquare\
       - vMag\
 2.4.0 - libCheck\
 2.4.1 - grid/square/rect formation \
       - arrangeGroupInNColumns formation \
       - 2Columns formation deep and wide formation\
 2.4.2 - getAirbasesInRangeOfPoint\
 2.4.3 - lerp \
 2.4.4 - getClosestAirbaseTo\
       - fixed bug in containsString when strings equal\
 2.4.5 - added cargo and mass options to createStaticObjectData\
 2.4.6 - fixed randompercent \
 2.4.7 - smokeColor2Num(smokeColor)\
 2.4.8 - linkStaticDataToUnit()\
 2.4.9 - trim functions \
       - createGroundUnitData uses trim function to remove leading/trailing blanks\
         so now we can use blanks after comma to separate types \
       - dcsCommon.trimArray(\
       - createStaticObjectData uses trim for type \
       - getEnemyCoalitionFor understands strings, still returns number\
       - coalition2county also undertsands 'red' and 'blue'\
 2.5.0 - \"Line\" formation with one unit places unit at center     \
 2.5.1 - vNorm(a)  \
 2.5.1 - added SA-18 Igla manpad to unitIsInfantry()\
 2.5.2 - added copyArray method\
       - corrected heading in createStaticObjectData\
 2.5.3 - corrected rotateGroupData bug for cz \
       - removed forced error in failed pickRandom\
 2.5.4 - rotateUnitData()\
       - randomBetween()\
 2.5.5 - stringStartsWithDigit()\
       - stringStartsWithLetter()\
       - stringIsPositiveNumber()\
 2.5.6 - corrected stringEndsWith() bug with str\
 2.5.7 - point2text(p) \
 2.5.8 - string2GroupCat()\
 2.5.9 - string2ObjectCat()\
 2.6.0 - unified uuid, removed uuIdent\
 2.6.1 - removed bug in rotateUnitData: cy --> cz param passing  \
 2.6.2 - new combineTables()\
 2.6.3 - new tacan2freq()\
 2.6.4 - new processHMS()\
 2.6.5 - new bearing2compass()\
       - new bearingdegrees2compass()\
       - new latLon2Text() - based on mist \
       \
--]]--\
\
    -- dcsCommon is a library of common lua functions \
    -- for easy access and simple mission programming\
    -- (c) 2021, 2022 by Chritian Franz and cf/x AG\
\
    dcsCommon.verbose = false -- set to true to see debug messages. Lots of them\
    dcsCommon.uuidStr = \"uuid-\"\
    dcsCommon.simpleUUID = 76543 -- a number to start. as good as any\
    \
    -- globals\
    dcsCommon.cbID = 0 -- callback id for simple callback scheduling\
    dcsCommon.troopCarriers = {\"Mi-8MT\", \"UH-1H\", \"Mi-24P\"} -- Ka-50 and Gazelle can't carry troops\
\
    -- verify that a module is loaded. obviously not required\
    -- for dcsCommon, but all higher-order modules\
    function dcsCommon.libCheck(testingFor, requiredLibs)\
        local canRun = true \
        for idx, libName in pairs(requiredLibs) do \
            if not _G[libName] then \
                trigger.action.outText(\"*** \" .. testingFor .. \" requires \" .. libName, 30)\
                canRun = false \
            end\
        end\
        return canRun\
    end\
\
    -- returns only positive values, lo must be >0 and <= hi \
    function dcsCommon.randomBetween(loBound, hiBound)\
        if not loBound then loBound = 1 end \
        if not hiBound then hiBound = 1 end \
        if loBound == hiBound then return loBound end \
\
        local delayMin = loBound\
        local delayMax = hiBound \
        local delay = delayMax \
    \
        if delayMin ~= delayMax then \
            -- pick random in range , say 3-7 --> 5 s!\
            local delayDiff = (delayMax - delayMin) + 1 -- 7-3 + 1\
            delay = dcsCommon.smallRandom(delayDiff) - 1 --> 0-4\
            delay = delay + delayMin \
            if delay > delayMax then delay = delayMax end \
            if delay < 1 then delay = 1 end \
        \
            if dcsCommon.verbose then \
                trigger.action.outText(\"+++dcsC: delay range \" .. delayMin .. \"-\" .. delayMax .. \": selected \" .. delay, 30)\
            end\
        end\
        \
        return delay\
    end\
    \
\
    -- taken inspiration from mist, as dcs lua has issues with\
    -- random numbers smaller than 50. Given a range of x numbers 1..x, it is \
    -- repeated a number of times until it fills an array of at least \
    -- 50 items (usually some more), and only then one itemis picked from \
    -- that array with a random number that is from a greater range (0..50+)\
    function dcsCommon.smallRandom(theNum) -- adapted from mist, only support ints\
        if theNum >= 50 then return math.random(theNum) end\
        \
        -- for small randoms (<50) \
        local lowNum, highNum\
        highNum = theNum\
        lowNum = 1\
        local total = 1\
        if math.abs(highNum - lowNum + 1) < 50 then -- if total values is less than 50\
            total = math.modf(50/math.abs(highNum - lowNum + 1)) -- number of times to repeat whole range to get above 50. e.g. 11 would be 5 times 1 .. 11, giving us 55 items total \
        end\
        local choices = {}\
        for i = 1, total do -- iterate required number of times\
            for x = lowNum, highNum do -- iterate between the range\
                choices[#choices +1] = x -- add each entry to a table\
            end\
        end\
        local rtnVal; -- = math.random(#choices) -- will now do a math.random of at least 50 choices\
        for i = 1, 15 do\
            rtnVal = math.random(#choices) -- iterate 15 times for randomization\
        end\
        return choices[rtnVal] -- return indexed\
    end\
    \
\
    function dcsCommon.getSizeOfTable(theTable)\
        local count = 0\
        for _ in pairs(theTable) do count = count + 1 end\
        return count\
    end\
\
    function dcsCommon.findAndRemoveFromTable(theTable, theElement) -- assumes array \
        if not theElement then return false end \
        if not theTable then return false end \
        for i=1, #theTable do \
            if theTable[i] == theElement then \
                -- this element found. remove from table \
                table.remove(theTable, i)\
                return true \
            end\
        end\
    end\
\
    function dcsCommon.pickRandom(theTable)\
        if not theTable then \
            trigger.action.outText(\"*** warning: nil table in pick random\", 30)\
        end\
        \
        if #theTable < 1 then \
            trigger.action.outText(\"*** warning: zero choice in pick random\", 30)\
            --local k = i.ll \
            return nil\
        end\
        if #theTable == 1 then return theTable[1] end\
        r = dcsCommon.smallRandom(#theTable) --r = math.random(#theTable)\
        return theTable[r]\
    end\
\
    -- enumerateTable - make an array out of a table for indexed access\
    function dcsCommon.enumerateTable(theTable)\
        if not theTable then theTable = {} end\
        local array = {}\
        for key, value in pairs(theTable) do \
            table.insert(array, value)\
        end\
        return array\
    end\
\
    -- combine table. creates new \
    function dcsCommon.combineTables(inOne, inTwo)\
        local outTable = {}\
        for idx, element in pairs(inOne) do \
            table.insert(outTable, element)\
        end\
        for idx, element in pairs(inTwo) do \
            table.insert(outTable, element)\
        end\
        return outTable\
    end\
-- \
-- A I R F I E L D S  A N D  F A R P S  \
--\
\
    -- airfield management \
    function dcsCommon.getAirbaseCat(aBase)\
        if not aBase then return nil end \
        \
        local airDesc = aBase:getDesc()\
        if not airDesc then return nil end \
        \
        local airCat = airDesc.category\
        return airCat \
    end\
\
    -- get free parking slot. optional parkingType can be used to \
    -- filter for a scpecific type, e.g. 104 = open field\
    function dcsCommon.getFirstFreeParkingSlot(aerodrome, parkingType) \
        if not aerodrome then return nil end \
        local freeSlots = aerodrome:getParking(true)\
        \
        for idx, theSlot in pairs(freeSlots) do \
            if not parkingType then \
                -- simply return the first we come across\
                return theSlot\
            end        \
            \
            if theSlot.Term_Type == parkingType then \
                return theSlot \
            end\
        end\
        \
        return nil \
    end\
\
    -- getAirbasesInRangeOfPoint: get airbases that are in range of point \
    function dcsCommon.getAirbasesInRangeOfPoint(center, range, filterCat, filterCoalition)\
        if not center then return {} end \
        if not range then range = 500 end -- 500m default \
        local basesInRange = {}\
        \
        local allAB = dcsCommon.getAirbasesWhoseNameContains(\"*\", filterCat, filterCoalition)\
        for idx, aBase in pairs(allAB) do             \
            local delta = dcsCommon.dist(center, aBase:getPoint())\
            if delta <= range then \
                table.insert(basesInRange, aBase)\
            end\
        end\
        return basesInRange\
    end\
\
    -- getAirbasesInRangeOfAirbase returns all airbases that \
    -- are in range of the given airbase \
    function dcsCommon.getAirbasesInRangeOfAirbase(airbase, includeCenter, range, filterCat, filterCoalition)\
        if not airbase then return {} end\
        if not range then range = 150000 end \
        local center = airbase:getPoint() \
        local centerName = airbase:getName() \
        \
        local ABinRange = {}\
        local allAB = dcsCommon.getAirbasesWhoseNameContains(\"*\", filterCat, filterCoalition)\
        \
        for idx, aBase in pairs(allAB) do \
            if aBase:getName() ~= centerName then \
                local delta = dcsCommon.dist(center, aBase:getPoint())\
                if delta <= range then \
                    table.insert(ABinRange, aBase)\
                end\
            end        \
        end\
        \
        if includeCenter then \
            table.insert(ABinRange, airbase)\
        end\
        \
        return ABinRange\
    end\
\
    function dcsCommon.getAirbasesInRangeOfAirbaseList(theCenterList, includeList, range, filterCat, filterCoalition)\
        local collectorDict = {}\
        for idx, aCenter in pairs(theCenterList) do \
            -- get all surrounding airbases. returns list of airfields \
            local surroundingAB = dcsCommon.getAirbasesInRangeOfAirbase(airbase, includeList, range, filterCat, filterCoalition)\
            \
            for idx2, theAirField in pairs (surroundingAB) do \
                collectorDict[airField] = theAirField \
            end\
        end\
        \
        -- make result an array\
        local theABList = dcsCommon.enumerateTable(collectorDict)\
        return theABList\
    end\
\
    -- getAirbasesWhoseNameContains - get all airbases containing \
    -- a name. filterCat is optional and can be aerodrome (0), farp (1), ship (2)\
    -- filterCoalition is optional and can be 0 (neutral), 1 (red), 2 (blue) \
    -- if no name given or aName = \"*\", then all bases are returned prior to filtering \
    function dcsCommon.getAirbasesWhoseNameContains(aName, filterCat, filterCoalition)\
        --trigger.action.outText(\"getAB(name): enter with \" .. aName, 30)\
        if not aName then aName = \"*\" end \
        local allYourBase = world.getAirbases() -- get em all \
        local areBelongToUs = {}\
        -- now iterate all bases\
        for idx, aBase in pairs(allYourBase) do\
            local airBaseName = aBase:getName() -- get display name\
            if aName == \"*\" or dcsCommon.containsString(airBaseName, aName) then \
                -- containsString is case insesitive unless told otherwise\
                --if aName ~= \"*\" then \
                --    trigger.action.outText(\"getAB(name): matched \" .. airBaseName, 30)\
                --end \
                local doAdd = true \
                if filterCat then \
                    -- make sure the airbase is of that category \
                    local airCat = dcsCommon.getAirbaseCat(aBase)\
                    doAdd = doAdd and airCat == filterCat \
                end\
                \
                if filterCoalition then \
                    doAdd = doAdd and filterCoalition == aBase:getCoalition()\
                end\
                \
                if doAdd then \
                    -- all good, add to table\
                    table.insert(areBelongToUs, aBase)\
                end            \
            end\
        end\
        return areBelongToUs\
    end\
\
    function dcsCommon.getFirstAirbaseWhoseNameContains(aName, filterCat, filterCoalition)\
        local allBases = dcsCommon.getAirbasesWhoseNameContains(aName, filterCat, filterCoalition)\
        for idx, aBase in pairs (allBases) do \
            -- simply return first \
            return aBase\
        end\
        return nil \
    end    \
\
    function dcsCommon.getClosestAirbaseTo(thePoint, filterCat, filterCoalition)\
        local delta = math.huge\
        local allYourBase = dcsCommon.getAirbasesWhoseNameContains(\"*\", filterCat, filterCoalition) -- get em all and filter\
        local closestBase = nil \
        for idx, aBase in pairs(allYourBase) do\
            -- iterate them all \
            local abPoint = aBase:getPoint()\
            newDelta = dcsCommon.dist(thePoint, {x=abPoint.x, y = 0, z=abPoint.z})\
            if newDelta < delta then \
                delta = newDelta\
                closestBase = aBase\
            end\
        end\
        return closestBase, delta \
    end\
\
-- \
-- U N I T S   M A N A G E M E N T \
--\
\
    -- number of living units in group\
    function dcsCommon.livingUnitsInGroup(group)\
        local living = 0\
        local allUnits = group:getUnits()\
        for key, aUnit in pairs(allUnits) do \
            if aUnit:isExist() and aUnit:getLife() >= 1 then \
                living = living + 1\
            end\
        end\
        return living\
    end\
\
    -- closest living unit in group to a point\
    function dcsCommon.getClosestLivingUnitToPoint(group, p)\
        if not p then return nil end\
        if not group then return nil end\
        local closestUnit = nil\
        local closestDist = math.huge\
        local allUnits = group:getUnits()\
        for key, aUnit in pairs(allUnits) do \
            if aUnit:isExist() and aUnit:getLife() >= 1 then \
                local thisDist = dcsCommon.dist(p, aUnit:getPoint())\
                if thisDist < closestDist then \
                    closestDist = thisDist\
                    closestUnit = aUnit \
                end\
            end\
        end\
        return closestUnit, closestDist\
    end\
    \
    -- closest living group to a point - cat can be nil or one of Group.Category = { AIRPLANE = 0, HELICOPTER = 1, GROUND = 2, SHIP = 3, TRAIN = 4}\
    function dcsCommon.getClosestLivingGroupToPoint(p, coal, cat) \
        if not cat then cat = 2 end -- ground is default \
        local closestGroup = nil;\
        local closestGroupDist = math.huge\
        local allGroups =  coalition.getGroups(coal, cat) -- get all groups from this coalition, perhaps filtered by cat \
        for key, grp in pairs(allGroups) do\
            local closestUnit, dist = dcsCommon.getClosestLivingUnitToPoint(grp, p)\
            if closestUnit then \
                if dist < closestGroupDist then \
                    closestGroup = grp\
                    closestGroupDist = dist\
                end\
            end            \
        end\
        return closestGroup, closestGroupDist\
    end\
\
    function dcsCommon.getLivingGroupsAndDistInRangeToPoint(p, range, coal, cat) \
        if not cat then cat = 2 end -- ground is default \
        local groupsInRange = {};\
        local allGroups = coalition.getGroups(coal, cat) -- get all groups from this coalition, perhaps filtered by cat \
        for key, grp in pairs(allGroups) do\
            local closestUnit, dist = dcsCommon.getClosestLivingUnitToPoint(grp, p)\
            if closestUnit then \
                if dist < range then \
                    table.insert(groupsInRange, {group = grp, dist = dist}) -- array\
                end\
            end            \
        end\
        -- sort the groups by distance\
        table.sort(groupsInRange, function (left, right) return left.dist < right.dist end )\
        return groupsInRange\
    end\
\
    -- distFlat ignores y, input must be xyz points, NOT xy points  \
    function dcsCommon.distFlat(p1, p2) \
        local point1 = {x = p1.x, y = 0, z=p1.z}\
        local point2 = {x = p2.x, y = 0, z=p2.z}\
        return dcsCommon.dist(point1, point2)\
    end\
    \
    -- distance between points\
    function dcsCommon.dist(point1, point2)     -- returns distance between two points\
      -- supports xyz and xy notations\
      if not point1 then \
        trigger.action.outText(\"+++ warning: nil point1 in common:dist\", 30)\
        point1 = {x=0, y=0, z=0}\
      end\
\
      if not point2 then \
        trigger.action.outText(\"+++ warning: nil point2 in common:dist\", 30)\
        point2 = {x=0, y=0, z=0}\
        stop.here.now = 1\
      end\
      \
      local p1 = {x = point1.x, y = point1.y}\
      if not point1.z then \
        p1.z = p1.y\
        p1.y = 0\
      else \
        p1.z = point1.z\
      end\
      \
      local p2 = {x = point2.x, y = point2.y}\
      if not point2.z then \
        p2.z = p2.y\
        p2.y = 0\
      else \
        p2.z = point2.z\
      end\
      \
      local x = p1.x - p2.x\
      local y = p1.y - p2.y \
      local z = p1.z - p2.z\
      \
      return (x*x + y*y + z*z)^0.5\
    end\
\
    function dcsCommon.delta(name1, name2) -- returns distance (in meters) of two named objects\
      local n1Pos = Unit.getByName(name1):getPosition().p\
      local n2Pos = Unit.getByName(name2):getPosition().p\
      return dcsCommon.dist(n1Pos, n2Pos)\
    end\
\
    -- lerp between a and b, x being 0..1 (percentage), clipped to [0..1]\
    function dcsCommon.lerp(a, b, x) \
        if not a then return 0 end\
        if not b then return 0 end\
        if not x then return a end\
        if x < 0 then x = 0 end \
        if x > 1 then x = 1 end \
        return a + (b - a ) * x\
    end\
\
    function dcsCommon.bearingFromAtoB(A, B) -- coords in x, z \
        dx = B.x - A.x\
        dz = B.z - A.z\
        bearing = math.atan2(dz, dx) -- in radiants\
        return bearing\
    end\
\
    function dcsCommon.bearingInDegreesFromAtoB(A, B)\
        local bearing = dcsCommon.bearingFromAtoB(A, B) -- in rads \
        bearing = math.floor(bearing / math.pi * 180)\
        if bearing < 0 then bearing = bearing + 360 end\
        if bearing > 360 then bearing = bearing - 360 end\
        return bearing\
    end\
    \
    function dcsCommon.compassPositionOfARelativeToB(A, B)\
        -- warning: is REVERSE in order for bearing, returns a string like 'Sorth', 'Southwest'\
        if not A then return \"***error:A***\" end\
        if not B then return \"***error:B***\" end\
        local bearing = dcsCommon.bearingInDegreesFromAtoB(B, A) -- returns 0..360\
        if bearing < 23 then return \"North\" end \
        if bearing < 68 then return \"NE\" end\
        if bearing < 112 then return \"East\" end \
        if bearing < 158 then return \"SE\" end \
        if bearing < 202 then return \"South\" end \
        if bearing < 248 then return \"SW\" end \
        if bearing < 292 then return \"West\" end\
        if bearing < 338 then return \"NW\" end \
        return \"North\"\
    end\
    \
    function dcsCommon.bearing2compass(inrad)\
        local bearing = math.floor(inrad / math.pi * 180)\
        if bearing < 0 then bearing = bearing + 360 end\
        if bearing > 360 then bearing = bearing - 360 end\
        return dcsCommon.bearingdegrees2compass(bearing)\
    end\
    \
    function dcsCommon.bearingdegrees2compass(bearing)\
        if bearing < 23 then return \"North\" end \
        if bearing < 68 then return \"NE\" end\
        if bearing < 112 then return \"East\" end \
        if bearing < 158 then return \"SE\" end \
        if bearing < 202 then return \"South\" end \
        if bearing < 248 then return \"SW\" end \
        if bearing < 292 then return \"West\" end\
        if bearing < 338 then return \"NW\" end \
        return \"North\"\
    end\
    \
    function dcsCommon.clockPositionOfARelativeToB(A, B, headingOfBInDegrees)\
        -- o'clock notation \
        if not A then return \"***error:A***\" end\
        if not B then return \"***error:B***\" end\
        if not headingOfBInDegrees then headingOfBInDegrees = 0 end \
        \
        local bearing = dcsCommon.bearingInDegreesFromAtoB(B, A) -- returns 0..360\
--        trigger.action.outText(\"+++comm: oclock - bearing = \" .. bearing .. \" and inHeading = \" .. headingOfBInDegrees, 30) \
        bearing = bearing - headingOfBInDegrees\
        return dcsCommon.getClockDirection(bearing)\
        \
    end \
    \
    -- given a heading, return clock with 0 being 12, 180 being 6 etc.\
    function dcsCommon.getClockDirection(direction) -- inspired by cws, improvements my own\
        if not direction then return 0 end\
        direction = math.fmod (direction, 360)\
        while direction < 0 do \
            direction = direction + 360\
        end\
        \
        if direction < 15 then -- special case 12 o'clock past 12 o'clock\
            return 12\
        end\
    \
        direction = direction + 15 -- add offset so we get all other times correct\
        return math.floor(direction/30)\
    \
    end\
\
    \
    function dcsCommon.randomDegrees()\
        local degrees = math.random(360) * 3.14152 / 180\
        return degrees\
    end\
\
    function dcsCommon.randomPercent()\
        local percent = math.random(100)/100\
        return percent\
    end\
\
    function dcsCommon.randomPointOnPerimeter(sourceRadius, x, z) \
        return dcsCommon.randomPointInCircle(sourceRadius, sourceRadius-1, x, z)\
    end\
\
    function dcsCommon.randomPointInCircle(sourceRadius, innerRadius, x, z)\
        if not x then x = 0 end\
        --local y = 0\
        if not innerRadius then innerRadius = 0 end        \
        if innerRadius < 0 then innerRadius = 0 end\
        \
        local percent = dcsCommon.randomPercent() -- 1 / math.random(100)\
        -- now lets get a random degree\
        local degrees = dcsCommon.randomDegrees() -- math.random(360) * 3.14152 / 180 -- ok, it's actually radiants. \
        local r = (sourceRadius-innerRadius) * percent \
        local x = x + (innerRadius + r) * math.cos(degrees)\
        local z = z + (innerRadius + r) * math.sin(degrees)\
    \
        local thePoint = {}\
        thePoint.x = x\
        thePoint.y = 0\
        thePoint.z = z \
        \
        return thePoint, degrees\
    end\
\
    -- get group location: get the group's location by \
    -- accessing the fist existing, alive member of the group that it finds\
    function dcsCommon.getGroupLocation(group)\
        -- nifty trick from mist: make this work with group and group name\
        if type(group) == 'string' then -- group name\
            group = Group.getByName(group)\
        end\
        \
        -- get all units\
        local allUnits = group:getUnits()\
\
        -- iterate through all members of group until one is alive and exists\
        for index, theUnit in pairs(allUnits) do \
            if (theUnit:isExist() and theUnit:getLife() > 0) then \
                return theUnit:getPosition().p \
            end;\
        end\
\
        -- if we get here, there was no live unit \
        --trigger.action.outText(\"+++cmn: A group has no live units. returning nil\", 10)\
        return nil \
        \
    end\
\
    -- get the group's first Unit that exists and is \
    -- alive \
    function dcsCommon.getGroupUnit(group)\
        if not group then return nil  end\
        \
        -- nifty trick from mist: make this work with group and group name\
        if type(group) == 'string' then -- group name\
            group = Group.getByName(group)\
        end\
        \
        if not group:isExist() then return nil end \
        \
        -- get all units\
        local allUnits = group:getUnits()\
\
        -- iterate through all members of group until one is alive and exists\
        for index, theUnit in pairs(allUnits) do \
            if (theUnit:isExist() and theUnit:getLife() > 0) then \
                return theUnit\
            end;\
        end\
\
        -- if we get here, there was no live unit \
        --trigger.action.outText(\"+++cmn A group has no live units. returning nil\", 10)\
        return nil \
        \
    end\
\
    -- and here the alias\
    function dcsCommon.getFirstLivingUnit(group)\
        return dcsCommon.getGroupUnit(group)\
    end\
    \
    -- isGroupAlive returns true if there is at least one unit in the group that isn't dead\
    function dcsCommon.isGroupAlive(group)\
        return (dcsCommon.getGroupUnit(group) ~= nil) \
    end\
\
    function dcsCommon.getLiveGroupUnits(group)\
        -- nifty trick from mist: make this work with group and group name\
        if type(group) == 'string' then -- group name\
            group = Group.getByName(group)\
        end\
        \
        local liveUnits = {}\
        -- get all units\
        local allUnits = group:getUnits()\
\
        -- iterate through all members of group until one is alive and exists\
        for index, theUnit in pairs(allUnits) do \
            if (theUnit:isExist() and theUnit:getLife() > 0) then \
                table.insert(liveUnits, theUnit) \
            end;\
        end\
\
        -- if we get here, there was no live unit \
        return liveUnits\
    end\
\
    function dcsCommon.getGroupTypeString(group) -- convert into comma separated types \
        if not group then \
            trigger.action.outText(\"+++cmn getGroupTypeString: nil group\", 30)\
            return \"\" \
        end\
        if not dcsCommon.isGroupAlive(group) then \
            trigger.action.outText(\"+++cmn getGroupTypeString: dead group\", 30)\
            return \"\" \
        end \
        local theTypes = \"\"\
        local liveUnits = dcsCommon.getLiveGroupUnits(group)\
        for i=1, #liveUnits do \
            if i > 1 then theTypes = theTypes .. \",\" end\
            theTypes = theTypes .. liveUnits[i]:getTypeName()\
        end\
        return theTypes\
    end\
\
    function dcsCommon.getGroupTypes(group) \
        if not group then \
            trigger.action.outText(\"+++cmn getGroupTypes: nil group\", 30)\
            return {}\
        end\
        if not dcsCommon.isGroupAlive(group) then \
            trigger.action.outText(\"+++cmn getGroupTypes: dead group\", 30)\
            return {}\
        end \
        local liveUnits = dcsCommon.getLiveGroupUnits(group)\
        local unitTypes = {}\
        for i=1, #liveUnits do \
            table.insert(unitTypes, liveUnits[i]:getTypeName())\
        end\
        return unitTypes\
    end\
\
    function dcsCommon.getEnemyCoalitionFor(aCoalition)\
        if aCoalition == 1 then return 2 end\
        if aCoalition == 2 then return 1 end\
        if type(aCoalition) == \"string\" then \
            aCoalition = aCoalition:lower()\
            if aCoalition == \"red\" then return 2 end\
            if aCoalition == \"blue\" then return 1 end\
        end\
        return nil\
    end\
\
    function dcsCommon.getACountryForCoalition(aCoalition)\
        -- scan the table of countries and get the first country that is part of aCoalition\
        -- this is useful if you want to create troops for a coalition but don't know the\
        -- coalition's countries \
        -- we start with id=0 (Russia), go to id=85 (Slovenia), but skip id = 14\
        local i = 0\
        while i < 86 do \
            if i ~= 14 then \
                if (coalition.getCountryCoalition(i) == aCoalition) then return i end\
            end\
            i = i + 1\
        end\
        \
        return nil\
    end\
--\
--\
-- C A L L B A C K   H A N D L E R \
--\
--\
\
    -- installing callbacks\
    -- based on mist, with optional additional hooks for pre- and post-\
    -- processing of the event\
    -- when filtering occurs in pre, an alternative 'rejected' handler can be called \
    function dcsCommon.addEventHandler(f, pre, post, rejected) -- returns ID \
        local handler = {} -- build a wrapper and connect the onEvent\
        --dcsCommon.cbID = dcsCommon.cbID + 1 -- increment unique count\
        handler.id = dcsCommon.uuid(\"eventHandler\")\
        handler.f = f -- the callback itself\
        if (rejected) then handler.rejected = rejected end\
        -- now set up pre- and post-processors. defaults are set in place\
        -- so pre and post are optional. If pre returns false, the callback will\
        -- not be invoked\
        if (pre) then handler.pre = pre else handler.pre = dcsCommon.preCall end\
        if (post) then handler.post = post else handler.post = dcsCommon.postCall end\
        function handler:onEvent(event)\
            if not self.pre(event) then \
                if dcsCommon.verbose then\
--                    trigger.action.outText(\"event \" .. event.id .. \" discarded by pre-processor\", 10)\
                end\
                if (self.rejected) then self.rejected(event) end \
                return\
            end\
            self.f(event) -- call the handler\
            self.post(event) -- do post-processing\
        end\
        world.addEventHandler(handler)\
        return handler.id\
    end\
\
    function dcsCommon.preCall(e)\
        -- we can filter here\
        -- if we return false, the call is abortet\
        if dcsCommon.verbose then\
            trigger.action.outText(\"event \" .. e.id .. \" received: PRE-PROCESSING\", 10)\
        end\
        return true;\
    end;\
\
    function dcsCommon.postCall(e)\
        -- we do pos proccing here \
        if dcsCommon.verbose then\
            trigger.action.outText(\"event \" .. e.id .. \" received: post proc\", 10)\
        end\
    end\
    \
    -- highly specific eventhandler for one event only\
    -- based on above, with direct filtering built in; skips pre\
    -- but does post\
    function dcsCommon.addEventHandlerForEventTypes(f, evTypes, post, rejected) -- returns ID \
        local handler = {} -- build a wrapper and connect the onEvent\
        dcsCommon.cbID = dcsCommon.cbID + 1 -- increment unique count\
        handler.id = dcsCommon.cbID\
        handler.what = evTypes\
        if (rejected) then handler.rejected = rejected end \
        \
        handler.f = f -- set the callback itself\
        -- now set up post-processor. pre is hard-coded to match evType\
        -- post is optional. If event.id is not in evTypes, the callback will\
        -- not be invoked\
        if (post) then handler.post = post else handler.post = dcsCommon.postCall end\
        function handler:onEvent(event)\
            hasMatch = false;\
            for key, evType in pairs(self.what) do\
                if evType == event.id then\
                    hasMatch = true;\
                    break;\
                end;\
            end;\
            if not hasMatch then \
                if dcsCommon.verbose then\
                    trigger.action.outText(\"event \" .. e.id .. \" discarded - not in whitelist evTypes\", 10)\
                end\
                if (self.rejected) then self.rejected(event) end \
                return;\
            end;\
            \
            self.f(event) -- call the actual handler as passed to us\
            self.post(event) -- do post-processing \
        end\
        world.addEventHandler(handler) -- add to event handlers\
        return handler.id\
    end\
    \
    \
    \
    -- remove event handler / callback, identical to Mist \
    -- note we don't call world.removeEventHandler, but rather directly \
    -- access world.eventHandlers directly and remove kvp directly.\
    function dcsCommon.removeEventHandler(id)\
        for key, handler in pairs(world.eventHandlers) do\
            if handler.id and handler.id == id then\
                world.eventHandlers[key] = nil\
                return true\
            end\
        end\
        return false\
    end\
\
--\
--\
-- C L O N I N G \
--\
--\
    -- topClone is a shallow clone of orig, only top level is iterated,\
    -- all values are ref-copied\
    function dcsCommon.topClone(orig)\
        local orig_type = type(orig)\
        local copy\
        if orig_type == 'table' then\
            copy = {}\
            for orig_key, orig_value in pairs(orig) do\
                copy[orig_key] = orig_value\
            end\
        else -- number, string, boolean, etc\
            copy = orig\
        end\
        return copy\
    end\
\
    -- clone is a recursive clone which will also clone\
    -- deeper levels, as used in units \
    function dcsCommon.clone(orig)\
        local orig_type = type(orig)\
        local copy\
        if orig_type == 'table' then\
            copy = {}\
            for orig_key, orig_value in next, orig, nil do\
                copy[dcsCommon.clone(orig_key)] = dcsCommon.clone(orig_value)\
            end\
            setmetatable(copy, dcsCommon.clone(getmetatable(orig)))\
        else -- number, string, boolean, etc\
            copy = orig\
        end\
        return copy\
    end\
\
    function dcsCommon.copyArray(inArray)\
        -- warning: this is a ref copy!\
        local theCopy = {}\
        for idx, element in pairs(inArray) do \
            table.insert(theCopy, element)\
        end\
        return theCopy \
    end\
--\
-- \
-- S P A W N I N G \
-- \
-- \
\
    function dcsCommon.createEmptyGroundGroupData (name)\
        local theGroup = {} -- empty group\
        theGroup.visible = false\
        theGroup.taskSelected = true\
        -- theGroup.route = {}\
        -- theGroup.groupId = id\
        theGroup.tasks = {}\
        -- theGroup.hidden = false -- hidden on f10?\
\
        theGroup.units = { } -- insert units here! -- use addUnitToGroupData\
\
        theGroup.x = 0\
        theGroup.y = 0\
        theGroup.name = name\
        -- theGroup.start_time = 0\
        theGroup.task = \"Ground Nothing\"\
        \
        return theGroup\
    end;\
\
    function dcsCommon.createEmptyAircraftGroupData (name)\
        local theGroup = dcsCommon.createEmptyGroundGroupData(name)--{} -- empty group\
\
        theGroup.task = \"Nothing\" -- can be others, like Transport, CAS, etc\
        -- returns with empty route\
        theGroup.route = dcsCommon.createEmptyAircraftRouteData() -- we can add points here \
        return theGroup\
    end;\
\
    function dcsCommon.createAircraftRoutePointData(x, z, altitudeInFeet, knots, altType, action)\
        local rp = {}\
        rp.x = x\
        rp.y = z\
        rp.action = \"Turning Point\"\
        rp.type = \"Turning Point\"\
        if action then rp.action = action; rp.type = action end -- warning: may not be correct, need to verify later\
        rp.alt = altitudeInFeet * 0.3048\
        rp.speed = knots * 0.514444 -- we use \
        rp.alt_type = \"BARO\"\
        if (altType) then rp.alt_type = altType end \
        return rp\
    end\
\
    function dcsCommon.addRoutePointDataToRouteData(inRoute, x, z, altitudeInFeet, knots, altType, action)\
        local p = dcsCommon.createAircraftRoutePointData(x, z, altitudeInFeet, knots, altType, action)\
        local thePoints = inRoute.points \
        table.insert(thePoints, p)\
    end\
    \
    function dcsCommon.addRoutePointDataToGroupData(group, x, z, altitudeInFeet, knots, altType, action)\
        if not group.route then group.route = dcsCommon.createEmptyAircraftRouteData() end\
        local theRoute = group.route \
        dcsCommon.addRoutePointDataToRouteData(theRoute, x, z, altitudeInFeet, knots, altType, action)\
    end\
\
    function dcsCommon.addRoutePointForGroupData(theGroup, theRP)\
        if not theGroup then return end \
        if not theGroup.route then theGroup.route = dcsCommon.createEmptyAircraftRouteData() end\
        \
        local theRoute = theGroup.route \
        local thePoints = theRoute.points \
        table.insert(thePoints, theRP)\
    end\
    \
    function dcsCommon.createEmptyAircraftRouteData()\
        local route = {}\
        route.points = {}\
        return route\
    end\
\
    function dcsCommon.createTakeOffFromParkingRoutePointData(aerodrome)\
        if not aerodrome then return nil end \
            \
        local rp = {}    \
        local freeParkingSlot = dcsCommon.getFirstFreeParkingSlot(aerodrome, 104) -- get big slot first \
        if not freeParkingSlot then \
            freeParkingSlot = dcsCommon.getFirstFreeParkingSlot(aerodrome) -- try any size\
        end\
            \
        if not freeParkingSlot then \
            trigger.action.outText(\"civA: no free parking at \" .. aerodrome:getName(), 30)\
            return nil \
        end\
            \
        local p = freeParkingSlot.vTerminalPos\
            \
        rp.airdromeId = aerodrome:getID() \
        rp.x = p.x\
        rp.y = p.z\
        rp.alt = p.y \
        rp.action = \"From Parking Area\"\
        rp.type = \"TakeOffParking\"\
            \
        rp.speed = 100; -- in m/s? If so, that's 360 km/h \
        rp.alt_type = \"BARO\"\
        return rp\
    end\
\
    function dcsCommon.createOverheadAirdromeRoutPintData(aerodrome)\
        if not aerodrome then return nil end \
        local rp = {}            \
        local p = aerodrome:getPoint()\
        rp.x = p.x\
        rp.y = p.z\
        rp.alt = p.y + 2000 -- 6000 ft overhead\
        rp.action = \"Turning Point\"\
        rp.type = \"Turning Point\"\
            \
        rp.speed = 133; -- in m/s? If so, that's 360 km/h \
        rp.alt_type = \"BARO\"\
        return rp\
    end\
    \
\
    function dcsCommon.createLandAtAerodromeRoutePointData(aerodrome)\
        if not aerodrome then return nil end \
            \
        local rp = {}            \
        local p = aerodrome:getPoint()\
        rp.airdromeId = aerodrome:getID() \
        rp.x = p.x\
        rp.y = p.z\
        rp.alt = p.y \
        rp.action = \"Landing\"\
        rp.type = \"Land\"\
            \
        rp.speed = 100; -- in m/s? If so, that's 360 km/h \
        rp.alt_type = \"BARO\"\
        return rp\
    end\
\
    \
    function dcsCommon.createRPFormationData(findex) -- must be added as \"task\" to an RP. use 4 for Echelon right\
        local task = {}\
        task.id = \"ComboTask\"\
        local params = {}\
        task.params = params\
        local tasks = {}\
        params.tasks = tasks\
        local t1 = {}\
        tasks[1] = t1\
        t1.number = 1\
        t1.auto = false \
        t1.id = \"WrappedAction\"\
        t1.enabled = true\
        local t1p = {}\
        t1.params = t1p\
        local action = {}\
        t1p.action = action \
        action.id = \"Option\"\
        local ap = {}\
        action.params = ap\
        ap.variantIndex = 3\
        ap.name = 5 -- AI.Option.Air.ID 5 = Formation \
        ap.formationIndex = findex -- 4 is echelon_right\
        ap.value = 262147\
        \
        return task \
    end\
\
    function dcsCommon.addTaskDataToRP(theTask, theGroup, rpIndex)\
        local theRoute = theGroup.route\
        local thePoints = theRoute.points\
        local rp = thePoints[rpIndex]\
        rp.task = theTask\
    end\
    \
    -- create a minimal payload table that is compatible with creating \
    -- a unit. you may need to alter this before adding the unit to\
    -- the mission. all params optional \
    function dcsCommon.createPayload(fuel, flare, chaff, gun) \
        local payload = {}\
        payload.pylons = {}\
        if not fuel then fuel = 1000 end -- in kg. check against fuelMassMax in type desc\
        if not flare then flare = 0 end\
        if not chaff then chaff = 0 end\
        if not gun then gun = 0 end\
        return payload \
        \
    end\
\
    function dcsCommon.createCallsign(cs) \
        local callsign = {}\
        callsign[1] = 1\
        callsign[2] = 1\
        callsign[3] = 1\
        if not cs then cs = \"Enfield11\" end\
        callsign.name = cs\
        return callsign\
    end\
    \
\
    -- create the data table required to spawn a unit.\
    -- unit types are defined in https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB\
    function dcsCommon.createGroundUnitData(name, unitType, transportable)\
        local theUnit = {}\
        unitType = dcsCommon.trim(unitType)\
        theUnit.type = unitType -- e.g. \"LAV-25\",\
        if not transportable then transportable = false end -- elaborate, not requried code\
        theUnit.transportable = {[\"randomTransportable\"] = transportable} \
        -- theUnit.unitId = id \
        theUnit.skill = \"Average\" -- always average \
        theUnit.x = 0 -- make it zero, zero!\
        theUnit.y = 0\
        theUnit.name = name\
        theUnit.playerCanDrive = false\
        theUnit.heading = 0\
        return theUnit\
    end \
\
    function dcsCommon.createAircraftUnitData(name, unitType, transportable, altitude, speed, heading)\
        local theAirUnit = dcsCommon.createGroundUnitData(name, unitType, transportable)\
        theAirUnit.alt = 100 -- make it 100m\
        if altitude then theAirUnit.alt = altitude end \
        theAirUnit.alt_type = \"RADIO\" -- AGL\
        theAirUnit.speed = 77 -- m/s --> 150 knots\
        if speed then theAirUnit.speed = speed end \
        if heading then theAirUnit.heading = heading end \
        theAirUnit.payload = dcsCommon.createPayload()\
        theAirUnit.callsign = dcsCommon.createCallsign()\
        return theAirUnit\
    end\
    \
\
    function dcsCommon.addUnitToGroupData(theUnit, theGroup, dx, dy, heading)\
        -- add a unit to a group, and place it at dx, dy of group's position,\
        -- taking into account unit's own current location\
        if not dx then dx = 0 end\
        if not dy then dy = 0 end\
        if not heading then heading = 0 end\
        theUnit.x = theUnit.x + dx + theGroup.x\
        theUnit.y = theUnit.y + dy + theGroup.y \
        theUnit.heading = heading\
        table.insert(theGroup.units, theUnit)\
    end;\
\
    function dcsCommon.createSingleUnitGroup(name, theUnitType, x, z, heading) \
        -- create the container \
        local theNewGroup = dcsCommon.createEmptyGroundGroupData(name)\
        local aUnit = {}\
        aUnit = dcsCommon.createGroundUnitData(name .. \"-1\", theUnitType, false)\
--        trigger.action.outText(\"dcsCommon - unit name retval \" .. aUnit.name, 30)\
        dcsCommon.addUnitToGroupData(aUnit, theNewGroup, x, z, heading)\
        return theNewGroup\
    end\
    \
\
    function dcsCommon.arrangeGroupDataIntoFormation(theNewGroup, radius, minDist, formation, innerRadius)\
        -- formations:\
        --    (default) \"line\" (left to right along x) -- that is Y direction\
        --    \"line_v\" a line top to bottom -- that is X direction\
        --    \"chevron\" - left to right middle too top\
        --    \"scattered\", \"random\" -- random, innerRadius used to clear area in center\
        --       \"circle\", \"circle_forward\" -- circle, forward facing\
        --    \"circle_in\" -- circle, inwarf facing\
        --    \"circle_out\" -- circle, outward facing\
        --    \"grid\", \"square\", \"rect\" -- optimal rectangle\
        --    \"2cols\", \"2deep\" -- 2 columns, n deep \
        --    \"2wide\" -- 2 columns wide, 2 deep \
\
        local num = #theNewGroup.units \
        \
        -- now do the formation stuff\
        -- make sure that they keep minimum  distance \
--        trigger.action.outText(\"dcsCommon - processing formation \" .. formation .. \" with radius = \" .. radius, 30)\
        if formation == \"LINE_V\" then \
            -- top to bottom in zone (heding 0). -- will run through x-coordinate \
            -- use entire radius top to bottom \
            local currX = -radius\
            local increment = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\
            for i=1, num do\
            \
                local u = theNewGroup.units[i]\
--                trigger.action.outText(\"formation unit \" .. u.name .. \" currX = \" .. currX, 30)\
                u.x = currX\
                currX = currX + increment\
            end\
        \
        elseif formation == \"LINE\" then \
            -- left to right in zone. runs through Y\
            -- left and right are y because at heading 0, forward is x (not y as expected)\
            -- if only one, place in middle of circle and be done \
            if num == 1 then \
                -- nothing. just stay in the middle \
            else \
                local currY = -radius\
                local increment = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\
                for i=1, num do\
                    local u = theNewGroup.units[i]\
--                    trigger.action.outText(\"formation unit \" .. u.name .. \" currX = \" .. currY, 30)\
                    u.y = currY\
                    currY = currY + increment\
                end    \
            end \
            \
        elseif formation == \"CHEVRON\" then \
            -- left to right in zone. runs through Y\
            -- left and right are y because at heading 0, forward is x (not y as expected)\
            local currY = -radius\
            local currX = 0\
            local incrementY = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\
            local incrementX = radius * 2/(num - 1) -- MUST NOT TRY WITH 1 UNIT!\
            for i=1, num do\
                local u = theNewGroup.units[i]\
--                trigger.action.outText(\"formation unit \" .. u.name .. \" currX = \" .. currX .. \" currY = \" .. currY, 30)\
                u.x = currX\
                u.y = currY\
                -- calc coords for NEXT iteration\
                currY = currY + incrementY -- march left to right\
                if i < num / 2 then -- march up\
                    currX = currX + incrementX \
                elseif i == num / 2 then -- even number, keep height\
                    currX = currX + 0 \
                else \
                    currX = currX - incrementX -- march down \
                end \
                -- note: when unit number even, the wedge is sloped. may need an odd/even test for better looks\
            end    \
\
        elseif formation == \"SCATTERED\" or formation == \"RANDOM\" then \
            -- use randomPointInCircle and tehn iterate over all vehicles for mindelta\
            processedUnits = {}\
            for i=1, num do\
                local emergencyBreak = 1 -- prevent endless loop\
                local lowDist = 10000\
                local uPoint = {}\
                local thePoint = {}\
                repeat     -- get random point intil mindistance to all is kept or emergencybreak\
                    for idx, rUnit in pairs(processedUnits) do -- get min dist to all positioned units\
                        thePoint = dcsCommon.randomPointInCircle(radius, innerRadius) -- returns x, 0, z\
                        uPoint.x = rUnit.x\
                        uPoint.y = 0\
                        uPoint.z = rUnit.y \
                        local dist = dcsCommon.dist(thePoint, uPoint) -- measure distance to unit\
                        if (dist < lowDist) then lowDist = dist end\
                    end\
                    emergencyBreak = emergencyBreak + 1\
                until (emergencyBreak > 20) or (lowDist > minDist)\
                -- we have random x, y \
                local u = theNewGroup.units[i] -- get unit to position\
                u.x = thePoint.x\
                u.y = thePoint.z -- z --> y mapping! \
                -- now add the unit to the 'processed' set \
                table.insert(processedUnits, u)\
            end    \
\
        elseif dcsCommon.stringStartsWith(formation, \"CIRCLE\") then\
            -- units are arranged on perimeter of circle defined by radius \
--            trigger.action.outText(\"formation circle detected\", 30)\
            local currAngle = 0\
            local angleInc = 2 * 3.14157 / num -- increase per spoke \
            for i=1, num do\
                local u = theNewGroup.units[i] -- get unit \
                u.x = radius * math.cos(currAngle)\
                u.y = radius * math.sin(currAngle)\
                \
                -- now baldower out heading \
                -- circle, circle_forward no modifier of heading\
                if dcsCommon.stringStartsWith(formation, \"CIRCLE_IN\") then \
                    -- make the heading inward faceing - that's angle + pi\
                    u.heading = u.heading + currAngle + 3.14157\
                elseif dcsCommon.stringStartsWith(formation, \"CIRCLE_OUT\") then \
                    u.heading = u.heading + currAngle + 0\
                end\
\
                currAngle = currAngle + angleInc\
            end\
        elseif formation == \"GRID\" or formation == \"SQUARE\" or formation == \"RECT\" then \
            if num < 2 then return end \
            -- arrange units in an w x h grid\
            -- e-g- 12 units = 4 x 3. \
            -- calculate w \
            local w = math.floor(num^(0.5) + 0.5)\
            dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\
            --[[--\
            local h = math.floor(num / w)\
            --trigger.action.outText(\"AdcsC: num=\" .. num .. \" w=\" .. w .. \"h=\" .. h .. \" -- num%w=\" .. num%w, 30)\
            if (num % w) > 0 then \
                h = h + 1\
            end\
            \
            --trigger.action.outText(\"BdcsC: num=\" .. num .. \" w=\" .. w .. \"h=\" .. h, 30)\
            \
            -- now w * h always >= num and num items fir in that grid\
            -- w is width, h is height, of course :) \
            -- now calculat xInc and yInc\
            local i = 1\
            local xInc = 0 \
            if w > 1 then xInc = 2 * radius / (w-1) end\
            local yInc = 0\
            if h > 1 then yInc = 2 * radius / (h-1) end \
            local currY = radius \
            if h < 2 then currY = 0 end -- special:_ place in Y middle if only one row)\
            while h > 0 do \
                local currX = radius \
                local wCnt = w \
                while wCnt > 0 and (i <= num) do \
                    local u = theNewGroup.units[i] -- get unit \
                    u.x = currX\
                    u.y = currY\
                    currX = currX - xInc\
                    wCnt = wCnt - 1\
                    i = i + 1\
                end\
                currY = currY - yInc \
                h = h - 1\
            end\
            --]]--\
        elseif formation == \"2DEEP\" or formation == \"2COLS\" then\
            if num < 2 then return end \
            -- arrange units in an 2 x h grid\
            local w = 2\
            dcsCommon.arrangeGroupInNColumnsDeep(theNewGroup, w, radius)\
\
        elseif formation == \"2WIDE\" then\
            if num < 2 then return end \
            -- arrange units in an 2 x h grid\
            local w = 2\
            dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\
        else \
            trigger.action.outText(\"dcsCommon - unknown formation: \" .. formation, 30)\
        end\
    \
    end\
    \
    function dcsCommon.arrangeGroupInNColumns(theNewGroup, w, radius)\
        local num = #theNewGroup.units\
        local h = math.floor(num / w)\
        if (num % w) > 0 then \
            h = h + 1\
        end\
        local i = 1\
        local xInc = 0 \
        if w > 1 then xInc = 2 * radius / (w-1) end\
        local yInc = 0\
        if h > 1 then yInc = 2 * radius / (h-1) end \
        local currY = radius \
        if h < 2 then currY = 0 end -- special:_ place in Y middle if only one row)\
        while h > 0 do \
            local currX = radius \
            local wCnt = w \
            while wCnt > 0 and (i <= num) do \
                local u = theNewGroup.units[i] -- get unit \
                u.x = currX\
                u.y = currY\
                currX = currX - xInc\
                wCnt = wCnt - 1\
                i = i + 1\
            end\
            currY = currY - yInc \
            h = h - 1\
        end\
    end\
    \
    function dcsCommon.arrangeGroupInNColumnsDeep(theNewGroup, w, radius)\
        local num = #theNewGroup.units\
        local h = math.floor(num / w)\
        if (num % w) > 0 then \
            h = h + 1\
        end\
        local i = 1\
        local yInc = 0 \
        if w > 1 then yInc = 2 * radius / (w-1) end\
        local xInc = 0\
        if h > 1 then xInc = 2 * radius / (h-1) end \
        local currX = radius \
        if h < 2 then currX = 0 end -- special:_ place in Y middle if only one row)\
        while h > 0 do \
            local currY = radius \
            local wCnt = w \
            while wCnt > 0 and (i <= num) do \
                local u = theNewGroup.units[i] -- get unit \
                u.x = currX\
                u.y = currY\
                currY = currY - yInc\
                wCnt = wCnt - 1\
                i = i + 1\
            end\
            currX = currX - xInc \
            h = h - 1\
        end\
    end\
    \
    \
    function dcsCommon.createGroundGroupWithUnits(name, theUnitTypes, radius, minDist, formation, innerRadius)\
        if not minDist then mindist = 4 end -- meters\
        if not formation then formation = \"line\" end \
        if not radius then radius = 30 end -- meters \
        if not innerRadius then innerRadius = 0 end\
        formation = formation:upper()\
        -- theUnitTypes can be either a single string or a table of strings\
        -- see here for TypeName https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB\
        -- formation defines how the units are going to be arranged in the\
        -- formation specified. \
        -- formations:\
        --    (default) \"line\" (left to right along x) -- that is Y direction\
        --    \"line_V\" a line top to bottom -- that is X direction\
        --    \"chevron\" - left to right middle too top\
        --    \"scattered\", \"random\" -- random, innerRadius used to clear area in center\
        --       \"circle\", \"circle_forward\" -- circle, forward facing\
        --    \"circle_in\" -- circle, inwarf facing\
        --    \"circle_out\" -- circle, outward facing\
\
        -- first, we create a group\
        local theNewGroup = dcsCommon.createEmptyGroundGroupData(name)\
        \
        -- now add a single unit or multiple units\
        if type(theUnitTypes) ~= \"table\" then \
--            trigger.action.outText(\"dcsCommon - i am here\", 30)\
--            trigger.action.outText(\"dcsCommon - name \" .. name, 30)\
--            trigger.action.outText(\"dcsCommon - unit type \" .. theUnitTypes, 30)\
            \
            local aUnit = {}\
            aUnit = dcsCommon.createGroundUnitData(name .. \"-1\", theUnitTypes, false)\
--            trigger.action.outText(\"dcsCommon - unit name retval \" .. aUnit.name, 30)\
            dcsCommon.addUnitToGroupData(aUnit, theNewGroup, 0, 0) -- create with data at location (0,0)\
            return theNewGroup\
        end \
\
        -- if we get here, theUnitTypes is a table\
        -- now loop and create a unit for each table\
        local num = 1\
        for key, theType in pairs(theUnitTypes) do \
            -- trigger.action.outText(\"+++dcsC: creating unit \" .. name .. \"-\" .. num .. \": \" .. theType, 30)\
            local aUnit = dcsCommon.createGroundUnitData(name .. \"-\"..num, theType, false)\
            dcsCommon.addUnitToGroupData(aUnit, theNewGroup, 0, 0)\
            num = num + 1\
        end\
        \
        dcsCommon.arrangeGroupDataIntoFormation(theNewGroup, radius, minDist, formation, innerRadius)\
        return theNewGroup\
\
    \
    end\
\
-- create a new group, based on group in mission. Groups coords are 0,0 for group and all\
-- x,y and heading\
    function dcsCommon.createGroupDataFromLiveGroup(name, newName) \
        if not newName then newName = dcsCommon.uuid(\"uniqName\") end\
        -- get access to the group\
        local liveGroup = Group.getByName(name)\
        if not liveGroup then return nil end\
        -- get the categorty\
        local cat = liveGroup:getCategory()\
        local theNewGroup = {}\
        \
        -- create a new empty group at (0,0) \
        if cat == Group.Category.AIRPLANE or cat == Group.Category.HELICOPTER then \
            theNewGroup = dcsCommon.createEmptyAircraftGroupData(newName)\
        elseif cat == Group.Category.GROUND then\
            theNewGroup = dcsCommon.createEmptyGroudGroupData(newName)\
        else \
            trigger.action.outText(\"dcsCommon - unknown category: \" .. cat, 30)\
            return nil\
        end\
        \
\
        -- now get all units from live group and create data units\
        -- note that unit data for group has x=0, y=0\
        liveUnits = liveGroup:getUnits()\
        \
        for index, theUnit in pairs(liveUnits) do \
            -- for each unit we get the desc \
            local desc = theUnit:getDesc() -- of interest is only typename \
            local newUnit = dcsCommon.createGroundUnitData(dcsCommon.uuid(newName),\
                                                           desc.typeName,\
                                                           false)\
            -- we now basically have a ground unit at (0,0) \
            -- add mandatory fields by type\
            if cat == Group.Category.AIRPLANE or cat == Group.Category.HELICOPTER then \
                newUnit.alt = 100 -- make it 100m\
                newUnit.alt_type = \"RADIO\" -- AGL\
                newUnit.speed = 77 -- m/s --> 150 knots\
                newUnit.payload = dcsCommon.createPayload() -- empty payload\
                newUnit.callsign = dcsCommon.createCallsign() -- 'enfield11'\
                \
            elseif cat == Group.Category.GROUND then\
                -- we got all we need\
            else \
                -- trigger.action.outText(\"dcsCommon - unknown category: \" .. cat, 30)\
                -- return nil\
                -- we also got all we need\
            end            \
            \
        end\
    \
    end;\
    \
\
    function dcsCommon.rotatePointAroundOrigin(inX, inY, angle) -- angle in degrees\
        local degrees =  3.14152 / 180 -- ok, it's actually radiants. \
        angle = angle * degrees -- turns into rads\
        local c = math.cos(angle)\
        local s = math.sin(angle)\
        local px\
        local py \
        px = inX * c - inY * s\
        py = inX * s + inY * c\
        return px, py        \
    end\
\
    function dcsCommon.rotateUnitData(theUnit, degrees, cx, cz)\
        if not cx then cx = 0 end\
        if not cz then cz = 0 end\
        local cy = cz \
        --trigger.action.outText(\"+++dcsC:rotGrp cy,cy = \"..cx .. \",\" .. cy, 30)\
        \
        local rads = degrees *  3.14152 / 180\
        do\
            theUnit.x = theUnit.x - cx -- MOVE TO ORIGIN OF ROTATION\
            theUnit.y = theUnit.y - cy                 \
            theUnit.x, theUnit.y = dcsCommon.rotatePointAroundOrigin(theUnit.x, theUnit.y, degrees)\
            theUnit.x = theUnit.x + cx -- MOVE BACK \
            theUnit.y = theUnit.y + cy                 \
\
            -- may also want to increase heading by degreess\
            theUnit.heading = theUnit.heading + rads \
        end\
    end\
    \
\
    function dcsCommon.rotateGroupData(theGroup, degrees, cx, cz)\
        if not cx then cx = 0 end\
        if not cz then cz = 0 end\
        local cy = cz \
        --trigger.action.outText(\"+++dcsC:rotGrp cy,cy = \"..cx .. \",\" .. cy, 30)\
        \
        local rads = degrees *  3.14152 / 180\
        -- turns all units in group around the group's center by degrees.\
        -- may also need to turn individual units by same amount\
        for i, theUnit in pairs (theGroup.units) do\
            theUnit.x = theUnit.x - cx -- MOVE TO ORIGIN OF ROTATION\
            theUnit.y = theUnit.y - cy                 \
            theUnit.x, theUnit.y = dcsCommon.rotatePointAroundOrigin(theUnit.x, theUnit.y, degrees)\
            theUnit.x = theUnit.x + cx -- MOVE BACK \
            theUnit.y = theUnit.y + cy                 \
\
            -- may also want to increase heading by degreess\
            theUnit.heading = theUnit.heading + rads \
        end\
    end\
\
    function dcsCommon.offsetGroupData(theGroup, dx, dy)\
        -- add dx and dy to group's and all unit's coords\
        for i, theUnit in pairs (theGroup.units) do \
            theUnit.x = theUnit.x + dx\
            theUnit.y = theUnit.y + dy\
        end\
        \
        theGroup.x = theGroup.x + dx\
        theGroup.y = theGroup.y + dy \
    end\
    \
    function dcsCommon.moveGroupDataTo(theGroup, xAbs, yAbs)\
        local dx = xAbs-theGroup.x\
        local dy = yAbs-theGroup.y\
        dcsCommon.offsetGroupData(theGroup, dx, dy)\
    end\
    \
    -- static objectr shapes and types are defined here\
    -- https://github.com/mrSkortch/DCS-miscScripts/tree/master/ObjectDB/Statics\
    \
    function dcsCommon.createStaticObjectData(name, objType, heading, dead, cargo, mass)\
        local staticObj = {}\
        if not heading then heading = 0 end \
        if not dead then dead = false end \
        if not cargo then cargo = false end \
        objType = dcsCommon.trim(objType) \
        \
        staticObj.heading = heading\
        -- staticObj.groupId = 0\
        -- staticObj.shape_name = shape -- e.g. H-Windsock_RW\
        staticObj.type = objType  -- e.g. Windsock\
        -- [\"unitId\"] = 3,\
        staticObj.rate = 1 -- score when killed\
        staticObj.name = name\
        -- staticObj.category = \"Fortifications\",\
        staticObj.y = 0\
        staticObj.x = 0\
        staticObj.dead = dead\
        staticObj.canCargo = cargo -- to cargo\
        if cargo then \
            if not mass then mass = 1234 end \
            staticObj.mass = mass -- to cargo\
        end\
        return staticObj\
    end\
    \
    function dcsCommon.createStaticObjectDataAt(loc, name, objType, heading, dead)\
        local theData = dcsCommon.createStaticObjectData(name, objType, heading, dead)\
        theData.x = loc.x\
        theData.y = loc.z \
        return theData\
    end\
    \
    function dcsCommon.createStaticObjectForCoalitionAtLocation(theCoalition, loc, name, objType, heading, dead) \
        if not heading then heading = math.random(360) * 3.1415 / 180 end\
        local theData = dcsCommon.createStaticObjectDataAt(loc, name, objType, heading, dead)\
        local theStatic = coalition.addStaticObject(theCoalition, theData)\
        return theStatic\
    end\
    \
    function dcsCommon.createStaticObjectForCoalitionInRandomRing(theCoalition, objType, x, z, innerRadius, outerRadius, heading, alive) \
        if not outerRadius then outerRadius = innerRadius end\
        if not heading then heading = math.random(360) * 3.1415 / 180 end\
        local dead = not alive\
        local p = dcsCommon.randomPointInCircle(outerRadius, innerRadius, x, z)\
        local theData = dcsCommon.createStaticObjectData(dcsCommon.uuid(\"static\"), objType, heading, dead)\
        theData.x = p.x\
        theData.y = p.z \
        \
        local theStatic = coalition.addStaticObject(theCoalition, theData)\
        return theStatic\
    end\
    \
    \
    \
    function dcsCommon.linkStaticDataToUnit(theStatic, theUnit, dx, dy, heading)\
        if not theStatic then \
            trigger.action.OutText(\"+++dcsC: NIL theStatic on linkStatic!\", 30)\
            return \
        end\
        -- NOTE: we may get current heading and subtract/add \
        -- to original heading \
        local rotX, rotY = dcsCommon.rotatePointAroundOrigin(dx, dy, -heading)\
        \
        if not theUnit then return end\
        if not theUnit:isExist() then return end \
        theStatic.linkOffset = true \
        theStatic.linkUnit = theUnit:getID()\
        local unitPos = theUnit:getPoint()\
        local offsets = {}\
        offsets.x = rotX  \
        offsets.y = rotY \
        offsets.angle = 0\
        theStatic.offsets = offsets\
    end\
    \
    function dcsCommon.offsetStaticData(theStatic, dx, dy)\
        theStatic.x = theStatic.x + dx\
        theStatic.y = theStatic.y + dy\
        -- now check if thre is a route (for linked objects)\
        if theStatic.route then \
            -- access points[1] x and y and copy from main\
            theStatic.route.points[1].x = theStatic.x\
            theStatic.route.points[1].y = theStatic.y\
        end\
    end\
    \
    function dcsCommon.moveStaticDataTo(theStatic, x, y)\
        theStatic.x = x\
        theStatic.y = y\
        -- now check if thre is a route (for linked objects)\
        if theStatic.route then \
            -- access points[1] x and y and copy from main\
            theStatic.route.points[1].x = theStatic.x\
            theStatic.route.points[1].y = theStatic.y\
        end\
\
    end\
    \
--\
--\
-- M I S C   M E T H O D S \
--\
--\
\
    function dcsCommon.arrayContainsString(theArray, theString) \
        if not theArray then return false end\
        if not theString then return false end\
        for i = 1, #theArray do \
            if theArray[i] == theString then return true end \
        end\
        return false \
    end\
    \
    function dcsCommon.splitString(inputstr, sep) \
        if sep == nil then\
            sep = \"%s\"\
        end\
        if inputstr == nil then \
            inputstr = \"\"\
        end\
        \
        local t={}\
        for str in string.gmatch(inputstr, \"([^\"..sep..\"]+)\") do\
            table.insert(t, str)\
        end\
        return t\
    \
    end\
    \
    function dcsCommon.trimFront(inputstr) \
        if not inputstr then return nil end \
        local s = inputstr\
        while string.len(s) > 1 and string.sub(s, 1, 1) == \" \" do \
            local snew = string.sub(s, 2) -- all except first\
            s = snew\
        end\
        return s\
    end\
    \
    function dcsCommon.trimBack(inputstr)\
        if not inputstr then return nil end \
        local s = inputstr\
        while string.len(s) > 1 and string.sub(s, -1) == \" \" do \
            local snew = string.sub(s, 1, -2) -- all except last\
            s = snew\
        end\
        return s\
    end\
    \
    function dcsCommon.trim(inputstr) \
        local t1 = dcsCommon.trimFront(inputstr)\
        local t2 = dcsCommon.trimBack(t1)\
        return t2\
    end\
    \
    function dcsCommon.trimArray(theArray)\
        local trimmedArray = {}\
        for idx, element in pairs(theArray) do \
            local tel = dcsCommon.trim(element)\
            table.insert(trimmedArray, tel)\
        end\
        return trimmedArray\
    end\
    \
    function dcsCommon.stringIsPositiveNumber(theString)\
        -- only full integer positive numbers supported \
        if not theString then return false end \
--        if theString == \"\" then return false end \
        for i = 1, #theString do \
            local c = theString:sub(i,i)\
            if c < \"0\" or c > \"9\" then return false end \
        end\
        return true \
    end\
    \
    function dcsCommon.stringStartsWithDigit(theString)\
        if #theString < 1 then return false end \
        local c = string.sub(theString, 1, 1) \
        return c >= \"0\" and c <= \"9\" \
    end\
    \
    function dcsCommon.stringStartsWithLetter(theString)\
        if #theString < 1 then return false end \
        local c = string.sub(theString, 1, 1)\
        if c >= \"a\" and c <= \"z\" then return true end  \
        if c >= \"A\" and c <= \"Z\" then return true end \
        return false \
    end\
    \
    function dcsCommon.stringStartsWith(theString, thePrefix)\
        return theString:find(thePrefix) == 1\
    end\
    \
    function dcsCommon.removePrefix(theString, thePrefix)\
        if not dcsCommon.stringStartsWith(theString, thePrefix) then \
            return theString\
        end;\
        return theString:sub(1 + #thePrefix)\
    end\
    \
    function dcsCommon.stringEndsWith(theString, theEnding)\
        return theEnding == \"\" or theString:sub(-#theEnding) == theEnding\
    end\
    \
    function dcsCommon.removeEnding(theString, theEnding) \
        if not dcsCommon.stringEndsWith(theString, theEnding) then \
            return theString\
        end\
        return theString:sub(1, #theString - #theEnding)\
    end\
    \
    function dcsCommon.containsString(inString, what, caseSensitive)\
        if (not caseSensitive) then \
            inString = string.upper(inString)\
            what = string.upper(what)\
        end\
        if inString == what then return true end -- when entire match \
        return string.find(inString, what)\
    end\
    \
    function dcsCommon.bool2Text(theBool) \
        if not theBool then theBool = false end \
        if theBool then return \"true\" end \
        return \"false\"\
    end\
    \
    function dcsCommon.bool2YesNo(theBool)\
        if not theBool then theBool = false end \
        if theBool then return \"yes\" end \
        return \"no\"\
    end\
\
    function dcsCommon.point2text(p) \
        if not p then return \"<!NIL!>\" end \
        local t = \"[x=\"\
        if p.x then t = t .. p.x .. \", \" else t = t .. \"<nil>, \" end \
        if p.y then t = t .. p.y .. \", \" else t = t .. \"<nil>, \" end \
        if p.z then t = t .. p.z .. \"]\" else t = t .. \"<nil>]\" end \
        return t \
    end\
\
    function dcsCommon.string2GroupCat(inString)\
\
        if not inString then return 2 end -- default ground \
        inString = inString:lower()\
        inString = dcsCommon.trim(inString)\
\
        local catNum = tonumber(inString)\
        if catNum then \
            if catNum < 0 then catNum = 0 end \
            if catNum > 4 then catNum = 4 end \
            return catNum \
        end\
    \
        catNum = 2 -- ground default \
        if dcsCommon.stringStartsWith(inString, \"grou\") then catNum = 2 end \
        if dcsCommon.stringStartsWith(inString, \"air\") then catNum = 0 end\
        if dcsCommon.stringStartsWith(inString, \"hel\") then catNum = 1 end\
        if dcsCommon.stringStartsWith(inString, \"shi\") then catNum = 3 end\
        if dcsCommon.stringStartsWith(inString, \"trai\") then catNum = 4 end\
\
        return catNum\
    end\
\
    function dcsCommon.string2ObjectCat(inString)\
\
        if not inString then return 3 end -- default static \
        inString = inString:lower()\
        inString = dcsCommon.trim(inString)\
\
        local catNum = tonumber(inString)\
        if catNum then \
            if catNum < 0 then catNum = 0 end \
            if catNum > 6 then catNum = 6 end \
            return catNum \
        end\
    \
        catNum = 3 -- static default \
        if dcsCommon.stringStartsWith(inString, \"uni\") then catNum = 1 end \
        if dcsCommon.stringStartsWith(inString, \"wea\") then catNum = 2 end\
        if dcsCommon.stringStartsWith(inString, \"bas\") then catNum = 4 end\
        if dcsCommon.stringStartsWith(inString, \"sce\") then catNum = 5 end\
        if dcsCommon.stringStartsWith(inString, \"car\") then catNum = 6 end\
\
        return catNum\
    end\
\
    -- recursively show the contents of a variable\
    function dcsCommon.dumpVar(key, value, prefix, inrecursion)\
        if not inrecursion then \
            -- output a marker to find in the log / screen\
            env.info(\"*** dcsCommon vardump START\")\
        end\
        if not value then value = \"nil\" end\
        if not prefix then prefix = \"\" end\
        prefix = \" \" .. prefix\
        if type(value) == \"table\" then \
            env.info(prefix .. key .. \": [ \")\
            -- iterate through all kvp\
            for k,v in pairs (value) do\
                dcsCommon.dumpVar(k, v, prefix, true)\
            end\
            env.info(prefix .. \" ] - end \" .. key)\
            \
        elseif type(value) == \"boolean\" then \
            local b = \"false\"\
            if value then b = \"true\" end\
            env.info(prefix .. key .. \": \" .. b)\
            \
        else -- simple var, show contents, ends recursion\
            env.info(prefix .. key .. \": \" .. value)\
        end\
        \
        if not inrecursion then \
            -- output a marker to find in the log / screen\
            trigger.action.outText(\"=== dcsCommon vardump END\", 30)\
            env.info(\"=== dcsCommon vardump END\")\
        end\
    end\
    \
    function dcsCommon.dumpVar2Str(key, value, prefix, inrecursion)\
        if not inrecursion then \
            -- output a marker to find in the log / screen\
            trigger.action.outText(\"*** dcsCommon vardump START\",30)\
        end\
        if not value then value = \"nil\" end\
        if not prefix then prefix = \"\" end\
        prefix = \" \" .. prefix\
        if type(value) == \"table\" then \
            trigger.action.outText(prefix .. key .. \": [ \", 30)\
            -- iterate through all kvp\
            for k,v in pairs (value) do\
                dcsCommon.dumpVar2Str(k, v, prefix, true)\
            end\
            trigger.action.outText(prefix .. \" ] - end \" .. key, 30)\
            \
        elseif type(value) == \"boolean\" then \
            local b = \"false\"\
            if value then b = \"true\" end\
            trigger.action.outText(prefix .. key .. \": \" .. b, 30)\
            \
        else -- simple var, show contents, ends recursion\
            trigger.action.outText(prefix .. key .. \": \" .. value, 30)\
        end\
        \
        if not inrecursion then \
            -- output a marker to find in the log / screen\
            trigger.action.outText(\"=== dcsCommon vardump END\", 30)\
            --env.info(\"=== dcsCommon vardump END\")\
        end\
    end\
    \
\
    \
    function dcsCommon.numberUUID()\
        dcsCommon.simpleUUID = dcsCommon.simpleUUID + 1\
        return dcsCommon.simpleUUID\
    end\
\
    function dcsCommon.uuid(prefix)\
        --dcsCommon.uuIdent = dcsCommon.uuIdent + 1\
        if not prefix then prefix = dcsCommon.uuidStr end\
        return prefix .. \"-\" .. dcsCommon.numberUUID() -- dcsCommon.uuIdent\
    end\
    \
    function dcsCommon.event2text(id) \
        if not id then return \"error\" end\
        if id == 0 then return \"invalid\" end\
        -- translate the event id to text\
        local events = {\"shot\", \"hit\", \"takeoff\", \"land\",\
                        \"crash\", \"eject\", \"refuel\", \"dead\",\
                        \"pilot dead\", \"base captured\", \"mission start\", \"mission end\", -- 12\
                        \"took control\", \"refuel stop\", \"birth\", \"human failure\", \
                        \"det. failure\", \"engine start\", \"engine stop\", \"player enter unit\",\
                        \"player leave unit\", \"player comment\", \"start shoot\", \"end shoot\",\
                        \"mark add\", \"mark changed\", \"makr removed\", \"kill\", \
                        \"score\", \"unit lost\", \"land after eject\", \"Paratrooper land\", \
                        \"chair discard after eject\", \"weapon add\", \"trigger zone\", \"landing quality mark\",\
                        \"BDA\", \"max\"}\
        if id > #events then return \"Unknown (ID=\" .. id .. \")\" end\
        return events[id]\
    end\
\
    function dcsCommon.smokeColor2Text(smokeColor)\
        if (smokeColor == 0) then return \"Green\" end\
        if (smokeColor == 1) then return \"Red\" end\
        if (smokeColor == 2) then return \"White\" end\
        if (smokeColor == 3) then return \"Orange\" end\
        if (smokeColor == 4) then return \"Blue\" end\
        \
        return (\"unknown: \" .. smokeColor)\
    end\
    \
    function dcsCommon.smokeColor2Num(smokeColor)\
        if not smokeColor then smokeColor = \"green\" end \
        if type(smokeColor) ~= \"string\" then return 0 end \
        smokeColor = smokeColor:lower()\
        if (smokeColor == \"green\") then return 0 end \
        if (smokeColor == \"red\") then return 1 end \
        if (smokeColor == \"white\") then return 2 end \
        if (smokeColor == \"orange\") then return 3 end \
        if (smokeColor == \"blue\") then return 4 end \
        return 0\
    end\
    \
    function dcsCommon.markPointWithSmoke(p, smokeColor)\
        local x = p.x \
        local z = p.z -- do NOT change the point directly\
        -- height-correct\
        local y = land.getHeight({x = x, y = z})\
        local newPoint= {x = x, y = y + 2, z = z}\
        trigger.action.smoke(newPoint, smokeColor)\
    end\
\
-- based on buzzer1977's idea, channel is number, eg in 74X, channel is 74, mode is \"X\"\
    function tacan2freq(channel, mode)    \
        if not mode then mode = \"X\" end \
        if not channel then channel = 1 end \
        if type(mode) ~= \"string\" then mode = \"X\" end \
        mode = mode:upper()\
        local offset = 1000000 * channel\
        if channel < 64 then \
            if mode == \"Y\" then\
                return 1087000000 + offset\
            end\
            return 961000000 + offset -- mode x\
        end\
    \
        if mode == \"Y\" then\
            return 961000000 + offset\
        end\
        return 1087000000 + offset -- mode x\
    end\
    \
    function dcsCommon.processHMS(msg, delta)\
        local rS = math.floor(delta)\
        local remainS = tostring(rS)\
        local rM = math.floor(delta/60)\
        local remainM = tostring(rM)\
        local rH = math.floor(delta/3600)\
        local remainH = tostring(rH)\
        local hmsH = remainH \
        if rH < 10 then hmsH = \"0\" .. hmsH end \
        \
        local hmsCount = delta - (rH * 3600) -- mins left \
        local mins = math.floor (hmsCount / 60)\
        local hmsM = tostring(mins)\
        if mins < 10 then hmsM = \"0\" .. hmsM end \
        \
        hmsCount = hmsCount - (mins * 60) \
        local secs = math.floor(hmsCount)\
        local hmsS = tostring(secs)\
        if secs < 10 then hmsS = \"0\" .. hmsS end \
        \
        msg = string.gsub(msg, \"<s>\", remainS)\
        msg = string.gsub(msg, \"<m>\", remainM)\
        msg = string.gsub(msg, \"<h>\", remainH)\
        \
        msg = string.gsub(msg, \"<:s>\", hmsS)\
        msg = string.gsub(msg, \"<:m>\", hmsM)\
        msg = string.gsub(msg, \"<:h>\", hmsH)\
        \
        return msg \
    end\
    \
--\
--\
-- V E C T O R   M A T H \
--\
--\
\
function dcsCommon.vAdd(a, b) \
    local r = {}\
    if not a then a = {x = 0, y = 0, z = 0} end\
    if not b then b = {x = 0, y = 0, z = 0} end\
    r.x = a.x + b.x \
    r.y = a.y + b.y \
    r.z = a.z + b.z \
    return r \
end\
\
function dcsCommon.vSub(a, b) \
    local r = {}\
    if not a then a = {x = 0, y = 0, z = 0} end\
    if not b then b = {x = 0, y = 0, z = 0} end\
    r.x = a.x - b.x \
    r.y = a.y - b.y \
    r.z = a.z - b.z \
    return r \
end\
\
function dcsCommon.vMultScalar(a, f) \
    local r = {}\
    if not a then a = {x = 0, y = 0, z = 0} end\
    if not f then f = 0 end\
    r.x = a.x * f \
    r.y = a.y * f \
    r.z = a.z * f \
    return r \
end\
\
function dcsCommon.vLerp (a, b, t)\
    if not a then a = {x = 0, y = 0, z = 0} end\
    if not b then b = {x = 0, y = 0, z = 0} end\
    \
    local d = dcsCommon.vSub(b, a)\
    local dt = dcsCommon.vMultScalar(d, t)\
    local r = dcsCommon.vAdd(a, dt)\
    return r\
end\
\
function dcsCommon.mag(x, y, z) \
    if not x then x = 0 end\
    if not y then y = 0 end \
    if not z then z = 0 end \
    \
    return (x * x + y * y + z * z)^0.5\
end\
\
function dcsCommon.vMag(a) \
    if not a then return 0 end \
    if not a.x then a.x = 0 end \
    if not a.y then a.y = 0 end \
    if not a.z then a.z = 0 end\
    return dcsCommon.mag(a.x, a.y, a.z) \
end\
\
function dcsCommon.magSquare(x, y, z) \
    if not x then x = 0 end\
    if not y then y = 0 end \
    if not z then z = 0 end \
    \
    return (x * x + y * y + z * z)\
end\
\
function dcsCommon.vNorm(a) \
    if not a then return {x = 0, y = 0, z = 0} end \
    m = dcsCommon.vMag(a)\
    if m <= 0 then return {x = 0, y = 0, z = 0} end \
    local r = {}\
    r.x = a.x / m \
    r.y = a.y / m \
    r.z = a.z / m\
    return r \
end\
\
function dcsCommon.dot (a, b) \
    if not a then a = {} end \
    if not a.x then a.x = 0 end \
    if not a.y then a.y = 0 end \
    if not a.z then a.z = 0 end\
    if not b then b = {} end \
    if not b.x then b.x = 0 end \
    if not b.y then b.y = 0 end \
    if not b.z then b.z = 0 end \
    \
    return a.x * b.x + a.y * b.y + a.z * b.z \
end\
--\
-- UNIT MISC\
-- \
function dcsCommon.isSceneryObject(theUnit)\
    if not theUnit then return false end\
    return theUnit.getCoalition == nil -- scenery objects do not return a coalition \
end\
\
function dcsCommon.isTroopCarrier(theUnit)\
    -- return true if conf can carry troups\
    if not theUnit then return false end \
    local uType = theUnit:getTypeName()\
    if dcsCommon.arrayContainsString(dcsCommon.troopCarriers, uType) then \
        -- may add additional tests before returning true\
        return true\
    end\
    return false\
end\
\
function dcsCommon.getUnitAlt(theUnit)\
    if not theUnit then return 0 end\
    if not theUnit:isExist() then return 0 end \
    local p = theUnit:getPoint()\
    return p.y \
end\
\
function dcsCommon.getUnitAGL(theUnit)\
    if not theUnit then return 0 end\
    if not theUnit:isExist() then return 0 end \
    local p = theUnit:getPoint()\
    local alt = p.y \
    local loc = {x = p.x, y = p.z}\
    local landElev = land.getHeight(loc)\
    return alt - landElev\
end \
\
function dcsCommon.getUnitSpeed(theUnit)\
    if not theUnit then return 0 end\
    if not theUnit:isExist() then return 0 end \
    local v = theUnit:getVelocity()\
    return dcsCommon.mag(v.x, v.y, v.z)\
end\
\
-- closing velocity of u1 and u2, seen from u1\
function dcsCommon.getClosingVelocity(u1, u2)\
    if not u1 then return 0 end \
    if not u2 then return 0 end \
    if not u1:isExist() then return 0 end \
    if not u2:isExist() then return 0 end \
    local v1 = u1:getVelocity()\
    local v2 = u2:getVelocity()\
    local dV = dcsCommon.vSub(v1,v2)\
    local a = u1:getPoint()\
    local b = u2:getPoint() \
    local aMinusB = dcsCommon.vSub(a,b) -- vector from u2 to u1\
    local abMag = dcsCommon.vMag(aMinusB) -- distance u1 to u2 \
    if abMag < .0001 then return 0 end \
    -- project deltaV onto vector from u2 to u1 \
    local vClose = dcsCommon.dot(dV, aMinusB) / abMag \
    return vClose \
end\
\
function dcsCommon.getGroupAvgSpeed(theGroup)\
    if not theGroup then return 0 end \
    if not dcsCommon.isGroupAlive(theGroup) then return 0 end \
    local totalSpeed = 0\
    local cnt = 0 \
    local livingUnits = theGroup:getUnits()\
    for idx, theUnit in pairs(livingUnits) do \
        cnt = cnt + 1\
        totalSpeed = totalSpeed + dcsCommon.getUnitSpeed(theUnit)\
    end \
    if cnt == 0 then return 0 end \
    return totalSpeed / cnt \
end\
 \
function dcsCommon.getGroupMaxSpeed(theGroup)\
    if not theGroup then return 0 end \
    if not dcsCommon.isGroupAlive(theGroup) then return 0 end \
    local maxSpeed = 0\
    local livingUnits = theGroup:getUnits()\
    for idx, theUnit in pairs(livingUnits) do \
        currSpeed = dcsCommon.getUnitSpeed(theUnit)\
        if currSpeed > maxSpeed then maxSpeed = currSpeed end \
    end \
    return maxSpeed\
end \
\
function dcsCommon.getUnitHeading(theUnit)\
    if not theUnit then return 0 end \
    if not theUnit:isExist() then return 0 end \
    local pos = theUnit:getPosition() -- returns three vectors, p is location\
\
    local heading = math.atan2(pos.x.z, pos.x.x)\
    -- make sure positive only, add 360 degrees\
    if heading < 0 then\
        heading = heading + 2 * math.pi    -- put heading in range of 0 to 2*pi\
    end\
    return heading \
end\
\
function dcsCommon.getUnitHeadingDegrees(theUnit)\
    local heading = dcsCommon.getUnitHeading(theUnit)\
    return heading * 57.2958 -- 180 / math.pi \
end\
\
function dcsCommon.unitIsInfantry(theUnit)\
    if not theUnit then return false end \
    if not theUnit:isExist() then return end\
    local theType = theUnit:getTypeName()\
    local isInfantry =  \
                dcsCommon.containsString(theType, \"infantry\", false) or \
                dcsCommon.containsString(theType, \"paratrooper\", false) or\
                dcsCommon.containsString(theType, \"stinger\", false) or\
                dcsCommon.containsString(theType, \"manpad\", false) or\
                dcsCommon.containsString(theType, \"soldier\", false) or \
                dcsCommon.containsString(theType, \"SA-18 Igla\", false)\
    return isInfantry\
end\
\
function dcsCommon.coalition2county(inCoalition)\
    -- simply return UN troops for 0 neutral,\
    -- joint red for 1  red\
    -- joint blue for 2 blue \
    if inCoalition == 1 then return 81 end -- cjtf red\
    if inCoalition == 2 then return 80 end -- blue \
    if type(inCoalition) == \"string\" then \
            inCoalition = inCoalition:lower()\
            if inCoalition == \"red\" then return 81 end\
            if inCoalition == \"blue\" then return 80 end\
    end\
        \
    trigger.action.outText(\"+++dcsC: coalition2county in (\" .. inCoalition .. \") converts to UN (82)!\", 30)\
    return 82 -- UN \
    \
end\
\
function dcsCommon.latLon2Text(lat, lon)\
    -- simplified mist version, thanks Grimes!\
    -- find hemisphere\
    local latHemi, lonHemi\
    if lat > 0 then latHemi = 'N' else latHemi = 'S' end\
    if lon > 0 then lonHemi = 'E' else lonHemi = 'W' end\
\
    -- remove sign since we have hemi\
    lat = math.abs(lat)\
    lon = math.abs(lon)\
\
    -- calc deg / mins \
    local latDeg = math.floor(lat)\
    local latMin = (lat - latDeg) * 60\
    local lonDeg = math.floor(lon)\
    local lonMin = (lon - lonDeg) * 60\
\
    local rawLatMin = latMin\
    latMin = math.floor(latMin)\
    local latSec = (rawLatMin - latMin) * 60\
\
    local rawLonMin = lonMin\
    lonMin = math.floor(lonMin)\
    local lonSec = (rawLonMin - lonMin) * 60\
\
    if latSec >= 60 then\
        latSec = latSec - 60\
        latMin = latMin + 1\
    end\
\
    if lonSec >= 60 then\
        lonSec = lonSec - 60\
        lonMin = lonMin + 1\
    end\
\
    local secFrmtStr = '%06.3f'\
\
    local lat = string.format('%02d', latDeg) .. '°' .. string.format('%02d', latMin) .. \"'\" .. string.format(secFrmtStr, latSec) .. '\"' .. latHemi\
    local lon = string.format('%02d', lonDeg) .. '°' .. string.format('%02d', lonMin) .. \"'\" .. string.format(secFrmtStr, lonSec) .. '\"' .. lonHemi\
    return lat, lon  \
end\
\
--\
--\
-- INIT\
--\
--\
    -- init any variables the lib requires internally\
    function dcsCommon.init()\
        cbID = 0\
        --dcsCommon.uuIdent = 0\
        if (dcsCommon.verbose) or true then\
          trigger.action.outText(\"dcsCommon v\" .. dcsCommon.version .. \" loaded\", 10)\
        end\
    end\
\
    \
-- do init. \
dcsCommon.init()\
\
--[[--\
\
to do: \
- formation 2Column\
- formation 3Column\
\
-]]--\
",
                    ["predicate"] = "a_do_script",
                }, -- end of [1]
                [2] = 
                {
                    ["text"] = "-- cf/x zone management module\
-- reads dcs zones and makes them accessible and mutable \
-- by scripting.\
--\
-- Copyright (c) 2021, 2022 by Christian Franz and cf/x AG\
--\
cfxZones = {}\
cfxZones.version = \"2.7.9\"\
--[[-- VERSION HISTORY\
 - 2.2.4 - getCoalitionFromZoneProperty\
         - getStringFromZoneProperty\
 - 2.2.5 - createGroundUnitsInZoneForCoalition corrected coalition --> country \
 - 2.2.6 - getVectorFromZoneProperty(theZone, theProperty, defaultVal)\
 - 2.2.7 - allow 'yes' as 'true' for boolean attribute \
 - 2.2.8 - getBoolFromZoneProperty supports default \
         - cfxZones.hasProperty\
 - 2.3.0 - property names are case insensitive \
 - 2.3.1 - getCoalitionFromZoneProperty allows 0, 1, 2 also\
 - 2.4.0 - all zones look for owner attribute, and set it to 0 (neutral) if not present \
 - 2.4.1 - getBoolFromZoneProperty upgraded by expected bool \
         - markZoneWithSmoke raised by 3 meters\
 - 2.4.2 - getClosestZone also returns delta \
 - 2.4.3 - getCoalitionFromZoneProperty() accepts 'all' as neutral \
           createUniqueZoneName()\
           getStringFromZoneProperty returns default if property value = \"\"\
           corrected bug in addZoneToManagedZones\
 - 2.4.4 - getPoint(aZone) returns uip-to-date pos for linked and normal zones\
         - linkUnit can use \"useOffset\" property to keep relative position\
 - 2.4.5 - updated various methods to support getPoint when referencing \
           zone.point  \
 - 2.4.6 - corrected spelling in markZoneWithSmoke\
 - 2.4.7 - copy reference to dcs zone into cfx zone \
 - 2.4.8 - getAllZoneProperties\
 - 2.4.9 - createSimpleZone no longer requires location \
         - parse dcs adds empty .properties = {} if none tehre \
         - createCircleZone adds empty properties \
         - createPolyZone adds empty properties \
 - 2.4.10 - pickRandomZoneFrom now defaults to all cfxZones.zones\
          - getBoolFromZoneProperty also recognizes 0, 1\
          - removed autostart\
 - 2.4.11 - removed typo in get closest zone \
 - 2.4.12 - getStringFromZoneProperty\
 - 2.5.0  - harden getZoneProperty and all getPropertyXXXX\
 - 2.5.1  - markZoneWithSmoke supports alt attribute \
 - 2.5.2  - getPoint also writes through to zone itself for optimization\
          - new method getPositiveRangeFromZoneProperty(theZone, theProperty, default)\
 - 2.5.3  - new getAllGroupsInZone()\
 - 2.5.4  - cleaned up getZoneProperty break on no properties \
          - extractPropertyFromDCS trims key and property \
 - 2.5.5  - pollFlag() centralized for banging \
          - allStaticsInZone\
 - 2.5.6  - flag accessor setFlagValue(), getFlagValue()  \
          - pollFlag supports theZone as final parameter\
          - randomDelayFromPositiveRange\
          - isMEFlag\
 - 2.5.7  - pollFlag supports dml flags\
 - 2.5.8  - flagArrayFromString\
          - getFlagNumber invokes tonumber() before returning result \
 - 2.5.9  - removed pass-back flag in getPoint() \
 - 2.6.0  - testZoneFlag() method based flag testing\
 - 2.6.1  - Watchflag parsing of zone condition for number-named flags\
          - case insensitive\
          - verbose for zone-local accepted (but not acted upon)\
          - hasProperty now offers active information when looking for '*?' and '*!'\
 - 2.7.0  - doPollFlag - fully support multiple flags per bang!\
 - 2.7.1  - setFlagValueMult()\
 - 2.7.2  - '261 repair'\
 - 2.7.3  - testZoneFlag returns mathodResult, lastVal\
          - evalFlagMethodImmediate()\
 - 2.7.4  - doPollFlag supports immediate number setting \
 - 2.7.5  - more QoL checks when mixing up ? and ! for attributes\
 - 2.7.6  - trim for getBoolFromZoneProperty and getStringFromZoneProperty\
 - 2.7.7  - randomInRange()\
          - show number of zones \
 - 2.7.8  - inc method now triggers if curr value > last value \
          - dec method noew triggers when curr value < last value \
          - testFlagByMethodForZone supports lohi, hilo transitions \
          - doPollFlag supports 'pulse'\
          - pulseFlag\
          - unpulse \
- 2.7.9   - getFlagValue QoL for <none>\
          - setFlagValue QoL for <none>\
          \
 \
--]]--\
cfxZones.verbose = false\
cfxZones.caseSensitiveProperties = false -- set to true to make property names case sensitive \
cfxZones.ups = 1 -- updates per second. updates moving zones\
\
cfxZones.zones = {} -- these are the zone as retrieved from the mission.\
                    -- ALWAYS USE THESE, NEVER DCS's ZONES!!!!\
\
-- a zone has the following attributes\
-- x, z -- coordinate of center. note they have correct x, 0, z coordinates so no y-->z mapping\
-- radius (zero if quad zone)\
-- isCircle (true if quad zone)\
-- poly the quad coords are in the poly attribute and are a \
-- 1..n, wound counter-clockwise as (currently) in DCS:\
-- lower left, lower right upper left, upper right, all coords are x, 0, z \
-- bounds - contain the AABB coords for the zone: ul (upper left), ur, ll (lower left), lr \
--          for both circle and poly, all (x, 0, z)\
\
-- zones can carry information in their names that can get processed into attributes\
-- use \
-- zones can also carry information in their 'properties' tag that ME allows to \
-- edit. cfxZones provides an easy method to access these properties \
--  - getZoneProperty (returns as string)\
--  - getMinMaxFromZoneProperty\
--  - getBoolFromZoneProperty\
--  - getNumberFromZoneProperty\
\
\
-- SUPPORTED PROPERTIES\
-- - \"linkedUnit\" - zone moves with unit of that name. must be exact match\
--   can be combined with other attributes that extend (e.g. scar manager and\
--   limited pilots/airframes \
--\
\
--\
-- readZonesFromDCS is executed exactly once at the beginning\
-- from then on, use only the cfxZones.zones table \
-- WARNING: cfxZones is NOT case-sensitive. All zone names are \
-- indexed by upper case. If you have two zones with same name but \
-- different case, one will be replaced\
--\
\
function cfxZones.readFromDCS(clearfirst)\
    if (clearfirst) then\
        cfxZones.zones = {}\
    end\
    -- not all missions have triggers or zones\
    if not env.mission.triggers then \
        if cfxZones.verbose then \
            trigger.action.outText(\"cf/x zones: no env.triggers defined\", 10)\
        end\
        return\
    end\
    \
    if not env.mission.triggers.zones then \
        if cfxZones.verbose then \
            trigger.action.outText(\"cf/x zones: no zones defined\", 10)\
        end\
        return;\
    end\
\
    -- we only retrieve the data we need. At this point it is name, location and radius\
    -- and put this in our own little  structure. we also convert to all upper case name for index\
    -- and assume that the name may also carry meaning, e.g. 'LZ:' defines a landing zone\
    -- so we can quickly create other sets from this\
    -- zone object. DCS 2.7 introduced quads, so this is supported as well\
    --   name - name in upper case\
    --   isCircle - true if circular zone \
    --   isPoly - true if zone is defined by convex polygon, e.g. quad \
    --   point - vec3 (x 0 z) - zone's in-world center, used to place the coordinate\
    --   radius - number, zero when quad\
    --   bounds - aabb with attributes ul, ur, ll, lr (upper left .. lower right) as (x, 0, z)\
    --   poly - array 1..n of poly points, wound counter-clockwise \
    \
    for i, dcsZone in pairs(env.mission.triggers.zones) do\
        if type(dcsZone) == 'table' then -- hint taken from MIST: verify type when reading from dcs\
                                         -- dcs data is like a box of chocolates...\
            local newZone = {}\
            -- name, converted to upper is used only for indexing\
            -- the original name remains untouched\
            newZone.dcsZone = dcsZone\
            newZone.name = dcsZone.name\
            newZone.isCircle = false\
            newZone.isPoly = false\
            newZone.radius = 0\
            newZone.poly = {}\
            newZone.bounds = {}\
            newZone.properties = {} -- dcs has this too, copy if present\
            if dcsZone.properties then \
                newZone.properties = dcsZone.properties \
            else\
                newZone.properties = {}\
            end -- WARNING: REF COPY. May need to clone \
            \
            local upperName = newZone.name:upper()\
            \
            -- location as 'point'\
            -- WARNING: zones locs are 2D (x,y) pairs, whily y in DCS is altitude.\
            --          so we need to change (x,y) into (x, 0, z). Since Zones have no\
            --          altitude (they are an infinite cylinder) this works. Remember to \
            --          drop y from zone calculations to see if inside. \
            newZone.point = cfxZones.createPoint(dcsZone.x, 0, dcsZone.y)\
\
\
            -- start type processing. if zone.type exists, we have a mission \
            -- created with 2.7 or above, else earlier \
            local zoneType = 0\
            if (dcsZone.type) then \
                zoneType = dcsZone.type \
            end\
            \
            if zoneType == 0 then \
                -- circular zone \
                newZone.isCircle = true \
                newZone.radius = dcsZone.radius\
    \
            elseif zoneType == 2 then\
                -- polyZone\
                newZone.isPoly = true \
                newZone.radius = dcsZone.radius -- radius is still written in DCS, may change later\
                -- now transfer all point in the poly\
                -- note: DCS in 2.7 misspells vertices as 'verticies'\
                -- correct vor this \
                local verts = {}\
                if dcsZone.verticies then verts = dcsZone.verticies \
                else \
                    -- in later versions, this was corrected\
                    verts = dcsZone.vertices -- see if this is ever called\
                end\
                \
                for v=1, #verts do\
                    local dcsPoint = verts[v]\
                    local polyPoint = cfxZones.createPointFromDCSPoint(dcsPoint) -- (x, y) -- (x, 0, y-->z)\
                    newZone.poly[v] = polyPoint\
                end\
            else \
                \
                trigger.action.outText(\"cf/x zones: malformed zone #\" .. i .. \" unknown type \" .. zoneType, 10)\
            end\
            \
\
            -- calculate bounds\
            cfxZones.calculateZoneBounds(newZone) \
\
            -- add to my table\
            cfxZones.zones[upperName] = newZone -- WARNING: UPPER ZONE!!!\
            --trigger.action.outText(\"znd: procced \" .. newZone.name .. \" with radius \" .. newZone.radius, 30)\
        else\
            if cfxZones.verbose then \
                trigger.action.outText(\"cf/x zones: malformed zone #\" .. i .. \" dropped\", 10)\
            end\
        end -- else var not a table\
        \
    end -- for all zones kvp\
end -- readFromDCS\
\
function cfxZones.calculateZoneBounds(theZone)\
    if not (theZone) then return \
    end\
    \
    local bounds = theZone.bounds -- copy ref!\
    \
    if theZone.isCircle then \
        -- aabb are easy: center +/- radius \
        local center = theZone.point\
        local radius = theZone.radius \
        -- dcs uses z+ is down on map\
        -- upper left is center - radius \
        bounds.ul = cfxZones.createPoint(center.x - radius, 0, center.z - radius)\
        bounds.ur = cfxZones.createPoint(center.x + radius, 0, center.z - radius)\
        bounds.ll = cfxZones.createPoint(center.x - radius, 0, center.z + radius)\
        bounds.lr = cfxZones.createPoint(center.x + radius, 0, center.z + radius)\
        \
    elseif theZone.isPoly then\
        local poly = theZone.poly -- ref copy!\
        -- create the four points\
        local ll = cfxZones.createPointFromPoint(poly[1])\
        local lr = cfxZones.createPointFromPoint(poly[1])\
        local ul = cfxZones.createPointFromPoint(poly[1])\
        local ur = cfxZones.createPointFromPoint(poly[1])\
\
        -- now iterate through all points and adjust bounds accordingly \
        for v=2, #poly do \
             local vertex = poly[v]\
             if (vertex.x < ll.x) then ll.x = vertex.x; ul.x = vertex.x end \
             if (vertex.x > lr.x) then lr.x = vertex.x; ur.x = vertex.x end \
             if (vertex.z < ul.z) then ul.z = vertex.z; ur.z = vertex.z end\
             if (vertex.z > ll.z) then ll.z = vertex.z; lr.z = vertex.z end \
            \
        end\
        \
        -- now keep the new point references\
        -- and store them in the zone's bounds\
        bounds.ll = ll\
        bounds.lr = lr\
        bounds.ul = ul\
        bounds.ur = ur \
    else \
        -- huston, we have a problem\
        if cfxZones.verbose then \
            trigger.action.outText(\"cf/x zones: calc bounds: zone \" .. theZone.name .. \" has unknown type\", 30)\
        end\
    end\
    \
end\
\
function cfxZones.createPoint(x, y, z)\
    local newPoint = {}\
    newPoint.x = x\
    newPoint.y = y\
    newPoint.z = z \
    return newPoint\
end\
\
function cfxZones.copyPoint(inPoint) \
    local newPoint = {}\
    newPoint.x = inPoint.x\
    newPoint.y = inPoint.y\
    newPoint.z = inPoint.z \
    return newPoint    \
end\
\
function cfxZones.createHeightCorrectedPoint(inPoint) -- this should be in dcsCommon\
    local cP = cfxZones.createPoint(inPoint.x, land.getHeight({x=inPoint.x, y=inPoint.z}),inPoint.z)\
    return cP\
end\
\
function cfxZones.getHeightCorrectedZonePoint(theZone)\
    return cfxZones.createHeightCorrectedPoint(theZone.point)\
end\
\
function cfxZones.createPointFromPoint(inPoint)\
    return cfxZones.copyPoint(inPoint)\
end\
\
function cfxZones.createPointFromDCSPoint(inPoint) \
    return cfxZones.createPoint(inPoint.x, 0, inPoint.y)\
end\
\
\
function cfxZones.createRandomPointInsideBounds(bounds)\
    local x = math.random(bounds.ll.x, ur.x)\
    local z = math.random(bounds.ll.z, ur.z)\
    return cfxZones.createPoint(x, 0, z)\
end\
\
function cfxZones.addZoneToManagedZones(theZone)\
    local upperName = string.upper(theZone.name) -- newZone.name:upper()\
    cfxZones.zones[upperName] = theZone\
end\
\
function cfxZones.createUniqueZoneName(inName, searchSet)\
    if not inName then return nil end \
    if not searchSet then searchSet = cfxZones.zones end \
    inName = inName:upper()\
    while searchSet[inName] ~= nil do \
        inName = inName .. \"X\"\
    end\
    return inName\
end\
\
function cfxZones.createSimpleZone(name, location, radius, addToManaged)\
    if not radius then radius = 10 end\
    if not addToManaged then addToManaged = false end \
    if not location then \
        location = {}\
    end\
    if not location.x then location.x = 0 end \
    if not location.z then location.z = 0 end \
    \
    local newZone = cfxZones.createCircleZone(name, location.x, location.z, radius)\
    \
    if addToManaged then \
        cfxZones.addZoneToManagedZones(newZone)\
    end\
    return newZone\
end\
\
function cfxZones.createCircleZone(name, x, z, radius) \
    local newZone = {}\
    newZone.isCircle = true\
    newZone.isPoly = false\
    newZone.poly = {}\
    newZone.bounds = {}\
            \
    newZone.name = name\
    newZone.radius = radius\
    newZone.point = cfxZones.createPoint(x, 0, z)\
 \
    -- props \
    newZone.properties = {}\
    \
    -- calculate my bounds\
    cfxZones.calculateZoneBounds(newZone)\
    \
    return newZone\
end\
\
function cfxZones.createPolyZone(name, poly) -- poly must be array of point type\
local newZone = {}\
    newZone.isCircle = false\
    newZone.isPoly = true\
    newZone.poly = {}\
    newZone.bounds = {}\
            \
    newZone.name = name\
    newZone.radius = 0\
    -- copy poly\
    for v=1, #poly do \
        local theVertex = poly[v] \
        newZone.poly[v] = cfxZones.createPointFromPoint(theVertex) \
    end\
    \
    -- properties \
    newZone.properties = {}\
    \
    cfxZones.calculateZoneBounds(newZone)\
end\
\
\
\
function cfxZones.createRandomZoneInZone(name, inZone, targetRadius, entirelyInside)\
    -- create a new circular zone with center placed inside inZone\
    -- if entirelyInside is false, only the zone's center is guaranteed to be inside\
    -- inZone.\
    \
--    trigger.action.outText(\"Zones: creating rZiZ with tr = \" .. targetRadius .. \" for \" .. inZone.name .. \" that as r = \" .. inZone.radius, 10)\
    \
    if inZone.isCircle then \
        local sourceRadius = inZone.radius\
        if entirelyInside and targetRadius > sourceRadius then targetRadius = sourceRadius end\
        if entirelyInside then sourceRadius = sourceRadius - targetRadius end\
    \
        -- ok, let's first create a random percentage value for the new radius\
        local percent = 1 / math.random(100)\
        -- now lets get a random degree\
        local degrees = math.random(360) * 3.14152 / 180 -- ok, it's actually radiants. \
        local r = sourceRadius * percent \
        local x = inZone.point.x + r * math.cos(degrees)\
        local z = inZone.point.z + r * math.sin(degrees)\
        -- construct new zone\
        local newZone = cfxZones.createCircleZone(name, x, z, targetRadius)\
        return newZone\
    \
    elseif inZone.isPoly then \
        -- we have a poly zone. the way we do this is simple:\
        -- generate random x, z with ranges of the bounding box \
        -- until the point falls within the polygon.\
        local newPoint = {}\
        local emergencyBrake = 0\
        repeat\
            newPoint = cfxZones.createRandomPointInsideBounds(inZone.bounds)\
            emergencyBrake = emergencyBrake + 1\
            if (emergencyBrake > 100) then \
                newPoint = cfxZones.copyPoint(inZone.Point)\
                trigger.action.outText(\"CreateZoneInZone: mergency brake for inZone\" .. inZone.name,  10)\
                break\
            end\
        until cfxZones.isPointInsidePoly(newPoint, inZone.poly)\
        \
        -- construct new zone\
        local newZone = cfxZones.createCircleZone(name, newPoint.x, newPoint.z, targetRadius)\
        return newZone\
        \
    else \
        -- zone type unknown\
        trigger.action.outText(\"CreateZoneInZone: unknown zone type for inZone =\" .. inZone.name ,  10)\
        return nil \
    end\
end\
\
-- polygon inside zone calculations\
\
\
-- isleft returns true if point P is to the left of line AB \
-- by determining the sign (up or down) of the normal vector of \
-- the two vectors PA and PB in the y coordinate. We arbitrarily define\
-- left as being > 0, so right is <= 0. As long as we always use the \
-- same comparison, it does not matter what up or down mean.\
-- this is important because we don't know if dcs always winds quads\
-- the same way, we must simply assume that they are wound as a polygon \
function cfxZones.isLeftXZ(A, B, P)\
    return ((B.x - A.x)*(P.z - A.z) - (B.z - A.z)*(P.x - A.x)) > 0\
end\
\
-- returns true/false for inside\
function cfxZones.isPointInsideQuad(thePoint, A, B, C, D) \
    -- Inside test (only convex polygons): \
    -- point lies on the same side of each quad's vertex AB, BC, CD, DA\
    -- how do we find out which side a point lies on? via the cross product\
    -- see isLeft below\
    \
    -- so all we need to do is make sure all results of isLeft for all\
    -- four sides are the same\
    mustMatch = isLeftXZ(A, B, thePoint) -- all test results must be the same and we are ok\
                                       -- they just must be the same side.\
    if (cfxZones.isLeftXZ(B, C, thePoint ~= mustMatch)) then return false end -- on other side than all before\
    if (cfxZones.isLeftXZ(C, D, thePoint ~= mustMatch)) then return false end \
    if (cfxZones.isLeftXZ(D, A, thePoint ~= mustMatch)) then return false end\
    return true\
end\
\
-- generalized version of insideQuad, assumes winding of poly, poly convex, poly closed\
function cfxZones.isPointInsidePoly(thePoint, poly)\
    local mustMatch = cfxZones.isLeftXZ(poly[1], poly[2], thePoint)\
    for v=2, #poly-1 do \
        if cfxZones.isLeftXZ(poly[v], poly[v+1], thePoint) ~= mustMatch then return false end\
    end\
    -- final test\
    if cfxZones.isLeftXZ(poly[#poly], poly[1], thePoint) ~= mustMatch then return false end\
    \
    return true\
end;\
\
function cfxZones.isPointInsideZone(thePoint, theZone)\
    local p = {x=thePoint.x, y = 0, z = thePoint.z} -- zones have no altitude\
    if (theZone.isCircle) then \
        local zp = cfxZones.getPoint(theZone)\
        local d = dcsCommon.dist(p, theZone.point)\
        return d < theZone.radius\
    end \
    \
    if (theZone.isPoly) then \
        --trigger.action.outText(\"zne: isPointInside: \" .. theZone.name .. \" is Polyzone!\", 30)\
        return (cfxZones.isPointInsidePoly(p, theZone.poly))\
    end\
\
    trigger.action.outText(\"isPointInsideZone: Unknown zone type for \" .. outerZone.name, 10)\
end\
\
-- isZoneInZone returns true if center of innerZone is inside  outerZone\
function cfxZones.isZoneInsideZone(innerZone, outerZone) \
    return cfxZones.isPointInsideZone(innerZone.point, outerZone)\
\
    \
end\
\
function cfxZones.getZonesContainingPoint(thePoint, testZones) -- return array \
    if not testZones then \
        testZones = cfxZones.zones \
    end \
    \
    local containerZones = {}\
    for tName, tData in pairs(testZones) do \
        if cfxZones.isPointInsideZone(thePoint, tData) then \
            table.insert(containerZones, tData)\
        end\
    end\
\
    return containerZones\
end\
\
function cfxZones.getFirstZoneContainingPoint(thePoint, testZones)\
    if not testZones then \
        testZones = cfxZones.zones \
    end \
    \
    for tName, tData in pairs(testZones) do \
        if cfxZones.isPointInsideZone(thePoint, tData) then \
            return tData\
        end\
    end\
\
    return nil\
end\
\
function cfxZones.getAllZonesInsideZone(superZone, testZones) -- returnes array!\
    if not testZones then \
        testZones = cfxZones.zones \
    end \
    \
    local containedZones = {}\
    for zName, zData in pairs(testZones) do\
        if cfxZones.isZoneInsideZone(zData, superZone) then \
            if zData ~= superZone then \
                -- we filter superzone because superzone usually resides \
                -- inside itself \
                table.insert(containedZones, zData)\
            end\
        end\
    end\
    return containedZones \
end\
\
function cfxZones.getZonesWithAttributeNamed(attributeName, testZones)\
    if not testZones then testZones = cfxZones.zones end \
\
    local attributZones = {}\
    for aName,aZone in pairs(testZones) do\
        local attr = cfxZones.getZoneProperty(aZone, attributeName)\
        if attr then \
            -- this zone has the requested attribute\
            table.insert(attributZones, aZone)\
        end\
    end\
    return attributZones\
end\
\
--\
-- units / groups in zone\
--\
function cfxZones.allGroupsInZone(theZone, categ) -- categ is optional, must be code \
    -- warning: does not check for exiting!\
    --trigger.action.outText(\"Zone \" .. theZone.name .. \" radius \" .. theZone.radius, 30)\
    local inZones = {}\
    local coals = {0, 1, 2} -- all coalitions\
    for idx, coa in pairs(coals) do \
        local allGroups = coalition.getGroups(coa, categ)\
        for key, group in pairs(allGroups) do -- iterate all groups\
            if cfxZones.isGroupPartiallyInZone(group, theZone) then\
                table.insert(inZones, group)\
            end\
        end\
    end\
    return inZones\
end\
\
function cfxZones.allStaticsInZone(theZone) -- categ is optional, must be code \
    -- warning: does not check for exiting!\
    local inZones = {}\
    local coals = {0, 1, 2} -- all coalitions\
    for idx, coa in pairs(coals) do \
        local allStats = coalition.getStaticObjects(coa)\
        for key, statO in pairs(allStats) do -- iterate all groups\
            local oP = statO:getPoint()\
            if cfxZones.pointInZone(oP, theZone) then\
                table.insert(inZones, statO)\
            end\
        end\
    end\
    return inZones\
end\
\
function cfxZones.groupsOfCoalitionPartiallyInZone(coal, theZone, categ) -- categ is optional\
    local groupsInZone = {}\
    local allGroups = coalition.getGroups(coal, categ)\
    for key, group in pairs(allGroups) do -- iterate all groups\
        if group:isExist() then\
            if cfxZones.isGroupPartiallyInZone(group, theZone) then\
                table.insert(groupsInZone, group)            \
            end\
        end\
    end\
    return groupsInZone\
end\
\
function cfxZones.isGroupPartiallyInZone(aGroup, aZone)\
    if not aGroup then return false end \
    if not aZone then return false end \
        \
    if not aGroup:isExist() then return false end \
    local allUnits = aGroup:getUnits()\
    for uk, aUnit in pairs (allUnits) do \
        if aUnit:isExist() and aUnit:getLife() > 1 then         \
            local p = aUnit:getPoint()\
            local inzone, percent, dist = cfxZones.pointInZone(p, aZone)\
            if inzone then -- cfxZones.isPointInsideZone(p, aZone) then             \
                --trigger.action.outText(\"zne: YAY <\" .. aUnit:getName() .. \"> IS IN \" .. aZone.name, 30) \
                return true\
            end \
            --trigger.action.outText(\"zne: <\" .. aUnit:getName() .. \"> not in \" .. aZone.name .. \", dist = \" .. dist .. \", rad = \", aZone.radius, 30) \
        end\
    end\
    return false\
end\
\
function cfxZones.isEntireGroupInZone(aGroup, aZone)\
    if not aGroup then return false end \
    if not aZone then return false end \
    if not aGroup:isExist() then return false end \
    local allUnits = aGroup:getUnits()\
    for uk, aUnit in pairs (allUnits) do \
        if aUnit:isExist() and aUnit:getLife() > 1 then \
            local p = aUnit:getPoint()\
            if not cfxZones.isPointInsideZone(p, aZone) then \
                return false\
            end\
        end\
    end\
    return true\
end\
\
\
--\
-- Zone Manipulation\
--\
\
function cfxZones.offsetZone(theZone, dx, dz)\
    -- first, update center \
    theZone.point.x = theZone.point.x + dx\
    theZone.point.z = theZone.point.z + dz \
    \
    -- now process all polygon points - it's empty for circular, so don't worry\
    for v=1, #theZone.poly do \
        theZone.poly[v].x = theZone.poly[v].x + dx\
        theZone.poly[v].z = theZone.poly[v].z + dz \
    end\
end\
\
function cfxZones.moveZoneTo(theZone, x, z)\
    local dx = x - theZone.point.x\
    local dz = z - theZone.point.z \
    cfxZones.offsetZone(theZone, dx, dz)\
end;\
\
function cfxZones.centerZoneOnUnit(theZone, theUnit) \
    local thePoint = theUnit:getPoint()\
    cfxZones.moveZoneTo(theZone, thePoint.x, thePoint.z)\
end\
\
\
--[[\
-- no longer makes sense with poly zones\
function cfxZones.isZoneEntirelyInsideZone(innerZone, outerZone)\
    if (innerZone.radius > outerZone.radius) then return false end -- cant fit inside\
    local d = dcsCommon.dist(innerZone.point, outerZone.point)\
    local reducedR = outerZone.radius - innerZone.radius\
    return d < reducedR\
end;\
--]]\
\
function cfxZones.dumpZones(zoneTable)\
    if not zoneTable then zoneTable = cfxZones.zones end \
    \
    trigger.action.outText(\"Zones START\", 10)\
    for i, zone in pairs(zoneTable) do \
        local myType = \"unknown\"\
        if zone.isCircle then myType = \"Circle\" end\
        if zone.isPoly then myType = \"Poly\" end \
        \
        trigger.action.outText(\"#\".. i .. \": \" .. zone.name .. \" of type \" .. myType, 10)\
    end\
    trigger.action.outText(\"Zones END\", 10)\
end\
\
function cfxZones.stringStartsWith(theString, thePrefix)\
    return theString:find(thePrefix) == 1\
end\
\
function cfxZones.keysForTable(theTable)\
    local keyset={}\
    local n=0\
\
    for k,v in pairs(tab) do\
        n=n+1\
        keyset[n]=k\
    end\
    return keyset\
end\
\
\
--\
-- return all zones that have a specific named property\
--\
function cfxZones.zonesWithProperty(propertyName, searchSet)\
    if not searchSet then searchSet = cfxZones.zones end \
    local theZones = {}\
    for k, aZone in pairs(searchSet) do \
        if not aZone then \
            trigger.action.outText(\"+++zone: nil aZone for \" .. k, 30)\
        else \
            local lU = cfxZones.getZoneProperty(aZone, propertyName)\
            if lU then \
                table.insert(theZones, aZone)\
            end\
        end\
    end    \
    return theZones\
end\
\
--\
-- return all zones from the zone table that begin with string prefix\
--\
function cfxZones.zonesStartingWithName(prefix, searchSet)\
    \
    if not searchSet then searchSet = cfxZones.zones end \
    \
--    trigger.action.outText(\"Enter: zonesStartingWithName for \" .. prefix , 30)\
    local prefixZones = {}\
    prefix = prefix:upper() -- all zones have UPPERCASE NAMES! THEY SCREAM AT YOU\
    for name, zone in pairs(searchSet) do\
--        trigger.action.outText(\"testing \" .. name:upper() .. \" starts with \" .. prefix , 30)\
        if cfxZones.stringStartsWith(name:upper(), prefix) then\
            prefixZones[name] = zone -- note: ref copy!\
            --trigger.action.outText(\"zone with prefix <\" .. prefix .. \"> found: \" .. name, 10)\
        end\
    end\
    \
    return prefixZones\
end\
\
--\
-- return all zones from the zone table that begin with the string or set of strings passed in prefix \
-- if you pass 'true' as second (optional) parameter, it will first look for all zones that begin\
-- with '+' and return only those. Use during debugging to force finding a specific zone\
--\
function cfxZones.zonesStartingWith(prefix, searchSet, debugging)\
    -- you can force zones by having their name start with \"+\"\
    -- which will force them to return immediately if debugging is true for this call\
\
    if (debugging) then \
        local debugZones = cfxZones.zonesStartingWithName(\"+\", searchSet)\
        if not (next(debugZones) == nil) then -- # operator only works on array elements \
            --trigger.action.outText(\"returning zones with prefix <\" .. prefix .. \">\", 10)\
            return debugZones \
        end \
    end\
    \
    --trigger.action.outText(\"#debugZones is  <\" .. #debugZones .. \">\", 10)\
\
    if (type(prefix) == \"string\") then \
        return cfxZones.zonesStartingWithName(prefix, searchSet)\
    end\
    \
    local allZones = {}\
    for i=1, #prefix do \
        -- iterate through all names in prefix set\
        local theName = prefix[i]\
        local newZones = cfxZones.zonesStartingWithName(theName, searchSet)\
        -- add them all to current table\
        for zName, zInfo in pairs(newZones) do \
            allZones[zName] = zInfo -- will also replace doublets\
        end\
    end\
    \
    return allZones\
end\
\
function cfxZones.getZoneByName(aName, searchSet) \
    if not searchSet then searchSet = cfxZones.zones end \
    aName = aName:upper()\
    return searchSet[aName] -- the joys of key value pairs\
end\
\
function cfxZones.getZonesContainingString(aString, searchSet) \
    if not searchSet then searchSet = cfxZones.zones end\
    aString = string.upper(aString)\
    resultSet = {}\
    for zName, zData in pairs(searchSet) do \
        if aString == string.upper(zData.name) then \
            resultSet[zName] = zData\
        end\
    end\
    \
end;\
\
-- filter zones by range to a point. returns indexed set\
function cfxZones.getZonesInRange(point, range, theZones)\
    if not theZones then theZones = cfxZones.zones end\
    \
    local inRangeSet = {}\
    for zName, zData in pairs (theZones) do \
        if dcsCommon.dist(point, zData.point) < range then \
            table.insert(inRangeSet, zData)\
        end\
    end\
    return inRangeSet \
end\
\
-- get closest zone returns the zone that is closest to point \
function cfxZones.getClosestZone(point, theZones)\
    if not theZones then theZones = cfxZones.zones end\
    local currDelta = math.huge \
    local closestZone = nil\
    for zName, zData in pairs(theZones) do \
        local zPoint = cfxZones.getPoint(zData)\
        local delta = dcsCommon.dist(point, zPoint)\
        if (delta < currDelta) then \
            currDelta = delta\
            closestZone = zData\
        end\
    end\
    return closestZone, currDelta \
end\
\
-- return a random zone from the table passed in zones\
function cfxZones.pickRandomZoneFrom(zones)\
    if not zones then zones = cfxZones.zones end\
    local indexedZones = dcsCommon.enumerateTable(zones)\
    local r = math.random(#indexedZones)\
    return indexedZones[r]\
end\
\
-- return an zone element by index \
function cfxZones.getZoneByIndex(theZones, theIndex) \
    local enumeratedZones = dcsCommon.enumerateTable(theZones)\
    if (theIndex > #enumeratedZones) then\
        trigger.action.outText(\"WARNING: zone index \" .. theIndex .. \" out of bounds - max = \" .. #enumeratedZones, 30)\
        return nil end\
    if (theIndex < 1) then return nil end\
    \
    return enumeratedZones[theIndex]\
end\
\
-- place a smoke marker in center of zone, offset by dx, dy \
function cfxZones.markZoneWithSmoke(theZone, dx, dz, smokeColor, alt)\
    if not alt then alt = 5 end \
    local point = cfxZones.getPoint(theZone) --{} -- theZone.point\
    point.x = point.x + dx -- getpoint updates and returns copy \
    point.z = point.z + dz \
    -- get height at point \
    point.y = land.getHeight({x = point.x, y = point.z}) + alt\
    -- height-correct\
    --local newPoint= {x = point.x, y = land.getHeight({x = point.x, y = point.z}) + 3, z= point.z}\
    trigger.action.smoke(point, smokeColor)\
end\
\
-- place a smoke marker in center of zone, offset by radius and degrees \
function cfxZones.markZoneWithSmokePolar(theZone, radius, degrees, smokeColor, alt)\
    local rads = degrees * math.pi / 180\
    local dx = radius * math.sin(rads)\
    local dz = radius * math.cos(rads)\
    cfxZones.markZoneWithSmoke(theZone, dx, dz, smokeColor, alt)\
end\
\
-- place a smoke marker in center of zone, offset by radius and randomized degrees \
function cfxZones.markZoneWithSmokePolarRandom(theZone, radius, smokeColor)\
    local degrees = math.random(360)\
    cfxZones.markZoneWithSmokePolar(theZone, radius, degrees, smokeColor)\
end\
\
\
-- unitInZone returns true if theUnit is inside the zone \
-- the second value returned is the percentage of distance\
-- from center to rim, with 100% being entirely in center, 0 = outside\
-- the third value returned is the distance to center\
function cfxZones.pointInZone(thePoint, theZone)\
\
    if not (theZone) then return false, 0, 0 end\
        \
    local pflat = {x = thePoint.x, y = 0, z = thePoint.z}\
    \
    local zpoint = cfxZones.getPoint(theZone) -- updates zone if linked \
    local ppoint = thePoint -- xyz\
    local pflat = {x = ppoint.x, y = 0, z = ppoint.z}\
    local dist = dcsCommon.dist(zpoint, pflat)\
    \
    if theZone.isCircle then \
        if theZone.radius <= 0 then \
            return false, 0, 0\
        end\
\
        local success = dist < theZone.radius\
        local percentage = 0\
        if (success) then \
            percentage = 1 - dist / theZone.radius \
        end\
        return success, percentage, dist \
    \
    elseif theZone.isPoly then\
        local success = cfxZones.isPointInsidePoly(pflat, theZone.poly)\
        return success, 0, dist\
    else \
        trigger.action.outText(\"pointInZone: Unknown zone type for \" .. theZone.name, 10)\
    end\
\
    return false\
end\
\
function cfxZones.unitInZone(theUnit, theZone)\
    if not (theUnit) then return false, 0, 0 end\
    if not (theUnit:isExist()) then return false, 0, 0 end\
    -- force zone update if it is linked to another zone \
    -- pointInZone does update\
    local thePoint = theUnit:getPoint()\
    return cfxZones.pointInZone(thePoint, theZone)\
    \
end\
\
-- returns all units of the input set that are inside the zone \
function cfxZones.unitsInZone(theUnits, theZone)\
    if not theUnits then return {} end\
    if not theZone then return {} end\
    \
    local zoneUnits = {}\
    for index, aUnit in pairs(theUnits) do \
        if cfxZones.unitInZone(aUnit, theZone) then \
            table.insert( zoneUnits, aUnit)\
        end\
    end\
    return zoneUnits\
end\
\
function cfxZones.closestUnitToZoneCenter(theUnits, theZone)\
    -- does not care if they really are in zone. call unitsInZone first\
    -- if you need to have them filtered\
    -- theUnits MUST BE ARRAY\
    if not theUnits then return nil end\
    if #theUnits == 0 then return nil end\
    local closestUnit = theUnits[1]\
    for i=2, #theUnits do\
        local aUnit = theUnits[i]\
        if dcsCommon.dist(theZone.point, closestUnit:getPoint()) > dcsCommon.dist(theZone.point, aUnit:getPoint()) then \
            closestUnit = aUnit\
        end\
    end\
    return closestUnit\
end\
\
function cfxZones.anyPlayerInZone(theZone) -- returns first player it finds\
    for pname, pinfo in pairs(cfxPlayer.playerDB) do\
        local playerUnit = pinfo.unit\
        if (cfxZones.unitInZone(playerUnit, theZone)) then \
            return true, playerUnit\
        end\
    end -- for all players \
    return false, nil\
end\
\
\
-- grow zone\
function cfxZones.growZone()\
    -- circular zones simply increase radius\
    -- poly zones: not defined \
    \
end\
\
\
-- creating units in a zone\
function cfxZones.createGroundUnitsInZoneForCoalition (theCoalition, groupName, theZone, theUnits, formation, heading) \
    -- theUnits can be string or table of string \
    if not groupName then groupName = \"G_\"..theZone.name end \
    -- group name will be taken from zone name and prependend with \"G_\"\
    local theGroup = dcsCommon.createGroundGroupWithUnits(groupName, theUnits, theZone.radius, nil, formation)\
    \
    -- turn the entire formation to heading\
    if (not heading) then heading = 0 end\
    dcsCommon.rotateGroupData(theGroup, heading) -- currently, group is still at origin, no cx, cy\
    \
    \
    -- now move the group to center of theZone\
    dcsCommon.moveGroupDataTo(theGroup, \
                          theZone.point.x, \
                          theZone.point.z) -- watchit: Z!!!\
\
\
    -- create the group in the world and return it\
    -- first we need to translate the coalition to a legal \
    -- country. we use UN for neutral, cjtf for red and blue \
    local theSideCJTF = dcsCommon.coalition2county(theCoalition)\
    return coalition.addGroup(theSideCJTF, Group.Category.GROUND, theGroup)\
\
end\
\
-- parsing zone names. The first part of the name until the first blank \" \" \
-- is the prefix and is dropped unless keepPrefix is true. \
-- all others are regarded as key:value pairs and are then added \
-- to the zone \
-- separated by equal sign \"=\" AND MUST NOT CONTAIN BLANKS\
--\
-- example usage \"followZone unit=rotary-1 dx=30 dy=25 rotateWithHeading=true\
--\
-- OLD DEPRECATED TECH -- TO BE DECOMMISSIONED SOON, DO NOT USE\
-- \
--[[--\
function cfxZones.parseZoneNameIntoAttributes(theZone, keepPrefix)\
--    trigger.action.outText(\"Parsing zone:  \".. theZone.name, 30)\
    if not keepPrefix then keepPrefix = false end -- simply for clarity\
    -- now split the name into space-separated strings\
    local attributes = dcsCommon.splitString(theZone.name, \" \")\
    if not keepPrefix then table.remove(attributes, 1) end -- pop prefix\
\
    -- now parse all substrings and add them as attributes to theZone\
    for i=1, #attributes do \
        local a = attributes[i]\
        local kvp = dcsCommon.splitString(a, \"=\")\
        if #kvp == 2 then \
            -- we have key value pair\
            local theKey = kvp[1]\
            local theValue = kvp[2]\
            theZone[theKey] = theValue \
--            trigger.action.outText(\"Zone \".. theZone.name .. \" parsed: Key = \" .. theKey .. \", Value = \" .. theValue, 30)\
        else \
--            trigger.action.outText(\"Zone \".. theZone.name .. \": dropped attribute \" .. a, 30)\
        end\
    end \
end\
--]]--\
-- OLD DEPRECATED TECH -- TO BE DECOMMISSIONED SOON, DO NOT USE\
--[[--\
function cfxZones.processCraterZones ()\
    local craters = cfxZones.zonesStartingWith(\"crater\")\
\
    \
\
    -- all these zones need to be processed and their name infor placed into attributes\
    for cName, cZone in pairs(craters) do\
        cfxZones.parseZoneNameIntoAttributes(cZone)\
        \
        -- blow stuff up at the location of the zone \
        local cPoint = cZone.point\
        cPoint.y = land.getHeight({x = cPoint.x, y = cPoint.z})  -- compensate for ground level\
        trigger.action.explosion(cPoint, 900)\
         \
        -- now interpret and act on the crater info \
        -- to destroy and place fire. \
        \
        -- fire has small, medium, large \
        -- eg. fire=large\
        \
    end\
end\
--]]--\
--\
-- Flag Pulling \
--\
function cfxZones.pulseFlag(theFlag, method, theZone)\
    local args = {}\
    args.theFlag = theFlag\
    args.method = method\
    args.theZone = theZone \
    local delay = 3\
    if dcsCommon.containsString(method, \",\") then \
        local parts = dcsCommon.splitString(method, \",\")\
        delay = parts[2]\
        if delay then delay = tonumber(delay) end  \
    end\
    if not delay then delay = 3 end \
    if theZone.verbose then \
        trigger.action.outText(\"+++zne: RAISING pulse t=\"..delay..\" for flag <\" .. theFlag .. \"> in zone <\" .. theZone.name ..\">\", 30)\
    end \
    local newVal = 1\
    cfxZones.setFlagValue(theFlag, newVal, theZone)\
    \
    -- schedule second half of pulse \
    timer.scheduleFunction(cfxZones.unPulseFlag, args, timer.getTime() + delay)\
end\
\
function cfxZones.unPulseFlag(args)\
    local theZone = args.theZone\
    local method = args.method \
    local theFlag = args.theFlag \
    local newVal = 0\
    -- we may later use method to determine pulse direction / newVal\
    -- for now, we always go low \
    if theZone.verbose then \
        trigger.action.outText(\"+++zne: DOWNPULSE pulse for flag <\" .. theFlag .. \"> in zone <\" .. theZone.name ..\">\", 30)\
    end\
    cfxZones.setFlagValue(theFlag, newVal, theZone)\
end\
\
function cfxZones.doPollFlag(theFlag, method, theZone)\
    if cfxZones.verbose then \
        trigger.action.outText(\"+++zones: polling flag \" .. theFlag .. \" with \" .. method, 30)\
    end \
    \
    if not theZone then \
        trigger.action.outText(\"+++zones: nil theZone on pollFlag\", 30)\
    end\
    \
    method = method:lower()\
    method = dcsCommon.trim(method)\
    val = tonumber(method)\
    if val then \
        cfxZones.setFlagValue(theFlag, val, theZone)\
        if cfxZones.verbose or theZone.verbose then\
            trigger.action.outText(\"+++zones: flag <\" .. theFlag .. \"> changed to #\" .. val, 30)\
        end \
        return \
    end \
    \
    --trigger.action.outText(\"+++zones: polling \" .. theZone.name .. \" method \" .. method .. \" flag \" .. theFlag, 30)\
    local currVal = cfxZones.getFlagValue(theFlag, theZone)\
    if method == \"inc\" or method == \"f+1\" then \
        --trigger.action.setUserFlag(theFlag, currVal + 1)\
        cfxZones.setFlagValue(theFlag, currVal+1, theZone)\
        \
    elseif method == \"dec\" or method == \"f-1\" then \
        -- trigger.action.setUserFlag(theFlag, currVal - 1)\
        cfxZones.setFlagValue(theFlag, currVal-1, theZone)\
\
    elseif method == \"off\" or method == \"f=0\" then \
        -- trigger.action.setUserFlag(theFlag, 0)\
        cfxZones.setFlagValue(theFlag, 0, theZone)\
\
    elseif method == \"flip\" or method == \"xor\" then \
        if currVal ~= 0 then \
--            trigger.action.setUserFlag(theFlag, 0)\
            cfxZones.setFlagValue(theFlag, 0, theZone)\
\
        else \
            --trigger.action.setUserFlag(theFlag, 1)\
            cfxZones.setFlagValue(theFlag, 1, theZone)\
        end\
        \
    elseif dcsCommon.stringStartsWith(method, \"pulse\") then \
        cfxZones.pulseFlag(theFlag, method, theZone)\
        \
    else \
        if method ~= \"on\" and method ~= \"f=1\" then \
            trigger.action.outText(\"+++zones: unknown method <\" .. method .. \"> - using 'on'\", 30)\
        end\
        -- default: on.\
--        trigger.action.setUserFlag(theFlag, 1)\
        cfxZones.setFlagValue(theFlag, 1, theZone)\
    end\
    \
    if cfxZones.verbose then\
        local newVal = cfxZones.getFlagValue(theFlag, theZone)\
        trigger.action.outText(\"+++zones: flag <\" .. theFlag .. \"> changed from \" .. currVal .. \" to \" .. newVal, 30)\
    end \
end\
\
function cfxZones.pollFlag(theFlag, method, theZone) \
    local allFlags = {}\
    if dcsCommon.containsString(theFlag, \",\") then \
        if cfxZones.verbose then \
            trigger.action.outText(\"+++zones: will poll flag set <\" .. theFlag .. \"> with \" .. method, 30)\
        end\
        allFlags = dcsCommon.splitString(theFlag, \",\")\
    else \
        table.insert(allFlags, theFlag)\
    end\
    \
    for idx, aFlag in pairs(allFlags) do \
        aFlag = dcsCommon.trim(aFlag)\
        -- note: mey require range preprocessing, but that's not\
        -- a priority \
        cfxZones.doPollFlag(aFlag, method, theZone)\
    end \
    \
end\
\
function cfxZones.setFlagValueMult(theFlag, theValue, theZone)\
    local allFlags = {}\
    if dcsCommon.containsString(theFlag, \",\") then \
        if cfxZones.verbose then \
            trigger.action.outText(\"+++zones: will multi-set flags <\" .. theFlag .. \"> to \" .. theValue, 30)\
        end\
        allFlags = dcsCommon.splitString(theFlag, \",\")\
    else \
        table.insert(allFlags, theFlag)\
    end\
    \
    for idx, aFlag in pairs(allFlags) do \
        aFlag = dcsCommon.trim(aFlag)\
        -- note: mey require range preprocessing, but that's not\
        -- a priority \
        cfxZones.setFlagValue(aFlag, theValue, theZone)\
    end \
end\
\
function cfxZones.setFlagValue(theFlag, theValue, theZone)\
    local zoneName = \"<dummy>\"\
    if not theZone then \
        trigger.action.outText(\"+++Zne: no zone on setFlagValue\")\
    else \
        zoneName = theZone.name -- for flag wildcards\
    end\
    \
    if type(theFlag) == \"number\" then \
        -- straight set, ME flag \
        trigger.action.setUserFlag(theFlag, theValue)\
        return \
    end\
    \
    -- we assume it's a string now\
    theFlag = dcsCommon.trim(theFlag) -- clear leading/trailing spaces\
    local nFlag = tonumber(theFlag) \
    if nFlag then \
        trigger.action.setUserFlag(theFlag, theValue)\
        return \
    end\
    \
    -- some QoL: detect \"<none>\"\
    if dcsCommon.containsString(theFlag, \"<none>\") then \
        trigger.action.outText(\"+++Zone: warning - setFlag has '<none>' flag name in zone <\" .. zoneName .. \">\", 30)\
    end\
    \
    -- now do wildcard processing. we have alphanumeric\
    if dcsCommon.stringStartsWith(theFlag, \"*\") then  \
        theFlag = zoneName .. theFlag\
    end\
    trigger.action.setUserFlag(theFlag, theValue)\
end \
\
function cfxZones.getFlagValue(theFlag, theZone)\
    local zoneName = \"<dummy>\"\
    if not theZone then \
        trigger.action.outText(\"+++Zne: no zone on getFlagValue\", 30)\
    else \
        zoneName = theZone.name -- for flag wildcards\
    end\
    \
    if type(theFlag) == \"number\" then \
        -- straight get, ME flag \
        return tonumber(trigger.misc.getUserFlag(theFlag))\
    end\
    \
    -- we assume it's a string now\
    theFlag = dcsCommon.trim(theFlag) -- clear leading/trailing spaces\
    local nFlag = tonumber(theFlag) \
    if nFlag then \
        return tonumber(trigger.misc.getUserFlag(theFlag))\
    end\
    \
    -- some QoL: detect \"<none>\"\
    if dcsCommon.containsString(theFlag, \"<none>\") then \
        trigger.action.outText(\"+++Zone: warning - getFlag has '<none>' flag name in zone <\" .. zoneName .. \">\", 30)\
    end\
    \
    -- now do wildcard processing. we have alphanumeric\
    if dcsCommon.stringStartsWith(theFlag, \"*\") then  \
            theFlag = zoneName .. theFlag\
    end\
    return tonumber(trigger.misc.getUserFlag(theFlag))\
end\
\
function cfxZones.isMEFlag(inFlag)\
    -- do NOT use me\
    trigger.action.outText(\"+++zne: warning: deprecated isMEFlag\", 30)\
    return true \
    -- returns true if inFlag is a pure positive number\
--    inFlag = dcsCommon.trim(inFlag)\
--    return dcsCommon.stringIsPositiveNumber(inFlag)\
end\
\
-- method-based flag testing \
function cfxZones.evalFlagMethodImmediate(currVal, theMethod, theZone)\
    -- immediate eval - does not look at last val. \
    -- return true/false/value based on theMethod's contraints \
    -- simple constraints\
    local lMethod = string.lower(theMethod)\
    if lMethod == \"#\" or lMethod == \"change\" then \
        -- ALWAYS RETURNS TRUE for currval <> 0, flase if currval = 0\
        return currVal ~= 0  \
    end\
    \
    if lMethod == \"0\" or lMethod == \"no\" or lMethod == \"false\" \
       or lMethod == \"off\" then \
        -- WARNING: ALWAYS RETURNS FALSE\
        return false  \
    end\
    \
    if lMethod == \"1\" or lMethod == \"yes\" or lMethod == \"true\" \
       or lMethod == \"on\" then \
        -- WARNING: ALWAYS RETURNS TRUE\
        return true  \
    end\
    \
    if lMethod == \"inc\" or lMethod == \"+1\" then \
        return currVal+1 -- this may be unexpected\
    end\
    \
    if lMethod == \"dec\" or lMethod == \"-1\" then \
        return currVal-1 -- this may be unexpectd\
    end \
    \
    -- number constraints\
    -- or flag constraints \
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \
    local op = string.sub(theMethod, 1, 1) \
    local remainder = string.sub(theMethod, 2)\
    remainder = dcsCommon.trim(remainder) -- remove all leading and trailing spaces\
    local rNum = tonumber(remainder)\
    if not rNum then \
        -- we use remainder as name for flag \
        -- PROCESS ESCAPE SEQUENCES\
        local esc = string.sub(remainder, 1, 1)\
        local last = string.sub(remainder, -1)\
        if esc == \"@\" then \
            remainder = string.sub(remainder, 2)\
            remainder = dcsCommon.trim(remainder)\
        end\
        \
        if esc == \"(\" and last == \")\" and string.len(remainder) > 2 then \
            -- note: iisues with startswith(\"(\") ???\
            remainder = string.sub(remainder, 2, -2)\
            remainder = dcsCommon.trim(remainder)        \
        end\
        if esc == \"\\\"\" and last == \"\\\"\" and string.len(remainder) > 2 then \
            remainder = string.sub(remainder, 2, -2)\
            remainder = dcsCommon.trim(remainder)        \
        end\
        if cfxZones.verbose then \
            trigger.action.outText(\"+++zne: accessing flag <\" .. remainder .. \">\", 30)\
        end \
        rNum = cfxZones.getFlagValue(remainder, theZone)\
    end \
    if rNum then \
        -- we have a comparison = \">\", \"=\", \"<\" followed by a number  \
        if op == \"=\" then \
            return currVal == rNum\
        end\
        \
        if op == \"#\" or op == \"~\" then \
            return currVal ~= rNum \
        end \
        \
        if op == \"<\" then \
            return currVal < rNum\
        end\
        \
        if op == \">\" then \
            return currVal > rNum\
        end\
    end\
    \
    -- if we get here, we have an error \
    local zoneName = \"<NIL>\"\
    if theZone then zoneName = theZone.name end \
    trigger.action.outText(\"+++Zne: illegal |\" .. theMethod .. \"| in eval for zone \" .. zoneName, 30 )\
    return false     \
end\
\
function cfxZones.testFlagByMethodForZone(currVal, lastVal, theMethod, theZone)\
    -- return true/false based on theMethod's contraints \
    -- simple constraints\
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \
    local lMethod = string.lower(theMethod)\
    if lMethod == \"#\" or lMethod == \"change\" then \
        -- check if currVal different from lastVal\
        return currVal ~= lastVal  \
    end\
    \
    if lMethod == \"0\" or lMethod == \"no\" or lMethod == \"false\" \
       or lMethod == \"off\" then \
        -- WARNING: ONLY RETURNS TRUE IF FALSE AND lastval not zero!\
        return currVal == 0 and currVal ~= lastVal  \
    end\
    \
    if lMethod == \"1\" or lMethod == \"yes\" or lMethod == \"true\" \
       or lMethod == \"on\" then \
        -- WARNING: only returns true if lastval was false!!!!\
        return (currVal ~= 0 and lastVal == 0)  \
    end\
    \
    if lMethod == \"inc\" or lMethod == \"+1\" then \
--        return currVal == lastVal+1 -- better: test for greater than \
        return currVal > lastVal\
    end\
    \
    if lMethod == \"dec\" or lMethod == \"-1\" then \
        --return currVal == lastVal-1\
        return currVal < lastVal \
    end \
    \
    if lMethod == \"lohi\" or lMethod == \"pulse\" then \
        return (lastVal <= 0 and currVal > 0)\
    end\
    \
    if lMethod == \"hilo\" then \
        return (lastVal > 0 and currVal <= 0)\
    end\
    \
    -- number constraints\
    -- or flag constraints \
    -- ONLY RETURN TRUE IF CHANGE AND CONSTRAINT MET \
    local op = string.sub(theMethod, 1, 1) \
    local remainder = string.sub(theMethod, 2)\
    remainder = dcsCommon.trim(remainder) -- remove all leading and trailing spaces\
    local rNum = tonumber(remainder)\
    if not rNum then \
        -- we use remainder as name for flag \
        -- PROCESS ESCAPE SEQUENCES\
        local esc = string.sub(remainder, 1, 1)\
        local last = string.sub(remainder, -1)\
        if esc == \"@\" then \
            remainder = string.sub(remainder, 2)\
            remainder = dcsCommon.trim(remainder)\
        end\
        \
        if esc == \"(\" and last == \")\" and string.len(remainder) > 2 then \
            -- note: iisues with startswith(\"(\") ???\
            remainder = string.sub(remainder, 2, -2)\
            remainder = dcsCommon.trim(remainder)        \
        end\
        if esc == \"\\\"\" and last == \"\\\"\" and string.len(remainder) > 2 then \
            remainder = string.sub(remainder, 2, -2)\
            remainder = dcsCommon.trim(remainder)        \
        end\
        if cfxZones.verbose then \
            trigger.action.outText(\"+++zne: accessing flag <\" .. remainder .. \">\", 30)\
        end \
        rNum = cfxZones.getFlagValue(remainder, theZone)\
    end \
    if rNum then \
        -- we have a comparison = \">\", \"=\", \"<\" followed by a number \
        -- THEY TRIGGER EACH TIME lastVal <> currVal AND condition IS MET  \
        if op == \"=\" then \
            return currVal == rNum and lastVal ~= currVal\
        end\
        \
        if op == \"#\" or op == \"~\" then \
            return currVal ~= rNum and lastVal ~= currVal \
        end \
        \
        if op == \"<\" then \
            return currVal < rNum and lastVal ~= currVal\
        end\
        \
        if op == \">\" then \
            return currVal > rNum and lastVal ~= currVal\
        end\
    end\
    \
    -- if we get here, we have an error \
    local zoneName = \"<NIL>\"\
    if theZone then zoneName = theZone.name end \
    trigger.action.outText(\"+++Zne: illegal method constraints |\" .. theMethod .. \"| for zone \" .. zoneName, 30 )\
    return false \
end\
\
\
function cfxZones.testZoneFlag(theZone, theFlagName, theMethod, latchName)\
    -- returns two values: true/false method result, and curr value\
    -- returns true if method constraints are met for flag theFlagName\
    -- as defined by theMethod \
    if not theMethod then \
        theMethod = \"change\"\
    end \
    \
    -- will read and update theZone[latchName] as appropriate \
    if not theZone then \
        trigger.action.outText(\"+++Zne: no zone for testZoneFlag\", 30)\
        return nil, nil \
    end \
    if not theFlagName then \
        -- this is common, no error, only on verbose \
        if cfxZones.verbose then \
            trigger.action.outText(\"+++Zne: no flagName for zone \" .. theZone.name .. \" for testZoneFlag\", 30)\
        end \
        return nil, nil\
    end\
    if not latchName then \
        trigger.action.outText(\"+++Zne: no latchName for zone \" .. theZone.name .. \" for testZoneFlag\", 30)\
        return nil, nil \
    end\
    -- get current value \
    local currVal = cfxZones.getFlagValue(theFlagName, theZone)\
    \
    -- get last value from latch\
    local lastVal = theZone[latchName]\
    if not lastVal then \
        trigger.action.outText(\"+++Zne: latch <\" .. latchName .. \"> not valid for zone \" .. theZone.name, 30)\
        return nil, nil\
    end\
    \
    -- now, test by method \
    -- we should only test if currVal <> lastVal \
    if currVal == lastVal then\
        return false, currVal\
    end \
    \
    --trigger.action.outText(\"+++Zne: about to test: c = \" .. currVal .. \", l = \" .. lastVal, 30)\
    local testResult = cfxZones.testFlagByMethodForZone(currVal, lastVal, theMethod, theZone)\
\
    -- update latch by method\
    theZone[latchName] = currVal \
\
    -- return result\
    return testResult, currVal\
end\
\
\
\
function cfxZones.flagArrayFromString(inString)\
-- original code from RND flag\
    if string.len(inString) < 1 then \
        trigger.action.outText(\"+++zne: empty flags\", 30)\
        return {} \
    end\
    if cfxZones.verbose then \
        trigger.action.outText(\"+++zne: processing <\" .. inString .. \">\", 30)\
    end \
    \
    local flags = {}\
    local rawElements = dcsCommon.splitString(inString, \",\")\
    -- go over all elements \
    for idx, anElement in pairs(rawElements) do \
        if dcsCommon.stringStartsWithDigit(anElement) and  dcsCommon.containsString(anElement, \"-\") then \
            -- interpret this as a range\
            local theRange = dcsCommon.splitString(anElement, \"-\")\
            local lowerBound = theRange[1]\
            lowerBound = tonumber(lowerBound)\
            local upperBound = theRange[2]\
            upperBound = tonumber(upperBound)\
            if lowerBound and upperBound then\
                -- swap if wrong order\
                if lowerBound > upperBound then \
                    local temp = upperBound\
                    upperBound = lowerBound\
                    lowerBound = temp \
                end\
                -- now add add numbers to flags\
                for f=lowerBound, upperBound do \
                    table.insert(flags, tostring(f))\
                end\
            else\
                -- bounds illegal\
                trigger.action.outText(\"+++zne: ignored range <\" .. anElement .. \"> (range)\", 30)\
            end\
        else\
            -- single number\
            f = dcsCommon.trim(anElement) -- DML flag upgrade: accept strings tonumber(anElement)\
            if f then \
                table.insert(flags, f)\
\
            else \
                trigger.action.outText(\"+++zne: ignored element <\" .. anElement .. \"> (single)\", 30)\
            end\
        end\
    end\
    if cfxZones.verbose then \
        trigger.action.outText(\"+++zne: <\" .. #flags .. \"> flags total\", 30)\
    end \
    return flags\
end\
\
--\
-- PROPERTY PROCESSING \
--\
\
function cfxZones.getAllZoneProperties(theZone, caseInsensitive) -- return as dict \
    if not caseInsensitive then caseInsensitive = false end \
    if not theZone then return {} end \
    \
    local dcsProps = theZone.properties -- zone properties in dcs format \
    local props = {}\
    -- dcs has all properties as array with values .key and .value \
    -- so convert them into a dictionary \
    for i=1, #dcsProps do \
        local theProp = dcsProps[i]\
        local theKey = \"dummy\"\
        if string.len(theProp.key) > 0 then theKey = theProp.key end \
        if caseInsensitive then theKey = theKey:upper() end \
        props[theKey] = theProp.value\
    end\
    return props \
end\
\
function cfxZones.extractPropertyFromDCS(theKey, theProperties)\
-- trim\
    theKey = dcsCommon.trim(theKey) \
--    make lower case conversion if not case sensitive\
    if not cfxZones.caseSensitiveProperties then \
        theKey = string.lower(theKey)\
    end\
\
-- iterate all keys and compare to what we are looking for     \
    for i=1, #theProperties do\
        local theP = theProperties[i]\
         \
        local existingKey = dcsCommon.trim(theP.key)  \
        if not cfxZones.caseSensitiveProperties then \
            existingKey = string.lower(existingKey)\
        end\
        if existingKey == theKey then \
            return theP.value\
        end\
    end\
    return nil \
end\
\
function cfxZones.getZoneProperty(cZone, theKey)\
    if not cZone then \
        trigger.action.outText(\"+++zone: no zone in getZoneProperty\", 30)\
--        breek.here.noew = 1\
        return nil\
    end \
    if not theKey then \
        trigger.action.outText(\"+++zone: no property key in getZoneProperty for zone \" .. cZone.name, 30)\
--        breakme.here = 1\
        return \
    end    \
\
    local props = cZone.properties\
    local theVal = cfxZones.extractPropertyFromDCS(theKey, props)\
    return theVal\
end\
\
function cfxZones.getStringFromZoneProperty(theZone, theProperty, default)\
    \
    if not default then default = \"\" end\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\
    if not p then return default end\
    if type(p) == \"string\" then \
        p = dcsCommon.trim(p)\
        if p == \"\" then p = default end \
        return p\
    end\
    return default -- warning. what if it was a number first?\
end\
\
function cfxZones.getMinMaxFromZoneProperty(theZone, theProperty)\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\
    local theNumbers = dcsCommon.splitString(p, \" \")\
\
    return tonumber(theNumbers[1]), tonumber(theNumbers[2])\
    \
end\
\
function cfxZones.randomInRange(minVal, maxVal)\
    if maxVal < minVal then \
        local t = minVal\
        minVal = maxVal \
        maxVal = t\
    end\
    return cfxZones.randomDelayFromPositiveRange(minVal, maxVal)\
end\
\
function cfxZones.randomDelayFromPositiveRange(minVal, maxVal) \
    if not maxVal then return minVal end \
    if not minVal then return maxVal end \
    local delay = maxVal\
    if minVal > 0 and minVal < delay then \
        -- we want a randomized from time from minTime .. delay\
        local varPart = delay - minVal + 1\
        varPart = dcsCommon.smallRandom(varPart) - 1\
        delay = minVal + varPart\
    end\
    return delay \
end\
\
function cfxZones.getPositiveRangeFromZoneProperty(theZone, theProperty, default)\
    -- reads property as string, and interprets as range 'a-b'. \
    -- if not a range but single number, returns both for upper and lower \
    --trigger.action.outText(\"***Zne: enter with <\" .. theZone.name .. \">: range for property <\" .. theProperty .. \">!\", 30)\
    if not default then default = 0 end \
    local lowerBound = default\
    local upperBound = default \
    \
    local rangeString = cfxZones.getStringFromZoneProperty(theZone, theProperty, \"\")\
    if dcsCommon.containsString(rangeString, \"-\") then \
        local theRange = dcsCommon.splitString(rangeString, \"-\")\
        lowerBound = theRange[1]\
        lowerBound = tonumber(lowerBound)\
        upperBound = theRange[2]\
        upperBound = tonumber(upperBound)\
        if lowerBound and upperBound then\
            -- swap if wrong order\
            if lowerBound > upperBound then \
                local temp = upperBound\
                upperBound = lowerBound\
                lowerBound = temp \
            end\
--            if rndFlags.verbose then \
--            trigger.action.outText(\"+++Zne: detected range <\" .. lowerBound .. \", \" .. upperBound .. \">\", 30)\
--            end\
        else\
            -- bounds illegal\
            trigger.action.outText(\"+++Zne: illegal range  <\" .. rangeString .. \">, using \" .. default .. \"-\" .. default, 30)\
            lowerBound = default\
            upperBound = default \
        end\
    else \
        upperBound = cfxZones.getNumberFromZoneProperty(theZone, theProperty, default) -- between pulses \
        lowerBound = upperBound\
    end\
--    trigger.action.outText(\"+++Zne: returning <\" .. lowerBound .. \", \" .. upperBound .. \">\", 30)\
    return lowerBound, upperBound\
end\
\
function cfxZones.hasProperty(theZone, theProperty) \
    local foundIt = cfxZones.getZoneProperty(theZone, theProperty)\
    if not foundIt then \
        -- check for possible forgotten or exchanged IO flags \
        if string.sub(theProperty, -1) == \"?\" then\
            local lessOp = theProperty:sub(1,-2)\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \
                trigger.action.outText(\"*** NOTE: \" .. theZone.name .. \"'s property <\" .. lessOp .. \"> may be missing a Query ('?') symbol\", 30)\
            end\
            local lessPlus = lessOp .. \"!\"\
            if cfxZones.getZoneProperty(theZone, lessPlus) ~= nil then \
                trigger.action.outText(\"*** NOTE: \" .. theZone.name .. \"'s property <\" .. lessOp .. \"> may be using '!' instead of '?' for input\", 30)\
            end\
            return false \
        end\
        \
        if string.sub(theProperty, -1) == \"!\" then \
            local lessOp = theProperty:sub(1,-2)\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \
                trigger.action.outText(\"*** NOTE: \" .. theZone.name .. \"'s property <\" .. lessOp .. \"> may be missing a Bang! ('!') symbol\", 30)\
            end\
            local lessPlus = lessOp .. \"?\"\
            if cfxZones.getZoneProperty(theZone, lessPlus) ~= nil then \
                trigger.action.outText(\"*** NOTE: \" .. theZone.name .. \"'s property <\" .. lessOp .. \"> may be using '!' instead of '?' for input\", 30)\
            end\
            return false \
        end\
        \
        if string.sub(theProperty, -1) == \":\" then \
            local lessOp = theProperty:sub(1,-2)\
            if cfxZones.getZoneProperty(theZone, lessOp) ~= nil then \
                trigger.action.outText(\"*** NOTE: \" .. theZone.name .. \"'s property <\" .. lessOp .. \"> may be missing a colon (':') at end\", 30)\
            end\
            return false \
        end\
        \
        return false \
    end\
    return true \
--    return foundIt ~= nil \
end\
\
function cfxZones.getBoolFromZoneProperty(theZone, theProperty, defaultVal)\
    if not defaultVal then defaultVal = false end \
    if type(defaultVal) ~= \"boolean\" then \
        defaultVal = false \
    end\
\
    if not theZone then \
        trigger.action.outText(\"WARNING: NIL Zone in getBoolFromZoneProperty\", 30)\
        return defaultVal\
    end\
\
\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\
    if not p then return defaultVal end\
\
    -- make sure we compare so default always works when \
    -- answer isn't exactly the opposite\
    p = p:lower() \
    p = dcsCommon.trim(p) \
    if defaultVal == false then \
        -- only go true if exact match to yes or true \
        theBool = false \
        theBool = (p == 'true') or (p == 'yes') or p == \"1\"\
        return theBool\
    end\
    \
    local theBool = true \
    -- only go false if exactly no or false or \"0\"\
    theBool = (p ~= 'false') and (p ~= 'no') and (p ~= \"0\") \
    return theBool\
end\
\
function cfxZones.getCoalitionFromZoneProperty(theZone, theProperty, default)\
    if not default then default = 0 end\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\
    if not p then return default end  \
    if type(p) == \"number\" then -- can't currently really happen\
        if p == 1 then return 1 end \
        if p == 2 then return 2 end \
        return 0\
    end\
    \
    if type(p) == \"string\" then \
        if p == \"1\" then return 1 end \
        if p == \"2\" then return 2 end \
        if p == \"0\" then return 0 end \
        \
        p = p:lower()\
        \
        if p == \"red\" then return 1 end \
        if p == \"blue\" then return 2 end \
        if p == \"neutral\" then return 0 end\
        if p == \"all\" then return 0 end \
        return default \
    end\
    \
    return default \
end\
\
function cfxZones.getNumberFromZoneProperty(theZone, theProperty, default)\
--TODO: trim string \
    if not default then default = 0 end\
    local p = cfxZones.getZoneProperty(theZone, theProperty)\
    p = tonumber(p)\
    if not p then return default else return p end\
end\
\
function cfxZones.getVectorFromZoneProperty(theZone, theProperty, minDims, defaultVal)\
    if not minDims then minDims = 0 end \
    if not defaultVal then defaultVal = 0 end \
    local s = cfxZones.getStringFromZoneProperty(theZone, theProperty, \"\")\
    local sVec = dcsCommon.splitString(s, \",\")\
    local nVec = {}\
    for idx, numString in pairs (sVec) do \
        local n = tonumber(numString)\
        if not n then n = defaultVal end\
        table.insert(nVec, n)\
    end\
    -- make sure vector contains at least minDims values \
    while #nVec < minDims do \
        table.insert(nVec, defaultVal)\
    end\
    \
    return nVec \
end\
\
function cfxZones.getSmokeColorStringFromZoneProperty(theZone, theProperty, default) -- smoke as 'red', 'green', or 1..5\
    if not default then default = \"red\" end \
    local s = cfxZones.getStringFromZoneProperty(theZone, theProperty, default)\
    s = s:lower()\
    s = dcsCommon.trim(s)\
    -- check numbers \
    if (s == \"0\") then return \"green\" end\
    if (s == \"1\") then return \"red\" end\
    if (s == \"2\") then return \"white\" end\
    if (s == \"3\") then return \"orange\" end\
    if (s == \"4\") then return \"blue\" end\
    \
    if s == \"green\" or\
       s == \"red\" or\
       s == \"white\" or\
       s == \"orange\" or\
       s == \"blue\" then return s end\
\
    return default \
end\
\
--\
-- Moving Zones. They contain a link to their unit\
-- they are always located at an offset (x,z) or delta, phi \
-- to their master unit. delta phi allows adjustment for heading\
-- The cool thing about moving zones in cfx is that they do not\
-- require special handling, they are always updated \
-- and work with 'pointinzone' etc automatically\
\
-- Always works on cfx Zones, NEVER on DCS zones.\
--\
-- requires that readFromDCS has been done\
--\
function cfxZones.getPoint(aZone) -- always works, even linked, point can be reused \
    if aZone.linkedUnit then \
        local theUnit = aZone.linkedUnit\
        -- has a link. is link existing?\
        if theUnit:isExist() then \
            -- updates zone position \
            cfxZones.centerZoneOnUnit(aZone, theUnit)\
            cfxZones.offsetZone(aZone, aZone.dx, aZone.dy)\
        end\
    end\
    local thePos = {}\
    thePos.x = aZone.point.x\
    thePos.y = 0 -- aZone.y \
    thePos.z = aZone.point.z\
    -- update the zone as well -- that's stupid!\
    --[[-- aZone.point = thePos \
    local retPoint = {} -- create new copy to pass back \
    retPoint.x = thePos.x\
    retPoint.y = 0 \
    retPoint.z = thePos.z\
    --]]--\
    return thePos \
end\
\
function cfxZones.linkUnitToZone(theUnit, theZone, dx, dy) -- note: dy is really Z, don't get confused!!!!\
    theZone.linkedUnit = theUnit\
    if not dx then dx = 0 end\
    if not dy then dy = 0 end \
    theZone.dx = dx\
    theZone.dy = dy \
end\
\
function cfxZones.updateMovingZones()\
    cfxZones.updateSchedule = timer.scheduleFunction(cfxZones.updateMovingZones, {}, timer.getTime() + 1/cfxZones.ups)\
    -- simply scan all cfx zones for the linkedUnit property and if there\
    -- update the zone's points\
    for aName,aZone in pairs(cfxZones.zones) do\
        if aZone.linkedUnit then \
            local theUnit = aZone.linkedUnit\
            -- has a link. is link existing?\
            if theUnit:isExist() then \
                cfxZones.centerZoneOnUnit(aZone, theUnit)\
                cfxZones.offsetZone(aZone, aZone.dx, aZone.dy)\
                --trigger.action.outText(\"cf/x zones update \" .. aZone.name, 30)\
            end\
        end\
    end\
end\
\
function cfxZones.startMovingZones()\
    -- read all zoness, and look for a property called 'linkedUnit'\
    -- which will make them a linked zone if there is a unit that exists\
    for aName,aZone in pairs(cfxZones.zones) do\
        local lU = cfxZones.getZoneProperty(aZone, \"linkedUnit\")\
        if lU then \
            -- this zone is linked to a unit\
            theUnit = Unit.getByName(lU)\
            local useOffset = cfxZones.getBoolFromZoneProperty(aZone, \"useOffset\", false)\
            if useOffset then aZone.useOffset = true end\
            if theUnit then\
                local dx = 0\
                local dz = 0\
                if useOffset then \
                    local delta = dcsCommon.vSub(aZone.point,theUnit:getPoint()) -- delta = B - A \
                    dx = delta.x \
                    dz = delta.z\
                end\
                cfxZones.linkUnitToZone(theUnit, aZone, dx, dz)\
                --trigger.action.outText(\"cf/x zones: linked \" .. aZone.name .. \" to \" .. theUnit:getName(), 30)\
                if useOffset then \
                    --trigger.action.outText(\"and dx = \" .. dx .. \" dz = \" .. dz, 30)\
                end\
            end\
        end\
        -- support for local verbose flag \
        aZone.verbose = cfxZones.getBoolFromZoneProperty(aZone, \"verbose\", false)\
    end\
end\
\
--\
-- init\
--\
\
function cfxZones.init()\
    -- read all zones into my own db\
    cfxZones.readFromDCS(true) -- true: erase old\
    \
    -- now, pre-read zone owner for all zones\
    -- note, all zones with this property are by definition owned zones.\
    -- and hence will be read anyway. this will merely ensure that the \
    -- ownership is established right away\
    -- unless owned zones module is missing, in which case \
    -- ownership is still established \
    local pZones = cfxZones.zonesWithProperty(\"owner\")\
    for n, aZone in pairs(pZones) do\
        aZone.owner = cfxZones.getCoalitionFromZoneProperty(aZone, \"owner\", 0)\
    end\
        \
    \
    -- now initialize moving zones\
    cfxZones.startMovingZones()\
    cfxZones.updateMovingZones() -- will auto-repeat\
    \
    trigger.action.outText(\"cf/x Zones v\".. cfxZones.version .. \": loaded, zones:\" .. dcsCommon.getSizeOfTable(cfxZones.zones), 30)\
\
end\
\
-- get everything rolling\
cfxZones.init()\
",
                    ["predicate"] = "a_do_script",
                }, -- end of [2]
                [3] = 
                {
                    ["text"] = "cfxReconMode = {}\
cfxReconMode.version = \"2.0.0\"\
cfxReconMode.verbose = false -- set to true for debug info  \
cfxReconMode.reconSound = \"UI_SCI-FI_Tone_Bright_Dry_20_stereo.wav\" -- to be played when somethiong discovered\
\
cfxReconMode.prioList = {} -- group names that are high prio and generate special event\
cfxReconMode.blackList = {} -- group names that are NEVER detected. Comma separated strings, e.g. {\"Always Hidden\", \"Invisible Group\"}\
cfxReconMode.dynamics = {} -- if a group name is dynamic\
cfxReconMode.zoneInfo = {} -- additional zone info \
\
cfxReconMode.scoutZones = {} -- zones that define aircraft. used for late eval of players \
cfxReconMode.allowedScouts = {} -- when not using autoscouts \
cfxReconMode.blindScouts = {} -- to exclude aircraft from being scouts \
cfxReconMode.removeWhenDestroyed = true \
cfxReconMode.activeMarks = {} -- all marks and their groups, indexed by groupName \
\
cfxReconMode.requiredLibs = {\
    \"dcsCommon\", -- always\
    \"cfxZones\", -- Zones, of course \
}\
\
--[[--\
VERSION HISTORY\
 1.0.0 - initial version \
 1.0.1 - removeScoutByName()\
 1.0.2 - garbage collection \
 1.1.0 - autoRecon - any aircraft taking off immediately\
         signs up, no message when signing up or closing down\
         standalone - copied common procs lerp, agl, dist, distflat\
         from dcsCommon\
         report numbers \
         verbose flag \
 1.2.0 - queued recons. One scout per second for more even\
         performance\
         removed gc since it's now integrated into \
         update queue\
         removeScout optimization when directly passing name\
         playerOnlyRecon for autoRecon \
         red, blue, grey side filtering on auto scout\
 1.2.1 - parametrized report sound \
 1.3.0 - added black list, prio list functionality \
 1.3.1 - callbacks now also push name, as group can be dead\
       - removed bug when removing dead groups from map\
 1.4.0 - import dcsCommon, cfxZones etc \
       - added lib check \
       - config zone \
       - prio+\
       - detect+\
 1.4.1 - invocation no longer happen twice for prio. \
       - recon sound \
       - read all flight groups at start to get rid of the \
       - late activation work-around \
 1.5.0 - removeWhenDestroyed()\
       - autoRemove()\
       - readConfigZone creates default config zone so we get correct defaulting \
 2.0.0 - DML integration prio+-->prio! detect+ --> detect! \
         and method\
       - changed access to prio and blacklist to hash\
       - dynamic option for prio and black \
       - trigger zones for designating prio and blacklist \
       - reworked stringInList to also include dynamics \
       - Report in SALT format: size, action, loc, time.\
       - Marks add size, action info\
       - LatLon or MGRS\
       - MGRS option in config \
       - filter onEvent for helo and aircraft \
       - allowedScouts and blind \
       - stronger scout filtering at startup \
       - better filtering on startup when autorecon and playeronly\
       - player lazy late checking, zone saving \
       - correct checks when not autorecon \
       - ability to add special flags to recon prio group \
       - event guard in onEvent\
       - <t> wildcard \
       - <lat>, <lon>, <mgrs> wildcards \
 \
 cfxReconMode is a script that allows units to perform reconnaissance\
 missions and, after detecting units, marks them on the map with \
 markers for their coalition and some text \
 Also, a callback is initiated for scouts as follows\
   signature: (reason, theSide, theSout, theGroup) with  \
   reason a string \
     'detected' a group was detected\
     'removed' a mark for a group timed out\
     'priority' a member of prio group was detected \
     'start' a scout started scouting\
     'end' a scout stopped scouting\
     'dead' a scout has died and was removed from pool \
   theSide - side of the SCOUT that detected units\
   theScout - the scout that detected the group \
   theGroup - the group that is detected  \
   theName - the group's name    \
--]]--\
\
cfxReconMode.detectionMinRange = 3000 -- meters at ground level\
cfxReconMode.detectionMaxRange = 12000 -- meters at max alt (10'000m)\
cfxReconMode.maxAlt = 9000 -- alt for maxrange (9km = 27k feet)\
\
cfxReconMode.autoRecon = true -- add all airborne units, unless \
cfxReconMode.redScouts = false -- set to false to prevent red scouts in auto mode\
cfxReconMode.blueScouts = true -- set to false to prevent blue scouts in auto-mode\
cfxReconMode.greyScouts = false -- set to false to prevent neutral scouts in auto mode\
cfxReconMode.playerOnlyRecon = false -- only players can do recon \
cfxReconMode.reportNumbers = true -- also add unit count in report \
cfxReconMode.prioFlag = nil \
cfxReconMode.detectFlag = nil \
cfxReconMode.method = \"inc\"\
cfxReconMode.applyMarks = true \
cfxReconMode.mgrs = false \
\
cfxReconMode.ups = 1 -- updates per second.\
cfxReconMode.scouts = {} -- units that are performing scouting.\
cfxReconMode.processedScouts = {} -- for managing performance: queue\
cfxReconMode.detectedGroups = {} -- so we know which have been detected\
cfxReconMode.marksFadeAfter = 30*60 -- after detection, marks disappear after\
                     -- this amount of seconds. -1 means no fade\
                     -- 60 is one minute\
\
cfxReconMode.callbacks = {} -- sig: cb(reason, side, scout, group)\
cfxReconMode.uuidCount = 0 -- for unique marks \
\
\
-- end standalone dcsCommon extract \
\
function cfxReconMode.uuid()\
    cfxReconMode.uuidCount = cfxReconMode.uuidCount + 1\
    return cfxReconMode.uuidCount\
end\
\
function cfxReconMode.addCallback(theCB)\
    table.insert(cfxReconMode.callbacks, theCB)\
end\
\
function cfxReconMode.invokeCallbacks(reason, theSide, theScout, theGroup, theName)\
    for idx, theCB in pairs(cfxReconMode.callbacks) do \
        theCB(reason, theSide, theScout, theGroup, theName)\
    end\
end\
\
-- add a priority/blackList group name to prio list \
function cfxReconMode.addToPrioList(aGroup, dynamic)\
    if not dynamic then dynamic = false end \
    if not aGroup then return end \
    if type(aGroup) == \"table\" and aGroup.getName then \
        aGroup = aGroup:getName()\
    end\
    if type(aGroup) == \"string\" then \
--        table.insert(cfxReconMode.prioList, aGroup)\
        cfxReconMode.prioList[aGroup] = aGroup\
        cfxReconMode.dynamics[aGroup] = dynamic \
    end\
end\
\
function cfxReconMode.addToBlackList(aGroup, dynamic)\
    if not dynamic then dynamic = false end \
    if not aGroup then return end \
    if type(aGroup) == \"table\" and aGroup.getName then \
        aGroup = aGroup:getName()\
    end\
    if type(aGroup) == \"string\" then \
        --table.insert(cfxReconMode.blackList, aGroup)\
        cfxReconMode.blackList[aGroup] = aGroup\
        cfxReconMode.dynamics[aGroup] = dynamic\
    end\
end\
\
function cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\
    if not dynamic then dynamic = false end \
    if not aGroup then return end \
    if type(aGroup) == \"table\" and aGroup.getName then \
        aGroup = aGroup:getName()\
    end\
    if type(aGroup) == \"string\" then \
        cfxReconMode.allowedScouts[aGroup] = aGroup\
        cfxReconMode.dynamics[aGroup] = dynamic\
    end\
end\
\
function cfxReconMode.addToBlindScoutList(aGroup, dynamic)\
    if not dynamic then dynamic = false end \
    if not aGroup then return end \
    if type(aGroup) == \"table\" and aGroup.getName then \
        aGroup = aGroup:getName()\
    end\
    if type(aGroup) == \"string\" then \
        cfxReconMode.blindScouts[aGroup] = aGroup\
        cfxReconMode.dynamics[aGroup] = dynamic\
    end\
end\
\
function cfxReconMode.isStringInList(theString, theList)\
    -- returns two values: inList, and original group name (if exist)\
    if not theString then return false, nil end \
    if type(theString) ~= \"string\" then return false, nil end\
    if not theList then return false, nil end \
    \
    -- first, try a direct look-up. if this produces a hit\
    -- we directly return true \
    if theList[theString] then return true, theString end \
    \
    -- now try the more involved retrieval with string starts with \
    for idx, aName in pairs(theList) do \
        if dcsCommon.stringStartsWith(theString, aName) then \
            -- they start the same. are dynamics allowed?\
            if cfxReconMode.dynamics[aName] then \
                return true, aName \
            end\
        end\
    end\
    \
    return false, nil\
end\
\
\
-- addScout directly adds a scout unit. Use from external \
-- to manually add a unit (e.g. via GUI when autoscout isExist\
-- off, or to force a scout unit (e.g. when scouts for a side\
-- are not allowed but you still want a unit from that side \
-- to scout\
-- since we use a queue for scouts, also always check the \
-- processed queue before adding to make sure a scout isn't \
-- entered multiple times \
\
function cfxReconMode.addScout(theUnit)\
    if not theUnit then \
        trigger.action.outText(\"+++cfxRecon: WARNING - nil Unit on add\", 30)\
        return\
    end\
    \
    if type(theUnit) == \"string\" then \
        local u = Unit.getByName(theUnit) \
        theUnit = u\
    end \
    \
    if not theUnit then \
        trigger.action.outText(\"+++cfxRecon: WARNING - did not find unit on add\", 30)\
        return \
    end    \
    if not theUnit:isExist() then return end \
    -- find out if this an update or a new scout \
    local thisID = tonumber(theUnit:getID())\
    local theName = theUnit:getName() \
    local lastUnit = cfxReconMode.scouts[theName]\
    local isProcced = false -- may also be in procced line \
    if not lastUnit then \
        lastUnit = cfxReconMode.processedScouts[theName]\
        if lastUnit then isProcced = true end \
    end\
\
    if lastUnit then \
        -- this is merely an overwrite \
        if cfxReconMode.verbose then trigger.action.outText(\"+++rcn: UPDATE scout \" .. theName .. \" -- no CB invoke\", 30) end \
    else \
        if cfxReconMode.verbose then trigger.action.outText(\"+++rcn: new scout \" .. theName .. \" with ID \" .. thisID, 30) end \
        -- a new scout! Invoke callbacks\
        local scoutGroup = theUnit:getGroup()\
        local theSide = scoutGroup:getCoalition()\
        cfxReconMode.invokeCallbacks(\"start\", theSide, theUnit, nil, \"<none>\")\
    end \
    \
    if isProcced then \
        -- overwrite exiting entry in procced queue\
        cfxReconMode.processedScouts[theName] = theUnit\
    else \
        -- add / overwrite into normal queue \
        cfxReconMode.scouts[theName] = theUnit\
    end \
    \
    if cfxReconMode.verbose then\
        trigger.action.outText(\"+++rcn: addded scout \" .. theUnit:getName(), 30)\
    end\
end\
\
\
function cfxReconMode.removeScout(theUnit)\
    if not theUnit then \
        trigger.action.outText(\"+++rcn: WARNING - nil Unit on remove\", 30)\
        return \
    end\
    \
    if type(theUnit) == \"string\" then \
        cfxReconMode.removeScoutByName(theUnit)\
        return \
    end \
    \
    if not theUnit then return end    \
    if not theUnit:isExist() then return end \
    cfxReconMode.removeScoutByName(theUnit:getName())\
    local scoutGroup = theUnit:getGroup()\
    local theSide = scoutGroup:getCoalition()\
    cfxReconMode.invokeCallbacks(\"end\", theSide, theUnit, nil, \"<none>\")\
end\
\
-- warning: removeScoutByName does NOT invoke callbacks, always\
-- use removeScout instead!\
function cfxReconMode.removeScoutByName(aName)\
    cfxReconMode.scouts[aName] = nil\
    cfxReconMode.processedScouts[aName] = nil -- also remove from processed stack \
    if cfxReconMode.verbose then\
        trigger.action.outText(\"+++rcn: removed scout \" .. aName, 30)\
    end\
end\
\
\
function cfxReconMode.canDetect(scoutPos, theGroup, visRange)\
    -- determine if a member of theGroup can be seen from \
    -- scoutPos at visRange \
    -- returns true and pos when detected\
    local allUnits = theGroup:getUnits()\
    for idx, aUnit in pairs(allUnits) do\
        if aUnit:isExist() and aUnit:getLife() >= 1 then \
            local uPos = aUnit:getPoint()\
            uPos.y = uPos.y + 3 -- raise my 3 meters\
            local d = dcsCommon.distFlat(scoutPos, uPos) \
            if d < visRange then \
                -- is in visual range. do we have LOS?\
                if land.isVisible(scoutPos, uPos) then \
                    -- group is visible, stop here, return true\
                    return true, uPos\
                end\
            else \
                -- OPTIMIZATION: if a unit is outside \
                -- detect range, we assume that entire group \
                -- is, since they are bunched together\
                -- edge cases may get lucky tests\
                return false, nil \
            end\
        end        \
    end\
    return false, nil -- nothing visible\
end\
\
function cfxReconMode.placeMarkForUnit(location, theSide, theGroup) \
    local theID = cfxReconMode.uuid()\
    local theDesc = \"Contact: \"..theGroup:getName()\
    if cfxReconMode.reportNumbers then \
--        theDesc = theDesc .. \" (\" .. theGroup:getSize() .. \" units)\"\
        theDesc = theDesc .. \" - \" .. cfxReconMode.getSit(theGroup) .. \", \" .. cfxReconMode.getAction(theGroup) .. \".\"\
    end\
    trigger.action.markToCoalition(\
                    theID, \
                    theDesc, \
                    location, \
                    theSide, \
                    false, \
                    nil)\
    return theID\
end\
\
function cfxReconMode.removeMarkForArgs(args)\
    local theSide = args[1]\
    local theScout = args[2]\
    local theGroup = args[3]\
    local theID = args[4]\
    local theName = args[5]\
    \
    -- only remove if it wasn't already removed.\
    -- this method is called async *and* sync!\
    if cfxReconMode.activeMarks[theName] then \
        trigger.action.removeMark(theID)\
        -- invoke callbacks\
        cfxReconMode.invokeCallbacks(\"removed\", theSide, theScout, theGroup, theName)\
        cfxReconMode.activeMarks[theName] = nil -- also remove from list of groups being checked\
    end \
    \
    cfxReconMode.detectedGroups[theName] = nil -- some housekeeping. \
end \
\
function cfxReconMode.getSit(theGroup)\
    local msg = \"\"\
        -- analyse the group we just discovered. We know it's a ground troop, so simply differentiate between vehicles and infantry \
        local theUnits = theGroup:getUnits()\
        local numInf = 0 \
        local numVehicles = 0 \
        for idx, aUnit in pairs(theUnits) do \
            if dcsCommon.unitIsInfantry(aUnit) then \
                numInf = numInf + 1\
            else \
                numVehicles = numVehicles + 1\
            end \
        end\
        if numInf > 0 and numVehicles > 0 then \
            -- mixed infantry and vehicles \
            msg = numInf .. \" infantry and \" .. numVehicles .. \" vehicles\" \
        elseif numInf > 0 then\
            -- only infantry\
            msg = numInf .. \" infantry\"\
        else \
            -- only vehicles\
            msg = numVehicles .. \" vehicles\"\
        end \
    return msg\
end\
\
function cfxReconMode.getAction(theGroup) \
    local msg = \"\"\
    -- simply get the first unit and get velocity vector. \
    -- if it's smaller than 1 m/s (= 3.6 kmh), it's \"Guarding\", if it's faster, it's \
    -- moving with direction\
    local theUnit = theGroup:getUnit(1)\
    local vvel = theUnit:getVelocity()\
    local vel = dcsCommon.vMag(vvel)\
    if vel < 1 then \
        msg = \"apparently guarding\"\
    else\
        local speed = \"\"\
        if vel < 3 then speed = \"slowly\"\
        elseif vel < 6 then speed = \"deliberately\"\
        else speed = \"briskly\" end \
        local heading = dcsCommon.getUnitHeading(theUnit) -- in rad \
        msg = speed .. \" moving \" .. dcsCommon.bearing2compass(heading)\
    end\
    return msg\
end\
\
function cfxReconMode.getLocation(theGroup)\
    local msg = \"\"\
    local theUnit = theGroup:getUnit(1)\
    local currPoint = theUnit:getPoint()\
    if cfxReconMode.mgrs then \
        local grid = coord.LLtoMGRS(coord.LOtoLL(currPoint))\
        msg = grid.UTMZone .. ' ' .. grid.MGRSDigraph .. ' ' .. grid.Easting .. ' ' .. grid.Northing\
    else \
        local lat, lon, alt = coord.LOtoLL(currPoint)\
        lat, lon = dcsCommon.latLon2Text(lat, lon)\
        msg = \"Lat \" .. lat .. \" Lon \" .. lon\
    end\
    return msg\
end\
\
function cfxReconMode.getTimeData()\
    local msg = \"\"\
    local absSecs = timer.getAbsTime()-- + env.mission.start_time\
    while absSecs > 86400 do \
        absSecs = absSecs - 86400 -- subtract out all days \
    end\
    msg = dcsCommon.processHMS(\"<:h>:<:m>:<:s>\", absSecs)\
    return \"at \" .. msg\
end\
\
function cfxReconMode.generateSALT(theScout, theGroup)\
    local msg = theScout:getName() .. \" reports new ground contact \" .. theGroup:getName() .. \":\\n\"\
    -- SALT: S = Situation or number of units A = action they are doing L = Location T = Time \
    msg = msg .. cfxReconMode.getSit(theGroup) .. \", \"-- S \
    msg = msg .. cfxReconMode.getAction(theGroup) .. \", \" -- A \
    msg = msg .. cfxReconMode.getLocation(theGroup) .. \", \" -- L \
    msg = msg .. cfxReconMode.getTimeData() -- T\
    \
    return msg\
end\
\
function cfxReconMode.processZoneMessage(inMsg, theZone) \
    if not inMsg then return \"<nil inMsg>\" end\
    local formerType = type(inMsg)\
    if formerType ~= \"string\" then inMsg = tostring(inMsg) end  \
    if not inMsg then inMsg = \"<inMsg is incompatible type \" .. formerType .. \">\" end \
    local outMsg = \"\"\
    -- replace line feeds \
    outMsg = inMsg:gsub(\"<n>\", \"\\n\")\
    if theZone then \
        outMsg = outMsg:gsub(\"<z>\", theZone.name)\
    end\
    -- replace <t> with current mission time HMS\
    local absSecs = timer.getAbsTime()-- + env.mission.start_time\
    while absSecs > 86400 do \
        absSecs = absSecs - 86400 -- subtract out all days \
    end\
    local timeString  = dcsCommon.processHMS(\"<:h>:<:m>:<:s>\", absSecs)\
    outMsg = outMsg:gsub(\"<t>\", timeString)\
    \
    -- replace <lat> with lat of zone point and <lon> with lon of zone point \
    -- and <mgrs> with mgrs coords of zone point \
    local currPoint = cfxZones.getPoint(theZone)\
    local lat, lon, alt = coord.LOtoLL(currPoint)\
    lat, lon = dcsCommon.latLon2Text(lat, lon)\
    outMsg = outMsg:gsub(\"<lat>\", lat)\
    outMsg = outMsg:gsub(\"<lon>\", lon)\
    currPoint = cfxZones.getPoint(theZone)\
    local grid = coord.LLtoMGRS(coord.LOtoLL(currPoint))\
    local mgrs = grid.UTMZone .. ' ' .. grid.MGRSDigraph .. ' ' .. grid.Easting .. ' ' .. grid.Northing\
    outMsg = outMsg:gsub(\"<mgrs>\", mgrs)\
    return outMsg\
end\
\
function cfxReconMode.detectedGroup(mySide, theScout, theGroup, theLoc)\
    -- put a mark on the map \
    if cfxReconMode.applyMarks then \
        local theID = cfxReconMode.placeMarkForUnit(theLoc, mySide, theGroup)\
        local gName = theGroup:getName()\
        local args = {mySide, theScout, theGroup, theID, gName}\
        cfxReconMode.activeMarks[gName] = args\
        -- schedule removal if desired \
        if cfxReconMode.marksFadeAfter > 0 then     \
            timer.scheduleFunction(cfxReconMode.removeMarkForArgs, args, timer.getTime() + cfxReconMode.marksFadeAfter)\
        end\
    end \
    \
    -- say something\
    if cfxReconMode.announcer then \
        local msg = cfxReconMode.generateSALT(theScout, theGroup)\
        trigger.action.outTextForCoalition(mySide, msg, 30)\
--        trigger.action.outTextForCoalition(mySide, theScout:getName() .. \" reports new ground contact \" .. theGroup:getName(), 30)\
        if cfxReconMode.verbose then \
            trigger.action.outText(\"+++rcn: announced for side \" .. mySide, 30)\
        end \
        -- play a sound \
        trigger.action.outSoundForCoalition(mySide, cfxReconMode.reconSound)\
    else \
    end \
    \
    -- see if it was a prio target \
    local inList, gName = cfxReconMode.isStringInList(theGroup:getName(), cfxReconMode.prioList)\
    if inList then \
--        if cfxReconMode.announcer then \
        if cfxReconMode.verbose then \
            trigger.action.outText(\"+++rcn: Priority target spotted\",    30)\
        end \
        -- invoke callbacks\
        cfxReconMode.invokeCallbacks(\"priority\", mySide, theScout, theGroup, theGroup:getName())\
        \
        -- increase prio flag \
        if cfxReconMode.prioFlag then \
            cfxZones.pollFlag(cfxReconMode.prioFlag, cfxReconMode.method, cfxReconMode.theZone)\
        end\
        \
        -- see if we were passed additional info in zInfo \
        if gName and cfxReconMode.zoneInfo[gName] then \
            local zInfo = cfxReconMode.zoneInfo[gName]\
            if zInfo.prioMessage then \
                local msg = zInfo.prioMessage\
                msg = cfxReconMode.processZoneMessage(msg, zInfo.theZone) \
                trigger.action.outTextForCoalition(mySide, msg, 30)\
                if cfxReconMode.verbose or zInfo.theZone.verbose then \
                    trigger.action.outText(\"+++rcn: prio message sent  for prio target zone <\" .. zInfo.theZone.name .. \">\",30)\
                end\
            end\
            \
            if zInfo.theFlag then \
                cfxZones.pollFlag(zInfo.theFlag, cfxReconMode.method, zInfo.theZone)\
                if cfxReconMode.verbose or zInfo.theZone.verbose then \
                    trigger.action.outText(\"+++rcn: banging <\" .. zInfo.theFlag .. \"> for prio target zone <\" .. zInfo.theZone.name .. \">\",30)\
                end\
            end \
        end\
    else \
        -- invoke callbacks\
        cfxReconMode.invokeCallbacks(\"detected\", mySide, theScout, theGroup, theGroup:getName())\
    \
        -- increase normal flag \
        if cfxReconMode.detectFlag then \
            cfxZones.pollFlag(cfxReconMode.detectFlag, cfxReconMode.method, cfxReconMode.theZone)\
        end\
    end\
end\
\
function cfxReconMode.performReconForUnit(theScout)\
    if not theScout then return end \
    if not theScout:isExist() then return end -- will be gc'd soon\
    -- get altitude above ground to calculate visual range \
    local alt = dcsCommon.getUnitAGL(theScout)\
    local visRange = dcsCommon.lerp(cfxReconMode.detectionMinRange, cfxReconMode.detectionMaxRange, alt/cfxReconMode.maxAlt)\
    local scoutPos = theScout:getPoint()\
    -- figure out which groups we are looking for\
    local myCoal = theScout:getCoalition()\
    local enemyCoal = 1 \
    if myCoal == 1 then enemyCoal = 2 end \
    \
    -- iterate all enemy units until we find one \
    -- and then stop this iteration (can only detect one \
    -- group per pass)\
    local enemyGroups = coalition.getGroups(enemyCoal)\
    for idx, theGroup in pairs (enemyGroups) do \
        -- make sure it's a ground unit \
        local isGround = theGroup:getCategory() == 2\
        if theGroup:isExist() and isGround then \
            local visible, location = cfxReconMode.canDetect(scoutPos, theGroup, visRange)\
            if visible then \
                -- see if we already detected this one \
                local groupName = theGroup:getName()\
                if cfxReconMode.detectedGroups[groupName] == nil then \
                    -- only now check against blackList\
                    local inList, gName = cfxReconMode.isStringInList(groupName, cfxReconMode.blackList) \
                    if not inList then \
                        -- visible and not yet seen \
                        -- perhaps add some percent chance now \
                        -- remember that we know this group \
                        cfxReconMode.detectedGroups[groupName] = theGroup\
                        cfxReconMode.detectedGroup(myCoal, theScout, theGroup, location)\
                        return -- stop, as we only detect one group per pass\
                    end \
                end\
            end\
        end\
    end\
end\
\
\
\
function cfxReconMode.updateQueues()\
    -- schedule next call \
    timer.scheduleFunction(cfxReconMode.updateQueues, {}, timer.getTime() + 1/cfxReconMode.ups)\
    \
    -- we only process the first aircraft in \
    -- the scouts array, move it to processed and then shrink\
    -- scouts table until it's empty. When empty, transfer all \
    -- back and start cycle anew\
\
    local theFocusScoutName = nil \
    local procCount = 0 -- no iterations done yet\
    for name, scout in pairs(cfxReconMode.scouts) do \
        theFocusScoutName = name -- remember so we can delete\
        if not scout:isExist() then \
            -- we ignore the scout, and it's \
            -- forgotten since no longer transferred\
            -- i.e. built-in GC\
            if cfxReconMode.verbose then\
                trigger.action.outText(\"+++rcn: GC - removing scout \" .. name .. \" because it no longer exists\", 30)\
            end\
            -- invoke 'end' for this scout  \
            cfxReconMode.invokeCallbacks(\"dead\", -1, nil, nil, name)\
        else\
            -- scan for this scout\
            cfxReconMode.performReconForUnit(scout)\
            -- move it to processed table\
            cfxReconMode.processedScouts[name] = scout\
        end\
        procCount = 1 -- remember we went through one iteration\
        break -- always end after first iteration\
    end\
\
    -- remove processed scouts from scouts array\
    if procCount > 0 then \
        -- we processed one scout (even if scout itself did not exist)\
        -- remove that scout from active scouts table\
        cfxReconMode.scouts[theFocusScoutName] = nil\
    else \
        -- scouts is empty. copy processed table back to scouts\
        -- restart scouts array, contains GC already \
        cfxReconMode.scouts = cfxReconMode.processedScouts\
        cfxReconMode.processedScouts = {} -- start new empty processed queue\
    end \
end\
\
function cfxReconMode.isGroupStillAlive(gName)\
        local theGroup = Group.getByName(gName)\
        if not theGroup then return false end \
        if not theGroup:isExist() then return false end \
        local allUnits = theGroup:getUnits()\
        for idx, aUnit in pairs (allUnits) do \
            if aUnit:getLife() >= 1 then return true end \
        end\
        return false \
end\
\
function cfxReconMode.autoRemove()\
    -- schedule next call \
    timer.scheduleFunction(cfxReconMode.autoRemove, {}, timer.getTime() + 1/cfxReconMode.ups)\
    \
    local toRemove = {}\
    -- scan all marked groups, and when they no longer exist, remove them \
    for idx, args in pairs (cfxReconMode.activeMarks) do\
        -- args = {mySide, theScout, theGroup, theID, gName}\
        local gName = args[5]\
        if not cfxReconMode.isGroupStillAlive(gName) then \
            -- remove mark, remove group from set \
            table.insert(toRemove, args)\
        end\
    end \
    \
    for idx, args in pairs(toRemove) do \
        cfxReconMode.removeMarkForArgs(args)\
        trigger.action.outText(\"+++recn: removed mark: \" .. args[5], 30)\
    end\
end\
\
-- late eval player \
function cfxReconMode.lateEvalPlayerUnit(theUnit)\
    -- check if a player is inside one of the scout zones \
    -- first: quick check if the player is already in a list \
    local aGroup = theUnit:getGroup() \
    local gName = aGroup:getName()\
    if cfxReconMode.allowedScouts[gName] then return end \
    if cfxReconMode.blindScouts[gName] then return end \
\
    -- get location \
    local p = theUnit:getPoint()\
    \
    -- iterate all scoutZones\
    for idx, theZone in pairs (cfxReconMode.scoutZones) do \
        local isScout = theZone.isScout\
        local dynamic = theZone.dynamic\
        local inZone = cfxZones.pointInZone(p, theZone)\
        if inZone then \
            if isScout then \
                cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\
                if cfxReconMode.verbose or theZone.verbose then \
                    if dynamic then \
                        trigger.action.outText(\"+++rcn: added LATE DYNAMIC PLAYER\" .. gName .. \" to allowed scouts\", 30)\
                    else \
                        trigger.action.outText(\"+++rcn: added LATE PLAYER \" .. gName .. \" to allowed scouts\", 30) \
                    end\
                end \
            else \
                cfxReconMode.addToBlindScoutList(aGroup, dynamic)\
                if cfxReconMode.verbose or theZone.verbose then \
                    if dynamic then \
                        trigger.action.outText(\"+++rcn: added LATE DYNAMIC PLAYER\" .. gName .. \" to BLIND scouts list\", 30)\
                    else \
                        trigger.action.outText(\"+++rcn: added LATE PLAYER \" .. gName .. \" to BLIND scouts list\", 30)\
                    end\
                end\
            end\
            return -- we stop after first found \
        end\
    end\
end\
\
-- event handler \
function cfxReconMode:onEvent(event) \
    if not event then return end \
    if not event.initiator then return end \
    if not (event.id == 15 or event.id == 3) then return end \
    \
    local theUnit = event.initiator \
    if not theUnit:isExist() then return end \
    local theGroup = theUnit:getGroup() \
--    trigger.action.outText(\"+++rcn-ENTER onEvent: \" .. event.id .. \" for <\" .. theUnit:getName() .. \">\", 30)\
    if not theGroup then return end \
    local gCat = theGroup:getCategory()\
    -- only continue if cat = 0 (aircraft) or 1 (helo)\
    if gCat > 1 then return end \
    \
    -- we simply add scouts as they are garbage-collected \
    -- every so often when they do not exist \
    if event.id == 15 or -- birth\
       event.id == 3 -- take-off. should already have been taken \
                     -- care of by birth, but you never know \
    then\
        -- check if a side must not have scouts.\
        -- this will prevent player units to auto-\
        -- scout when they are on that side. in that case\
        -- you must add manually\
        local theSide = theUnit:getCoalition()\
        \
        local isPlayer = theUnit:getPlayerName()\
        if isPlayer then  \
            -- since players wake up late, we lazy-eval their group\
            -- and add it to the blind/scout lists\
            cfxReconMode.lateEvalPlayerUnit(theUnit)\
            if cfxReconMode.verbose then \
                trigger.action.outText(\"+++rcn: late player check complete for <\" .. theUnit:getName() .. \">\", 30)\
            end\
        else \
            isPlayer = false -- safer than sorry\
        end \
        \
        if cfxReconMode.autoRecon then \
            if theSide == 0 and not cfxReconMode.greyScouts then \
                return -- grey scouts are not allowed\
            end\
            if theSide == 1 and not cfxReconMode.redScouts then \
                return -- grey scouts are not allowed\
            end\
            if theSide == 2 and not cfxReconMode.blueScouts then \
                return -- grey scouts are not allowed\
            end\
        \
            if cfxReconMode.playerOnlyRecon then \
                if not isPlayer then \
                    if cfxReconMode.verbose then \
                        trigger.action.outText(\"+++rcn: <\" .. theUnit:getName() .. \"> filtered: no player unit\", 30)\
                    end \
                    return -- only players can do recon. this unit is AI\
                end\
            end\
        end \
        \
        -- check if cfxReconMode.autoRecon is enabled\
        -- otherwise, abort the aircraft is not in \
        -- scourlist \
        local gName = theGroup:getName()\
        if not cfxReconMode.autoRecon then \
            -- no auto-recon. plane must be in scouts list \
            local inList, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.allowedScouts)\
            if not inList then \
                if cfxReconMode.verbose then \
                    trigger.action.outText(\"+++rcn: <\" .. theUnit:getName() .. \"> filtered: not in scout list\", 30)\
                end\
                return \
            end\
        end\
        \
        -- check if aircraft is in blindlist \
        -- abort if so \
        local inList, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.blindScouts)\
        if inList then \
            if cfxReconMode.verbose then \
                trigger.action.outText(\"+++rcn: <\" .. theUnit:getName() .. \"> filtered: unit cannot scout\", 30)\
            end\
            return \
        end\
        \
        if cfxReconMode.verbose then \
            trigger.action.outText(\"+++rcn: event \" .. event.id .. \" for unit \" .. theUnit:getName(), 30)\
        end \
        cfxReconMode.addScout(theUnit)\
    end\
--    trigger.action.outText(\"+++rcn-onEvent: \" .. event.id .. \" for <\" .. theUnit:getName() .. \">\", 30)\
end\
\
--\
-- read all existing planes \
-- \
function cfxReconMode.processScoutGroups(theGroups)\
    for idx, aGroup in pairs(theGroups) do \
        -- process all planes in that group \
        -- we are very early in the mission, only few groups really \
        -- exist now, the rest of the units come in with 15 event\
        if aGroup:isExist() then \
            -- see if we want to add these aircraft to the \
            -- active scout list \
            \
            local gName = aGroup:getName()\
            local isBlind, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.blindScouts)\
            local isScout, ignored = cfxReconMode.isStringInList(gName, cfxReconMode.allowedScouts)\
            \
            local doAdd = cfxReconMode.autoRecon\
            if cfxReconMode.autoRecon then \
                local theSide = aGroup:getCoalition()\
                if theSide == 0 and not cfxReconMode.greyScouts then\
                    doAdd = false \
                elseif theSide == 1 and not cfxReconMode.redScouts then \
                    doAdd = false \
                elseif theSide == 2 and not cfxReconMode.blueScouts then \
                    doAdd = false \
                end \
            end\
            \
            if isBlind then doAdd = false end \
            if isScout then doAdd = true end -- overrides all \
            \
            if doAdd then \
                local allUnits = Group.getUnits(aGroup)\
                for idy, aUnit in pairs (allUnits) do \
                    if aUnit:isExist() then \
                        if cfxReconMode.autoRecon and cfxReconMode.playerOnlyRecon and (aUnit:getPlayerName() == nil)\
                        then\
                            if cfxReconMode.verbose then\
                                trigger.action.outText(\"+++rcn: skipped unit \" ..aUnit:getName() .. \" because not player unit\", 30)\
                            end\
                        else\
                            cfxReconMode.addScout(aUnit)\
                            if cfxReconMode.verbose then\
                                trigger.action.outText(\"+++rcn: added unit \" ..aUnit:getName() .. \" to pool at startup\", 30)\
                            end\
                        end\
                    end\
                end\
            else \
                if cfxReconMode.verbose then \
                    trigger.action.outText(\"+++rcn: filtered group \" .. gName .. \" from being entered into scout pool at startup\", 30)\
                end\
            end \
        end\
    end\
end\
\
function cfxReconMode.initScouts()\
    -- get all groups of aircraft. Unrolled loop 0..2 \
    -- added helicopters, removed check for grey/red/bluescouts,\
    -- as that happens in processScoutGroups \
    local theAirGroups = {}  \
    theAirGroups = coalition.getGroups(0, 0) -- 0 = aircraft\
    cfxReconMode.processScoutGroups(theAirGroups)\
    theAirGroups = coalition.getGroups(0, 1) -- 1 = helicopter\
    cfxReconMode.processScoutGroups(theAirGroups)\
\
    theAirGroups = coalition.getGroups(1, 0) -- 0 = aircraft\
    cfxReconMode.processScoutGroups(theAirGroups)\
    theAirGroups = coalition.getGroups(1, 1) -- 1 = helicopter\
    cfxReconMode.processScoutGroups(theAirGroups)\
\
    theAirGroups = coalition.getGroups(2, 0) -- 0 = aircraft\
    cfxReconMode.processScoutGroups(theAirGroups)\
    theAirGroups = coalition.getGroups(2, 1) -- 1 = helicopter\
    cfxReconMode.processScoutGroups(theAirGroups)\
end\
\
--\
-- read config \
--\
function cfxReconMode.readConfigZone()\
    -- note: must match exactly!!!!\
    local theZone = cfxZones.getZoneByName(\"reconModeConfig\") \
    if not theZone then \
        if cfxReconMode.verbose then\
            trigger.action.outText(\"+++rcn: no config zone!\", 30) \
        end \
        theZone = cfxZones.createSimpleZone(\"reconModeConfig\")\
    else  \
        if cfxReconMode.verbose then \
            trigger.action.outText(\"+++rcn: found config zone!\", 30) \
        end \
    end \
    \
    cfxReconMode.verbose = cfxZones.getBoolFromZoneProperty(theZone, \"verbose\", false)\
\
    cfxReconMode.autoRecon = cfxZones.getBoolFromZoneProperty(theZone, \"autoRecon\", true)\
    cfxReconMode.redScouts = cfxZones.getBoolFromZoneProperty(theZone, \"redScouts\", false)\
    cfxReconMode.blueScouts = cfxZones.getBoolFromZoneProperty(theZone, \"blueScouts\", true)    \
    cfxReconMode.greyScouts = cfxZones.getBoolFromZoneProperty(theZone, \"greyScouts\", false)\
    cfxReconMode.playerOnlyRecon = cfxZones.getBoolFromZoneProperty(theZone, \"playerOnlyRecon\", false)\
    cfxReconMode.reportNumbers = cfxZones.getBoolFromZoneProperty(theZone, \"reportNumbers\", true)\
        \
    cfxReconMode.detectionMinRange = cfxZones.getNumberFromZoneProperty(theZone, \"detectionMinRange\", 3000)\
    cfxReconMode.detectionMaxRange = cfxZones.getNumberFromZoneProperty(theZone, \"detectionMaxRange\", 12000)\
    cfxReconMode.maxAlt = cfxZones.getNumberFromZoneProperty(theZone, \"maxAlt\", 9000)\
    \
    if cfxZones.hasProperty(theZone, \"prio+\") then \
        cfxReconMode.prioFlag = cfxZones.getStringFromZoneProperty(theZone, \"prio+\", \"none\")\
    elseif cfxZones.hasProperty(theZone, \"prio!\") then \
        cfxReconMode.prioFlag = cfxZones.getStringFromZoneProperty(theZone, \"prio!\", \"*<none>\")\
    end\
    \
    if cfxZones.hasProperty(theZone, \"detect+\") then \
        cfxReconMode.detectFlag = cfxZones.getStringFromZoneProperty(theZone, \"detect+\", \"none\")\
    elseif cfxZones.hasProperty(theZone, \"detect!\") then \
        cfxReconMode.detectFlag = cfxZones.getStringFromZoneProperty(theZone, \"detect!\", \"*<none>\")\
    end\
    \
    cfxReconMode.method = cfxZones.getStringFromZoneProperty(theZone, \"method\", \"inc\")\
    if cfxZones.hasProperty(theZone, \"reconMethod\") then \
        cfxReconMode.method = cfxZones.getStringFromZoneProperty(theZone, \"reconMethod\", \"inc\")\
    end\
    \
    cfxReconMode.applyMarks = cfxZones.getBoolFromZoneProperty(theZone, \"applyMarks\", true)\
    cfxReconMode.announcer = cfxZones.getBoolFromZoneProperty(theZone, \"announcer\", true)\
    -- trigger.action.outText(\"recon: announcer is \" .. dcsCommon.bool2Text(cfxReconMode.announcer), 30) -- announced\
    if cfxZones.hasProperty(theZone, \"reconSound\") then \
        cfxReconMode.reconSound = cfxZones.getStringFromZoneProperty(theZone, \"reconSound\", \"<nosound>\")\
    end\
    \
    cfxReconMode.removeWhenDestroyed = cfxZones.getBoolFromZoneProperty(theZone, \"autoRemove\", true)\
    \
    cfxReconMode.mgrs = cfxZones.getBoolFromZoneProperty(theZone, \"mgrs\", false)\
    \
    cfxReconMode.theZone = theZone -- save this zone \
end\
\
--\
-- read blackList and prio list groups\
--\
\
\
function cfxReconMode.processReconZone(theZone) \
    local theList = cfxZones.getStringFromZoneProperty(theZone, \"recon\", \"prio\")\
    theList = string.upper(theList)\
    local isBlack = dcsCommon.stringStartsWith(theList, \"BLACK\")\
\
    local zInfo = {}\
    zInfo.theZone = theZone\
    zInfo.isBlack = isBlack    \
    if cfxZones.hasProperty(theZone, \"spotted!\") then \
        zInfo.theFlag = cfxZones.getStringFromZoneProperty(theZone, \"spotted!\", \"*<none>\")\
    end\
    \
    if cfxZones.hasProperty(theZone, \"prioMessage\") then \
        zInfo.prioMessage = cfxZones.getStringFromZoneProperty(theZone, \"prioMessage\", \"<none>\")\
    end\
    \
    local dynamic = cfxZones.getBoolFromZoneProperty(theZone, \"dynamic\", false)\
    zInfo.dynamic = dynamic \
    local categ = 2 -- ground troops only\
    local allGroups = cfxZones.allGroupsInZone(theZone, categ)\
    for idx, aGroup in pairs(allGroups) do \
        local gName = aGroup:getName()\
        cfxReconMode.zoneInfo[gName] = zInfo \
        if isBlack then \
            cfxReconMode.addToBlackList(aGroup, dynamic)\
            if cfxReconMode.verbose or theZone.verbose then \
                if dynamic then trigger.action.outText(\"+++rcn: added DYNAMIC \" .. aGroup:getName() .. \" to blacklist\", 30)\
                else trigger.action.outText(\"+++rcn: added \" .. aGroup:getName() .. \" to blacklist\", 30) \
                end\
            end \
        else \
            cfxReconMode.addToPrioList(aGroup, dynamic)\
            if cfxReconMode.verbose or theZone.verbose then \
                if dynamic then trigger.action.outText(\"+++rcn: added DYNAMIC \" .. aGroup:getName() .. \" to priority target list\", 30)\
                else trigger.action.outText(\"+++rcn: added \" .. aGroup:getName() .. \" to priority target list\", 30)\
                end\
            end\
        end\
    end\
end\
\
function cfxReconMode.processScoutZone(theZone) \
    local isScout = cfxZones.getBoolFromZoneProperty(theZone, \"scout\", true)\
    local dynamic = cfxZones.getBoolFromZoneProperty(theZone, \"dynamic\")\
    theZone.dynamic = dynamic\
    theZone.isScout = isScout\
    \
    local categ = 0 -- aircraft\
    local allFixed = cfxZones.allGroupsInZone(theZone, categ)\
    local categ = 1 -- helos\
    local allRotor = cfxZones.allGroupsInZone(theZone, categ)\
    local allGroups = dcsCommon.combineTables(allFixed, allRotor)\
    for idx, aGroup in pairs(allGroups) do \
        if isScout then \
            cfxReconMode.addToAllowedScoutList(aGroup, dynamic)\
            if cfxReconMode.verbose or theZone.verbose then \
                if dynamic then trigger.action.outText(\"+++rcn: added DYNAMIC \" .. aGroup:getName() .. \" to allowed scouts\", 30)\
                else trigger.action.outText(\"+++rcn: added \" .. aGroup:getName() .. \" to allowed scouts\", 30) \
                end\
            end \
        else \
            cfxReconMode.addToBlindScoutList(aGroup, dynamic)\
            if cfxReconMode.verbose or theZone.verbose then \
                if dynamic then trigger.action.outText(\"+++rcn: added DYNAMIC \" .. aGroup:getName() .. \" to BLIND scouts list\", 30)\
                else trigger.action.outText(\"+++rcn: added \" .. aGroup:getName() .. \" to BLIND scouts list\", 30)\
                end\
            end\
        end\
    end\
    \
    table.insert(cfxReconMode.scoutZones, theZone)\
end\
\
function cfxReconMode.readReconGroups()\
    local attrZones = cfxZones.getZonesWithAttributeNamed(\"recon\")\
    for k, aZone in pairs(attrZones) do \
        cfxReconMode.processReconZone(aZone)\
    end\
end\
\
function cfxReconMode.readScoutGroups()\
    local attrZones = cfxZones.getZonesWithAttributeNamed(\"scout\")\
    for k, aZone in pairs(attrZones) do \
        cfxReconMode.processScoutZone(aZone)\
    end\
end\
\
--\
-- start \
--\
function cfxReconMode.start()\
    -- lib check \
    if not dcsCommon.libCheck(\"cfx Recon Mode\", \
        cfxReconMode.requiredLibs) then\
        return false \
    end\
    \
    -- read config \
    cfxReconMode.readConfigZone()\
    \
    -- gather prio and blacklist groups \
    cfxReconMode.readReconGroups() \
    \
    -- gather allowed and forbidden scouts \
    cfxReconMode.readScoutGroups()\
    \
    -- gather exiting planes \
    cfxReconMode.initScouts()\
    \
    -- start update cycle\
    cfxReconMode.updateQueues()\
    \
    -- if dead groups are removed from map,\
    -- schedule housekeeping \
    if cfxReconMode.removeWhenDestroyed then \
        cfxReconMode.autoRemove()\
    end\
    \
    if true or cfxReconMode.autoRecon then \
        -- install own event handler to detect \
        -- when a unit takes off and add it to scout\
        -- roster \
        world.addEventHandler(cfxReconMode)\
    end\
    \
    trigger.action.outText(\"cfx Recon version \" .. cfxReconMode.version .. \" started.\", 30)\
    return true\
end\
\
--\
-- test callback \
--\
function cfxReconMode.demoReconCB(reason, theSide, theScout, theGroup, theName)\
    trigger.action.outText(\"recon CB: \" .. reason .. \" -- \" .. theScout:getName() .. \" spotted \" .. theName, 30)\
end\
\
if not cfxReconMode.start() then \
    cfxReconMode = nil\
end\
\
-- debug: wire up my own callback\
-- cfxReconMode.addCallback(cfxReconMode.demoReconCB)\
\
\
--[[--\
\
ideas:\
 \
- renew lease. when already sighted, simply renew lease, maybe update location.\
- update marks and renew lease \
TODO: red+ and blue+ - flags to increase when a plane of the other side is detected\
TODO: recon: scout and blind for aircraft in group to add / remove scouts, maybe use scout keyword \
 \
allow special bangs per priority group \
--]]--\
\
\
 \
 ",
                    ["predicate"] = "a_do_script",
                }, -- end of [3]
                [4] = 
                {
                    ["text"] = "cfxArtilleryZones = {}\
cfxArtilleryZones.version = \"2.2.0\" \
cfxArtilleryZones.requiredLibs = {\
    \"dcsCommon\", -- always\
    \"cfxZones\", -- Zones, of course \
}\
cfxArtilleryZones.verbose = false \
--[[--\
    Version History\
 1.0.0 - initial version\
 1.0.1 - simSmokeZone\
 2.0.0 - zone attributes for shellNum, shellVariance,\
         cooldown, addMark, transitionTime\
       - doFireAt method\
       - simFireAt now calls doFireAt \
       - added all params to crteateArtilleryTarget\
       - createArtillerTarget replaced createArtilleryZone \
       - addMark now used so arty zones can be hidden on map\
       - added triggerFlag attribute \
       - update now fires every time when flag changes \
 2.0.1 - added verbose setting \
       - base accuracy now derived from radius \
       - added coalition check for ZonesInRange\
       - att transition time to zone info mark\
       - made compatible with linked zones \
       - added silent attribute \
       - added transition time to arty command chatter \
 2.0.2 - boom?, arty? synonyms \
 2.1.0 - DML Flag Support \
       - code cleanup\
 2.2.0 - DML Watchflag integration \
 \
    Artillery Target Zones *** EXTENDS ZONES ***\
    Target Zones for artillery. Can determine which zones are in range and visible and then handle artillery barrage to this zone \
    Copyright (c) 2021, 2022 by Christian Franz and cf/x AG\
\
    USAGE\
    Via ME: Add the relevant attributes to the zone \
    Via Script: Use createArtilleryTarget() \
\
\
    Callbacks\
    when fire at target is invoked, a callback can be \
    invoked so your code knows that fire control has been \
    given a command or that projectiles are impacting.\
    Signature\
    callback(rason, zone, data), with \
    reason: 'firing' - fire command given for zone \
            'impact' a projectile has hit\
    zone:   artilleryZone\
    data:   empty on 'fire' \
            .point where impact point\
            .strength power of explosion \
    \
--]]--\
cfxArtilleryZones.artilleryZones = {}\
cfxArtilleryZones.updateDelay = 1 -- every second \
\
\
--\
-- C A L L B A C K S \
-- \
cfxArtilleryZones.callbacks = {}\
function cfxArtilleryZones.addCallback(theCallback)\
    table.insert(cfxArtilleryZones.callbacks, theCallback)\
end\
\
function cfxArtilleryZones.invokeCallbacksFor(reason, zone, data)\
    for idx, theCB in pairs (cfxArtilleryZones.callbacks) do \
        theCB(reason, zone, data)\
    end\
end\
\
function cfxArtilleryZones.demoCallback(reason, zone, data)\
    -- reason: 'fire' or 'impact'\
    -- fire has no data, impact has data.point and data.strength \
end\
\
function cfxArtilleryZones.createArtilleryTarget(name, point, coalition, spotRange, transitionTime, baseAccuracy, shellNum, shellStrength, shellVariance, triggerFlag, addMark, cooldown, silent, autoAdd) -- was: createArtilleryZone, changed params list \
    if not point then return end \
    if not autoAdd then autoAdd = false end \
    if not coalition then coalition = 0 end \
    if not spotRange then spotRange = 3000 end \
    if not shellStrength then shellStrength = 500 end \
    if not transitionTime then transitionTime = 20 end \
    if not shellNum then shellNum = 17 end \
    if not addMark then addMark = false end \
    if not name then name = \"dftZName\" end \
    if not shellVariance then shellVariance = 0.2 end \
    if not cooldown then cooldown = 120 end \
    if not baseAccuracy then baseAccuracy = 100 end \
    if not silent then silent = false end \
    \
    name = cfxZones.createUniqueZoneName(name)\
    \
    local newZone = cfxZones.createSimpleZone(name,\
        point, \
        100, \
        autoAdd)\
    newZone.spotRange = spotRange\
    newZone.coalition = coalition\
    newZone.landHeight = land.getHeight({x = newZone.point.x, y= newZone.point.z})\
    newZone.transitionTime = transitionTime\
    newZone.shellNum = shellNum \
    newZone.shellStrength = shellStrength\
    newZone.triggerFlag = triggerFlag -- can be nil \
    if triggerFlag then \
        newZone.lastTriggerValue = trigger.misc.getUserFlag(triggerFlag) -- save last value\
    end \
    newZone.addMark = addMark\
    if autoAdd then cfxArtilleryZones.addArtilleryZone(newZone) end \
    newZone.shellVariance = shellVariance\
    newZone.cooldown = cooldown\
    newZone.silent = silent \
end\
\
function cfxArtilleryZones.processArtilleryZone(aZone)\
    aZone.artilleryTarget = cfxZones.getStringFromZoneProperty(aZone, \"artilleryTarget\", aZone.name)\
    aZone.coalition = cfxZones.getCoalitionFromZoneProperty(aZone, \"coalition\", 0) -- side that marks it on map, and who fires arty\
    aZone.spotRange = cfxZones.getNumberFromZoneProperty(aZone, \"spotRange\", 3000) -- FO max range to direct fire\
    aZone.shellStrength = cfxZones.getNumberFromZoneProperty(aZone, \"shellStrength\", 500) -- power of shells (strength)\
\
    aZone.shellNum = cfxZones.getNumberFromZoneProperty(aZone, \"shellNum\", 17) -- number of shells in bombardment\
    aZone.transitionTime = cfxZones.getNumberFromZoneProperty(aZone, \"transitionTime\", 20) -- average time of travel for projectiles \
    aZone.addMark = cfxZones.getBoolFromZoneProperty(aZone, \"addMark\", true) -- note: defaults to true \
    aZone.shellVariance = cfxZones.getNumberFromZoneProperty(aZone, \"shellVariance\", 0.2) -- strength of explosion can vary by +/- this amount\
    \
    -- watchflag:\
    -- triggerMethod\
    aZone.artyTriggerMethod = cfxZones.getStringFromZoneProperty(aZone, \"artyTriggerMethod\", \"change\")\
\
    if cfxZones.hasProperty(aZone, \"triggerMethod\") then \
        aZone.artyTriggerMethod = cfxZones.getStringFromZoneProperty(aZone, \"triggerMethod\", \"change\")\
    end\
    \
    if cfxZones.hasProperty(aZone, \"f?\") then \
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \"f?\", \"none\")\
    end\
    --[[--\
    if cfxZones.hasProperty(aZone, \"triggerFlag\") then \
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \"triggerFlag\", \"none\")\
    end\
    --]]--\
    if cfxZones.hasProperty(aZone, \"artillery?\") then \
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \"artillery?\", \"none\")\
    end\
    if cfxZones.hasProperty(aZone, \"in?\") then \
        aZone.artyTriggerFlag = cfxZones.getStringFromZoneProperty(aZone, \"in?\", \"none\")\
    end\
    \
    if aZone.artyTriggerFlag then \
        aZone.lastTriggerValue = trigger.misc.getUserFlag(aZone.artyTriggerFlag) -- save last value\
    end\
    aZone.cooldown =cfxZones.getNumberFromZoneProperty(aZone, \"cooldown\", 120) -- seconds \
    aZone.baseAccuracy = cfxZones.getNumberFromZoneProperty(aZone, \"baseAccuracy\", aZone.radius) -- meters from center radius shell impact\
    -- use zone radius as mase accuracy for simple placement\
    aZone.silent = cfxZones.getBoolFromZoneProperty(aZone, \"silent\", false)\
end\
\
function cfxArtilleryZones.addArtilleryZone(aZone)\
    -- add landHeight to this zone \
    aZone.landHeight = land.getHeight({x = aZone.point.x, y= aZone.point.z})\
    -- mark it on the map \
    aZone.artyCooldownTimer = -1000 \
    cfxArtilleryZones.placeMarkForSide(aZone.point, aZone.coalition, aZone.name .. \", FO=\" .. aZone.spotRange .. \"m\" .. \", tt=\" .. aZone.transitionTime)\
    table.insert(cfxArtilleryZones.artilleryZones, aZone)\
end\
\
function cfxArtilleryZones.findArtilleryZoneNamed(aName)\
    aZone = cfxZones.getZoneByName(aName) \
    if not aZone then return nil end \
    -- check if it is an arty zone \
    if not aZone.artilleryTarget then return nil end \
    -- all is well\
    return aZone \
end\
\
function cfxArtilleryZones.removeArtilleryZone(aZone)\
    if type(aZone) == \"string\" then \
        aZone = cfxArtilleryZones.findArtilleryZoneNamed(aZone) \
    end\
    if not aZone then return end \
    \
    -- now create new table \
    local filtered = {}\
    for idx, theZone in pairs(cfxArtilleryZones.artilleryZones) do \
        if theZone ~= aZone then \
            table.insert(filtered, theZone)\
        end \
    end\
    cfxArtilleryZones.artilleryZones = filtered \
end\
\
function cfxArtilleryZones.artilleryZonesInRangeOfUnit(theUnit)\
    if not theUnit then return {} end \
    if not theUnit:isExist() then return {} end\
    local myCoalition = theUnit:getCoalition()\
    local zonesInRange = {}\
    local p = theUnit:getPoint()\
    \
    for idx, aZone in pairs(cfxArtilleryZones.artilleryZones) do \
        -- is it one of mine?\
        if aZone.coalition == myCoalition then\
            -- is it close enough?\
            local zP = cfxZones.getPoint(aZone)\
            aZone.landHeight = land.getHeight({x = zP.x, y= zP.z})\
            local zonePoint = {x = zP.x, y = aZone.landHeight, z = zP.z}\
            local d = dcsCommon.dist(p,zonePoint)\
            if d < aZone.spotRange then \
                -- LOS check \
                if land.isVisible(p, zonePoint) then \
                    -- yeah, add to list \
                    table.insert(zonesInRange, aZone)\
                end\
            end\
        end \
    end\
    return zonesInRange\
end\
\
\
--\
-- MARK ON MAP\
--\
cfxArtilleryZones.uuidCount = 0\
function cfxArtilleryZones.uuid()\
    cfxArtilleryZones.uuidCount = cfxArtilleryZones.uuidCount + 1\
    return cfxArtilleryZones.uuidCount\
end\
\
function cfxArtilleryZones.placeMarkForSide(location, theSide, theDesc) \
    local theID = cfxArtilleryZones.uuid()\
    local theDesc = \"ARTY: \".. theDesc\
    trigger.action.markToCoalition(\
                    theID, \
                    theDesc, \
                    location, \
                    theSide, \
                    false, \
                    nil)\
    return theID\
end\
\
function cfxArtilleryZones.removeMarkForArgs(args)\
    local theID = args[1]    \
    trigger.action.removeMark(theID)\
end \
\
--\
-- FIRE AT A ZONE\
-- \
\
--\
-- BOOM command\
--\
function cfxArtilleryZones.doBoom(args)\
    trigger.action.explosion(args.point, args.strength)\
    data = {}\
    data.point = args.point \
    data.strength = args.strength \
    cfxArtilleryZones.invokeCallbacksFor('impact', args.zone, data)\
end\
\
function cfxArtilleryZones.doFireAt(aZone, maxDistFromCenter)\
    if type(aZone) == \"string\" then \
        local mZone = cfxArtilleryZones.findArtilleryZoneNamed(aZone)\
        aZone = mZone\
    end\
    if not aZone then return end \
\
    if not maxDistFromCenter then maxDistFromCenter = aZone.baseAccuracy end \
    \
    local accuracy = maxDistFromCenter \
    local zP = cfxZones.getPoint(aZone)\
    aZone.landHeight = land.getHeight({x = zP.x, y= zP.z}) \
    local center = {x=zP.x, y=aZone.landHeight, z=zP.z} -- center of where shells hit \
    local shellNum = aZone.shellNum\
    local shellBaseStrength = aZone.shellStrength\
    local shellVariance = aZone.shellVariance  \
    local transitionTime = aZone.transitionTime\
    \
    for i=1, shellNum do\
        local thePoint = dcsCommon.randomPointInCircle(accuracy, 0, center.x, center.z)\
        thePoint.y = land.getHeight({x=thePoint.x, y=thePoint.z})\
        local boomArgs = {}\
        local strVar = shellBaseStrength * shellVariance\
        strVar = strVar * (2 * dcsCommon.randomPercent() - 1.0) -- go from -1 to 1\
        \
        boomArgs.strength = shellBaseStrength + strVar\
        thePoint.y = land.getHeight({x = thePoint.x, y = thePoint.z}) + 1  -- elevate to ground height + 1\
        boomArgs.point = thePoint\
        boomArgs.zone = aZone\
        local timeVar = 5 * (2 * dcsCommon.randomPercent() - 1.0) -- +/- 1.5 seconds\
        if timeVar < 0 then timeVar = -timeVar end \
\
        timer.scheduleFunction(cfxArtilleryZones.doBoom, boomArgs, timer.getTime() + transitionTime + timeVar)\
    end\
    \
    -- invoke callbacks \
    cfxArtilleryZones.invokeCallbacksFor('fire', aZone, {})\
end\
\
function cfxArtilleryZones.simFireAtZone(aZone, aGroup, dist)\
    \
    if not dist then dist = aZone.spotRange end \
    local shellBaseStrength = aZone.shellStrength \
\
    local maxAccuracy = 100 -- m radius when close\
    local minAccuracy = 500 -- m radius whan at max sport dist \
    local currAccuracy = minAccuracy \
    if dist <= 1000 then \
        currAccuracy = maxAccuracy \
    else \
        local percent = (dist-1000) / (aZone.spotRange-1000)\
        currAccuracy = dcsCommon.lerp(maxAccuracy, minAccuracy, percent)\
    end\
    currAccuracy = math.floor(currAccuracy)\
    cfxArtilleryZones.doFireAt(aZone, currAccuracy) \
\
    aZone.artyCooldownTimer = timer.getTime() + aZone.cooldown -- 120 -- 2 minutes reload\
    if not aZone.silent then \
        local addInfo = \" with d=\" .. dist .. \", var = \" .. currAccuracy .. \" pB=\" .. shellBaseStrength .. \" tt=\" .. aZone.transitionTime\
    \
        trigger.action.outTextForCoalition(aGroup:getCoalition(), \"Artillery firing on \".. aZone.name .. addInfo, 30)\
    end \
    --trigger.action.smoke(center, 2) -- mark location visually\
end \
\
function cfxArtilleryZones.simSmokeZone(aZone, aGroup, aColor)\
    -- this is simsmoke: transition time is fixed, and we do not\
    -- use arty units. all very simple. we merely place smoke on\
    -- ground \
    if not aColor then aColor = \"red\" end \
    if type(aColor) == \"string\" then \
        aColor = dcsCommon.smokeColor2Num(aColor)\
    end\
    local zP = cfxZones.getPoint(aZone)\
    aZone.landHeight = land.getHeight({x = zP.x, y= zP.z})\
    \
    local transitionTime = aZone.transitionTime --17 -- seconds until phosphor lands\
    local center = {x = zP.x, \
                    y =aZone.landHeight + 3, \
                    z = zP.z\
                   } -- center of where shells hit \
    -- we now can 'dirty' the position by something. not yet\
    local currAccuracy = 200\
\
    local thePoint = dcsCommon.randomPointInCircle(currAccuracy, 50, center.x, center.z)\
    \
    timer.scheduleFunction(cfxArtilleryZones.doSmoke, {thePoint, aColor}, timer.getTime() + transitionTime)\
    \
    if not aGroup then return end \
    if aZone.silent then return end \
    \
    trigger.action.outTextForCoalition(aGroup:getCoalition(), \"Artillery firing single phosphor round at \".. aZone.name, 30)\
end \
\
function cfxArtilleryZones.doSmoke(args) \
    local thePoint = args[1]\
    local aColor = args[2]\
    dcsCommon.markPointWithSmoke(thePoint, aColor)\
end\
\
--\
-- UPDATE\
--\
\
function cfxArtilleryZones.update()\
    -- call me in a couple of minutes to 'rekindle'\
    timer.scheduleFunction(cfxArtilleryZones.update, {}, timer.getTime() + cfxArtilleryZones.updateDelay)\
    \
    -- iterate all zones to see if a trigger has changed \
    for idx, aZone in pairs(cfxArtilleryZones.artilleryZones) do \
        if cfxZones.testZoneFlag(aZone, aZone.artyTriggerFlag, aZone.artyTriggerMethod, \"lastTriggerValue\") then\
            -- a triggered release!\
            cfxArtilleryZones.doFireAt(aZone) -- all from zone vars!    \
            if cfxArtilleryZones.verbose then \
                local addInfo = \" with var = \" .. aZone.baseAccuracy .. \" pB=\" .. aZone.shellStrength\
                trigger.action.outText(\"Artillery T-Firing on \".. aZone.name .. addInfo, 30)\
            end \
        end\
        \
    \
        -- old code\
        if aZone.artyTriggerFlag then \
            local currTriggerVal = cfxZones.getFlagValue(aZone.artyTriggerFlag, aZone) -- trigger.misc.getUserFlag(aZone.artyTriggerFlag)\
            if currTriggerVal ~= aZone.lastTriggerValue\
            then \
                -- a triggered release!\
                cfxArtilleryZones.doFireAt(aZone) -- all from zone vars!\
                \
                if cfxArtilleryZones.verbose then \
                    local addInfo = \" with var = \" .. aZone.baseAccuracy .. \" pB=\" .. aZone.shellStrength\
                    trigger.action.outText(\"Artillery T-Firing on \".. aZone.name .. addInfo, 30)\
                end \
                aZone.lastTriggerValue = currTriggerVal\
            end\
\
        end\
    end\
end\
\
--\
-- START \
--\
\
function cfxArtilleryZones.start()\
    if not dcsCommon.libCheck(\"cfx Artillery Zones\", \
        cfxArtilleryZones.requiredLibs) then\
        return false \
    end\
    \
    -- collect all spawn zones \
    local attrZones = cfxZones.getZonesWithAttributeNamed(\"artilleryTarget\")\
    \
    -- now create a spawner for all, add them to the spawner updater, and spawn for all zones that are not\
    -- paused \
    for k, aZone in pairs(attrZones) do \
        cfxArtilleryZones.processArtilleryZone(aZone) -- process attribute and add to zone\
        cfxArtilleryZones.addArtilleryZone(aZone) -- remember it so we can smoke it\
    end\
\
    -- start update loop\
    cfxArtilleryZones.update()\
    \
    -- say hi\
    trigger.action.outText(\"cfx Artillery Zones v\" .. cfxArtilleryZones.version .. \" started.\", 30)\
    return true \
end\
\
-- let's go \
if not cfxArtilleryZones.start() then \
    trigger.action.outText(\"cf/x Artillery Zones aborted: missing libraries\", 30)\
    cfxArtilleryZones = nil \
end\
\
",
                    ["predicate"] = "a_do_script",
                }, -- end of [4]
            }, -- end of ["actions"]
            ["comment"] = "Load DML",
        }, -- end of [1]
    }, -- end of ["trigrules"]
    ["currentKey"] = 781,
    ["start_time"] = 28800,
    ["forcedOptions"] = 
    {
    }, -- end of ["forcedOptions"]
    ["failures"] = 
    {
        ["hydro"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "hydro",
            ["mm"] = 0,
        }, -- end of ["hydro"]
        ["eos"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "eos",
            ["mm"] = 0,
        }, -- end of ["eos"]
        ["ecm"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "ecm",
            ["mm"] = 0,
        }, -- end of ["ecm"]
        ["l_engine"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "l_engine",
            ["mm"] = 0,
        }, -- end of ["l_engine"]
        ["autopilot"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "autopilot",
            ["mm"] = 0,
        }, -- end of ["autopilot"]
        ["hud"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "hud",
            ["mm"] = 0,
        }, -- end of ["hud"]
        ["asc"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "asc",
            ["mm"] = 0,
        }, -- end of ["asc"]
        ["rws"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "rws",
            ["mm"] = 0,
        }, -- end of ["rws"]
        ["r_engine"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "r_engine",
            ["mm"] = 0,
        }, -- end of ["r_engine"]
        ["mfd"] = 
        {
            ["hh"] = 0,
            ["prob"] = 100,
            ["enable"] = false,
            ["mmint"] = 1,
            ["id"] = "mfd",
            ["mm"] = 0,
        }, -- end of ["mfd"]
    }, -- end of ["failures"]
} -- end of mission
