597 lines
26 KiB
Lua
597 lines
26 KiB
Lua
-- 3
|
|
|
|
local SpearheadDB = {}
|
|
do -- DB
|
|
|
|
local singleton = nil
|
|
|
|
---comment
|
|
---@param Logger table
|
|
---@return table
|
|
function SpearheadDB:new(Logger)
|
|
if singleton ~= nil then
|
|
Logger:info("Returning an already initiated instance of SpearheadDB")
|
|
return singleton
|
|
end
|
|
|
|
local o = {}
|
|
setmetatable(o, { __index = self })
|
|
|
|
o.Logger = Logger
|
|
o.tables = {}
|
|
do --INIT ALL TABLES
|
|
Logger:debug("Initiating tables")
|
|
|
|
o.tables.all_zones = {}
|
|
o.tables.stage_zones = {}
|
|
o.tables.mission_zones = {}
|
|
o.tables.random_mission_zones = {}
|
|
o.tables.farp_zones = {}
|
|
o.tables.cap_route_zones = {}
|
|
|
|
o.tables.stage_zonesByNumer = {}
|
|
|
|
do -- INIT ZONE TABLES
|
|
if env.mission.triggers and env.mission.triggers.zones then
|
|
for zone_ind, zone_data in pairs(env.mission.triggers.zones) do
|
|
local zone_name = zone_data.name
|
|
local split_string = Spearhead.Util.split_string(zone_name, "_")
|
|
table.insert(o.tables.all_zones, zone_name)
|
|
|
|
if string.lower(split_string[1]) == "missionstage" then
|
|
table.insert(o.tables.stage_zones, zone_name)
|
|
if split_string[2] then
|
|
local stringified = tostring(split_string[2]) or "unknown"
|
|
if o.tables.stage_zonesByNumer[stringified] == nil then
|
|
o.tables.stage_zonesByNumer[stringified] = zone_name
|
|
else
|
|
table.insert(Spearhead.MissionEditingWarnings, "Duplicate Stage Order number found. This zone will work, but will not be part of the CAP script")
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
if string.lower(split_string[1]) == "mission" then
|
|
table.insert(o.tables.mission_zones, zone_name)
|
|
end
|
|
|
|
if string.lower(split_string[1]) == "randommission" then
|
|
table.insert(o.tables.random_mission_zones, zone_name)
|
|
end
|
|
|
|
if string.lower(split_string[1]) == "farp" then
|
|
table.insert(o.tables.farp_zones, zone_name)
|
|
end
|
|
|
|
if string.lower(split_string[1]) == "caproute" then
|
|
table.insert(o.tables.cap_route_zones, zone_name)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
Logger:debug("initiated zone tables, continuing with descriptions")
|
|
o.tables.descriptions = {}
|
|
do --load markers
|
|
if env.mission.drawings and env.mission.drawings.layers then
|
|
for i, layer in pairs(env.mission.drawings.layers) do
|
|
if string.lower(layer.name) == "author" then
|
|
for key, layer_object in pairs(layer.objects) do
|
|
local inZone = Spearhead.DcsUtil.isPositionInZones(layer_object.mapX, layer_object.mapY, o.tables.mission_zones)
|
|
if Spearhead.Util.tableLength(inZone) >= 1 then
|
|
local name = inZone[1]
|
|
if name ~= nil then
|
|
o.tables.descriptions[name] = layer_object.text
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
o.tables.missionZonesPerStage = {}
|
|
for key, missionZone in pairs(o.tables.mission_zones) do
|
|
local found = false
|
|
local i = 1
|
|
while found == false and i <= Spearhead.Util.tableLength(o.tables.stage_zones) do
|
|
local stageZone = o.tables.stage_zones[i]
|
|
if Spearhead.DcsUtil.isZoneInZone(missionZone, stageZone) == true then
|
|
if o.tables.missionZonesPerStage[stageZone] == nil then
|
|
o.tables.missionZonesPerStage[stageZone] = {}
|
|
end
|
|
table.insert(o.tables.missionZonesPerStage[stageZone], missionZone)
|
|
end
|
|
i = i + 1
|
|
end
|
|
end
|
|
|
|
o.tables.randomMissionZonesPerStage = {}
|
|
for key, missionZone in pairs(o.tables.random_mission_zones) do
|
|
local found = false
|
|
local i = 1
|
|
while found == false and i <= Spearhead.Util.tableLength(o.tables.stage_zones) do
|
|
local stageZone = o.tables.stage_zones[i]
|
|
if Spearhead.DcsUtil.isZoneInZone(missionZone, stageZone) == true then
|
|
if o.tables.randomMissionZonesPerStage[stageZone] == nil then
|
|
o.tables.randomMissionZonesPerStage[stageZone] = {}
|
|
end
|
|
table.insert(o.tables.randomMissionZonesPerStage[stageZone], missionZone)
|
|
end
|
|
i = i + 1
|
|
end
|
|
end
|
|
|
|
local isAirbaseInZone = {}
|
|
o.tables.airbasesPerStage = {}
|
|
o.tables.farpIdsInFarpZones = {}
|
|
local airbases = world.getAirbases()
|
|
for _, airbase in pairs(airbases) do
|
|
local baseId = airbase:getID()
|
|
local point = airbase:getPoint()
|
|
local found = false
|
|
for _, zoneName in pairs(o.tables.stage_zones) do
|
|
if found == false then
|
|
if Spearhead.DcsUtil.isPositionInZone(point.x, point.z, zoneName) == true then
|
|
found = true
|
|
local baseIdString = tostring(baseId) or "nil"
|
|
isAirbaseInZone[baseIdString] = true
|
|
|
|
if airbase:getDesc().category == 0 then
|
|
--Airbase
|
|
if Spearhead.DcsUtil.getStartingCoalition(baseId) == 2 then
|
|
airbase:setCoalition(1)
|
|
airbase:autoCapture(false)
|
|
end
|
|
|
|
if o.tables.airbasesPerStage[zoneName] == nil then
|
|
o.tables.airbasesPerStage[zoneName] = {}
|
|
end
|
|
|
|
table.insert(o.tables.airbasesPerStage[zoneName], baseId)
|
|
else
|
|
-- farp
|
|
local i = 1
|
|
local farpFound = false
|
|
while farpFound == false and i <= Spearhead.Util.tableLength(o.tables.farp_zones) do
|
|
local farpZoneName = o.tables.farp_zones[i]
|
|
if Spearhead.DcsUtil.isPositionInZone(point.x, point.z, farpZoneName) == true then
|
|
farpFound = true
|
|
|
|
if o.tables.farpIdsInFarpZones[farpZoneName] == nil then
|
|
o.tables.farpIdsInFarpZones[farpZoneName] = {}
|
|
end
|
|
|
|
airbase:setCoalition(1)
|
|
airbase:autoCapture(false)
|
|
table.insert(o.tables.farpIdsInFarpZones[farpZoneName], baseIdString)
|
|
end
|
|
i = i +1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
o.tables.farpZonesPerStage = {}
|
|
for _, farpZoneName in pairs(o.tables.farp_zones) do
|
|
local findFirst = function (farpZoneName)
|
|
for _, stage_zone in pairs(o.tables.stage_zones) do
|
|
if Spearhead.DcsUtil.isZoneInZone(farpZoneName, stage_zone) then
|
|
return stage_zone
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local found = findFirst(farpZoneName)
|
|
if found then
|
|
|
|
if o.tables.farpZonesPerStage[found] == nil then
|
|
o.tables.farpZonesPerStage[found] = {}
|
|
end
|
|
|
|
table.insert(o.tables.farpZonesPerStage[found], farpZoneName)
|
|
end
|
|
end
|
|
|
|
|
|
local is_group_taken = {}
|
|
do
|
|
local all_groups = Spearhead.DcsUtil.getAllGroupNames()
|
|
for _, value in pairs(all_groups) do
|
|
is_group_taken[value] = false
|
|
end
|
|
end
|
|
|
|
local getAvailableGroups = function()
|
|
local result = {}
|
|
for name, value in pairs(is_group_taken) do
|
|
if value == false then
|
|
table.insert(result, name)
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
local getAvailableCAPGroups = function()
|
|
local result = {}
|
|
for name, value in pairs(is_group_taken) do
|
|
if value == false and Spearhead.Util.startswith(name, "CAP") then
|
|
table.insert(result, name)
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
--- airbaseId <> groupname[]
|
|
o.tables.capGroupsOnAirbase = {}
|
|
local loadCapUnits = function()
|
|
local all_groups = getAvailableCAPGroups()
|
|
Logger:debug(all_groups)
|
|
local airbases = world.getAirbases()
|
|
for _, airbase in pairs(airbases) do
|
|
local baseId = airbase:getID()
|
|
local point = airbase:getPoint()
|
|
|
|
o.tables.capGroupsOnAirbase[baseId] = {}
|
|
local groups = Spearhead.DcsUtil.areGroupsInCustomZone(all_groups,
|
|
{ x = point.x, z = point.z, radius = 6600 })
|
|
for _, groupName in pairs(groups) do
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.capGroupsOnAirbase[baseId], groupName)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- missionZoneName <> groupname[]
|
|
o.tables.groupsInMissionZone = {}
|
|
local loadMissionzoneUnits = function()
|
|
local all_groups = getAvailableGroups()
|
|
for _, missionZoneName in pairs(o.tables.mission_zones) do
|
|
o.tables.groupsInMissionZone[missionZoneName] = {}
|
|
local groups = Spearhead.DcsUtil.getGroupsInZone(all_groups, missionZoneName)
|
|
for _, groupName in pairs(groups) do
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.groupsInMissionZone[missionZoneName], groupName)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- missionZoneName <> groupname[]
|
|
o.tables.groupsInRandomMissions = {}
|
|
local loadRandomMissionzoneUnits = function()
|
|
local all_groups = getAvailableGroups()
|
|
for _, missionZoneName in pairs(o.tables.random_mission_zones) do
|
|
o.tables.groupsInRandomMissions[missionZoneName] = {}
|
|
local groups = Spearhead.DcsUtil.getGroupsInZone(all_groups, missionZoneName)
|
|
for _, groupName in pairs(groups) do
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.groupsInRandomMissions[missionZoneName], groupName)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- farpZoneName <> groupname[]
|
|
o.tables.groupsInFarpZone = {}
|
|
local loadFarpGroups = function()
|
|
local all_groups = getAvailableGroups()
|
|
for _, farpZone in pairs(o.tables.farp_zones) do
|
|
o.tables.groupsInFarpZone[farpZone] = {}
|
|
local groups = Spearhead.DcsUtil.getGroupsInZone(all_groups, farpZone)
|
|
for _, groupName in pairs(groups) do
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.groupsInFarpZone[farpZone], groupName)
|
|
end
|
|
end
|
|
end
|
|
|
|
--- farpZoneName <> groupname[]
|
|
o.tables.redAirbaseGroupsPerAirbase = {}
|
|
o.tables.blueAirbaseGroupsPerAirbase = {}
|
|
local loadAirbaseGroups = function()
|
|
local all_groups = getAvailableGroups()
|
|
local airbases = world.getAirbases()
|
|
for _, airbase in pairs(airbases) do
|
|
local baseId = tostring(airbase:getID())
|
|
local point = airbase:getPoint()
|
|
|
|
if isAirbaseInZone[tostring(baseId) or "something" ] == true and airbase:getDesc().Category == Airbase.Category.AIRDROME then
|
|
o.tables.redAirbaseGroupsPerAirbase[baseId] = {}
|
|
o.tables.blueAirbaseGroupsPerAirbase[baseId] = {}
|
|
local groups = Spearhead.DcsUtil.areGroupsInCustomZone(all_groups, { x = point.x, z = point.z, radius = 6600 })
|
|
for _, groupName in pairs(groups) do
|
|
|
|
if Spearhead.DcsUtil.IsGroupStatic(groupName) == true then
|
|
local object = StaticObject.getByName(groupName)
|
|
if object then
|
|
if object:getCoalition() == coalition.side.RED then
|
|
table.insert(o.tables.redAirbaseGroupsPerAirbase[baseId], groupName)
|
|
is_group_taken[groupName] = true
|
|
elseif object:getCoalition() == coalition.side.BLUE then
|
|
table.insert(o.tables.blueAirbaseGroupsPerAirbase[baseId], groupName)
|
|
is_group_taken[groupName] = true
|
|
end
|
|
end
|
|
else
|
|
local group = Group.getByName(groupName)
|
|
if group then
|
|
if group:getCoalition() == coalition.side.RED then
|
|
table.insert(o.tables.redAirbaseGroupsPerAirbase[baseId], groupName)
|
|
is_group_taken[groupName] = true
|
|
elseif group:getCoalition() == coalition.side.BLUE then
|
|
table.insert(o.tables.blueAirbaseGroupsPerAirbase[baseId], groupName)
|
|
is_group_taken[groupName] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
o.tables.miscGroupsInStages = {}
|
|
local loadMiscGroupsInStages = function ()
|
|
local all_groups = getAvailableGroups()
|
|
for _, stage_zone in pairs(o.tables.stage_zones) do
|
|
o.tables.miscGroupsInStages[stage_zone] = {}
|
|
local groups = Spearhead.DcsUtil.getGroupsInZone(all_groups, stage_zone)
|
|
for _, groupName in pairs(groups) do
|
|
if Spearhead.DcsUtil.IsGroupStatic(groupName) == true then
|
|
local object = StaticObject.getByName(groupName)
|
|
if object and object:getCoalition() ~= coalition.side.NEUTRAL then
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.miscGroupsInStages[stage_zone], groupName)
|
|
end
|
|
else
|
|
local group = Group.getByName(groupName)
|
|
if group and group:getCoalition() ~= coalition.side.NEUTRAL then
|
|
is_group_taken[groupName] = true
|
|
table.insert(o.tables.miscGroupsInStages[stage_zone], groupName)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
loadCapUnits()
|
|
loadMissionzoneUnits()
|
|
loadRandomMissionzoneUnits()
|
|
loadFarpGroups()
|
|
loadAirbaseGroups()
|
|
loadMiscGroupsInStages()
|
|
|
|
Logger:debug(o.tables.miscGroupsInStages)
|
|
|
|
local cleanup = function () --CLean up all groups that are now managed inside zones by spearhead
|
|
|
|
local count = 0
|
|
for name, taken in pairs(is_group_taken) do
|
|
if taken == true then
|
|
Spearhead.DcsUtil.DestroyGroup(name)
|
|
count = count + 1
|
|
end
|
|
end
|
|
Logger:info("Destroyed " .. count .. " units that are now managed in zones by Spearhead")
|
|
end
|
|
cleanup()
|
|
|
|
--- key: zoneName value: { current, routes = [ { point1, point2 } ] }
|
|
o.tables.capRoutes = {}
|
|
for _, zoneName in pairs(o.tables.stage_zones) do
|
|
|
|
local configValue = {
|
|
current = 0,
|
|
routes = {}
|
|
}
|
|
for _, cap_route_zone in pairs(o.tables.cap_route_zones) do
|
|
if Spearhead.DcsUtil.isZoneInZone(cap_route_zone, zoneName) == true then
|
|
local zone = Spearhead.DcsUtil.getZoneByName(cap_route_zone)
|
|
if zone then
|
|
if zone.zone_type == Spearhead.DcsUtil.ZoneType.Cilinder then
|
|
table.insert(configValue.routes, { point1 = { x = zone.x , z = zone.z }, point2 = nil } )
|
|
else
|
|
local function getDist(a, b)
|
|
return math.sqrt((b.x - a.x) ^ 2 + (b.z - a.z) ^ 2)
|
|
end
|
|
|
|
local biggest = nil
|
|
local biggestA = nil
|
|
local biggestB = nil
|
|
|
|
for i=1, 3 do
|
|
for ii = i + 1, 4 do
|
|
|
|
local a = zone.verts[i]
|
|
local b = zone.verts[ii]
|
|
local dist = getDist(a,b)
|
|
|
|
if biggest == nil or dist > biggest then
|
|
biggestA = a
|
|
biggestB = b
|
|
biggest = dist
|
|
end
|
|
end
|
|
end
|
|
|
|
if biggestA and biggestB then
|
|
table.insert(configValue.routes,
|
|
{
|
|
point1 = { x = biggestA.x , z = biggestA.z },
|
|
point2 = { x = biggestB.x , z = biggestB.z }
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
o.tables.capRoutes[zoneName] = configValue
|
|
end
|
|
|
|
o.tables.missionCodes = {}
|
|
end
|
|
|
|
o.GetDescriptionForMission = function(self, missionZoneName)
|
|
return self.tables.descriptions[missionZoneName]
|
|
end
|
|
|
|
o.getCapRouteInZone = function(self, targetZone, baseId)
|
|
|
|
local routeData = self.tables.capRoutes[targetZone]
|
|
if routeData then
|
|
local count = Spearhead.Util.tableLength(routeData.routes)
|
|
if count > 0 then
|
|
routeData.current = routeData.current + 1
|
|
if count < routeData.current then
|
|
routeData.current = 1
|
|
end
|
|
|
|
return routeData.routes[routeData.current]
|
|
end
|
|
end
|
|
do
|
|
local function GetClosestPointOnCircle(pC, radius, p)
|
|
local vX = p.x - pC.x;
|
|
local vY = p.z - pC.z;
|
|
local magV = math.sqrt(vX*vX + vY*vY);
|
|
local aX = pC.x + vX / magV * radius;
|
|
local aY = pC.z + vY / magV * radius;
|
|
return { x = aX, z = aY }
|
|
end
|
|
local stagezone = Spearhead.DcsUtil.getZoneByName(targetZone)
|
|
if stagezone then
|
|
local base = Spearhead.DcsUtil.getAirbaseById(baseId)
|
|
if base then
|
|
local closest = nil
|
|
if stagezone.zone_type == Spearhead.DcsUtil.ZoneType.Cilinder then
|
|
closest = GetClosestPointOnCircle({x = stagezone.x, z = stagezone.z}, stagezone.radius, base:getPoint())
|
|
else
|
|
local function getDist(a, b)
|
|
return math.sqrt((b.x - a.x) ^ 2 + (b.z - a.z) ^ 2)
|
|
end
|
|
|
|
local closestDistance = -1
|
|
for _, vert in pairs(stagezone.verts) do
|
|
local distance = getDist(vert, base:getPoint())
|
|
if closestDistance == -1 or distance < closestDistance then
|
|
closestDistance = distance
|
|
closest = vert
|
|
end
|
|
end
|
|
end
|
|
|
|
if math.random(1,2)%2 == 0 then
|
|
return { point1 = closest, point2 = {x = stagezone.x, z = stagezone.z} }
|
|
else
|
|
return { point1 = {x = stagezone.x, z = stagezone.z}, point2 = closest }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
---comment
|
|
---@param self table
|
|
---@param number number
|
|
---@return string zoneName
|
|
o.getStageZoneByStageNumber = function (self, number)
|
|
local numberString = tostring(number)
|
|
return self.tables.stage_zonesByNumer[numberString]
|
|
end
|
|
|
|
---comment
|
|
---@param self table
|
|
---@return table result a list of stage zone names
|
|
o.getStagezoneNames = function (self)
|
|
return self.tables.stage_zones
|
|
end
|
|
|
|
o.getMissionsForStage = function (self, stagename)
|
|
return self.tables.missionZonesPerStage[stagename] or {}
|
|
end
|
|
|
|
o.getRandomMissionsForStage = function(self, stagename)
|
|
return self.tables.randomMissionZonesPerStage[stagename] or {}
|
|
end
|
|
|
|
o.getGroupsForMissionZone = function (self, missionZoneName)
|
|
if Spearhead.Util.startswith(missionZoneName, "RANDOMMISSION") == true then
|
|
return self.tables.groupsInRandomMissions[missionZoneName] or {}
|
|
end
|
|
return self.tables.groupsInMissionZone[missionZoneName] or {}
|
|
end
|
|
|
|
o.getMissionBriefingForMissionZone = function (self, missionZoneName)
|
|
return self.tables.descriptions[missionZoneName] or ""
|
|
end
|
|
|
|
---comment
|
|
---@param self table
|
|
---@param stageName string
|
|
---@return table result airbase IDs. Use Spearhead.DcsUtil.getAirbaseById
|
|
o.getAirbaseIdsInStage = function (self, stageName)
|
|
return self.tables.airbasesPerStage[stageName] or {}
|
|
end
|
|
|
|
o.getFarpZonesInStage = function (self, stageName)
|
|
return self.tables.farpZonesPerStage[stageName]
|
|
end
|
|
|
|
---comment
|
|
---@param self table
|
|
---@param airbaseId number
|
|
---@return table
|
|
o.getCapGroupsAtAirbase = function(self, airbaseId)
|
|
return self.tables.capGroupsOnAirbase[airbaseId] or {}
|
|
end
|
|
|
|
o.getRedGroupsAtAirbase = function (self, airbaseId)
|
|
local baseId = tostring(airbaseId)
|
|
return self.tables.redAirbaseGroupsPerAirbase[baseId] or {}
|
|
end
|
|
|
|
o.getBlueGroupsAtAirbase = function (self, airbaseId)
|
|
local baseId = tostring(airbaseId)
|
|
return self.tables.blueAirbaseGroupsPerAirbase[baseId] or {}
|
|
end
|
|
|
|
o.getMiscGroupsAtStage = function(self, stageName)
|
|
return self.tables.miscGroupsInStages[stageName] or {}
|
|
end
|
|
|
|
o.GetNewMissionCode = function (self)
|
|
local code = nil
|
|
local tries = 0
|
|
while code == nil and tries < 10 do
|
|
local random = math.random(1000, 9999)
|
|
if self.tables.missionCodes[random] == nil then
|
|
code = random
|
|
end
|
|
tries = tries + 1
|
|
end
|
|
return code
|
|
|
|
--[[
|
|
TODO: What to do when there's no random possible
|
|
]]
|
|
end
|
|
|
|
do -- LOG STATE
|
|
Logger:info("initiated the database with amount of zones: ")
|
|
Logger:info("Stages: " .. Spearhead.Util.tableLength(o.tables.stage_zones))
|
|
Logger:info("Missions: " .. Spearhead.Util.tableLength(o.tables.mission_zones))
|
|
Logger:info("Random Missions: " .. Spearhead.Util.tableLength(o.tables.random_mission_zones))
|
|
Logger:info("Farps: " .. Spearhead.Util.tableLength(o.tables.farp_zones))
|
|
Logger:info("Airbases: " .. Spearhead.Util.tableLength(o.tables.airbasesPerStage))
|
|
Logger:info("RedAirbase Groups: " .. Spearhead.Util.tableLength(o.tables.redAirbaseGroupsPerAirbase["21"]))
|
|
Spearhead.Util.tableLength(o.tables.airbasesPerStage)
|
|
end
|
|
singleton = o
|
|
return o
|
|
end
|
|
end
|
|
|
|
Spearhead.DB = SpearheadDB
|