weyne/dcs-retribution
1
0
Fork 0
mirror of https://github.com/dcs-retribution/dcs-retribution.git synced 2025-11-10 15:41:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Ground objects are always generated and destroyable, even when it's not the current mission objective.

Browse Source 
Fix : SAM site destruction status is saved correctly.
Added most SAM site to generator.
This commit is contained in:
Khopa
2019-10-06 16:14:13 +02:00
parent 17352bfcf7
commit 2167953b87
40 changed files with 808 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
gen/groundobjectsgen.py
View File

@@ -1,6 +1,7 @@
import logging
from game import db
from game.db import unit_type_from_name
from .conflictgen import *
from .naming import *
@@ -42,7 +43,6 @@ class GroundObjectsGenerator:
)
def generate(self):
side = self.m.country(self.game.enemy_country)
cp = None # type: ControlPoint
if self.conflict.attackers_country.name == self.game.player_country:
@@ -52,54 +52,58 @@ class GroundObjectsGenerator:
consumed_farps = set()
for ground_object in cp.ground_objects:
if ground_object.dcs_identifier == "AA":
if ground_object.is_dead:
continue
for cp in self.game.theater.controlpoints:
unit_type = random.choice(self.game.commision_unit_types(cp, AirDefence))
assert unit_type is not None, "Cannot find unit type for GroundObject defense ({})!".format(cp)
group = self.m.aaa_vehicle_group(
country=side,
name=ground_object.string_identifier,
_type=unit_type,
position=ground_object.position,
heading=ground_object.heading,
)
logging.info("generated defense object identifier {} with mission id {}".format(group.name, group.id))
if cp.captured:
country = self.game.player_country
else:
if ground_object.dcs_identifier in warehouse_map:
static_type = warehouse_map[ground_object.dcs_identifier]
country = self.game.enemy_country
side = self.m.country(country)
for ground_object in cp.ground_objects:
if ground_object.dcs_identifier == "AA":
for g in ground_object.groups:
if len(g.units) > 0:
vg = self.m.vehicle_group(side, g.name, unit_type_from_name(g.units[0].type), position=g.position)
vg.units[0].name = self.m.string(g.units[0].name)
for i,u in enumerate(g.units):
if i > 0:
vehicle = Vehicle(self.m.next_unit_id(), self.m.string(u.name), u.type)
vehicle.position.x = u.position.x
vehicle.position.y = u.position.y
vehicle.heading = u.heading
vg.add_unit(vehicle)
else:
static_type = fortification_map[ground_object.dcs_identifier]
if ground_object.dcs_identifier in warehouse_map:
static_type = warehouse_map[ground_object.dcs_identifier]
else:
static_type = fortification_map[ground_object.dcs_identifier]
if not static_type:
print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
continue
if not static_type:
print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
continue
if ground_object.group_id not in consumed_farps:
consumed_farps.add(ground_object.group_id)
if random.randint(0, 100) > 50:
farp_aa(
self.m,
side,
ground_object.string_identifier,
ground_object.position,
)
if ground_object.group_id not in consumed_farps:
consumed_farps.add(ground_object.group_id)
if random.randint(0, 100) > 50:
farp_aa(
self.m,
side,
ground_object.string_identifier,
ground_object.position,
)
group = self.m.static_group(
country=side,
name=ground_object.string_identifier,
_type=static_type,
position=ground_object.position,
heading=ground_object.heading,
dead=ground_object.is_dead,
)
group = self.m.static_group(
country=side,
name=ground_object.string_identifier,
_type=static_type,
position=ground_object.position,
heading=ground_object.heading,
dead=ground_object.is_dead,
)
logging.info("generated {}object identifier {} with mission id {}".format("dead " if ground_object.is_dead else "", group.name, group.id))
logging.info("generated {}object identifier {} with mission id {}".format("dead " if ground_object.is_dead else "", group.name, group.id))
def farp_aa(mission_obj, country, name, position: mapping.Point):
@@ -116,7 +120,6 @@ def farp_aa(mission_obj, country, name, position: mapping.Point):
units = [
AirDefence.SPAAA_ZSU_23_4_Shilka,
AirDefence.AAA_ZU_23_Closed,
Armor.MBT_T_55,
]
v = mission_obj.vehicle(name + "_AAA", random.choice(units))

73
gen/sam/group_generator.py Normal file
View File

@@ -0,0 +1,73 @@
import math
import random
from dcs import unitgroup
from dcs.point import PointAction
from dcs.unit import Vehicle
class AntiAirGroupGenerator():
def __init__(self, game, ground_object, group_object_group_id):
self.game = game
self.go = ground_object
self.position = ground_object.position
self.heading = random.randint(0, 359)
self.vg = unitgroup.VehicleGroup(self.game.next_group_id(), self.go.group_identifier)
wp = self.vg.add_waypoint(self.position, PointAction.OffRoad, 0)
wp.ETA_locked = True
def generate(self):
raise NotImplementedError
def get_generated_group(self):
return self.vg
def add_unit(self, unit_type, name, pos_x, pos_y, heading):
nn = "cgroup|" + str(self.go.cp_id) + '|' + str(self.go.group_id) + '|' + str(self.go.group_identifier) + "|" + name
unit = Vehicle(self.game.next_unit_id(),
nn, unit_type.id)
unit.position.x = pos_x
unit.position.y = pos_y
unit.heading = heading
self.vg.add_unit(unit)
return unit
def get_circular_position(self, num_units, launcher_distance, coverage=90):
"""
Given a position on the map, array a group of units in a circle a uniform distance from the unit
:param num_units:
number of units to play on the circle
:param launcher_distance:
distance the units should be from the center unit
:param coverage:
0-360
:return:
list of tuples representing each unit location
[(pos_x, pos_y, heading), ...]
"""
if coverage == 360:
# one of the positions is shared :'(
outer_offset = coverage / num_units
else:
outer_offset = coverage / (num_units - 1)
positions = []
if num_units % 2 == 0:
current_offset = self.heading - ((coverage / (num_units - 1)) / 2)
else:
current_offset = self.heading
current_offset -= outer_offset * (math.ceil(num_units / 2) - 1)
for x in range(1, num_units + 1):
positions.append((
self.position.x + launcher_distance * math.cos(math.radians(current_offset)),
self.position.y + launcher_distance * math.sin(math.radians(current_offset)),
current_offset,
))
current_offset += outer_offset
return positions

19
gen/sam/sam_avenger.py Normal file
View File

@@ -0,0 +1,19 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class AvengerGenerator(AntiAirGroupGenerator):
"""
This generate an Avenger group
"""
def generate(self):
num_launchers = random.randint(2, 3)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_Avenger_M1097, "SPAA#" + str(i), position[0], position[1], position[2])

19
gen/sam/sam_chaparral.py Normal file
View File

@@ -0,0 +1,19 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class ChaparralGenerator(AntiAirGroupGenerator):
"""
This generate a Chaparral group
"""
def generate(self):
num_launchers = random.randint(2, 4)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_Chaparral_M48, "SPAA#" + str(i), position[0], position[1], position[2])

18
gen/sam/sam_gepard.py Normal file
View File

@@ -0,0 +1,18 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class GepardGenerator(AntiAirGroupGenerator):
"""
This generate a Gepard group
"""
def generate(self):
self.add_unit(AirDefence.SPAAA_Gepard, "SPAAA", self.position.x, self.position.y, self.heading)
if random.randint(0, 1) == 1:
self.add_unit(AirDefence.SPAAA_Gepard, "SPAAA2", self.position.x, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x + 80, self.position.y, self.heading)

82
gen/sam/sam_group_generator.py Normal file
View File

@@ -0,0 +1,82 @@
import math
import random
from dcs import unitgroup
from dcs.point import PointAction
from dcs.unit import Vehicle
from dcs.unittype import UnitType
from dcs.vehicles import AirDefence
from game import db
from gen.sam.sam_avenger import AvengerGenerator
from gen.sam.sam_chaparral import ChaparralGenerator
from gen.sam.sam_gepard import GepardGenerator
from gen.sam.sam_hawk import HawkGenerator
from gen.sam.sam_linebacker import LinebackerGenerator
from gen.sam.sam_patriot import PatriotGenerator
from gen.sam.sam_rapier import RapierGenerator
from gen.sam.sam_roland import RolandGenerator
from gen.sam.sam_sa10 import SA10Generator
from gen.sam.sam_sa11 import SA11Generator
from gen.sam.sam_sa13 import SA13Generator
from gen.sam.sam_sa15 import SA15Generator
from gen.sam.sam_sa19 import SA19Generator
from gen.sam.sam_sa2 import SA2Generator
from gen.sam.sam_sa3 import SA3Generator
from gen.sam.sam_sa6 import SA6Generator
from gen.sam.sam_sa8 import SA8Generator
from gen.sam.sam_sa9 import SA9Generator
from gen.sam.sam_vulcan import VulcanGenerator
from gen.sam.sam_zsu23 import ZSU23Generator
from gen.sam.sam_zu23 import ZU23Generator
from gen.sam.sam_zu23_ural import ZU23UralGenerator
def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
"""
This generate a SAM group
:param parentCp: The parent control point
:param ground_object: The ground object which will own the sam group
:param country: Owner country
:return: Nothing, but put the group reference inside the ground object
"""
SAM_MAP = {
AirDefence.SAM_Hawk_PCP:HawkGenerator,
AirDefence.AAA_ZU_23_Closed:ZU23Generator,
AirDefence.AAA_ZU_23_Insurgent_on_Ural_375:ZU23UralGenerator,
AirDefence.SPAAA_ZSU_23_4_Shilka:ZSU23Generator,
AirDefence.AAA_Vulcan_M163: VulcanGenerator,
AirDefence.SAM_Linebacker_M6: LinebackerGenerator,
AirDefence.Rapier_FSA_Launcher: RapierGenerator,
AirDefence.SAM_Avenger_M1097: AvengerGenerator,
AirDefence.SPAAA_Gepard: GepardGenerator,
AirDefence.SAM_Roland_ADS: RolandGenerator,
AirDefence.SAM_Patriot_LN_M901: PatriotGenerator,
AirDefence.SAM_Chaparral_M48: ChaparralGenerator,
AirDefence.SAM_SA_2_LN_SM_90: SA2Generator,
AirDefence.SAM_SA_3_S_125_LN_5P73: SA3Generator,
AirDefence.SAM_SA_6_Kub_LN_2P25: SA6Generator,
AirDefence.SAM_SA_8_Osa_9A33: SA8Generator,
AirDefence.SAM_SA_9_Strela_1_9P31: SA9Generator,
AirDefence.SAM_SA_10_S_300PS_LN_5P85C: SA10Generator,
AirDefence.SAM_SA_10_S_300PS_CP_54K6: SA10Generator,
AirDefence.SAM_SA_11_Buk_LN_9A310M1: SA11Generator,
AirDefence.SAM_SA_13_Strela_10M3_9A35M3: SA13Generator,
AirDefence.SAM_SA_15_Tor_9A331: SA15Generator,
AirDefence.SAM_SA_19_Tunguska_2S6: SA19Generator,
}
possible_sams = [u for u in db.FACTIONS[faction]["units"] if u in AirDefence.__dict__.values()]
if len(possible_sams) > 0:
sam = random.choice(possible_sams)
generator = SAM_MAP[sam](game, ground_object, 0)
generator.generate()
ground_object.groups = [generator.get_generated_group()]

25
gen/sam/sam_hawk.py Normal file
View File

@@ -0,0 +1,25 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class HawkGenerator(AntiAirGroupGenerator):
"""
This generate an HAWK group
"""
def generate(self):
self.add_unit(AirDefence.SAM_Hawk_PCP, "PCP", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Hawk_SR_AN_MPQ_50, "SR", self.position.x + 20, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Hawk_TR_AN_MPQ_46, "TR", self.position.x + 40, self.position.y, self.heading)
# Triple A for close range defense
self.add_unit(AirDefence.AAA_Vulcan_M163, "AAA", self.position.x + 20, self.position.y+30, self.heading)
num_launchers = random.randint(3, 6)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_Hawk_LN_M192, "LN#" + str(i), position[0], position[1], position[2])

19
gen/sam/sam_linebacker.py Normal file
View File

@@ -0,0 +1,19 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class LinebackerGenerator(AntiAirGroupGenerator):
"""
This generate an m6 linebacker group
"""
def generate(self):
num_launchers = random.randint(2, 4)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_Linebacker_M6, "M6#" + str(i), position[0], position[1], position[2])

30
gen/sam/sam_patriot.py Normal file
View File

@@ -0,0 +1,30 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class PatriotGenerator(AntiAirGroupGenerator):
"""
This generate a Patriot group
"""
def generate(self):
# Command Post
self.add_unit(AirDefence.SAM_Patriot_AMG_AN_MRC_137, "MRC", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Patriot_ECS_AN_MSQ_104, "MSQ", self.position.x + 30, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Patriot_ICC, "ICC", self.position.x + 60, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Patriot_EPP_III, "EPP", self.position.x, self.position.y + 30, self.heading)
self.add_unit(AirDefence.SAM_Patriot_STR_AN_MPQ_53, "ICC", self.position.x + 30, self.position.y + 30, self.heading)
num_launchers = random.randint(2, 4)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_Patriot_LN_M901, "LN#" + str(i), position[0], position[1], position[2])
# Short range protection for high value site
num_launchers = random.randint(2, 4)
positions = self.get_circular_position(num_launchers, launcher_distance=300, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.AAA_Vulcan_M163, "SPAAA#" + str(i), position[0], position[1], position[2])

21
gen/sam/sam_rapier.py Normal file
View File

@@ -0,0 +1,21 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class RapierGenerator(AntiAirGroupGenerator):
"""
This generate a Rapier Group
"""
def generate(self):
self.add_unit(AirDefence.Rapier_FSA_Blindfire_Tracker, "BT", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.Rapier_FSA_Optical_Tracker, "OT", self.position.x + 20, self.position.y, self.heading)
num_launchers = random.randint(3, 6)
positions = self.get_circular_position(num_launchers, launcher_distance=80, coverage=240)
for i, position in enumerate(positions):
self.add_unit(AirDefence.Rapier_FSA_Launcher, "LN#" + str(i), position[0], position[1], position[2])

15
gen/sam/sam_roland.py Normal file
View File

@@ -0,0 +1,15 @@
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class RolandGenerator(AntiAirGroupGenerator):
"""
This generate a Roland group
"""
def generate(self):
self.add_unit(AirDefence.SAM_Roland_ADS, "ADS", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_Roland_EWR, "EWR", self.position.x + 40, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x + 80, self.position.y, self.heading)

43
gen/sam/sam_sa10.py Normal file
View File

@@ -0,0 +1,43 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA10Generator(AntiAirGroupGenerator):
"""
This generate a SA-10 group
"""
def generate(self):
# Command Post
self.add_unit(AirDefence.SAM_SA_10_S_300PS_CP_54K6, "CP", self.position.x, self.position.y, self.heading)
# Search Radar
self.add_unit(AirDefence.SAM_SA_10_S_300PS_SR_5N66M, "SR", self.position.x, self.position.y, self.heading)
# Search radar for missiles (optionnal)
self.add_unit(AirDefence.SAM_SA_10_S_300PS_SR_64H6E, "SR", self.position.x, self.position.y, self.heading)
# 2 different launcher type (C & D)
num_launchers = random.randint(6, 8)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
for i, position in enumerate(positions):
if i%2 == 0:
self.add_unit(AirDefence.SAM_SA_10_S_300PS_LN_5P85C, "LN#" + str(i), position[0], position[1], position[2])
else:
self.add_unit(AirDefence.SAM_SA_10_S_300PS_LN_5P85D, "LN#" + str(i), position[0], position[1], position[2])
# Then let's add short range protection to this high value site
# Sa-13 Strela are great for that
num_launchers = random.randint(2, 4)
positions = self.get_circular_position(num_launchers, launcher_distance=300, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_13_Strela_10M3_9A35M3, "IR#" + str(i), position[0], position[1], position[2])
# And even some AA
num_launchers = random.randint(6, 8)
positions = self.get_circular_position(num_launchers, launcher_distance=350, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.AAA_ZU_23_Emplacement, "AA#" + str(i), position[0], position[1], position[2])

21
gen/sam/sam_sa11.py Normal file
View File

@@ -0,0 +1,21 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA11Generator(AntiAirGroupGenerator):
"""
This generate a SA-11 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SA_11_Buk_CC_9S470M1, "CC", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_SA_11_Buk_SR_9S18M1, "SR", self.position.x+20, self.position.y, self.heading)
num_launchers = random.randint(2, 4)
positions = self.get_circular_position(num_launchers, launcher_distance=140, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_11_Buk_LN_9A310M1, "LN#" + str(i), position[0], position[1], position[2])

20
gen/sam/sam_sa13.py Normal file
View File

@@ -0,0 +1,20 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class SA13Generator(AntiAirGroupGenerator):
"""
This generate a SA-13 group
"""
def generate(self):
self.add_unit(Unarmed.Transport_UAZ_469, "UAZ", self.position.x, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_KAMAZ_43101, "TRUCK", self.position.x+40, self.position.y, self.heading)
num_launchers = random.randint(2, 3)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_13_Strela_10M3_9A35M3, "LN#" + str(i), position[0], position[1], position[2])

14
gen/sam/sam_sa15.py Normal file
View File

@@ -0,0 +1,14 @@
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class SA15Generator(AntiAirGroupGenerator):
"""
This generate a SA-15 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SA_15_Tor_9A331, "ADS", self.position.x, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_UAZ_469, "EWR", self.position.x + 40, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_KAMAZ_43101, "TRUCK", self.position.x + 80, self.position.y, self.heading)

21
gen/sam/sam_sa19.py Normal file
View File

@@ -0,0 +1,21 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA19Generator(AntiAirGroupGenerator):
"""
This generate a SA-19 group
"""
def generate(self):
num_launchers = random.randint(1, 3)
if num_launchers == 1:
self.add_unit(AirDefence.SAM_SA_19_Tunguska_2S6, "LN#0", self.position.x, self.position.y, self.heading)
else:
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_19_Tunguska_2S6, "LN#" + str(i), position[0], position[1], position[2])

21
gen/sam/sam_sa2.py Normal file
View File

@@ -0,0 +1,21 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA2Generator(AntiAirGroupGenerator):
"""
This generate a SA-2 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SR_P_19, "SR", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_SA_2_TR_SNR_75_Fan_Song, "TR", self.position.x + 20, self.position.y, self.heading)
num_launchers = random.randint(3, 6)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_2_LN_SM_90, "LN#" + str(i), position[0], position[1], position[2])

21
gen/sam/sam_sa3.py Normal file
View File

@@ -0,0 +1,21 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA3Generator(AntiAirGroupGenerator):
"""
This generate a SA-3 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SR_P_19, "SR", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_SA_3_S_125_TR_SNR, "TR", self.position.x + 20, self.position.y, self.heading)
num_launchers = random.randint(3, 6)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_3_S_125_LN_5P73, "LN#" + str(i), position[0], position[1], position[2])

20
gen/sam/sam_sa6.py Normal file
View File

@@ -0,0 +1,20 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA6Generator(AntiAirGroupGenerator):
"""
This generate a SA-6 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SA_6_Kub_STR_9S91, "STR", self.position.x, self.position.y, self.heading)
num_launchers = random.randint(2, 4)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_6_Kub_LN_2P25, "LN#" + str(i), position[0], position[1], position[2])

15
gen/sam/sam_sa8.py Normal file
View File

@@ -0,0 +1,15 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class SA8Generator(AntiAirGroupGenerator):
"""
This generate a SA-8 group
"""
def generate(self):
self.add_unit(AirDefence.SAM_SA_8_Osa_9A33, "OSA", self.position.x, self.position.y, self.heading)
self.add_unit(AirDefence.SAM_SA_8_Osa_LD_9T217, "LD", self.position.x + 20, self.position.y, self.heading)

20
gen/sam/sam_sa9.py Normal file
View File

@@ -0,0 +1,20 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class SA9Generator(AntiAirGroupGenerator):
"""
This generate a SA-9 group
"""
def generate(self):
self.add_unit(Unarmed.Transport_UAZ_469, "UAZ", self.position.x, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_KAMAZ_43101, "TRUCK", self.position.x+40, self.position.y, self.heading)
num_launchers = random.randint(2, 3)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SAM_SA_9_Strela_1_9P31, "LN#" + str(i), position[0], position[1], position[2])

18
gen/sam/sam_vulcan.py Normal file
View File

@@ -0,0 +1,18 @@
import random
from dcs.vehicles import AirDefence, Unarmed
from gen.sam.group_generator import AntiAirGroupGenerator
class VulcanGenerator(AntiAirGroupGenerator):
"""
This generate a Vulcan group
"""
def generate(self):
self.add_unit(AirDefence.AAA_Vulcan_M163, "SPAAA", self.position.x, self.position.y, self.heading)
if random.randint(0, 1) == 1:
self.add_unit(AirDefence.AAA_Vulcan_M163, "SPAAA2", self.position.x, self.position.y, self.heading)
self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x + 80, self.position.y, self.heading)

18
gen/sam/sam_zsu23.py Normal file
View File

@@ -0,0 +1,18 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class ZSU23Generator(AntiAirGroupGenerator):
"""
This generate a ZSU 23 group
"""
def generate(self):
num_launchers = random.randint(2, 5)
positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
for i, position in enumerate(positions):
self.add_unit(AirDefence.SPAAA_ZSU_23_4_Shilka, "SPAA#" + str(i), position[0], position[1], position[2])

25
gen/sam/sam_zu23.py Normal file
View File

@@ -0,0 +1,25 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class ZU23Generator(AntiAirGroupGenerator):
"""
This generate a ZU23 flak artillery group
"""
def generate(self):
grid_x = random.randint(2, 4)
grid_y = random.randint(2, 4)
spacing = random.randint(10,40)
index = 0
for i in range(grid_x):
for j in range(grid_y):
index = index+1
self.add_unit(AirDefence.AAA_ZU_23_Closed, "AAA#" + str(index),
self.position.x + spacing*i,
self.position.y + spacing*j, self.heading)

18
gen/sam/sam_zu23_ural.py Normal file
View File

@@ -0,0 +1,18 @@
import random
from dcs.vehicles import AirDefence
from gen.sam.group_generator import AntiAirGroupGenerator
class ZU23UralGenerator(AntiAirGroupGenerator):
"""
This generate a Zu23 Ural group
"""
def generate(self):
num_launchers = random.randint(2, 8)
positions = self.get_circular_position(num_launchers, launcher_distance=80, coverage=360)
for i, position in enumerate(positions):
self.add_unit(AirDefence.AAA_ZU_23_on_Ural_375, "SPAA#" + str(i), position[0], position[1], position[2])