mirror of
https://github.com/FlightControl-Master/MOOSE_MISSIONS.git
synced 2026-08-27 15:37:03 +00:00
funkyfranky
1749 lines
62 KiB
Lua
1749 lines
62 KiB
Lua
--[[
|
|
Copyright (c) 2016 Snafu, Stonehouse, Rivvern, Chameleon Silk, lukrop.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute copies of the Software,
|
|
and to permit persons to whom the Software is furnished to do so, subject to
|
|
the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software and the Software shall not be
|
|
included in whole or part in any sort of paid for software or paid for downloadable
|
|
content (DLC) without the express permission of the copyright holders.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
]]
|
|
|
|
--[[--
|
|
## Overview
|
|
Autonomous GCI and CAP script for DCS: World.
|
|
The script provides an autonomous model of combat air patrols and ground controlled
|
|
interceptors for use with DCS World by mission builders.
|
|
|
|
After minimal setup the script will automatically spawn CAP and GCI flights for two
|
|
sides and give them patrol and intercept tasks as well as returning them to base when
|
|
threats cease to be detected.
|
|
|
|
Originally created by Snafu, enhanced and further modified by Stonehouse,
|
|
Rivvern, Chameleon Silk.
|
|
|
|
Rewritten by lukrop.
|
|
|
|
## Links
|
|
|
|
Github repository: <https://github.com/lukrop/GCICAP>
|
|
|
|
@script GCICAP
|
|
@author Snafu
|
|
@author Stonehouse
|
|
@author Rivvern
|
|
@author Chameleon Silk
|
|
@author lukrop
|
|
@copyright 2016 Snafu, Stonehouse, Rivvern, Chameleon Silk, lukrop.
|
|
@license Modified MIT. See LICENSE file.
|
|
]]
|
|
|
|
gcicap = {}
|
|
gcicap.red = {}
|
|
gcicap.red.gci = {}
|
|
gcicap.red.cap = {}
|
|
gcicap.blue = {}
|
|
gcicap.blue.gci = {}
|
|
gcicap.blue.cap = {}
|
|
gcicap.cap = {}
|
|
gcicap.gci = {}
|
|
|
|
--- Sets how verbose the log output will be.
|
|
-- Possible values are "none", "info", "warning" and "error".
|
|
-- I recommend "error" for production.
|
|
gcicap.log_level = "error"
|
|
|
|
--- Interval, in seconds, of main function.
|
|
-- Default 30 seconds.
|
|
gcicap.interval = 30
|
|
|
|
--- Interval, in seconds, GCI flights get vectors on targets.
|
|
-- AI GCI flights don't use their radar, to be as stealth as
|
|
-- possible, relying on those vectors.
|
|
-- Default 15 seconds.
|
|
gcicap.vector_interval = 15
|
|
|
|
--- How far does a target have to move before an intercept is revectored
|
|
gcicap.revector_threshold = 15000
|
|
|
|
--- Initial spawn delay between CAPs
|
|
-- Default 30 seconds.
|
|
gcicap.initial_spawn_delay = 30
|
|
|
|
--- Enable/disable borders for the red side.
|
|
-- CAP units only engage if enemy units intrude their airspace
|
|
gcicap.red.borders_enabled = true
|
|
|
|
--- Enable/disable borders for the blue side.
|
|
-- CAP units only engage if enemy units intrude their airspace
|
|
gcicap.blue.borders_enabled = true
|
|
|
|
--- CAP minimum altitudes in meters.
|
|
-- Default 4500
|
|
gcicap.cap.min_alt = 6100
|
|
|
|
--- CAP maximum altitudes in meters.
|
|
-- Default 7500
|
|
gcicap.cap.max_alt = 10500
|
|
|
|
--- Speed for CAP flights on their CAP route.
|
|
-- speed is in m/s. Default 220.
|
|
gcicap.cap.speed = 220
|
|
|
|
--- Speed for GCI flights on intercept
|
|
-- speed is in m/s. Default 300.
|
|
gcicap.gci.speed = 300
|
|
|
|
--- Maximum engage distance for CAP flights as long as they are on patrol.
|
|
-- this might be overruled by an intercept vector given from
|
|
-- ground control (EWR). Default 15000.
|
|
gcicap.cap.max_engage_distance = 15000
|
|
|
|
--- Minimum red CAP VUL time in minutes.
|
|
-- Minimum time the red CAP flight will orbit on station.
|
|
gcicap.red.cap.vul_time_min = 25
|
|
|
|
--- Maximum red CAP VUL time in minutes.
|
|
-- Maximum time the red CAP flight will orbit on station.
|
|
gcicap.red.cap.vul_time_max = 40
|
|
|
|
--- Minimum blue CAP VUL time in minutes.
|
|
gcicap.blue.cap.vul_time_min = 25
|
|
|
|
--- Maximum blue CAP VUL time in minutes.
|
|
gcicap.blue.cap.vul_time_max = 30
|
|
|
|
--- Use race-track orbit for CAP flights
|
|
-- If true CAPs will use a race-track pattern for orbit
|
|
-- between two points in the CAP zone.
|
|
gcicap.cap.race_track_orbit = false
|
|
|
|
--[[ INOP at the time
|
|
--- Minimum leg length for red CAP orbits in meters.
|
|
gcicap.red.cap.leg_min = 10000
|
|
|
|
--- Maximum leg length for red CAP orbits in meters.
|
|
gcicap.red.cap.leg_min = 20000
|
|
|
|
--- Minimum leg length for blue CAP orbits in meters.
|
|
gcicap.blue.cap.leg_min = 10000
|
|
|
|
--- Maximum leg length for blue CAP orbits in meters.
|
|
gcicap.blue.cap.leg_min = 20000
|
|
]]--
|
|
|
|
--- Enable/disable red CAP flights airborne start.
|
|
-- set to true for CAP flight to start airborne at script initialisation
|
|
-- (mission start), false for taking off from the airfield.
|
|
-- Default true.
|
|
gcicap.red.cap.start_airborne = false
|
|
|
|
--- Enable/disable blue CAP flights airborne start.
|
|
gcicap.blue.cap.start_airborne = false
|
|
|
|
--- Amount of red CAP zones.
|
|
-- placed with triggerzones in the ME.
|
|
gcicap.red.cap.zones_count = 4
|
|
|
|
--- Amount of blue CAP zones.
|
|
gcicap.blue.cap.zones_count = 4
|
|
|
|
--- Amount of red CAP groups concurrently in the air.
|
|
gcicap.red.cap.groups_count = 3
|
|
|
|
--- Amount of blue CAP groups concurrently in the air.
|
|
gcicap.blue.cap.groups_count = 2
|
|
|
|
--- Group size of red CAP flights.
|
|
-- Can be "2", "4" or "randomized"
|
|
--
|
|
-- If "2" it consists of 2 planes, if "4" it consists of 4 planes
|
|
-- if "randomized", the CAP groups consist of either 2 or 4 planes
|
|
gcicap.red.cap.group_size = "randomized"
|
|
|
|
--- Group size of blue CAP flights.
|
|
-- See @{gcicap.red.cap.group_size}
|
|
gcicap.blue.cap.group_size = "4"
|
|
|
|
--- Maximum amount of concurrent red intercepts.
|
|
gcicap.red.gci.groups_count = 3
|
|
|
|
--- Maximum amount of concurrent blue intercepts.
|
|
gcicap.blue.gci.groups_count = 2
|
|
|
|
--- Group size of red GCI flights.
|
|
-- Can be "2", "4" or "dynamic"
|
|
--
|
|
-- If "2" it consists of 2 planes, if "4" it consists of 4 planes
|
|
-- if "dynamic", the GCI groups consist of as much aircrafts
|
|
-- as the intruder group.
|
|
gcicap.red.gci.group_size = "dynamic"
|
|
|
|
--- Group size of blue GCI flights.
|
|
-- See @{gcicap.red.gci.group_size}
|
|
gcicap.blue.gci.group_size = "dynamic"
|
|
|
|
--- Enable/disable GCI messages for red
|
|
gcicap.red.gci.messages = false
|
|
|
|
--- Enable/disable GCI messages for blue
|
|
gcicap.blue.gci.messages = false
|
|
|
|
--- How long a GCI message will be shown in seconds.
|
|
gcicap.gci.message_time = 5
|
|
|
|
--- Display GCI messages with metric measurment for red.
|
|
-- If false the imperial system is used.
|
|
gcicap.red.gci.messages_metric = true
|
|
|
|
--- Display GCI messages with metric measurment for blue.
|
|
-- If false the imperial system is used.
|
|
gcicap.blue.gci.messages_metric = false
|
|
|
|
--- Names of red groups which will receive GCI messages.
|
|
-- Leave blank for all groups of coalition
|
|
-- @usage gcicap.red.gci.messages_to = { "my group 1", "GCI Flight" }
|
|
gcicap.red.gci.messages_to = {}
|
|
|
|
--- Names of blue groups which will receive GCI messages.
|
|
-- See @{gcicap.red.gci.messages_to} for format.
|
|
gcicap.blue.gci.messages_to = {}
|
|
|
|
--- How red CAP flights are spawned.
|
|
-- can be "parking", "takeoff" or "air" and defines the way the fighters spawn
|
|
-- takeoff is NOT RECOMMENDED currently since their occur timing issues with tasking
|
|
-- if a flight is queued for takeoff and not already in the game world while getting tasked
|
|
--
|
|
-- Default 'parking'
|
|
gcicap.red.cap.spawn_mode = "parking"
|
|
|
|
--- How red GCI flights are spawned.
|
|
-- @see gcicap.red.cap.spawn_mode
|
|
gcicap.red.gci.spawn_mode = "parking"
|
|
|
|
--- How blue CAP flights are spawned.
|
|
-- @see gcicap.red.cap.spawn_mode
|
|
gcicap.blue.cap.spawn_mode = "parking"
|
|
|
|
--- How blue GCI flights are spawned.
|
|
-- @see gcicap.red.cap.spawn_mode
|
|
gcicap.blue.gci.spawn_mode = "parking"
|
|
|
|
--- Hide or reveal blue air units in the mission.
|
|
gcicap.blue.hide_groups = false
|
|
|
|
--- Hide or reveal red air units in the mission.
|
|
gcicap.red.hide_groups = false
|
|
|
|
--- Enable/disable red CAP flights.
|
|
gcicap.red.cap.enabled = true
|
|
|
|
--- Enable/disable blue CAP flights.
|
|
gcicap.blue.cap.enabled = true
|
|
|
|
--- Enable/disable red GCI flights.
|
|
gcicap.red.gci.enabled = true
|
|
|
|
--- Enable/disable blue GCI flights.
|
|
gcicap.blue.gci.enabled = true
|
|
|
|
--- Enabel/disable resource limitation for red.
|
|
-- If set to true limits the amount of groups a side can spawn.
|
|
gcicap.red.limit_resources = false
|
|
|
|
--- Enabel/disable resource limitation for blue.
|
|
-- @see gcicap.red.limit_resources
|
|
gcicap.blue.limit_resources = false
|
|
|
|
--- Amount of groups(!) red has at it's disposal.
|
|
-- In other words how many Groups of airplanes
|
|
-- this side can spawn.
|
|
gcicap.red.supply = 24
|
|
|
|
--- Amount of groups(!) red has at it's disposal.
|
|
-- @see gcicap.red.supply
|
|
gcicap.blue.supply = 24
|
|
|
|
--- Name of the trigger zone which defines red CAP zones.
|
|
-- This will be postfixed with the number of
|
|
-- the zone. e.g. "redCAPzone3" or "blueCAPzone1".
|
|
--
|
|
-- Default: 'redCAPzone'.
|
|
gcicap.red.cap.zone_name = 'redCAPzone'
|
|
|
|
--- Name of the trigger zone which defines blue CAP zones.
|
|
-- Default: 'blueCAPzone'.
|
|
-- @see gcicap.red.cap.zone_name
|
|
gcicap.blue.cap.zone_name = 'blueCAPzone'
|
|
|
|
--- Name of group which waypoints define the red border.
|
|
-- Default: 'redborder'.
|
|
gcicap.red.border_group = 'redborder'
|
|
|
|
--- Name of group which waypoints define the blue border.
|
|
-- Default: 'blueborder'.
|
|
gcicap.blue.border_group = 'blueborder'
|
|
|
|
--- GCI template unit's names prefix.
|
|
gcicap.gci.template_prefix = '__GCI__'
|
|
|
|
--- CAP template unit's names prefix.
|
|
gcicap.cap.template_prefix = '__CAP__'
|
|
|
|
--- Count of template units.
|
|
-- Remember that this means you need that many
|
|
-- template units for each type. E.g. if the template_count is 2 you
|
|
-- would need two GCI and two CAP template units for each side.
|
|
gcicap.template_count = 4
|
|
|
|
--- Wether red will also acquire targets by AWACS aircraft.
|
|
-- This is is currently broken since isTargetDetected doesn't
|
|
-- seem to work with AWACS airplanes. Needs a workaround.
|
|
--
|
|
-- Default false.
|
|
gcicap.red.awacs = false
|
|
|
|
--- Wether blue will also acquire targets by AWACS aircraft.
|
|
-- @see gcicap.red.awacs
|
|
gcicap.blue.awacs = true
|
|
|
|
--- Garbage collector move timeout
|
|
-- If a unit (aircraft) is on the ground and didn't move
|
|
-- since this timeout, in seconds, it will be removed.
|
|
-- This applies only to aircraft spawned by GCICAP.
|
|
gcicap.move_timeout = 300
|
|
|
|
-- shortcut to the bullseye
|
|
gcicap.red.bullseye = coalition.getMainRefPoint(coalition.side.RED)
|
|
gcicap.blue.bullseye = coalition.getMainRefPoint(coalition.side.BLUE)
|
|
|
|
gcicap.sides = { "red", "blue" }
|
|
gcicap.tasks = { "cap", "gci" }
|
|
|
|
gcicap.log = mist.Logger:new("GCICAP", gcicap.log_level)
|
|
|
|
do
|
|
--- Flight class.
|
|
-- @type gcicap.Flight
|
|
gcicap.Flight = {}
|
|
|
|
local function getFlightIndex(group)
|
|
if type(group) ~= "string" then
|
|
if group:getName() then
|
|
group = group:getName()
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
for i, side in pairs(gcicap.sides) do
|
|
for j, task in pairs(gcicap.tasks) do
|
|
for n = 1, #gcicap[side][task].flights do
|
|
if gcicap[side][task].flights[n].group_name == group then
|
|
return {side = side, task = task, index = n}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--- Returns the flight for the given group.
|
|
-- @tparam string|Group group this can be a Group object
|
|
-- or the group name.
|
|
-- @treturn gcicap.Flight the flight for the given group.
|
|
function gcicap.Flight.getFlight(group)
|
|
f = getFlightIndex(group)
|
|
if f then
|
|
return gcicap[f.side][f.task].flights[f.index]
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
--- Creates a new flight.
|
|
-- @tparam Group group group of the flight.
|
|
-- @tparam Airbase airbase homplate of the new flight.
|
|
-- @tparam string task task of the new flight. Can be "cap" or "gci".
|
|
-- @param param task parameter. This can be a zone table if it's a
|
|
-- CAP flight or it could be a target unit if it's a GCI flight.
|
|
function gcicap.Flight:new(group, airbase, task, param)
|
|
if group:isExist() then
|
|
local side = gcicap.coalitionToSide(group:getCoalition())
|
|
local f = {}
|
|
f.side = side
|
|
f.give_up = false
|
|
f.group = group
|
|
f.group_name = group:getName()
|
|
f.airbase = airbase
|
|
f.task = task
|
|
-- is the flight RTB?
|
|
f.rtb = false
|
|
f.in_zone = false
|
|
|
|
if task == "cap" then
|
|
f.zone = param
|
|
f.zone_name = param.name
|
|
f.intercepting = false
|
|
f.vul_time = math.random(gcicap[side].cap.vul_time_min,
|
|
gcicap[side].cap.vul_time_max)
|
|
else -- task should be "gci"
|
|
f.target = param
|
|
f.target_group = param.group
|
|
f.intercepting = true
|
|
f.intercept_point = { x = 0, y = 0, z = 0 }
|
|
end
|
|
|
|
-- get current timestamp
|
|
local timestamp = timer.getAbsTime()
|
|
f.units_moved = {}
|
|
-- set timestamp for each unit
|
|
-- this is later used for garbage collection checks
|
|
for u, unit in pairs(group:getUnits()) do
|
|
f.units_moved[u] = {}
|
|
f.units_moved[u].unit = unit
|
|
f.units_moved[u].last_moved = timestamp
|
|
f.units_moved[u].spawned_at = timestamp
|
|
end
|
|
|
|
setmetatable(f, self)
|
|
self.__index = self
|
|
|
|
table.insert(gcicap[side][task].flights, f)
|
|
gcicap.log:info("Registered flight: $1", f.group_name)
|
|
|
|
return f
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
--- Removes the flight
|
|
-- @tparam gcicap.Flight self flight object
|
|
function gcicap.Flight:remove()
|
|
if self.zone then
|
|
-- if we didn't already leave the zone do it now.
|
|
self:leaveCAPZone()
|
|
end
|
|
local f = getFlightIndex(self.group_name)
|
|
local r = table.remove(gcicap[f.side][f.task].flights, f.index)
|
|
if r then
|
|
gcicap.log:info("Removing flight $1 with index $2", r.group_name, f.index)
|
|
end
|
|
end
|
|
|
|
--- Decreases active flights counter in this flights zone.
|
|
-- Actually just decreases the active flights
|
|
-- counter of a zone. Does NOT task the flight itself.
|
|
function gcicap.Flight:leaveCAPZone()
|
|
if self.in_zone then
|
|
local zone = self.zone
|
|
if zone.patrol_count <= 1 then
|
|
zone.patrol_count = 0
|
|
else
|
|
zone.patrol_count = zone.patrol_count - 1
|
|
end
|
|
self.in_zone = false
|
|
|
|
-- get current time
|
|
local time_now = timer.getAbsTime()
|
|
-- get time on station by substracting vul start time from current time
|
|
-- and convert it to minutes
|
|
local time_on_station = 0
|
|
if self.vul_start then
|
|
time_on_station = (time_now - self.vul_start) / 60
|
|
end
|
|
local vul_diff = self.vul_time - time_on_station
|
|
-- set new vul time only if more than 5 minutes
|
|
if vul_diff > 5 then
|
|
self.vul_time = vul_diff
|
|
else
|
|
self.vul_time = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
--- Increases active flights counter in this flights zone.
|
|
-- Actually just increases the active flights
|
|
-- counter of a zone. Does NOT task the flight itself.
|
|
function gcicap.Flight:enterCAPZone()
|
|
if not self.in_zone then
|
|
self.intercepting = false
|
|
self.in_zone = true
|
|
local zone = self.zone
|
|
zone.patrol_count = zone.patrol_count + 1
|
|
end
|
|
end
|
|
|
|
--- Tasks the flight to search and engage the target.
|
|
-- @tparam Unit intruder target unit.
|
|
-- @tparam[opt] boolean cold whether the flight should not destroy
|
|
-- the target and just follow it. Default false.
|
|
function gcicap.Flight:vectorToTarget(intruder, cold)
|
|
local target = nil
|
|
if intruder.group then
|
|
target = gcicap.getFirstActiveUnit(intruder.group)
|
|
end
|
|
if target == nil or intruder.group == nil then return end
|
|
|
|
-- check if interceptor even still exists
|
|
if self.group:isExist() then
|
|
if target:isExist() and target:inAir() and self.give_up ~= true then
|
|
local target_pos = target:getPoint()
|
|
local ctl = self.group:getController()
|
|
|
|
local gci_task = {
|
|
id = 'Mission',
|
|
params = {
|
|
route = {
|
|
points = {
|
|
[1] = {
|
|
alt = target_pos.y,
|
|
x = target_pos.x,
|
|
y = target_pos.z,
|
|
speed = gcicap.gci.speed,
|
|
action = "Turning Point",
|
|
type = "Turning Point",
|
|
task = {
|
|
id = "ComboTask",
|
|
params = {
|
|
tasks = {
|
|
[1] = {
|
|
number = 1,
|
|
key = "CAP",
|
|
id = "EngageTargets",
|
|
enabled = true,
|
|
auto = true,
|
|
params = {
|
|
targetTypes = { [1] = "Air" },
|
|
priority = 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
[2] = {
|
|
alt = target_pos.y,
|
|
x = target_pos.x,
|
|
y = target_pos.z,
|
|
speed = gcicap.gci.speed,
|
|
action = "Turning Point",
|
|
type = "Turning Point",
|
|
task = {
|
|
-- i don't really like this WrappedAction but it's needed in
|
|
-- the case the CGI completes this waypoint because of lack/loss
|
|
-- of target
|
|
id = 'WrappedAction',
|
|
params = {
|
|
action = {
|
|
id = 'Script',
|
|
params = {
|
|
command = "local group = ...\
|
|
local flight = gcicap.Flight.getFlight(group)\
|
|
if flight then\
|
|
flight.give_up = true\
|
|
if flight.zone then\
|
|
if flight.intercepting then\
|
|
flight:taskWithCAP()\
|
|
end\
|
|
else\
|
|
if not flight.target then\
|
|
flight:taskWithRTB()\
|
|
end\
|
|
end\
|
|
else\
|
|
gcicap.log:error('Could not find flight')\
|
|
end"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
-- checkout of the patrol zone
|
|
if self.zone and not self.intercepting then
|
|
self:leaveCAPZone()
|
|
end
|
|
|
|
intruder.intercepted = true
|
|
-- only set/reset the task if the target has moved significantly since last GCI update
|
|
if mist.utils.get3DDist( target_pos, self.intercept_point ) > gcicap.revector_threshold then
|
|
-- if there's still an EWR detecting or we are responding to the initial call
|
|
-- then set the target position. do not allow revectoring if no EWR is detecting us now
|
|
if (Unit.isExist(intruder.detected_by) and intruder.detected_by:isActive()) then
|
|
self.give_up = false
|
|
self.intercept_point = mist.utils.deepCopy(target_pos)
|
|
ctl:setTask(gci_task)
|
|
gcicap.log:info("Vectoring $1 to $2 ($3)", self.group:getName(),
|
|
intruder.group:getName(), target:getName())
|
|
|
|
else
|
|
gcicap.log:info("Cannot revector $1 to $2 because no longer detecting",self.group:getName(),intruder.group:getName())
|
|
end
|
|
end
|
|
self.intercepting = true
|
|
|
|
-- taskEngageGroup provides omniscient knowledge of where the group to be attacked is, which sucks
|
|
if not cold then
|
|
--gcicap.taskEngageGroup(self.group, intruder.group)
|
|
gcicap.taskEngage(self.group, 15000)
|
|
end
|
|
|
|
-- reschedule function until either the interceptor or the intruder is dead
|
|
mist.scheduleFunction(gcicap.Flight.vectorToTarget, {self, intruder, cold},
|
|
timer.getTime() + gcicap.vector_interval)
|
|
|
|
else -- the target is dead or we had to give up, resume CAP or RTB
|
|
if self.zone then
|
|
-- send CAP back to work only if still intercepting
|
|
if self.intercepting then
|
|
self:taskWithCAP()
|
|
end
|
|
else
|
|
self.intercepting = false
|
|
-- send GCI back to homeplate
|
|
self:taskWithRTB()
|
|
end
|
|
end
|
|
else
|
|
-- our interceptor group is dead let's see if the
|
|
-- intruder is still there and set him to not beeing intercepted anymore
|
|
if target:isExist() then
|
|
intruder.intercepted = false
|
|
end
|
|
end
|
|
end
|
|
|
|
--- Tasks flight with combat air patrol.
|
|
-- Creates waypoints inside it's assigned zone and tasks
|
|
-- the flight with patroling along the route.
|
|
-- @tparam[opt] boolean cold If set to true the flight won't
|
|
-- engage any enemy unit's it detects by itself. Default false.
|
|
function gcicap.Flight:taskWithCAP(cold)
|
|
-- only task with CAP if ther is still vul time left
|
|
if self.vul_time == 0 then
|
|
-- send flight RTB if no vul time left.
|
|
gcicap.log:info("No vul time left for $1", self.group_name)
|
|
self:taskWithRTB()
|
|
else
|
|
local group = self.group
|
|
local ctl = group:getController()
|
|
local side = gcicap.coalitionToSide(group:getCoalition())
|
|
local start_pos = gcicap.getFirstActiveUnit(group):getPoint()
|
|
local leg_dist = math.random(gcicap[side].cap.leg_min, gcicap[side].cap.leg_max)
|
|
local cap_route = gcicap.buildCAPRoute(start_pos, self.zone.name, self.vul_time, leg_dist)
|
|
local cap_task = {
|
|
id = 'Mission',
|
|
params = {
|
|
route = cap_route
|
|
}
|
|
}
|
|
|
|
self.intercepting = false
|
|
self.intercept_point = { x = 0, y = 0, z = 0 }
|
|
ctl:setTask(cap_task)
|
|
self:enterCAPZone()
|
|
ctl:setOption(AI.Option.Air.id.RADAR_USING, AI.Option.Air.val.RADAR_USING.FOR_SEARCH_IF_REQUIRED)
|
|
|
|
if not cold then
|
|
gcicap.taskEngage(group)
|
|
end
|
|
gcicap.log:info("Tasking $1 with CAP in zone $2", group:getName(), self.zone.name)
|
|
end
|
|
end
|
|
|
|
--- Tasks the flight to return to it's homeplate.
|
|
-- @tparam[opt] Airbase airbase optionally use this as homeplate/airbase
|
|
-- to return to.
|
|
-- @tparam[opt] boolean cold If set to true the flight won't
|
|
-- engage any targets it detects on the way back to base.
|
|
-- Default false.
|
|
function gcicap.Flight:taskWithRTB(airbase, cold)
|
|
if not airbase then
|
|
airbase = self.airbase
|
|
end
|
|
|
|
if self.zone then
|
|
self:leaveCAPZone()
|
|
local side = self.side
|
|
-- let's try to spawn a new CAP flight as soon as the current one is tasked with RTB.
|
|
-- never spawn more than 2 x the groups_count, to prevent spam in case something ever goes wrong.
|
|
if (not gcicap[side].limit_resources or
|
|
(gcicap[side].limit_resources and gcicap[side].supply > 0))
|
|
and #gcicap[side].cap.flights < gcicap[side].cap.groups_count * 2 then
|
|
gcicap.spawnCAP(side, self.zone, gcicap[side].cap.spawn_mode)
|
|
end
|
|
end
|
|
self.rtb = true
|
|
local group = self.group
|
|
local ctl = group:getController()
|
|
local af_pos = mist.utils.makeVec2(airbase:getPoint())
|
|
local af_id = airbase:getID()
|
|
local rtb_task = {
|
|
id = 'Mission',
|
|
params = {
|
|
route = {
|
|
points = {
|
|
[1] = {
|
|
alt = gcicap.cap.min_alt,
|
|
alt_type = "BARO",
|
|
speed = gcicap.cap.speed,
|
|
x = af_pos.x,
|
|
y = af_pos.y,
|
|
aerodromeId = af_id,
|
|
type = "Land",
|
|
action = "Landing",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ctl:setTask(rtb_task)
|
|
|
|
if not cold then
|
|
-- only engage if enemy is inside of 10km of the leg
|
|
gcicap.taskEngage(group, 10000)
|
|
end
|
|
|
|
gcicap.log:info("Tasking $1 with RTB to $2", group:getName(), airbase:getName())
|
|
end
|
|
|
|
--- Functions
|
|
-- @section gcicap
|
|
|
|
--- Clean up inactive/stuck flights.
|
|
local function garbageCollector(side)
|
|
local timestamp = timer.getAbsTime()
|
|
for t, task in pairs(gcicap.tasks) do
|
|
for f, flight in pairs(gcicap[side][task].flights) do
|
|
if flight.group then
|
|
if flight.group:isExist() then
|
|
for u = 1, #flight.units_moved do
|
|
local unit = flight.units_moved[u].unit
|
|
-- check if unit exists
|
|
if unit then
|
|
if unit:isExist() then
|
|
-- if unit is in air we won't do anything
|
|
if not unit:inAir() then
|
|
-- check if unit is moving
|
|
local mag = mist.vec.mag(unit:getVelocity())
|
|
if mag == 0 then
|
|
-- get the last time the unit moved
|
|
local last_moved = flight.units_moved[u].last_moved
|
|
if timestamp - last_moved > gcicap.move_timeout then
|
|
gcicap.log:info("Cleaning up $1", flight.group:getName())
|
|
flight.group:destroy()
|
|
flight:remove()
|
|
end
|
|
else
|
|
flight.units_moved[u].last_moved = timestamp
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
flight:remove()
|
|
end
|
|
else
|
|
flight:remove()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function checkForTemplateUnits(side)
|
|
if gcicap[side].gci.enabled then
|
|
for i = 1, gcicap.template_count do
|
|
local unit = gcicap.gci.template_prefix..side..i
|
|
if not Unit.getByName(unit) then
|
|
gcicap.log:alert("GCI template unit missing: $1", unit)
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
if gcicap[side].cap.enabled then
|
|
for i = 1, gcicap.template_count do
|
|
local unit = gcicap.cap.template_prefix..side..i
|
|
if not Unit.getByName(unit) then
|
|
gcicap.log:alert("CAP template unit missing: $1", unit)
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
if gcicap[side].borders_enabled then
|
|
if not Group.getByName(gcicap[side].border_group) then
|
|
gcicap.log:alert("Border group is missing: $1", gcicap[side].border_group)
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function checkForTriggerZones(side)
|
|
for i = 1, gcicap[side].cap.zones_count do
|
|
local zone_name = gcicap[side].cap.zone_name..i
|
|
if not trigger.misc.getZone(zone_name) then
|
|
gcicap.log:alert("CAP trigger zone is missing: $1", zone_name)
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function manageCAP(side)
|
|
local patroled_zones = 0
|
|
|
|
for i = 1, #gcicap[side].cap.zones do
|
|
local zone = gcicap[side].cap.zones[i]
|
|
gcicap.log:info("Zone $1 has $2 patrols", zone.name, zone.patrol_count)
|
|
|
|
-- see if we can send a new CAP into the zone
|
|
if zone.patrol_count <= 0 then
|
|
-- first check if we already hit the maximum amounts of routine CAP groups
|
|
if #gcicap[side].cap.flights < gcicap[side].cap.groups_count then
|
|
-- check if we limit resources and if we have enough supplies
|
|
-- if we don't limit resource or have enough supplies we spawn
|
|
if not gcicap[side].limit_resources or
|
|
(gcicap[side].limit_resources and gcicap[side].supply > 0) then
|
|
-- finally spawn it
|
|
gcicap.spawnCAP(side, gcicap[side].cap.zones[i], gcicap[side].cap.spawn_mode)
|
|
end
|
|
end
|
|
else
|
|
patroled_zones = patroled_zones + 1
|
|
end
|
|
end
|
|
-- if all zones are patroled and we still have cap groups left
|
|
-- send them to a random zone
|
|
if #gcicap[side].cap.flights < gcicap[side].cap.groups_count then
|
|
if not gcicap[side].limit_resources or
|
|
(gcicap[side].limit_resources and gcicap[side].supply > 0) then
|
|
local random_zone = math.random(1, #gcicap[side].cap.zones)
|
|
gcicap.spawnCAP(side, gcicap[side].cap.zones[random_zone], gcicap[side].cap.spawn_mode)
|
|
end
|
|
end
|
|
gcicap.log:info("$1 patrols in $2/$3 zones with $4 flights",
|
|
side, patroled_zones, gcicap[side].cap.zones_count, #gcicap[side].cap.flights)
|
|
end
|
|
|
|
local function handleIntrusion(side)
|
|
for i = 1, #gcicap[side].intruders do
|
|
local intruder = gcicap[side].intruders[i]
|
|
if intruder.group then
|
|
if intruder.group:isExist() then
|
|
-- check if we need to do something about him
|
|
if not intruder.intercepted then
|
|
-- first check if we have something to work with
|
|
if #gcicap[side].cap.flights > 0
|
|
or #gcicap[side].gci.flights > 0
|
|
or #gcicap[side].gci.flights < gcicap[side].gci.groups_count then
|
|
-- get closest flight to intruder if there is any
|
|
local closest = nil
|
|
local intruder_unit = gcicap.getFirstActiveUnit(intruder.group)
|
|
local closest_flights = gcicap.getClosestFlightsToUnit(side, intruder_unit)
|
|
-- we found close flights
|
|
local flight_avail = false
|
|
if closest_flights then
|
|
for j = 1, #closest_flights do
|
|
closest = closest_flights[j]
|
|
--fligh_avail = (not closest.flight.rtb) and (not closest.flight.intercepting)
|
|
flight_avail = (not closest.flight.intercepting)
|
|
if flight_avail then
|
|
gcicap.log:info("Found flight $1 which is avaliable for tasking.",
|
|
closest.flight.group:getName())
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if flight_avail then
|
|
-- check if we have a airfield which is closer to the unit than the closest flight
|
|
-- but add some distance to the airfield since it takes time for a potential spawned
|
|
-- flight to take-off
|
|
local closest_af, af_distance = gcicap.getClosestAirfieldToUnit(side, intruder_unit)
|
|
af_distance = af_distance + 15000 -- add 15km
|
|
if closest.distance < af_distance or af_distance == -1 then
|
|
-- task flight with intercept
|
|
closest.flight.give_up = false
|
|
closest.flight:vectorToTarget(intruder)
|
|
return
|
|
end
|
|
if (not gcicap[side].limit_resources
|
|
or (gcicap[side].limit_resources and gcicap[side].supply > 0))
|
|
and #gcicap[side].gci.flights < gcicap[side].gci.groups_count
|
|
and gcicap[side].gci.enabled then
|
|
-- spawn CGI
|
|
gcicap.log:info("Airfield closer to intruder than flight or no flight available. Spawning GCI")
|
|
local gci = gcicap.spawnGCI(side, intruder)
|
|
end
|
|
else
|
|
if (not gcicap[side].limit_resources
|
|
or (gcicap[side].limit_resources and gcicap[side].supply > 0))
|
|
and #gcicap[side].gci.flights < gcicap[side].gci.groups_count
|
|
and gcicap[side].gci.enabled then
|
|
-- spawn CGI
|
|
gcicap.log:info("No CAP flights or already airborne GCI. Spawning GCI")
|
|
local gci = gcicap.spawnGCI(side, intruder)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
-- the intruder group doesn't exist (anymore) remove it
|
|
table.remove(gcicap[side].intruders, i)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- returns airfields of given side which are marked with
|
|
-- triggerzones (triggerzone name is exactly the same as airfield name).
|
|
local function getAirfields(side)
|
|
local coal_airfields = coalition.getAirbases(gcicap.sideToCoalition(side))
|
|
local gcicap_airfields = {}
|
|
|
|
-- loop over all coalition airfields
|
|
for i = 1, #coal_airfields do
|
|
-- get name of airfield
|
|
local af_name = coal_airfields[i]:getName()
|
|
if not string.match(af_name, "FARP") then
|
|
-- check if a triggerzone exists with that exact name
|
|
if mist.DBs.zonesByName[af_name] then
|
|
-- add it to our airfield list for gcicap
|
|
gcicap_airfields[#gcicap_airfields + 1] = coal_airfields[i]
|
|
end
|
|
end
|
|
end
|
|
|
|
if #gcicap_airfields == 0 then
|
|
gcicap.log:warn("No airbase for $1 found", side)
|
|
end
|
|
return gcicap_airfields
|
|
end
|
|
|
|
-- returns all currently active aircraft of the given side
|
|
-- parameter side has to be "red" or "blue"
|
|
local function getAllActiveAircrafts(side)
|
|
local filter = { "[" .. side .. "][plane]", "[" .. side .. "][helicopter]"}
|
|
local all_aircraft = mist.makeUnitTable(filter)
|
|
local active_aircraft = {}
|
|
|
|
for i = 1, #all_aircraft do
|
|
local ac = Unit.getByName(all_aircraft[i])
|
|
if ac ~= nil then
|
|
if Unit.isActive(ac) then
|
|
table.insert(active_aircraft, ac)
|
|
end
|
|
end
|
|
end
|
|
if #active_aircraft == 0 then
|
|
gcicap.log:warn("No active aircraft for $1 found", side)
|
|
end
|
|
return active_aircraft
|
|
end
|
|
|
|
-- returns all currently active EWR and AWACS units of the given side
|
|
-- parameter side has to be "red" or "blue"
|
|
local function getAllActiveEWR(side)
|
|
local filter = { "[" .. side .. "][plane]", "[" .. side .. "][vehicle]", "[" .. side .. "][ship]"}
|
|
local all_vecs = mist.makeUnitTable(filter)
|
|
local active_ewr = {}
|
|
|
|
for i = 1, #all_vecs do
|
|
local vec = Unit.getByName(all_vecs[i])
|
|
if vec ~= nil then
|
|
if Unit.isActive(vec) then
|
|
local vec_type = Unit.getTypeName(vec)
|
|
if vec_type == "55G6 EWR"
|
|
or vec_type == "1L13 EWR"
|
|
or vec_type == "Hawk sr"
|
|
or vec_type == "Patriot str" then
|
|
table.insert(active_ewr, { unit = vec, is_awacs = false} )
|
|
end
|
|
-- ED has a bug; the E-2D vehicle has type E-2C
|
|
if (vec_type == "A-50" and gcicap[side].awacs)
|
|
or (vec_type == "E-2C" and gcicap[side].awacs)
|
|
or (vec_type == "E-3A" and gcicap[side].awacs) then
|
|
table.insert(active_ewr, { unit = vec, is_awacs = true} )
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if #active_ewr == 0 then
|
|
gcicap.log:warn("No active EWR for $1 found", side)
|
|
end
|
|
return active_ewr
|
|
end
|
|
|
|
local function checkForAirspaceIntrusion(side)
|
|
-- init some local vars
|
|
local border = gcicap[side].border
|
|
local active_ewr = gcicap[side].active_ewr
|
|
local intruder_count = 0
|
|
local intruder_side = ""
|
|
local toremove = {}
|
|
if side == "red" then
|
|
-- set the side of the intruder
|
|
intruder_side = "blue"
|
|
elseif side == "blue" then
|
|
intruder_side = "red"
|
|
end
|
|
local active_ac = gcicap[intruder_side].active_aircraft
|
|
|
|
-- only do something if we have active ewr and active aircraft
|
|
if #active_ac > 0 and #active_ewr > 0 then
|
|
-- loop over all aircraft
|
|
for i = 1, #active_ac do
|
|
local ac = active_ac[i]
|
|
local ac_detected = false
|
|
local ac_intruded = false
|
|
local ac_pos = {}
|
|
local ac_group = nil
|
|
local intruder_num = 0
|
|
local ewr = nil
|
|
if ac ~= nil then
|
|
ac_group = ac:getGroup()
|
|
if ac_group:isExist() then
|
|
ac_pos = ac:getPoint()
|
|
|
|
-- now loop over all ewr units
|
|
for n = 1, #active_ewr do
|
|
local ewr_controller = nil
|
|
if active_ewr[n].is_awacs then
|
|
ewr_controller = active_ewr[n].unit:getController()
|
|
else
|
|
ewr_controller = active_ewr[n].unit:getGroup():getController()
|
|
end
|
|
-- and check if the EWR detected the aircraft
|
|
if ewr_controller:isTargetDetected(ac, RADAR) then
|
|
ewr = active_ewr[n].unit
|
|
ac_detected = true
|
|
-- stop once it was detected by one EWR
|
|
break
|
|
end
|
|
end
|
|
|
|
if ac_detected then
|
|
-- do we check borders?
|
|
if gcicap[side].borders_enabled then
|
|
ac_intruded = mist.pointInPolygon(ac_pos, border)
|
|
else
|
|
-- if not the aircarft is always intruding
|
|
ac_intruded = true
|
|
end
|
|
|
|
if ac_intruded then
|
|
local in_list = false
|
|
-- check if we already know about the intruder
|
|
for j = 1, #gcicap[side].intruders do
|
|
if gcicap[side].intruders[j].name == ac_group:getName() then
|
|
in_list = true
|
|
intruder_num = j
|
|
break
|
|
end
|
|
end
|
|
if not in_list then
|
|
intruder_count = intruder_count + 1
|
|
|
|
gcicap.log:info("$1 ($2) intruded airspace of $3 detected by $4 ($5)",
|
|
ac_group:getName(), ac:getName(), side,
|
|
ewr:getGroup():getName(), ewr:getName())
|
|
|
|
intruder = {
|
|
name = ac_group:getName(),
|
|
--unit = ac,
|
|
group = ac_group,
|
|
detected_by = ewr,
|
|
--groupID = ac_group:getID(),
|
|
--unitID = ac:getID(),
|
|
--unitType = ac:getTypeName(),
|
|
size = ac_group:getSize(),
|
|
intercepted = false,
|
|
}
|
|
table.insert(gcicap[side].intruders, intruder)
|
|
intruder_num = #gcicap[side].intruders
|
|
end
|
|
|
|
-- send message to all units of coalition or some specified groups
|
|
-- that we have a intruder
|
|
if gcicap[side].gci.messages then
|
|
local par = {
|
|
units = { ac:getName() },
|
|
ref = gcicap[side].bullseye,
|
|
alt = ac_pos.y,
|
|
}
|
|
-- do we want to display in metric units?
|
|
if gcicap[side].gci.messages_metric then
|
|
par.metric = true
|
|
end
|
|
|
|
local msg_for = {}
|
|
-- if groups are specified find their units names and add them to the list
|
|
if #gcicap[side].gci.messages_to > 0 then
|
|
msg_for.units = {}
|
|
for g, group_name in pairs(gcicap[side].gci.messages_to) do
|
|
group = Group.getByName(group_name)
|
|
if group ~= nil then
|
|
for u, unit in pairs(group:getUnits()) do
|
|
table.insert(msg_for.units, unit:getName())
|
|
end
|
|
end
|
|
end
|
|
else
|
|
msg_for.coa = { side }
|
|
end
|
|
-- get the bearing, range and altitude from bullseye to intruder
|
|
local bra = mist.getBRString(par)
|
|
local bra_string = "Airpsace intrusion! BRA from bullseye "..bra
|
|
local msg = {
|
|
text = bra_string,
|
|
displayTime = gcicap.gci.message_time,
|
|
msgFor = msg_for,
|
|
name = "gcicap.gci.msg"..intruder_num,
|
|
}
|
|
-- finally send the message
|
|
mist.message.add(msg)
|
|
end
|
|
end -- if ac_intruded
|
|
else
|
|
-- the ac is _not_ intruding so we should remove it from the intruders list
|
|
|
|
local in_list = false
|
|
local intruder_num = 0
|
|
-- check if we already know about the intruder
|
|
for j = 1, #gcicap[side].intruders do
|
|
if gcicap[side].intruders[j].name == ac_group:getName() then
|
|
in_list = true
|
|
intruder_num = j
|
|
break
|
|
end
|
|
end
|
|
if in_list then toremove[#toremove + 1] = intruder_num end
|
|
end -- if ac_detected
|
|
end -- if ac_group is existing
|
|
end -- if ac ~= nil
|
|
end -- for #active_ac
|
|
end -- if active_ac > 0 and active_ewr > 0
|
|
|
|
-- we need to remove intruders from outside the loop
|
|
if #toremove > 0 then
|
|
for i = 1,#toremove do
|
|
intruder_count = intruder_count - 1
|
|
gcicap.log:info("Aircraft "..gcicap[side].intruders[i].name.." no longer intruding")
|
|
table.remove(gcicap[side].intruders,i)
|
|
end
|
|
end
|
|
if intruder_count > 0 then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
--return gcicap[side].intruders
|
|
end
|
|
|
|
-- returns a random airfield for the given side
|
|
local function getRandomAirfield(side)
|
|
local rand = math.random(1, #gcicap[side].airfields)
|
|
return gcicap[side].airfields[rand]
|
|
end
|
|
|
|
local function buildFirstWp(airbase, spawn_mode)
|
|
local airbase_pos = airbase:getPoint()
|
|
local airbase_id = airbase:getID()
|
|
local wp = mist.fixedWing.buildWP(airbase_pos)
|
|
|
|
if spawn_mode == "parking" then -- start from parking area
|
|
wp.airdromeId = airbase_id
|
|
wp.type = "TakeOffParking"
|
|
wp.action = "From Parking Area"
|
|
elseif spawn_mode == "takeoff" then -- or start from runway
|
|
wp.airdromeId = airbase_id
|
|
wp.type = "TakeOff"
|
|
wp.action = "From Runway"
|
|
elseif spawn_mode == "air" then
|
|
-- randomize spawn position a little bit in case of air start
|
|
wp.x = wp.x + (50 * math.sin(math.random(10)))
|
|
wp.y = wp.y + (50 * math.sin(math.random(10)))
|
|
end
|
|
|
|
return wp
|
|
end
|
|
|
|
--- Converts coaltion number to side string.
|
|
-- 0 = "neutral", 1 = "red", 2 = "blue"
|
|
-- @tparam number coal coaltion number.
|
|
-- @treturn string side
|
|
function gcicap.coalitionToSide(coal)
|
|
if coal == coalition.side.NEUTRAL then return "neutral"
|
|
elseif coal == coalition.side.RED then return "red"
|
|
elseif coal == coalition.side.BLUE then return "blue"
|
|
end
|
|
end
|
|
|
|
--- Converts side string to coaltion number.
|
|
-- 0 = "neutral", 1 = "red", 2 = "blue"
|
|
-- @tparam string side side string.
|
|
-- @treturn number coalition number.
|
|
-- @see coalitionToSide
|
|
function gcicap.sideToCoalition(side)
|
|
if side == "neutral" then return coalition.side.NEUTRAL
|
|
elseif side == "red" then return coalition.side.RED
|
|
elseif side == "blue" then return coalition.side.BLUE
|
|
end
|
|
end
|
|
|
|
--- Returns first active unit of a group.
|
|
-- @tparam Group group group whose first active
|
|
-- unit to return.
|
|
-- @treturn Unit first active unit of group.
|
|
function gcicap.getFirstActiveUnit(group)
|
|
if group ~= nil then
|
|
-- engrish mast0r isExistsingsed
|
|
if not group:isExist() then return nil end
|
|
local units = group:getUnits()
|
|
for i = 1, group:getSize() do
|
|
if units[i] then
|
|
return units[i]
|
|
end
|
|
end
|
|
return nil
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
--- Returns the closest airfield to unit.
|
|
-- Returned airfield is controlled by given side. This function
|
|
-- also returns the distance to the unit.
|
|
-- @tparam string side side string, either "red" or "blue".
|
|
-- The airfield returned has to be controlled by this side.
|
|
-- @tparam Unit unit unit to use as reference.
|
|
-- @treturn table @{closestAirfieldReturn}
|
|
function gcicap.getClosestAirfieldToUnit(side, unit)
|
|
if not unit then
|
|
gcicap.log:error("Couldn't find unit.")
|
|
return
|
|
end
|
|
local airfields = gcicap[side].airfields
|
|
|
|
if #airfields == 0 then
|
|
gcicap.log:warn("There are no airfields of side $1", side)
|
|
return nil
|
|
end
|
|
|
|
local unit_pos = mist.utils.makeVec2(unit:getPoint())
|
|
local min_distance = -1
|
|
local closest_af = nil
|
|
|
|
for i = 1, #airfields do
|
|
local af = airfields[i]
|
|
local af_pos = mist.utils.makeVec2(af:getPoint())
|
|
local distance = mist.utils.get2DDist(unit_pos, af_pos)
|
|
|
|
if distance < min_distance or min_distance == -1 then
|
|
min_distance = distance
|
|
closest_af = af
|
|
end
|
|
end
|
|
|
|
--- Table returned by getClosestAirfieldToUnit.
|
|
-- @table closestAirfieldReturn
|
|
-- @tfield Airbase airfield the Airbase object
|
|
-- @tfield number distance the distance in meters
|
|
-- to the unit.
|
|
--return {airfield = closest_af, distance = min_distance}
|
|
return closest_af, min_distance
|
|
end
|
|
|
|
--- Returns the closest flights to the given unit.
|
|
-- Flights returned are of given side. This function also returns
|
|
-- their distance to the unit. The returned flights are sorted
|
|
-- by distance. First is the closest.
|
|
-- @tparam string side side whose flights to search.
|
|
-- @tparam Unit unit unit object used as reference.
|
|
-- @treturn table Array sorted by distance
|
|
-- containing @{closestFlightsReturn} tables.
|
|
function gcicap.getClosestFlightsToUnit(side, unit)
|
|
if not unit then
|
|
gcicap.log:error("Couldn't find unit.")
|
|
return
|
|
end
|
|
local closest_flights = {}
|
|
if #gcicap[side].cap.flights == 0 and #gcicap[side].gci.flights == 0 then
|
|
gcicap.log:info("No CAP or GCI flights of side $1 active", side)
|
|
return nil
|
|
else
|
|
local unit_pos = mist.utils.makeVec2(unit:getPoint())
|
|
local min_distance = -1
|
|
for t, task in pairs(gcicap.tasks) do
|
|
local flights = gcicap[side][task].flights
|
|
for i = 1, #flights do
|
|
if flights[i].group then
|
|
local u = gcicap.getFirstActiveUnit(flights[i].group)
|
|
if u then
|
|
local u_pos = mist.utils.makeVec2(u:getPoint())
|
|
local distance = mist.utils.get2DDist(unit_pos, u_pos)
|
|
table.insert(closest_flights, {flight = flights[i], distance = distance })
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- sort closest flights
|
|
table.sort(closest_flights, function(a,b)
|
|
if a.distance < b.distance then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end)
|
|
|
|
--- Table returned by getClosestFlightsToUnit.
|
|
-- @table closestFlightsReturn
|
|
-- @tfield gcicap.Flight flight object
|
|
-- @tfield number distance distance in meters from
|
|
-- the unit.
|
|
return closest_flights
|
|
end
|
|
end
|
|
|
|
--- Returns a table containting a CAP route.
|
|
-- Route originating from given airbase, waypoints
|
|
-- are placed randomly inside given zone. Optionally
|
|
-- you can specify the amount of waypoints inside the zone.
|
|
-- @tparam string zone trigger zone name
|
|
-- @tparam number vul_time time on station
|
|
-- @tparam number leg_distance leg distance for race-track pattern orbit.
|
|
function gcicap.buildCAPRoute(start_pos, zone, vul_time, leg_distance)
|
|
local points = {}
|
|
-- make altitude consistent for the whole route.
|
|
local alt = math.random(gcicap.cap.min_alt, gcicap.cap.max_alt)
|
|
|
|
local start_vul_script = "local group = ...\
|
|
local flight = gcicap.Flight.getFlight(group)\
|
|
if flight then\
|
|
gcicap.log:info('$1 starting vul time $2 at $3',\
|
|
flight.group_name, flight.vul_time, flight.zone.name)\
|
|
flight.vul_start = timer.getAbsTime()\
|
|
else\
|
|
gcicap.log:error('Could not find flight')\
|
|
end"
|
|
|
|
local end_vul_script = "local group = ...\
|
|
local flight = gcicap.Flight.getFlight(group)\
|
|
if flight then\
|
|
gcicap.log:info('$1 vul time over at $2',\
|
|
flight.group_name, flight.zone.name)\
|
|
flight:taskWithRTB()\
|
|
else\
|
|
gcicap.log:error('Could not find flight')\
|
|
end"
|
|
|
|
-- build orbit start waypoint
|
|
local orbit_start_point = mist.getRandomPointInZone(zone)
|
|
-- add a bogus waypoint so the start vul time script block
|
|
-- isn't executed instantly after tasking
|
|
points[1] = mist.fixedWing.buildWP(start_pos)
|
|
points[2] = mist.fixedWing.buildWP(orbit_start_point)
|
|
points[2].task = {}
|
|
points[2].task.id = 'ComboTask'
|
|
points[2].task.params = {}
|
|
points[2].task.params.tasks = {}
|
|
points[2].task.params.tasks[1] = {
|
|
number = 1,
|
|
auto = false,
|
|
id = 'WrappedAction',
|
|
enabled = true,
|
|
params = {
|
|
action = {
|
|
id = 'Script',
|
|
params = {
|
|
command = start_vul_script
|
|
}
|
|
}
|
|
}
|
|
}
|
|
points[2].task.params.tasks[2] = {
|
|
number = 2,
|
|
auto = false,
|
|
id = 'ControlledTask',
|
|
enabled = true,
|
|
params = {
|
|
task = {
|
|
id = 'Orbit',
|
|
params = {
|
|
altitude = alt,
|
|
pattern = 'Race-Track',
|
|
speed = gcicap.cap.speed
|
|
}
|
|
},
|
|
stopCondition = {
|
|
duration = vul_time * 60
|
|
}
|
|
}
|
|
}
|
|
|
|
-- if we don't use the race-track pattern we'll add the vul end time
|
|
-- waypoint right where the start waypoint is and use the 'Circle' pattern.
|
|
local orbit_end_point
|
|
if not gcicap.cap.race_track_orbit then
|
|
points[2].task.params.tasks[2].params.task.params.pattern = 'Circle'
|
|
orbit_end_point = start_pos
|
|
else
|
|
-- build second waypoint (leg end waypoint)
|
|
--local orbit_end_point = mist.getRandPointInCircle(orbit_start_point, leg_distance, leg_distance)
|
|
orbit_end_point = mist.getRandomPointInZone(zone)
|
|
end
|
|
|
|
points[3] = mist.fixedWing.buildWP(orbit_end_point)
|
|
points[3].task = {
|
|
id = 'WrappedAction',
|
|
params = {
|
|
action = {
|
|
id = 'Script',
|
|
params = {
|
|
command = end_vul_script
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for i = 1, 3 do
|
|
points[i].speed = gcicap.cap.speed
|
|
points[i].alt = alt
|
|
end
|
|
|
|
-- local ground_level = land.getHeight(point)
|
|
-- -- avoid crashing into hills
|
|
-- if (alt - 100) < ground_level then
|
|
-- alt = alt + ground_level
|
|
-- end
|
|
|
|
gcicap.log:info("Built CAP route with $1 min vul time at $2 meters in $3", vul_time, alt, zone)
|
|
|
|
local route = {}
|
|
route.points = points
|
|
return route
|
|
end
|
|
|
|
--- Tasks group to automatically engage any spotted targets.
|
|
-- @tparam Group group group to task.
|
|
-- @tparam[opt] number max_dist maximum engagment distance.
|
|
-- Targets further out (from the route) won't be engaged.
|
|
function gcicap.taskEngage(group, max_dist)
|
|
if not max_dist then
|
|
max_dist = gcicap.cap.max_engage_distance
|
|
end
|
|
local ctl = group:getController()
|
|
local engage = {
|
|
id = 'EngageTargets',
|
|
params = {
|
|
maxDist = max_dist,
|
|
maxDistEnabled = true,
|
|
targetTypes = { [1] = "Air" },
|
|
priority = 0
|
|
}
|
|
}
|
|
ctl:pushTask(engage)
|
|
end
|
|
|
|
--- Tasks group to engage a group.
|
|
-- @tparam Group group group to task.
|
|
-- @tparam Group target group that should be engaged by
|
|
-- given group.
|
|
function gcicap.taskEngageGroup(group, target)
|
|
local ctl = group:getController()
|
|
local engage_group = {
|
|
id = 'EngageGroup',
|
|
params = {
|
|
groupId = target:getID(),
|
|
directionEnabled = false,
|
|
priority = 0,
|
|
altittudeEnabled = false,
|
|
}
|
|
}
|
|
ctl:pushTask(engage_group)
|
|
end
|
|
|
|
--- Spawns a fighter group.
|
|
-- @tparam string side side of the newly created group.
|
|
-- Can be "red" or "blue".
|
|
-- @tparam string name new group name.
|
|
-- @tparam number size count of aircraft in the new group.
|
|
-- @tparam Airbase airbase home plate of the new group.
|
|
-- @tparam string spawn_mode How the new group will be spawned.
|
|
-- Can be 'parking' or 'air'. 'parking' will spawn them at the ramp
|
|
-- wit engines turned off. 'air' will spawn them in the air already
|
|
-- flying.
|
|
-- @tparam string task Task of the new group. Can either be 'cap',
|
|
-- for combat air patrol, or 'gci', for ground controlled intercept.
|
|
-- @tparam[opt] string zone zone name in which to spawn the unit. This only is
|
|
-- taken into account if spawn_mode is "in-zone".
|
|
-- @tparam[opt] boolean cold if set to true the newly group won't engage
|
|
-- any enemys until tasked otherwise. Default false.
|
|
-- @treturn Group|nil newly spawned group or nil on failure.
|
|
function gcicap.spawnFighterGroup(side, name, size, airbase, spawn_mode, task, zone, cold)
|
|
local template_unit_name = gcicap[task].template_prefix..side..math.random(1, gcicap.template_count)
|
|
local template_unit = Unit.getByName(template_unit_name)
|
|
if not template_unit then
|
|
gcicap.log:error("Can't find template unit $1. This should never happen.\
|
|
Somehow the template unit got deleted.", template_unit_name)
|
|
return nil
|
|
end
|
|
local template_group = mist.getGroupData(template_unit:getGroup():getName())
|
|
local template_unit_data = template_group.units[1]
|
|
local airbase_pos = airbase:getPoint()
|
|
local group_data = {}
|
|
local unit_data = {}
|
|
local onboard_num = template_unit_data.onboard_num - 1
|
|
local route = {}
|
|
|
|
local rand_point = {}
|
|
if spawn_mode == "in-zone" then
|
|
rand_point = mist.getRandomPointInZone(zone)
|
|
end
|
|
|
|
for i = 1, size do
|
|
unit_data[i] = {}
|
|
unit_data[i].type = template_unit_data.type
|
|
unit_data[i].name = name.." Pilot "..i
|
|
if spawn_mode == "in-zone" then
|
|
unit_data[i].x = rand_point.x + (50 * math.sin(math.random(10)))
|
|
unit_data[i].y = rand_point.y + (50 * math.sin(math.random(10)))
|
|
else
|
|
unit_data[i].x = airbase_pos.x + (50 * math.sin(math.random(10)))
|
|
unit_data[i].y = airbase_pos.z + (50 * math.sin(math.random(10)))
|
|
end
|
|
unit_data[i].alt = gcicap[side].cap.min_alt
|
|
unit_data[i].onboard_num = onboard_num + i
|
|
unit_data[i].groupName = name
|
|
unit_data[i].payload = template_unit_data.payload
|
|
unit_data[i].skill = template_unit_data.skill
|
|
unit_data[i].livery_id = template_unit_data.livery_id
|
|
if side == 'blue' then
|
|
unit_data[i].callsign = {}
|
|
unit_data[i].callsign[1] = 4 -- Colt
|
|
unit_data[i].callsign[2] = gcicap[side].cap.flight_num
|
|
unit_data[i].callsign[3] = i
|
|
else
|
|
unit_data[i].callsign = 600 + gcicap[side].cap.flight_num + i
|
|
end
|
|
end
|
|
|
|
group_data.units = unit_data
|
|
group_data.groupName = name
|
|
group_data.hidden = gcicap[side].hide_groups
|
|
--group_data.country = template_group.country
|
|
group_data.country = template_unit:getCountry()
|
|
group_data.category = template_group.category
|
|
group_data.task = "CAP"
|
|
|
|
route.points = {}
|
|
if spawn_mode == "in-zone" then
|
|
route.points[1] = mist.fixedWing.buildWP(rand_point)
|
|
route.points[1].alt = gcicap[side].cap.min_alt
|
|
route.points[1].speed = gcicap[side].cap.speed
|
|
else
|
|
route.points[1] = buildFirstWp(airbase, spawn_mode)
|
|
end
|
|
group_data.route = route
|
|
|
|
if mist.groupTableCheck(group_data) then
|
|
local spawn_pos = airbase:getName()
|
|
if spawn_mode == "in-zone" then
|
|
spawn_pos = zone
|
|
end
|
|
gcicap.log:info("Spawning fighter group $1 at $2", name, spawn_pos)
|
|
mist.dynAdd(group_data)
|
|
else
|
|
gcicap.log:error("Couldn't spawn group with following groupTable: $1", group_data)
|
|
end
|
|
|
|
return Group.getByName(name)
|
|
end
|
|
|
|
--- Spawns a CAP flight.
|
|
-- @tparam string side side for the new CAP.
|
|
-- @tparam string zone CAP zone (trigger zone) name.
|
|
-- @tparam string spawn_mode how the new CAP will be spawned.
|
|
-- Can be 'parking' or 'air'.
|
|
function gcicap.spawnCAP(side, zone, spawn_mode)
|
|
-- increase flight number
|
|
gcicap[side].cap.flight_num = gcicap[side].cap.flight_num + 1
|
|
-- select random airbase (for now) TODO: choose closest airfield
|
|
local airbase = getRandomAirfield(side)
|
|
local group_name = "CAP "..side.." "..gcicap[side].cap.flight_num
|
|
-- define size of the flight
|
|
local size = gcicap[side].cap.group_size
|
|
if size == "randomized" then
|
|
size = math.random(1,2)*2
|
|
else
|
|
size = tonumber(size)
|
|
end
|
|
-- actually spawn something
|
|
local group = gcicap.spawnFighterGroup(side, group_name, size, airbase, spawn_mode, "cap", zone.name)
|
|
--local ctl = group:getController()
|
|
--ctl:setOption(AI.Option.Air.id.RADAR_USING, AI.Option.Air.val.RADAR_USING.FOR_ATTACK_ONLY)
|
|
gcicap[side].supply = gcicap[side].supply - 1
|
|
-- keep track of the flight
|
|
local flight = gcicap.Flight:new(group, airbase, "cap", zone)
|
|
-- task the group, for some odd reason we have to wait until we use setTask
|
|
-- on a freshly spawned group.
|
|
mist.scheduleFunction(gcicap.Flight.taskWithCAP, {flight}, timer.getTime() + 5)
|
|
return group
|
|
end
|
|
|
|
--- Spawns a GCI flight.
|
|
-- @tparam string side side for the new GCI.
|
|
-- @tparam Unit intruder unit to intercept.
|
|
-- @tparam Airbase airbase airbase at which to spawn the GCI flight.
|
|
function gcicap.spawnGCI(side, intruder, airbase)
|
|
-- increase flight number
|
|
gcicap[side].gci.flight_num = gcicap[side].gci.flight_num + 1
|
|
-- select closest airfield to unit
|
|
local intruder_unit = gcicap.getFirstActiveUnit(intruder.group)
|
|
local closest_af = gcicap.getClosestAirfieldToUnit(side, intruder_unit)
|
|
if closest_af then
|
|
airbase = closest_af
|
|
else
|
|
gcicap.log:warn("Couldn't find close airfield for GCI. Choosing one at random.")
|
|
airbase = getRandomAirfield(side)
|
|
end
|
|
local tgt_units = intruder.group:getUnits()
|
|
local group_name = "GCI "..side.." "..gcicap[side].gci.flight_num
|
|
-- define size of the flight
|
|
local size = gcicap[side].gci.group_size
|
|
if size == "randomized" then
|
|
size = math.random(1,2)*2
|
|
elseif size == "dynamic" then
|
|
size = #tgt_units
|
|
else
|
|
size = tonumber(size)
|
|
end
|
|
-- actually spawn something
|
|
local group = gcicap.spawnFighterGroup(side, group_name, size, airbase, gcicap[side].gci.spawn_mode, "gci")
|
|
local ctl = group:getController()
|
|
-- make the GCI units only use their radar for attacking
|
|
ctl:setOption(AI.Option.Air.id.RADAR_USING, AI.Option.Air.val.RADAR_USING.FOR_ATTACK_ONLY)
|
|
gcicap[side].supply = gcicap[side].supply - 1
|
|
-- keep track of the flight
|
|
local flight = gcicap.Flight:new(group, airbase, "gci", intruder)
|
|
-- vector the interceptor group on the target the first time.
|
|
mist.scheduleFunction(gcicap.Flight.vectorToTarget, {flight, intruder}, timer.getTime() + 5)
|
|
return group
|
|
end
|
|
|
|
--- Initialization function
|
|
-- Checks if all template units are present. Creates
|
|
-- border polygons if borders enabled.
|
|
-- @todo complete documentation.
|
|
function gcicap.init()
|
|
for i, side in pairs(gcicap.sides) do
|
|
if not (checkForTemplateUnits(side) and checkForTriggerZones(side)) then
|
|
return false
|
|
end
|
|
if gcicap[side].borders_enabled then
|
|
gcicap[side].border = mist.getGroupPoints(gcicap[side].border_group)
|
|
end
|
|
gcicap[side].intruders = {}
|
|
gcicap[side].cap.zones = {}
|
|
gcicap[side].cap.flights = {}
|
|
gcicap[side].gci.flights = {}
|
|
gcicap[side].cap.flight_num = 0
|
|
gcicap[side].gci.flight_num = 0
|
|
gcicap[side].airfields = getAirfields(side)
|
|
|
|
if gcicap[side].cap.enabled then
|
|
-- loop through all zones
|
|
for i = 1, gcicap[side].cap.zones_count do
|
|
local zone_name = gcicap[side].cap.zone_name..i
|
|
local point = trigger.misc.getZone(zone_name).point
|
|
local size = trigger.misc.getZone(zone_name).radius
|
|
|
|
-- create zone table
|
|
gcicap[side].cap.zones[i] = {
|
|
name = zone_name,
|
|
pos = point,
|
|
radius = size,
|
|
patrol_count = 0,
|
|
}
|
|
end
|
|
|
|
for i = 1, gcicap[side].cap.groups_count do
|
|
local spawn_mode = "parking"
|
|
if gcicap[side].cap.start_airborne then
|
|
spawn_mode = "in-zone"
|
|
end
|
|
-- try to fill all zones
|
|
local zone = gcicap[side].cap.zones[i]
|
|
-- if we have more flights than zones we select one random zone
|
|
if zone == nil then
|
|
zone = gcicap[side].cap.zones[math.random(1, gcicap[side].cap.zones_count)]
|
|
end
|
|
-- actually spawn the group
|
|
--local grp = gcicap.spawnCAP(side, zone, spawn_mode)
|
|
-- delay the spawn by gcicap interval seconds after one another
|
|
local spawn_delay = (i - 1) * gcicap.initial_spawn_delay
|
|
mist.scheduleFunction(gcicap.spawnCAP, {side, zone, spawn_mode}, timer.getTime() + spawn_delay)
|
|
end
|
|
end
|
|
end
|
|
-- add event handler managing despawns
|
|
return true
|
|
end
|
|
|
|
--- Main function.
|
|
-- Run approx. every @{gcicap.interval} sconds. A random amount
|
|
-- of 0 to 2 seconds is added for declustering.
|
|
-- @todo do the "declustering" at a different level. Probably
|
|
-- more efficient.
|
|
function gcicap.main()
|
|
for i, side in pairs(gcicap.sides) do
|
|
-- update list of occupied airfields
|
|
gcicap[side].airfields = getAirfields(side)
|
|
-- update list of all aircraft
|
|
gcicap[side].active_aircraft = getAllActiveAircrafts(side)
|
|
-- update list of all EWR
|
|
gcicap[side].active_ewr = getAllActiveEWR(side)
|
|
end
|
|
|
|
-- check for airspace intrusions after updating all the lists
|
|
for i, side in pairs(gcicap.sides) do
|
|
if gcicap[side].cap.enabled then
|
|
manageCAP(side)
|
|
end
|
|
checkForAirspaceIntrusion(side)
|
|
handleIntrusion(side)
|
|
garbageCollector(side)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
if gcicap.init() then
|
|
local start_delay = gcicap.initial_spawn_delay * math.max(gcicap.red.cap.groups_count, gcicap.blue.cap.groups_count)
|
|
mist.scheduleFunction(gcicap.main, {}, timer.getTime() + start_delay, gcicap.interval)
|
|
end
|
|
|
|
-- vim: sw=2:ts=2
|