Create an automated A2G defense system based on a detection network of reconnaissance vehicles and air units, coordinating SEAD, BAI and CAS operations.

When your mission is in the need to take control of the AI to automate and setup a process of air to ground defenses, this is the module you need. The defense system work through the definition of defense coordinates, which are points in your friendly area within the battle field, that your mission need to have defended. Multiple defense coordinates can be setup. Defense coordinates can be strategic or tactical positions or references to strategic units or scenery. The A2G dispatcher will evaluate every x seconds the tactical situation around each defense coordinate. When a defense coordinate is under threat, it will communicate through the command center that defensive actions need to be taken and will launch groups of air units for defense. The level of threat to the defense coordinate varies upon the strength and types of the enemy units, the distance to the defense point, and the defensiveness parameters. Defensive actions are taken through probability, but the closer and the more threat the enemy poses to the defense coordinate, the faster it will be attacked by friendly A2G units.

Please study carefully the underlying explanations how to setup and use this module, as it has many features. It also requires a little study to ensure that you get a good understanding of the defense mechanisms, to ensure a strong defense for your missions.

USAGE GUIDE

1. AI_A2G_DISPATCHER constructor:

The AI_A2G_DISPATCHER.New() method creates a new AI_A2G_DISPATCHER instance.

1.1. Define the reconnaissance network:

As part of the AI_A2G_DISPATCHER :New() constructor, a reconnaissance network must be given as the first parameter. A reconnaissance network is provided by passing a Functional.Detection object. The most effective reconnaissance for the A2G dispatcher would be to use the Functional.Detection#DETECTION_AREAS object.

A reconnaissance network, is used to detect enemy ground targets, potentially group them into areas, and to understand the position, level of threat of the enemy.

As explained in the introduction, depending on the type of mission you want to achieve, different types of units can be applied to detect ground enemy targets. Ground based units are very useful to act as a reconnaissance, but they lack sometimes the visibility to detect targets at greater range. Recce are very useful to acquire the position of enemy ground targets when spread out over the battlefield at strategic positions. Ground units also have varying detectors, and especially the ground units which have laser guiding missiles can be extremely effective at detecting targets at great range. The terrain elevation characteristics are a big tool in making ground recce to be more effective. If you succeed to position recce at higher level terrain providing a broad and far overview of the lower terrain in the distance, then the recce will be very effective at detecting approaching enemy targets. Therefore, always use the terrain very carefully!

Beside ground level units to use for reconnaissance, air units are also very effective. The are capable of patrolling at great speed covering a large terrain. However, airborne recce can be vulnerable to air to ground attacks, and you need air superiority to make then effective. Also the instruments available at the air units play a big role in the effectiveness of the reconnaissance. Air units which have ground detection capabilities will be much more effective than air units with only visual detection capabilities. For the red coalition, the Mi-28N and for the blue side, the reaper are such effective reconnaissance airborne units.

Reconnaissance networks are dynamically constructed, that is, they form part of the Functional.Detection instance that is given as the first parameter to the A2G dispatcher. By defining in a smart way the names or name prefixes of the reconnaissance groups, these groups will be automatically added or removed to or from the reconnaissance network, when these groups are spawned in or destroyed during the ongoing battle. By spawning in dynamically additional recce, you can ensure that there is sufficient reconnaissance coverage so the defense mechanism is continuously alerted of new enemy ground targets.

The following is an example defense of a new reconnaissance network using a Functional.Detection#DETECTION_AREAS object.

   -- Define a SET_GROUP object that builds a collection of groups that define the recce network.
   -- Here we build the network with all the groups that have a name starting with CCCP Recce.
   DetectionSetGroup = SET_GROUP:New() -- Define a set of group objects, called DetectionSetGroup.

   DetectionSetGroup:FilterPrefixes( { "CCCP Recce" } ) -- The DetectionSetGroup will search for groups that start with the name "CCCP Recce".

   -- This command will start the dynamic filtering, so when groups spawn in or are destroyed,
   -- which have a group name starting with "CCCP Recce", then these will be automatically added or removed from the set.
   DetectionSetGroup:FilterStart()

   -- This command defines the reconnaissance network.
   -- It will group any detected ground enemy targets within a radius of 1km.
   -- It uses the DetectionSetGroup, which defines the set of reconnaissance groups to detect for enemy ground targets.
   Detection = DETECTION_AREAS:New( DetectionSetGroup, 1000 )

   -- Setup the A2G dispatcher, and initialize it.
   A2GDispatcher = AI_A2G_DISPATCHER:New( Detection )

The above example creates a SET_GROUP instance, and stores this in the variable (object) DetectionSetGroup. DetectionSetGroup is then being configured to filter all active groups with a group name starting with "CCCP Recce" to be included in the set. DetectionSetGroup is then calling FilterStart(), which is starting the dynamic filtering or inclusion of these groups. Note that any destroy or new spawn of a group having a name, starting with the above prefix, will be removed or added to the set.

Then a new detection object is created from the class DETECTION_AREAS. A grouping radius of 1000 meters (1km) is chosen.

The Detection object is then passed to the AI_A2G_DISPATCHER.New() method to indicate the reconnaissance network configuration and setup the A2G defense detection mechanism.

1.2. Setup the A2G dispatcher for both a red and blue coalition.

Following the above described procedure, you'll need to create for each coalition an separate detection network, and a separate A2G dispatcher. Ensure that while doing so, that you name the objects differently both for red and blue coalition.

For example like this for the red coalition:

   DetectionRed = DETECTION_AREAS:New( DetectionSetGroupRed, 1000 )
   A2GDispatcherRed = AI_A2G_DISPATCHER:New( DetectionRed )

And for the blue coalition:

   DetectionBlue = DETECTION_AREAS:New( DetectionSetGroupBlue, 1000 )
   A2GDispatcherBlue = AI_A2G_DISPATCHER:New( DetectionBlue )

Note: Also the SET_GROUP objects should be created for each coalition separately, containing each red and blue recce respectively!

1.3. Define the enemy ground target grouping radius, in case you use DETECTION_AREAS:

The target grouping radius is a property of the DETECTION_AREAS class, that was passed to the AI_A2G_DISPATCHER:New() method but can be changed. The grouping radius should not be too small, but also depends on the types of ground forces and the way you want your mission to evolve. A large radius will mean large groups of enemy ground targets, while making smaller groups will result in a more fragmented defense system. Typically I suggest a grouping radius of 1km. This is the right balance to create efficient defenses.

Note that detected targets are constantly re-grouped, that is, when certain detected enemy ground units are moving further than the group radius then these units will become a separate area being detected. This may result in additional defenses being started by the dispatcher, so don't make this value too small! Again, about 1km, or 1000 meters, is recommended.

2. Setup (a) Defense Coordinate(s).

As explained above, defense coordinates are the center of your defense operations. The more threat to the defense coordinate, the higher it is likely a defensive action will be launched.

Find below an example how to add defense coordinates:

   -- Add defense coordinates.
   A2GDispatcher:AddDefenseCoordinate( "HQ", GROUP:FindByName( "HQ" ):GetCoordinate() )

In this example, the coordinate of a group called "HQ" is retrieved, using :GetCoordinate() This returns a COORDINATE object, pointing to the first unit within the GROUP object.

The method AI_A2G_DISPATCHER.AddDefenseCoordinate() adds a new defense coordinate to the A2GDispatcher object. The first parameter is the key of the defense coordinate, the second the coordinate itself.

Later, a COORDINATE_UNIT will be added to the framework, which can be used to assign "moving" coordinates to an A2G dispatcher.

REMEMBER!

• Defense coordinates are the center of the A2G dispatcher defense system!
• You can define more defense coordinates to defend a larger area.
• Detected enemy ground targets are not immediately engaged, but are engaged with a reactivity or probability calculation!

But, there is more to it ...

2.1. The Defense Radius.

The defense radius defines the maximum radius that a defense will be initiated around each defense coordinate. So even when there are targets further away than the defense radius, then these targets won't be engaged upon. By default, the defense radius is set to 100km (100.000 meters), but can be changed using the AI_A2G_DISPATCHER.SetDefenseRadius() method. Note that the defense radius influences the defense reactivity also! The larger the defense radius, the more reactive the defenses will be.

For example:

   A2GDispatcher:SetDefenseRadius( 30000 )

This defines an A2G dispatcher which will engage on enemy ground targets within 30km radius around the defense coordinate. Note that the defense radius applies to all defense coordinates defined within the A2G dispatcher.

2.2. The Defense Reactivity.

There are three levels that can be configured to tweak the defense reactivity. As explained above, the threat to a defense coordinate is also determined by the distance of the enemy ground target to the defense coordinate. If you want to have a low defense reactivity, that is, the probability that an A2G defense will engage to the enemy ground target, then use the AI_A2G_DISPATCHER.SetDefenseReactivityLow() method. For medium and high reactivity, use the methods AI_A2G_DISPATCHER.SetDefenseReactivityMedium() and AI_A2G_DISPATCHER.SetDefenseReactivityHigh() respectively.

Note that the reactivity of defenses is always in relation to the Defense Radius! the shorter the distance, the less reactive the defenses will be in terms of distance to enemy ground targets!

For example:

   A2GDispatcher:SetDefenseReactivityHigh()

This defines an A2G dispatcher with high defense reactivity.

3. Squadrons.

The A2G dispatcher works with Squadrons, that need to be defined using the different methods available.

Use the method AI_A2G_DISPATCHER.SetSquadron() to setup a new squadron active at an airfield, FARP or carrier, while defining which helicopter or plane templates are being used by the squadron and how many resources are available.

Multiple squadrons can be defined within one A2G dispatcher, each having specific defense tasks and defense parameter settings!

Squadrons:

• Have name (string) that is the identifier or key of the squadron.
• Have specific helicopter or plane templates.
• Are located at one airbase, farp or carrier.
• Optionally have a limited set of resources. The default is that squadrons have unlimited resources.

The name of the squadron given acts as the squadron key in all A2GDispatcher:SetSquadron...() or A2GDispatcher:GetSquadron...() methods.

Additionally, squadrons have specific configuration options to:

• Control how new helicopters or aircraft are taking off from the airfield, farp or carrier (in the air, cold, hot, at the runway).
• Control how returning helicopters or aircraft are landing at the airfield, farp or carrier (in the air near the airbase, after landing, after engine shutdown).
• Control the grouping of new helicopters or aircraft spawned at the airfield, farp or carrier. If there is more than one helicopter or aircraft to be spawned, these may be grouped.
• Control the overhead or defensive strength of the squadron. Depending on the types of helicopters, planes, amount of resources and payload (weapon configuration) chosen, the mission designer can choose to increase or reduce the amount of planes spawned.

The method AI_A2G_DISPATCHER.SetSquadron() defines for you a new squadron. The provided parameters are the squadron name, airbase name and a list of template prefixes, and a number that indicates the amount of resources.

For example, this defines 3 new squadrons:

   A2GDispatcher:SetSquadron( "Maykop SEAD", AIRBASE.Caucasus.Maykop_Khanskaya, { "CCCP KA-50" }, 10 )
   A2GDispatcher:SetSquadron( "Maykop CAS", "CAS", { "CCCP KA-50" }, 10 )
   A2GDispatcher:SetSquadron( "Maykop BAI", "BAI", { "CCCP KA-50" }, 10 )

The latter 2 will depart from FARPs, which bare the name "CAS" and "BAI".

3.1. Squadrons Tasking.

Squadrons can be commanded to execute 3 types of tasks, as explained above:

• SEAD: Suppression of Air Defenses, which are ground targets that have medium or long range radar emitters.
• BAI : Battlefield Air Interdiction, which are targets further away from the front-line.
• CAS : Close Air Support, when there are enemy ground targets close to friendly units.

You need to configure each squadron which task types you want it to perform. Read on ...

3.2. Squadrons enemy ground target engagement types.

There are two ways how targets can be engaged: directly on call from the airfield, FARP or carrier, or through a patrol.

Patrols are extremely handy, as these will get your helicopters or airplanes airborne in advance. They will patrol in defined zones outlined, and will engage with the targets once commanded. If the patrol zone is close enough to the enemy ground targets, then the time required to engage is heavily minimized!

However; patrols come with a side effect: since your resources are airborne, they will be vulnerable to incoming air attacks from the enemy.

The mission designer needs to carefully balance the need for patrols or the need for engagement on call from the airfields.

3.3. Squadron on call engagement.

So to make squadrons engage targets from the airfields, use the following methods:

• For SEAD, use the AI_A2G_DISPATCHER.SetSquadronSead() method.
• For BAI, use the AI_A2G_DISPATCHER.SetSquadronBai() method.
• For CAS, use the AI_A2G_DISPATCHER.SetSquadronCas() method.

Note that for the tasks, specific helicopter or airplane templates are required to be used, which you can configure using your mission editor. Especially the payload (weapons configuration) is important to get right.

For example, the following will define for the squadrons different tasks:

   A2GDispatcher:SetSquadron( "Maykop SEAD", AIRBASE.Caucasus.Maykop_Khanskaya, { "CCCP KA-50 SEAD" }, 10 )
   A2GDispatcher:SetSquadronSead( "Maykop SEAD", 120, 250 )

   A2GDispatcher:SetSquadron( "Maykop BAI", "BAI", { "CCCP KA-50 BAI" }, 10 )
   A2GDispatcher:SetSquadronBai( "Maykop BAI", 120, 250 )

   A2GDispatcher:SetSquadron( "Maykop CAS", "CAS", { "CCCP KA-50 CAS" }, 10 )
   A2GDispatcher:SetSquadronCas( "Maykop CAS", 120, 250 )

3.4. Squadron on patrol engagement.

Squadrons can be setup to patrol in the air near the engagement hot zone. When needed, the A2G defense units will be close to the battle area, and can engage quickly.

So to make squadrons engage targets from a patrol zone, use the following methods:

• For SEAD, use the AI_A2G_DISPATCHER.SetSquadronSeadPatrol() method.
• For BAI, use the AI_A2G_DISPATCHER.SetSquadronBaiPatrol() method.
• For CAS, use the AI_A2G_DISPATCHER.SetSquadronCasPatrol() method.

Because a patrol requires more parameters, the following methods must be used to fine-tune the patrols for each squadron.

• For SEAD, use the AI_A2G_DISPATCHER.SetSquadronSeadPatrolInterval() method.
• For BAI, use the AI_A2G_DISPATCHER.SetSquadronBaiPatrolInterval() method.
• For CAS, use the AI_A2G_DISPATCHER.SetSquadronCasPatrolInterval() method.

Here an example to setup patrols of various task types:

   A2GDispatcher:SetSquadron( "Maykop SEAD", AIRBASE.Caucasus.Maykop_Khanskaya, { "CCCP KA-50 SEAD" }, 10 )
   A2GDispatcher:SetSquadronSeadPatrol( "Maykop SEAD", PatrolZone, 300, 500, 50, 80, 250, 300 )
   A2GDispatcher:SetSquadronPatrolInterval( "Maykop SEAD", 2, 30, 60, 1, "SEAD" )

   A2GDispatcher:SetSquadron( "Maykop BAI", "BAI", { "CCCP KA-50 BAI" }, 10 )
   A2GDispatcher:SetSquadronBaiPatrol( "Maykop BAI", PatrolZone, 800, 900, 50, 80, 250, 300 )
   A2GDispatcher:SetSquadronPatrolInterval( "Maykop BAI", 2, 30, 60, 1, "BAI" )

   A2GDispatcher:SetSquadron( "Maykop CAS", "CAS", { "CCCP KA-50 CAS" }, 10 )
   A2GDispatcher:SetSquadronCasPatrol( "Maykop CAS", PatrolZone, 600, 700, 50, 80, 250, 300 )
   A2GDispatcher:SetSquadronPatrolInterval( "Maykop CAS", 2, 30, 60, 1, "CAS" )

3.5. Set squadron takeoff methods

Use the various SetSquadronTakeoff... methods to control how squadrons are taking-off from the home airfield, FARP or ship.

• AI_A2G_DISPATCHER.SetSquadronTakeoff() is the generic configuration method to control takeoff from the air, hot, cold or from the runway. See the method for further details.
• AI_A2G_DISPATCHER.SetSquadronTakeoffInAir() will spawn new aircraft from the squadron directly in the air.
• AI_A2G_DISPATCHER.SetSquadronTakeoffFromParkingCold() will spawn new aircraft in without running engines at a parking spot at the airfield.
• AI_A2G_DISPATCHER.SetSquadronTakeoffFromParkingHot() will spawn new aircraft in with running engines at a parking spot at the airfield.
• AI_A2G_DISPATCHER.SetSquadronTakeoffFromRunway() will spawn new aircraft at the runway at the airfield.

The default landing method is to spawn new aircraft directly in the air.

Use these methods to fine-tune for specific airfields that are known to create bottlenecks, or have reduced airbase efficiency. The more and the longer aircraft need to taxi at an airfield, the more risk there is that:

• aircraft will stop waiting for each other or for a landing aircraft before takeoff.
• aircraft may get into a "dead-lock" situation, where two aircraft are blocking each other.
• aircraft may collide at the airbase.
• aircraft may be awaiting the landing of a plane currently in the air, but never lands ...

Currently within the DCS engine, the airfield traffic coordination is erroneous and contains a lot of bugs. If you experience while testing problems with aircraft takeoff or landing, please use one of the above methods as a solution to workaround these issues!

This example sets the default takeoff method to be from the runway. And for a couple of squadrons overrides this default method.

 -- Setup the takeoff methods

 -- Set the default takeoff method
 A2GDispatcher:SetDefaultTakeoffFromRunway()

 -- Set the individual squadrons takeoff method
 A2GDispatcher:SetSquadronTakeoff( "Mineralnye", AI_A2G_DISPATCHER.Takeoff.Air )
 A2GDispatcher:SetSquadronTakeoffInAir( "Sochi" )
 A2GDispatcher:SetSquadronTakeoffFromRunway( "Mozdok" )
 A2GDispatcher:SetSquadronTakeoffFromParkingCold( "Maykop" )
 A2GDispatcher:SetSquadronTakeoffFromParkingHot( "Novo" )

3.5.1. Set Squadron takeoff altitude when spawning new aircraft in the air.

In the case of the AI_A2G_DISPATCHER.SetSquadronTakeoffInAir() there is also an other parameter that can be applied. That is modifying or setting the altitude from where planes spawn in the air. Use the method AI_A2G_DISPATCHER.SetSquadronTakeoffInAirAltitude() to set the altitude for a specific squadron. The default takeoff altitude can be modified or set using the method AI_A2G_DISPATCHER.SetSquadronTakeoffInAirAltitude(). As part of the method AI_A2G_DISPATCHER.SetSquadronTakeoffInAir() a parameter can be specified to set the takeoff altitude. If this parameter is not specified, then the default altitude will be used for the squadron.

3.5.2. Set Squadron takeoff interval.

The different types of available airfields have different amounts of available launching platforms:

• Airbases typically have a lot of platforms.
• FARPs have 4 platforms.
• Ships have 2 to 4 platforms.

Depending on the demand of requested takeoffs by the A2G dispatcher, an airfield can become overloaded. Too many aircraft need to be taken off at the same time, which will result in clutter as described above. In order to better control this behaviour, a takeoff scheduler is implemented, which can be used to control how many aircraft are ordered for takeoff between specific time intervals. The takeoff intervals can be specified per squadron, which make sense, as each squadron have a "home" airfield.

For this purpose, the method AI_A2G_DISPATCHER.SetSquadronTakeoffInterval() can be used to specify the takeoff intervals of aircraft groups per squadron to avoid cluttering of aircraft at airbases. This is especially useful for FARPs and ships. Each takeoff dispatch is queued by the dispatcher and when the interval time has been reached, a new group will be spawned or activated for takeoff.

The interval needs to be estimated, and depends on the time needed for the aircraft group to actually depart from the launch platform, and the way how the aircraft are starting up. Cold starts take the longest duration, hot starts a few seconds, and runway takeoff also a few seconds for FARPs and ships.

See the underlying example:

 -- Imagine a squadron launched from a FARP, with a grouping of 4.
 -- Aircraft will cold start from the FARP, and thus, a maximum of 4 aircraft can be launched at the same time.
 -- Additionally, depending on the group composition of the aircraft, defending units will be ordered for takeoff together.
 -- It takes about 3 to 4 minutes for helicopters to takeoff from FARPs in cold start.
 A2GDispatcher:SetSquadronTakeoffInterval( "Mineralnye", 60 * 4 )

3.6. Set squadron landing methods

In analogy with takeoff, the landing methods are to control how squadrons land at the airfield:

• AI_A2G_DISPATCHER.SetSquadronLanding() is the generic configuration method to control landing, namely despawn the aircraft near the airfield in the air, right after landing, or at engine shutdown.
• AI_A2G_DISPATCHER.SetSquadronLandingNearAirbase() will despawn the returning aircraft in the air when near the airfield.
• AI_A2G_DISPATCHER.SetSquadronLandingAtRunway() will despawn the returning aircraft directly after landing at the runway.
• AI_A2G_DISPATCHER.SetSquadronLandingAtEngineShutdown() will despawn the returning aircraft when the aircraft has returned to its parking spot and has turned off its engines.

You can use these methods to minimize the airbase coordination overhead and to increase the airbase efficiency. When there are lots of aircraft returning for landing, at the same airbase, the takeoff process will be halted, which can cause a complete failure of the A2G defense system, as no new SEAD, BAI or CAS planes can takeoff. Note that the method AI_A2G_DISPATCHER.SetSquadronLandingNearAirbase() will only work for returning aircraft, not for damaged or out of fuel aircraft. Damaged or out-of-fuel aircraft are returning to the nearest friendly airbase and will land, and are out of control from ground control.

This example defines the default landing method to be at the runway. And for a couple of squadrons overrides this default method.

 -- Setup the Landing methods

 -- The default landing method
 A2GDispatcher:SetDefaultLandingAtRunway()

 -- The individual landing per squadron
 A2GDispatcher:SetSquadronLandingAtRunway( "Mineralnye" )
 A2GDispatcher:SetSquadronLandingNearAirbase( "Sochi" )
 A2GDispatcher:SetSquadronLandingAtEngineShutdown( "Mozdok" )
 A2GDispatcher:SetSquadronLandingNearAirbase( "Maykop" )
 A2GDispatcher:SetSquadronLanding( "Novo", AI_A2G_DISPATCHER.Landing.AtRunway )

3.7. Set squadron grouping.

Use the method AI_A2G_DISPATCHER.SetSquadronGrouping() to set the grouping of aircraft when spawned in.

In the case of on call engagement, the AI_A2G_DISPATCHER.SetSquadronGrouping() method has additional behaviour. When there aren't enough patrol flights airborne, a on call will be initiated for the remaining targets to be engaged. Depending on the grouping parameter, the spawned flights for on call aircraft are grouped into this setting.
For example with a group setting of 2, if 3 targets are detected and cannot be engaged by the available patrols or any airborne flight, an additional on call flight needs to be started.

The grouping value is set for a Squadron, and can be dynamically adjusted during mission execution, so to adjust the defense flights grouping when the tactical situation changes.

3.8. Set the squadron overhead to balance the effectiveness of the A2G defenses.

The effectiveness can be set with the overhead parameter. This is a number that is used to calculate the amount of Units that dispatching command will allocate to GCI in surplus of detected amount of units. The default value of the overhead parameter is 1.0, which means equal balance.

However, depending on the (type of) aircraft (strength and payload) in the squadron and the amount of resources available, this parameter can be changed.

The AI_A2G_DISPATCHER.SetSquadronOverhead() method can be used to tweak the defense strength, taking into account the plane types of the squadron.

For example, a A-10C with full long-distance A2G missiles payload, may still be less effective than a Su-23 with short range A2G missiles... So in this case, one may want to use the AI_A2G_DISPATCHER.SetOverhead() method to allocate more defending planes as the amount of detected attacking ground units. The overhead must be given as a decimal value with 1 as the neutral value, which means that overhead values:

• Higher than 1.0, for example 1.5, will increase the defense unit amounts. For 4 attacking ground units detected, 6 aircraft will be spawned.
• Lower than 1, for example 0.75, will decrease the defense unit amounts. For 4 attacking ground units detected, only 3 aircraft will be spawned.

The amount of defending units is calculated by multiplying the amount of detected attacking ground units as part of the detected group multiplied by the overhead parameter, and rounded up to the smallest integer.

Typically, for A2G defenses, values small than 1 will be used. Here are some good values for a couple of aircraft to support CAS operations:

• A-10C: 0.15
• Su-34: 0.15
• A-10A: 0.25
• SU-25T: 0.10

So generically, the amount of missiles that an aircraft can take will determine its attacking effectiveness. The longer the range of the missiles, the less risk that the defender may be destroyed by the enemy, thus, the less aircraft needs to be activated in a defense.

The overhead value is set for a Squadron, and can be dynamically adjusted during mission execution, so to adjust the defense overhead when the tactical situation changes.

3.8. Set the squadron engage limit.

To limit the amount of aircraft to defend against a large group of intruders, an engage limit can be defined per squadron. This limit will avoid an extensive amount of aircraft to engage with the enemy if the attacking ground forces are enormous.

Use the method AI_A2G_DISPATCHER.SetSquadronEngageLimit() to limit the amount of aircraft that will engage with the enemy, per squadron.

4. Set the fuel threshold.

When an aircraft gets out of fuel with only a certain % of fuel left, which is 15% (0.15) by default, there are two possible actions that can be taken: - The aircraft will go RTB, and will be replaced with a new aircraft if possible. - The aircraft will refuel at a tanker, if a tanker has been specified for the squadron.

Use the method AI_A2G_DISPATCHER.SetSquadronFuelThreshold() to set the squadron fuel threshold of the aircraft for all squadrons.

6. Other configuration options

6.1. Set a tactical display panel.

Every 30 seconds, a tactical display panel can be shown that illustrates what the status is of the different groups controlled by AI_A2G_DISPATCHER. Use the method AI_A2G_DISPATCHER.SetTacticalDisplay() to switch on the tactical display panel. The default will not show this panel. Note that there may be some performance impact if this panel is shown.

10. Default settings.

Default settings configure the standard behaviour of the squadrons. This section a good overview of the different parameters that setup the behaviour of ALL the squadrons by default. Note that default behaviour can be tweaked, and thus, this will change the behaviour of all the squadrons. Unless there is a specific behaviour set for a specific squadron, the default configured behaviour will be followed.

10.1. Default takeoff behaviour.

The default takeoff behaviour is set to in the air, which means that new spawned aircraft will be spawned directly in the air above the airbase by default.

The default takeoff method can be set for ALL squadrons that don't have an individual takeoff method configured.

• AI_A2G_DISPATCHER.SetDefaultTakeoff() is the generic configuration method to control takeoff by default from the air, hot, cold or from the runway. See the method for further details.
• AI_A2G_DISPATCHER.SetDefaultTakeoffInAir() will spawn by default new aircraft from the squadron directly in the air.
• AI_A2G_DISPATCHER.SetDefaultTakeoffFromParkingCold() will spawn by default new aircraft in without running engines at a parking spot at the airfield.
• AI_A2G_DISPATCHER.SetDefaultTakeoffFromParkingHot() will spawn by default new aircraft in with running engines at a parking spot at the airfield.
• AI_A2G_DISPATCHER.SetDefaultTakeoffFromRunway() will spawn by default new aircraft at the runway at the airfield.

10.2. Default landing behaviour.

The default landing behaviour is set to near the airbase, which means that returning aircraft will be despawned directly in the air by default.

The default landing method can be set for ALL squadrons that don't have an individual landing method configured.

• AI_A2G_DISPATCHER.SetDefaultLanding() is the generic configuration method to control by default landing, namely despawn the aircraft near the airfield in the air, right after landing, or at engine shutdown.
• AI_A2G_DISPATCHER.SetDefaultLandingNearAirbase() will despawn by default the returning aircraft in the air when near the airfield.
• AI_A2G_DISPATCHER.SetDefaultLandingAtRunway() will despawn by default the returning aircraft directly after landing at the runway.
• AI_A2G_DISPATCHER.SetDefaultLandingAtEngineShutdown() will despawn by default the returning aircraft when the aircraft has returned to its parking spot and has turned off its engines.

10.3. Default overhead.

The default overhead is set to 0.25. That essentially means that for each 4 ground enemies there will be 1 aircraft dispatched.

The default overhead value can be set for ALL squadrons that don't have an individual overhead value configured.

Use the AI_A2G_DISPATCHER.SetDefaultOverhead() method can be used to set the default overhead or defense strength for ALL squadrons.

10.4. Default grouping.

The default grouping is set to one aircraft. That essentially means that there won't be any grouping applied by default.

The default grouping value can be set for ALL squadrons that don't have an individual grouping value configured.

Use the method AI_A2G_DISPATCHER.SetDefaultGrouping() to set the default grouping of spawned aircraft for all squadrons.

10.5. Default RTB fuel threshold.

When an aircraft gets out of fuel with only a certain % of fuel left, which is 15% (0.15) by default, it will go RTB, and will be replaced with a new aircraft when applicable.

Use the method AI_A2G_DISPATCHER.SetDefaultFuelThreshold() to set the default fuel threshold of spawned aircraft for all squadrons.

10.6. Default RTB damage threshold.

When an aircraft is damaged to a certain %, which is 40% (0.40) by default, it will go RTB, and will be replaced with a new aircraft when applicable.

Use the method AI_A2G_DISPATCHER.SetDefaultDamageThreshold() to set the default damage threshold of spawned aircraft for all squadrons.

10.7. Default settings for patrol.

10.7.1. Default patrol time Interval.

Patrol dispatching is time event driven, and will evaluate in random time intervals if a new patrol needs to be dispatched.

The default patrol time interval is between 180 and 600 seconds.

Use the method AI_A2G_DISPATCHER.SetDefaultPatrolTimeInterval() to set the default patrol time interval of dispatched aircraft for ALL squadrons.

Note that you can still change the patrol limit and patrol time intervals for each patrol individually using the AI_A2G_DISPATCHER.SetSquadronPatrolTimeInterval() method.

10.7.2. Default patrol limit.

Multiple patrol can be airborne at the same time for one squadron, which is controlled by the patrol limit. The default patrol limit is 1 patrol per squadron to be airborne at the same time. Note that the default patrol limit is used when a squadron patrol is defined, and cannot be changed afterwards. So, ensure that you set the default patrol limit before you define or setup the squadron patrol.

Use the method AI_A2G_DISPATCHER.SetDefaultPatrolTimeInterval() to set the default patrol time interval of dispatched aircraft patrols for all squadrons.
Note that you can still change the patrol limit and patrol time intervals for each patrol individually using the AI_A2G_DISPATCHER.SetSquadronPatrolTimeInterval() method.

10.7.3. Default tanker for refuelling when executing SEAD, BAI and CAS operations.

Instead of sending SEAD, BAI and CAS aircraft to RTB when out of fuel, you can let SEAD, BAI and CAS aircraft refuel in mid air using a tanker. This greatly increases the efficiency of your SEAD, BAI and CAS operations.

In the mission editor, setup a group with task Refuelling. A tanker unit of the correct coalition will be automatically selected. Then, use the method AI_A2G_DISPATCHER.SetDefaultTanker() to set the tanker for the dispatcher. Use the method AI_A2G_DISPATCHER.SetDefaultFuelThreshold() to set the % left in the defender aircraft tanks when a refuel action is needed.

When the tanker specified is alive and in the air, the tanker will be used for refuelling.

For example, the following setup will set the default refuel tanker to "Tanker":

 -- Set the default tanker for refuelling to "Tanker", when the default fuel threshold has reached 90% fuel left.
 A2GDispatcher:SetDefaultFuelThreshold( 0.9 )
 A2GDispatcher:SetDefaultTanker( "Tanker" )

10.8. Default settings for GCI.

10.8.1. Optimal intercept point calculation.

When intruders are detected, the intrusion path of the attackers can be monitored by the EWR.
Although defender planes might be on standby at the airbase, it can still take some time to get the defenses up in the air if there aren't any defenses airborne. This time can easily take 2 to 3 minutes, and even then the defenders still need to fly towards the target, which takes also time.

Therefore, an optimal intercept point is calculated which takes a couple of parameters:

• The average bearing of the intruders for an amount of seconds.
• The average speed of the intruders for an amount of seconds.
• An assumed time it takes to get planes operational at the airbase.

The intercept point will determine:

• If there are any friendlies close to engage the target. These can be defenders performing CAP or defenders in RTB.
• The optimal airbase from where defenders will takeoff for GCI.

Use the method AI_A2G_DISPATCHER.SetIntercept() to modify the assumed intercept delay time to calculate a valid interception.

10.8.2. Default Disengage Radius.

The radius to disengage any target when the distance of the defender to the home base is larger than the specified meters. The default Disengage Radius is 300km (300000 meters). Note that the Disengage Radius is applicable to ALL squadrons!

Use the method AI_A2G_DISPATCHER.SetDisengageRadius() to modify the default Disengage Radius to another distance setting.

11. Airbase capture:

Different squadrons can be located at one airbase. If the airbase gets captured, that is when there is an enemy unit near the airbase and there are no friendlies at the airbase, the airbase will change coalition ownership. As a result, further SEAD, BAI, and CAS operations from that airbase will stop. However, the squadron will still stay alive. Any aircraft that is airborne will continue its operations until all airborne aircraft of the squadron are destroyed. This is to keep consistency of air operations and avoid confusing players.