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

Faction rework, working :)

Browse Source
This commit is contained in:
Khopa 2020-10-22 13:33:18 +02:00
parent b744238fb8
commit aa1ac56ec3
18 changed files with 163 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
game/db.py
View File

@ -1325,6 +1325,7 @@ def upgrade_to_supercarrier(unit, name: str):
else: else:
return unit return unit
def unit_task(unit: UnitType) -> Optional[Task]: def unit_task(unit: UnitType) -> Optional[Task]:
for task, units in UNIT_BY_TASK.items(): for task, units in UNIT_BY_TASK.items():
if unit in units: if unit in units:
@ -1336,8 +1337,10 @@ def unit_task(unit: UnitType) -> Optional[Task]:
print(unit.name + " cause issue") print(unit.name + " cause issue")
return None return None
def find_unittype(for_task: Task, country_name: str) -> List[UnitType]: def find_unittype(for_task: Task, country_name: str) -> List[UnitType]:
return [x for x in UNIT_BY_TASK[for_task] if x in FACTIONS[country_name]["units"]] return [x for x in UNIT_BY_TASK[for_task] if x in FACTIONS[country_name].units]
def find_infantry(country_name: str) -> List[UnitType]: def find_infantry(country_name: str) -> List[UnitType]:
inf = [ inf = [
@ -1354,14 +1357,17 @@ def find_infantry(country_name: str) -> List[UnitType]:
Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand,
Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents
] ]
return [x for x in inf if x in FACTIONS[country_name]["units"]] return [x for x in inf if x in FACTIONS[country_name].infantry_units]
def unit_type_name(unit_type) -> str: def unit_type_name(unit_type) -> str:
return unit_type.id and unit_type.id or unit_type.name return unit_type.id and unit_type.id or unit_type.name
def unit_type_name_2(unit_type) -> str: def unit_type_name_2(unit_type) -> str:
return unit_type.name and unit_type.name or unit_type.id return unit_type.name and unit_type.name or unit_type.id
def unit_type_from_name(name: str) -> Optional[UnitType]: def unit_type_from_name(name: str) -> Optional[UnitType]:
if name in vehicle_map: if name in vehicle_map:
return vehicle_map[name] return vehicle_map[name]

54
game/factions/faction.py
View File

@ -7,6 +7,7 @@ from dcs.planes import PlaneType, plane_map
from dcs.unittype import VehicleType, UnitType from dcs.unittype import VehicleType, UnitType
from dcs.vehicles import vehicle_map, Armor, Unarmed, Infantry, Fortification, Artillery, AirDefence from dcs.vehicles import vehicle_map, Armor, Unarmed, Infantry, Fortification, Artillery, AirDefence
from game.data.building_data import WW2_ALLIES_BUILDINGS, DEFAULT_AVAILABLE_BUILDINGS, WW2_GERMANY_BUILDINGS
from game.data.doctrine import Doctrine, MODERN_DOCTRINE, COLDWAR_DOCTRINE, WWII_DOCTRINE from game.data.doctrine import Doctrine, MODERN_DOCTRINE, COLDWAR_DOCTRINE, WWII_DOCTRINE
@ -41,14 +42,23 @@ class Faction:
logistics_units: [VehicleType] logistics_units: [VehicleType]
# List of units that can be deployed as SHORAD # List of units that can be deployed as SHORAD
shorad_units: [VehicleType] shorads: [str]
# Possible SAMS site generators for this faction # Possible SAMS site generators for this faction
sams: [str] sams: [str]
# Possible Missile site generators for this faction
missiles: [str]
# Required mods or asset packs # Required mods or asset packs
requirements: {str: str} requirements: {str: str}
# possible aircraft carrier units
aircraft_carrier: [UnitType]
# possible helicopter carrier units
helicopter_carrier: [UnitType]
# Possible carrier names # Possible carrier names
carrier_names: [str] carrier_names: [str]
@ -64,15 +74,24 @@ class Faction:
# Available cruisers # Available cruisers
cruisers: [str] cruisers: [str]
# JTAC # How many navy group should we try to generate per CP on startup for this faction
navy_group_count: int
# How many missiles group should we try to generate per CP on startup for this faction
missiles_group_count: int
# Whether this faction has JTAC access
has_jtac: bool has_jtac: bool
# Unit to use as JTAC # Unit to use as JTAC for this faction
jtac_unit: str jtac_unit: str
# doctrine # doctrine
doctrine: Doctrine doctrine: Doctrine
# List of available buildings for this faction
building_set: [str]
def __init__(self): def __init__(self):
self.country = "" self.country = ""
self.name = "" self.name = ""
@ -83,14 +102,19 @@ class Faction:
self.artillery_units = [] self.artillery_units = []
self.infantry_units = [] self.infantry_units = []
self.logistics_units = [] self.logistics_units = []
self.shorad_units = [] self.shorads = []
self.sams = [] self.sams = []
self.missiles = []
self.requirements = {} self.requirements = {}
self.aircraft_carrier = []
self.helicopter_carrier = []
self.carrier_names = [] self.carrier_names = []
self.lha_names = [] self.lha_names = []
self.navy_generators = [] self.navy_generators = []
self.destroyers = [] self.destroyers = []
self.cruisers = [] self.cruisers = []
self.navy_group_count = 0
self.missiles_group_count = 0
self.has_jtac = False self.has_jtac = False
self.jtac_unit = "" self.jtac_unit = ""
self.doctrine = None self.doctrine = None
@ -111,18 +135,23 @@ class Faction:
faction.artillery_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("artillery_units", [])] if f is not None] faction.artillery_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("artillery_units", [])] if f is not None]
faction.infantry_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("infantry_units", [])] if f is not None] faction.infantry_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("infantry_units", [])] if f is not None]
faction.logistics_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("logistics_units", [])] if f is not None] faction.logistics_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("logistics_units", [])] if f is not None]
faction.shorad_units = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("shorad_units", [])] if f is not None] faction.shorads = [f for f in [vehicle_loader(vehicle) for vehicle in json.get("shorads", [])] if f is not None]
faction.sams = json.get("sams", []) faction.sams = json.get("sams", [])
faction.missiles = json.get("missiles", [])
faction.name = json.get("requirements", {}) faction.name = json.get("requirements", {})
faction.carrier_names = json.get("carrier_names", []) faction.carrier_names = json.get("carrier_names", [])
faction.lha_names = json.get("lha_names", []) faction.lha_names = json.get("lha_names", [])
faction.navy_generators = json.get("navy_generators", []) faction.navy_generators = json.get("navy_generators", [])
faction.aircraft_carrier = [f for f in [ship_loader(vehicle) for vehicle in json.get("aircraft_carrier", [])] if f is not None]
faction.helicopter_carrier = [f for f in [ship_loader(vehicle) for vehicle in json.get("helicopter_carrier", [])] if f is not None]
faction.destroyers = [f for f in [ship_loader(vehicle) for vehicle in json.get("destroyers", [])] if f is not None] faction.destroyers = [f for f in [ship_loader(vehicle) for vehicle in json.get("destroyers", [])] if f is not None]
faction.cruisers = [f for f in [ship_loader(vehicle) for vehicle in json.get("cruisers", [])] if f is not None] faction.cruisers = [f for f in [ship_loader(vehicle) for vehicle in json.get("cruisers", [])] if f is not None]
faction.has_jtac = json.get("has_jtac", False) faction.has_jtac = json.get("has_jtac", False)
faction.jtac_unit = json.get("jtac_unit", "") faction.jtac_unit = aircraft_loader(json.get("jtac_unit", None))
faction.navy_group_count = int(json.get("navy_group_count", 1))
faction.missiles_group_count = int(json.get("missiles_group_count", 0))
# Load doctrine # Load doctrine
doctrine = json.get("doctrine", "modern") doctrine = json.get("doctrine", "modern")
@ -133,6 +162,15 @@ class Faction:
else: else:
faction.doctrine = WWII_DOCTRINE faction.doctrine = WWII_DOCTRINE
# Load the building set
building_set = json.get("building_set", "default")
if building_set == "default":
faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
elif building_set == "ww2ally":
faction.building_set = WW2_ALLIES_BUILDINGS
else:
faction.building_set = WW2_GERMANY_BUILDINGS
return faction return faction
@property @property
@ -146,7 +184,9 @@ def unit_loader(unit: str, class_repository:[]) -> Optional[PlaneType]:
:param unit: Unit name as string :param unit: Unit name as string
:return: The unit as a PyDCS type :return: The unit as a PyDCS type
""" """
if unit in plane_map.keys(): if unit is None:
return None
elif unit in plane_map.keys():
return plane_map[unit] return plane_map[unit]
else: else:
for mother_class in class_repository: for mother_class in class_repository:

16
game/game.py
View File

@ -26,6 +26,7 @@ from . import persistency
from .debriefing import Debriefing from .debriefing import Debriefing
from .event.event import Event, UnitsDeliveryEvent from .event.event import Event, UnitsDeliveryEvent
from .event.frontlineattack import FrontlineAttackEvent from .event.frontlineattack import FrontlineAttackEvent
from .factions.faction import Faction
from .infos.information import Information from .infos.information import Information
from .settings import Settings from .settings import Settings
from plugin import LuaPluginManager from plugin import LuaPluginManager
@ -76,9 +77,9 @@ class Game:
self.events: List[Event] = [] self.events: List[Event] = []
self.theater = theater self.theater = theater
self.player_name = player_name self.player_name = player_name
self.player_country = db.FACTIONS[player_name]["country"] self.player_country = db.FACTIONS[player_name].country
self.enemy_name = enemy_name self.enemy_name = enemy_name
self.enemy_country = db.FACTIONS[enemy_name]["country"] self.enemy_country = db.FACTIONS[enemy_name].country
self.turn = 0 self.turn = 0
self.date = date(start_date.year, start_date.month, start_date.day) self.date = date(start_date.year, start_date.month, start_date.day)
self.game_stats = GameStats() self.game_stats = GameStats()
@ -123,11 +124,11 @@ class Game:
self.enemy_country = "Russia" self.enemy_country = "Russia"
@property @property
def player_faction(self) -> Dict[str, Any]: def player_faction(self) -> Faction:
return db.FACTIONS[self.player_name] return db.FACTIONS[self.player_name]
@property @property
def enemy_faction(self) -> Dict[str, Any]: def enemy_faction(self) -> Faction:
return db.FACTIONS[self.enemy_name] return db.FACTIONS[self.enemy_name]
def _roll(self, prob, mult): def _roll(self, prob, mult):
@ -314,7 +315,7 @@ class Game:
potential_cp_armor = self.theater.enemy_points() potential_cp_armor = self.theater.enemy_points()
i = 0 i = 0
potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if u in db.UNIT_BY_TASK[PinpointStrike]] potential_units = db.FACTIONS[self.enemy_name].frontline_units
print("Enemy Recruiting") print("Enemy Recruiting")
print(potential_cp_armor) print(potential_cp_armor)
@ -340,8 +341,9 @@ class Game:
if budget_for_armored_units > 0: if budget_for_armored_units > 0:
budget_for_aircraft += budget_for_armored_units budget_for_aircraft += budget_for_armored_units
potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if potential_units = [u for u in db.FACTIONS[self.enemy_name].aircrafts
u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]] if u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]]
if len(potential_units) > 0 and len(potential_cp_armor) > 0: if len(potential_units) > 0 and len(potential_cp_armor) > 0:
while budget_for_aircraft > 0: while budget_for_aircraft > 0:
i = i + 1 i = i + 1

4
game/operation/operation.py
View File

@ -66,9 +66,9 @@ class Operation:
to_cp: ControlPoint): to_cp: ControlPoint):
self.game = game self.game = game
self.attacker_name = attacker_name self.attacker_name = attacker_name
self.attacker_country = db.FACTIONS[attacker_name]["country"] self.attacker_country = db.FACTIONS[attacker_name].country
self.defender_name = defender_name self.defender_name = defender_name
self.defender_country = db.FACTIONS[defender_name]["country"] self.defender_country = db.FACTIONS[defender_name].country
print(self.defender_country, self.attacker_country) print(self.defender_country, self.attacker_country)
self.from_cp = from_cp self.from_cp = from_cp
self.departure_cp = departure_cp self.departure_cp = departure_cp

6
gen/armor.py
View File

@ -142,13 +142,13 @@ class GroundConflictGenerator:
# Add JTAC # Add JTAC
jtacPlugin = LuaPluginManager().getPlugin("jtacautolase") jtacPlugin = LuaPluginManager().getPlugin("jtacautolase")
useJTAC = jtacPlugin and jtacPlugin.isEnabled() useJTAC = jtacPlugin and jtacPlugin.isEnabled()
if "has_jtac" in self.game.player_faction and self.game.player_faction["has_jtac"] and useJTAC: if self.game.player_faction.has_jtac and useJTAC:
n = "JTAC" + str(self.conflict.from_cp.id) + str(self.conflict.to_cp.id) n = "JTAC" + str(self.conflict.from_cp.id) + str(self.conflict.to_cp.id)
code = 1688 - len(self.jtacs) code = 1688 - len(self.jtacs)
utype = MQ_9_Reaper utype = MQ_9_Reaper
if "jtac_unit" in self.game.player_faction: if self.game.player_faction.jtac_unit is not None:
utype = self.game.player_faction["jtac_unit"] utype = self.game.player_faction.jtac_unit
jtac = self.mission.flight_group(country=self.mission.country(self.game.player_country), jtac = self.mission.flight_group(country=self.mission.country(self.game.player_country),
name=n, name=n,

3
gen/defenses/armor_group_generator.py
View File

@ -11,8 +11,7 @@ def generate_armor_group(faction:str, game, ground_object):
This generate a group of ground units This generate a group of ground units
:return: Generated group :return: Generated group
""" """
possible_unit = [u for u in db.FACTIONS[faction].frontline_units if u in Armor.__dict__.values()]
possible_unit = [u for u in db.FACTIONS[faction]["units"] if u in Armor.__dict__.values()]
if len(possible_unit) > 0: if len(possible_unit) > 0:
unit_type = random.choice(possible_unit) unit_type = random.choice(possible_unit)
return generate_armor_group_of_type(game, ground_object, unit_type) return generate_armor_group_of_type(game, ground_object, unit_type)

12
gen/fleet/carrier_group.py
View File

@ -12,19 +12,15 @@ class CarrierGroupGenerator(GroupGenerator):
def generate(self): def generate(self):
# Add carrier # Add carrier
if "aircraft_carrier" in self.faction.keys(): if len(self.faction.aircraft_carrier) > 0:
carrier_type = random.choice(self.faction.aircraft_carrier)
if "supercarrier" in self.faction.keys() and self.game.settings.supercarrier:
carrier_type = random.choice(self.faction["supercarrier"])
else:
carrier_type = random.choice(self.faction["aircraft_carrier"])
self.add_unit(carrier_type, "Carrier", self.position.x, self.position.y, self.heading) self.add_unit(carrier_type, "Carrier", self.position.x, self.position.y, self.heading)
else: else:
return return
# Add destroyers escort # Add destroyers escort
if "destroyer" in self.faction.keys(): if len(self.faction.destroyers) > 0:
dd_type = random.choice(self.faction["destroyer"]) dd_type = random.choice(self.faction.destroyers)
self.add_unit(dd_type, "DD1", self.position.x + 2500, self.position.y + 4500, self.heading) self.add_unit(dd_type, "DD1", self.position.x + 2500, self.position.y + 4500, self.heading)
self.add_unit(dd_type, "DD2", self.position.x + 2500, self.position.y - 4500, self.heading) self.add_unit(dd_type, "DD2", self.position.x + 2500, self.position.y - 4500, self.heading)

10
gen/fleet/lha_group.py
View File

@ -12,13 +12,15 @@ class LHAGroupGenerator(GroupGenerator):
def generate(self): def generate(self):
# Add carrier # Add carrier
if "helicopter_carrier" in self.faction.keys(): if len(self.faction.helicopter_carrier) > 0:
carrier_type = random.choice(self.faction["helicopter_carrier"]) carrier_type = random.choice(self.faction.helicopter_carrier)
self.add_unit(carrier_type, "LHA", self.position.x, self.position.y, self.heading) self.add_unit(carrier_type, "LHA", self.position.x, self.position.y, self.heading)
else:
return
# Add destroyers escort # Add destroyers escort
if "destroyer" in self.faction.keys(): if len(self.faction.destroyers) > 0:
dd_type = random.choice(self.faction["destroyer"]) dd_type = random.choice(self.faction.destroyers)
self.add_unit(dd_type, "DD1", self.position.x + 1250, self.position.y + 1450, self.heading) self.add_unit(dd_type, "DD1", self.position.x + 1250, self.position.y + 1450, self.heading)
self.add_unit(dd_type, "DD2", self.position.x + 1250, self.position.y - 1450, self.heading) self.add_unit(dd_type, "DD2", self.position.x + 1250, self.position.y - 1450, self.heading)

18
gen/fleet/ship_group_generator.py
View File

@ -34,16 +34,14 @@ def generate_ship_group(game, ground_object, faction_name: str):
:return: Nothing, but put the group reference inside the ground object :return: Nothing, but put the group reference inside the ground object
""" """
faction = db.FACTIONS[faction_name] faction = db.FACTIONS[faction_name]
if "boat" in faction: if len(faction.navy_generators) > 0:
generators = faction["boat"] gen = random.choice(faction.navy_generators)
if len(generators) > 0: if gen in SHIP_MAP.keys():
gen = random.choice(generators) generator = SHIP_MAP[gen](game, ground_object, faction)
if gen in SHIP_MAP.keys(): generator.generate()
generator = SHIP_MAP[gen](game, ground_object, faction) return generator.get_generated_group()
generator.generate() else:
return generator.get_generated_group() logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
else:
logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
return None return None

2
gen/flights/flightplan.py
View File

@ -46,7 +46,7 @@ class FlightPlanBuilder:
faction = self.game.player_faction faction = self.game.player_faction
else: else:
faction = self.game.enemy_faction faction = self.game.enemy_faction
self.doctrine: Doctrine = faction.get("doctrine", MODERN_DOCTRINE) self.doctrine: Doctrine = faction.doctrine
def populate_flight_plan( def populate_flight_plan(
self, flight: Flight, self, flight: Flight,

4
gen/missiles/missiles_group_generator.py
View File

@ -14,8 +14,8 @@ def generate_missile_group(game, ground_object, faction_name: str):
:return: Nothing, but put the group reference inside the ground object :return: Nothing, but put the group reference inside the ground object
""" """
faction = db.FACTIONS[faction_name] faction = db.FACTIONS[faction_name]
if "missiles" in faction: if len(faction.missiles) > 0:
generators = faction["missiles"] generators = faction.missiles
if len(generators) > 0: if len(generators) > 0:
gen = random.choice(generators) gen = random.choice(generators)
if gen in MISSILES_MAP.keys(): if gen in MISSILES_MAP.keys():

87
gen/sam/sam_group_generator.py
View File

@ -34,37 +34,33 @@ from gen.sam.sam_zu23_ural import ZU23UralGenerator
from gen.sam.sam_zu23_ural_insurgent import ZU23UralInsurgentGenerator from gen.sam.sam_zu23_ural_insurgent import ZU23UralInsurgentGenerator
SAM_MAP = { SAM_MAP = {
AirDefence.SAM_Hawk_PCP: HawkGenerator, "HawkGenerator": HawkGenerator,
AirDefence.AAA_ZU_23_Emplacement: ZU23Generator, "ZU23Generator": ZU23Generator,
AirDefence.AAA_ZU_23_Closed: ZU23Generator, "ZU23UralGenerator": ZU23UralGenerator,
AirDefence.AAA_ZU_23_on_Ural_375: ZU23UralGenerator, "ZU23UralInsurgentGenerator": ZU23UralInsurgentGenerator,
AirDefence.AAA_ZU_23_Insurgent_on_Ural_375: ZU23UralInsurgentGenerator, "ZU23InsurgentGenerator": ZU23InsurgentGenerator,
AirDefence.AAA_ZU_23_Insurgent_Closed: ZU23InsurgentGenerator, "ZSU23Generator": ZSU23Generator,
AirDefence.AAA_ZU_23_Insurgent: ZU23InsurgentGenerator, "VulcanGenerator": VulcanGenerator,
AirDefence.SPAAA_ZSU_23_4_Shilka: ZSU23Generator, "LinebackerGenerator": LinebackerGenerator,
AirDefence.AAA_Vulcan_M163: VulcanGenerator, "RapierGenerator": RapierGenerator,
AirDefence.SAM_Linebacker_M6: LinebackerGenerator, "AvengerGenerator": AvengerGenerator,
AirDefence.Rapier_FSA_Launcher: RapierGenerator, "GepardGenerator": GepardGenerator,
AirDefence.SAM_Avenger_M1097: AvengerGenerator, "RolandGenerator": RolandGenerator,
AirDefence.SPAAA_Gepard: GepardGenerator, "PatriotGenerator": PatriotGenerator,
AirDefence.SAM_Roland_ADS: RolandGenerator, "ChaparralGenerator": ChaparralGenerator,
AirDefence.SAM_Patriot_LN_M901: PatriotGenerator, "BoforsGenerator": BoforsGenerator,
AirDefence.SAM_Patriot_EPP_III: PatriotGenerator, "FlakGenerator": FlakGenerator,
AirDefence.SAM_Chaparral_M48: ChaparralGenerator, "SA2Generator": SA2Generator,
AirDefence.AAA_Bofors_40mm: BoforsGenerator, "SA3Generator": SA3Generator,
AirDefence.AAA_8_8cm_Flak_36: FlakGenerator, "SA6Generator": SA6Generator,
AirDefence.SAM_SA_2_LN_SM_90: SA2Generator, "SA8Generator": SA8Generator,
AirDefence.SAM_SA_3_S_125_LN_5P73: SA3Generator, "SA9Generator": SA9Generator,
AirDefence.SAM_SA_6_Kub_LN_2P25: SA6Generator, "SA10Generator": SA10Generator,
AirDefence.SAM_SA_8_Osa_9A33: SA8Generator, "SA11Generator": SA11Generator,
AirDefence.SAM_SA_9_Strela_1_9P31: SA9Generator, "SA13Generator": SA13Generator,
AirDefence.SAM_SA_10_S_300PS_LN_5P85C: SA10Generator, "SA15Generator": SA15Generator,
AirDefence.SAM_SA_10_S_300PS_CP_54K6: SA10Generator, "SA19Generator": SA19Generator,
AirDefence.SAM_SA_11_Buk_LN_9A310M1: SA11Generator, "HQ7Generator": HQ7Generator
AirDefence.SAM_SA_13_Strela_10M3_9A35M3: SA13Generator,
AirDefence.SAM_SA_15_Tor_9A331: SA15Generator,
AirDefence.SAM_SA_19_Tunguska_2S6: SA19Generator,
AirDefence.HQ_7_Self_Propelled_LN: HQ7Generator
} }
SAM_PRICES = { SAM_PRICES = {
@ -102,20 +98,12 @@ SAM_PRICES = {
} }
def get_faction_possible_sams_units(faction: str) -> List[UnitType]:
"""
Return the list
:param faction: Faction to search units for
"""
return [u for u in db.FACTIONS[faction]["units"] if u in AirDefence.__dict__.values()]
def get_faction_possible_sams_generator(faction: str) -> List[UnitType]: def get_faction_possible_sams_generator(faction: str) -> List[UnitType]:
""" """
Return the list of possible SAM generator for the given faction Return the list of possible SAM generator for the given faction
:param faction: Faction to search units for :param faction: Faction name to search units for
""" """
return [SAM_MAP[u] for u in get_faction_possible_sams_units(faction)] return db.FACTIONS[faction].sams
def generate_anti_air_group(game, parent_cp, ground_object, faction:str): def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
@ -126,24 +114,25 @@ def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
:param country: Owner country :param country: Owner country
:return: Nothing, but put the group reference inside the ground object :return: Nothing, but put the group reference inside the ground object
""" """
possible_sams = get_faction_possible_sams_units(faction) possible_sams_generators = get_faction_possible_sams_generator(faction)
if len(possible_sams) > 0: if len(possible_sams_generators) > 0:
sam = random.choice(possible_sams) sam = random.choice(possible_sams_generators)
generator = SAM_MAP[sam](game, ground_object) generator = SAM_MAP[sam](game, ground_object)
generator.generate() generator.generate()
return generator.get_generated_group() return generator.get_generated_group()
return None return None
def generate_shorad_group(game, parent_cp, ground_object, faction:str): def generate_shorad_group(game, parent_cp, ground_object, faction_name: str):
if("shorad") in db.FACTIONS[faction].keys(): faction = db.FACTIONS[faction_name]
shorad = db.FACTIONS[faction]["shorad"]
sam = random.choice(shorad) if len(faction.shorads) > 0:
sam = random.choice(faction.shorads)
generator = SAM_MAP[sam](game, ground_object) generator = SAM_MAP[sam](game, ground_object)
generator.generate() generator.generate()
return generator.get_generated_group() return generator.get_generated_group()
else: else:
return generate_anti_air_group(game, parent_cp, ground_object, faction) return generate_anti_air_group(game, parent_cp, ground_object, faction_name)

12
resources/factions/china_2010.json
View File

@ -35,11 +35,11 @@
"Infantry_Soldier_Rus", "Infantry_Soldier_Rus",
"Paratrooper_RPG_16" "Paratrooper_RPG_16"
], ],
"shorad_units": [ "shorads": [
"SAM_SA_9_Strela_1_9P31", "SA9Generator",
"SAM_SA_13_Strela_10M3_9A35M3", "SA13Generator",
"SPAAA_ZSU_23_4_Shilka", "ZSU23Generator",
"AAA_ZU_23_Closed" "ZU23Generator"
], ],
"sams": [ "sams": [
"HQ7Generator", "HQ7Generator",
@ -65,7 +65,7 @@
"Wuzhi Shan", "Wuzhi Shan",
"Wudang Shan" "Wudang Shan"
], ],
"destroyer": [ "destroyers": [
"Type_052B_Destroyer", "Type_052B_Destroyer",
"Type_052C_Destroyer" "Type_052C_Destroyer"
], ],

14
resources/factions/russia_1990.json
View File

@ -38,11 +38,11 @@
"Infantry_Soldier_Rus", "Infantry_Soldier_Rus",
"Paratrooper_RPG_16" "Paratrooper_RPG_16"
], ],
"shorad_units": [ "shorads": [
"SAM_SA_9_Strela_1_9P31", "SA9Generator",
"SAM_SA_13_Strela_10M3_9A35M3", "SA13Generator",
"SPAAA_ZSU_23_4_Shilka", "ZSU23Generator",
"AAA_ZU_23_Closed" "ZU23Generator"
], ],
"sams": [ "sams": [
"SA6Generator", "SA6Generator",
@ -55,10 +55,10 @@
], ],
"lhanames": [ "lhanames": [
], ],
"destroyer": [ "destroyers": [
"FF_1135M_Rezky" "FF_1135M_Rezky"
], ],
"cruiser": [ "cruisers": [
"FSG_1241_1MP_Molniya" "FSG_1241_1MP_Molniya"
], ],
"requirements": {}, "requirements": {},

10
resources/factions/russia_2010.json
View File

@ -45,9 +45,9 @@
"Infantry_Soldier_Rus", "Infantry_Soldier_Rus",
"Paratrooper_RPG_16" "Paratrooper_RPG_16"
], ],
"shorad_units": [ "shorads": [
"SAM_SA_19_Tunguska_2S6", "SA19Generator",
"SAM_SA_13_Strela_10M3_9A35M3" "SA13Generator"
], ],
"sams": [ "sams": [
"SA11Generator", "SA11Generator",
@ -62,10 +62,10 @@
], ],
"lhanames": [ "lhanames": [
], ],
"destroyer": [ "destroyers": [
"FF_1135M_Rezky" "FF_1135M_Rezky"
], ],
"cruiser": [ "cruisers": [
"FSG_1241_1MP_Molniya" "FSG_1241_1MP_Molniya"
], ],
"requirements": {}, "requirements": {},

8
resources/factions/usa_2005.json
View File

@ -40,8 +40,8 @@
"Infantry_M4", "Infantry_M4",
"Soldier_M249" "Soldier_M249"
], ],
"shorad_units": [ "shorads": [
"SAM_Avenger_M1097" "AvengerGenerator"
], ],
"sams": [ "sams": [
"HawkGenerator", "HawkGenerator",
@ -53,10 +53,10 @@
"helicopter_carrier": [ "helicopter_carrier": [
"LHA_1_Tarawa" "LHA_1_Tarawa"
], ],
"destroyer": [ "destroyers": [
"USS_Arleigh_Burke_IIa" "USS_Arleigh_Burke_IIa"
], ],
"cruiser": [ "cruisers": [
"Ticonderoga_class" "Ticonderoga_class"
], ],
"requirements": {}, "requirements": {},

2
resources/tools/generate_loadout_check.py
View File

@ -20,7 +20,7 @@ for t, uts in db.UNIT_BY_TASK.items():
pos.x += 10000 pos.x += 10000
for ut in uts: for ut in uts:
pos.y += 5000 pos.y += 5000
ctr = mis.country([v["country"] for k, v in db.FACTIONS.items() if ut in v["units"]][0]) ctr = mis.country([v["country"] for k, v in db.FACTIONS.items() if ut in v.units][0])
g = mis.flight_group_inflight( g = mis.flight_group_inflight(
country=ctr, country=ctr,

34
theater/start_generator.py
View File

@ -31,7 +31,7 @@ from theater import (
) )
from theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW from theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW
UNIT_VARIETY = 3 UNIT_VARIETY = 6
UNIT_AMOUNT_FACTOR = 16 UNIT_AMOUNT_FACTOR = 16
UNIT_COUNT_IMPORTANCE_LOG = 1.3 UNIT_COUNT_IMPORTANCE_LOG = 1.3
@ -90,6 +90,7 @@ def generate_groundobjects(theater: ConflictTheater, game):
faction_name = game.player_name faction_name = game.player_name
else: else:
faction_name = game.enemy_name faction_name = game.enemy_name
faction = db.FACTIONS[faction_name]
if cp.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP: if cp.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP:
# Create ground object group # Create ground object group
@ -110,8 +111,8 @@ def generate_groundobjects(theater: ConflictTheater, game):
g.groups.append(group) g.groups.append(group)
cp.ground_objects.append(g) cp.ground_objects.append(g)
# Set new name : # Set new name :
if "carrier_names" in db.FACTIONS[faction_name]: if len(faction.carrier_names) > 0:
cp.name = random.choice(db.FACTIONS[faction_name]["carrier_names"]) cp.name = random.choice(faction.carrier_names)
else: else:
cp_to_remove.append(cp) cp_to_remove.append(cp)
elif cp.cptype == ControlPointType.LHA_GROUP: elif cp.cptype == ControlPointType.LHA_GROUP:
@ -133,8 +134,8 @@ def generate_groundobjects(theater: ConflictTheater, game):
g.groups.append(group) g.groups.append(group)
cp.ground_objects.append(g) cp.ground_objects.append(g)
# Set new name : # Set new name :
if "lhanames" in db.FACTIONS[faction_name]: if len(faction.lha_names) > 0:
cp.name = random.choice(db.FACTIONS[faction_name]["lhanames"]) cp.name = random.choice(faction.lha_names)
else: else:
cp_to_remove.append(cp) cp_to_remove.append(cp)
else: else:
@ -171,19 +172,14 @@ def generate_groundobjects(theater: ConflictTheater, game):
logging.info(ground_object.groups) logging.info(ground_object.groups)
# Generate navy groups # Generate navy groups
if "boat" in db.FACTIONS[faction_name].keys() and cp.allow_sea_units: if len(faction.navy_generators) > 0 and cp.allow_sea_units:
if cp.captured and game.settings.do_not_generate_player_navy: if cp.captured and game.settings.do_not_generate_player_navy:
continue continue
if not cp.captured and game.settings.do_not_generate_enemy_navy: if not cp.captured and game.settings.do_not_generate_enemy_navy:
continue continue
boat_count = 1 for i in range(faction.navy_group_count):
if "boat_count" in db.FACTIONS[faction_name].keys():
boat_count = int(db.FACTIONS[faction_name]["boat_count"])
for i in range(boat_count):
point = find_location(False, cp.position, theater, 5000, 40000, [], False) point = find_location(False, cp.position, theater, 5000, 40000, [], False)
@ -210,15 +206,9 @@ def generate_groundobjects(theater: ConflictTheater, game):
g.groups.append(group) g.groups.append(group)
cp.ground_objects.append(g) cp.ground_objects.append(g)
if len(faction.missiles) > 0:
for i in range(faction.missiles_group_count):
if "missiles" in db.FACTIONS[faction_name].keys():
missiles_count = 1
if "missiles_count" in db.FACTIONS[faction_name].keys():
missiles_count = int(db.FACTIONS[faction_name]["missiles_count"])
for i in range(missiles_count):
point = find_location(True, cp.position, theater, 2500, 40000, [], False) point = find_location(True, cp.position, theater, 2500, 40000, [], False)
@ -347,9 +337,7 @@ def generate_cp_ground_points(cp: ControlPoint, theater, game, group_id, templat
faction = game.enemy_name faction = game.enemy_name
faction_data = db.FACTIONS[faction] faction_data = db.FACTIONS[faction]
available_categories = DEFAULT_AVAILABLE_BUILDINGS available_categories = faction_data.building_set
if "objects" in faction_data.keys():
available_categories = faction_data["objects"]
if len(available_categories) == 0: if len(available_categories) == 0:
return False return False