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:
return unit
def unit_task(unit: UnitType) -> Optional[Task]:
for task, units in UNIT_BY_TASK.items():
if unit in units:
@ -1336,8 +1337,10 @@ def unit_task(unit: UnitType) -> Optional[Task]:
print(unit.name + " cause issue")
return None
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]:
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_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:
return unit_type.id and unit_type.id or unit_type.name
def unit_type_name_2(unit_type) -> str:
return unit_type.name and unit_type.name or unit_type.id
def unit_type_from_name(name: str) -> Optional[UnitType]:
if name in vehicle_map:
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.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
@ -41,14 +42,23 @@ class Faction:
logistics_units: [VehicleType]
# List of units that can be deployed as SHORAD
shorad_units: [VehicleType]
shorads: [str]
# Possible SAMS site generators for this faction
sams: [str]
# Possible Missile site generators for this faction
missiles: [str]
# Required mods or asset packs
requirements: {str: str}
# possible aircraft carrier units
aircraft_carrier: [UnitType]
# possible helicopter carrier units
helicopter_carrier: [UnitType]
# Possible carrier names
carrier_names: [str]
@ -64,15 +74,24 @@ class Faction:
# Available cruisers
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
# Unit to use as JTAC
# Unit to use as JTAC for this faction
jtac_unit: str
# doctrine
doctrine: Doctrine
# List of available buildings for this faction
building_set: [str]
def __init__(self):
self.country = ""
self.name = ""
@ -83,14 +102,19 @@ class Faction:
self.artillery_units = []
self.infantry_units = []
self.logistics_units = []
self.shorad_units = []
self.shorads = []
self.sams = []
self.missiles = []
self.requirements = {}
self.aircraft_carrier = []
self.helicopter_carrier = []
self.carrier_names = []
self.lha_names = []
self.navy_generators = []
self.destroyers = []
self.cruisers = []
self.navy_group_count = 0
self.missiles_group_count = 0
self.has_jtac = False
self.jtac_unit = ""
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.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.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.missiles = json.get("missiles", [])
faction.name = json.get("requirements", {})
faction.carrier_names = json.get("carrier_names", [])
faction.lha_names = json.get("lha_names", [])
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.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.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
doctrine = json.get("doctrine", "modern")
@ -133,6 +162,15 @@ class Faction:
else:
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
@property
@ -146,7 +184,9 @@ def unit_loader(unit: str, class_repository:[]) -> Optional[PlaneType]:
:param unit: Unit name as string
: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]
else:
for mother_class in class_repository:

16
game/game.py
View File

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

4
game/operation/operation.py
View File

@ -66,9 +66,9 @@ class Operation:
to_cp: ControlPoint):
self.game = game
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_country = db.FACTIONS[defender_name]["country"]
self.defender_country = db.FACTIONS[defender_name].country
print(self.defender_country, self.attacker_country)
self.from_cp = from_cp
self.departure_cp = departure_cp

6
gen/armor.py
View File

@ -142,13 +142,13 @@ class GroundConflictGenerator:
# Add JTAC
jtacPlugin = LuaPluginManager().getPlugin("jtacautolase")
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)
code = 1688 - len(self.jtacs)
utype = MQ_9_Reaper
if "jtac_unit" in self.game.player_faction:
utype = self.game.player_faction["jtac_unit"]
if self.game.player_faction.jtac_unit is not None:
utype = self.game.player_faction.jtac_unit
jtac = self.mission.flight_group(country=self.mission.country(self.game.player_country),
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
:return: Generated group
"""
possible_unit = [u for u in db.FACTIONS[faction]["units"] if u in Armor.__dict__.values()]
possible_unit = [u for u in db.FACTIONS[faction].frontline_units if u in Armor.__dict__.values()]
if len(possible_unit) > 0:
unit_type = random.choice(possible_unit)
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):
# Add carrier
if "aircraft_carrier" in self.faction.keys():
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"])
if len(self.faction.aircraft_carrier) > 0:
carrier_type = random.choice(self.faction.aircraft_carrier)
self.add_unit(carrier_type, "Carrier", self.position.x, self.position.y, self.heading)
else:
return
# Add destroyers escort
if "destroyer" in self.faction.keys():
dd_type = random.choice(self.faction["destroyer"])
if len(self.faction.destroyers) > 0:
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, "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):
# Add carrier
if "helicopter_carrier" in self.faction.keys():
carrier_type = random.choice(self.faction["helicopter_carrier"])
if len(self.faction.helicopter_carrier) > 0:
carrier_type = random.choice(self.faction.helicopter_carrier)
self.add_unit(carrier_type, "LHA", self.position.x, self.position.y, self.heading)
else:
return
# Add destroyers escort
if "destroyer" in self.faction.keys():
dd_type = random.choice(self.faction["destroyer"])
if len(self.faction.destroyers) > 0:
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, "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
"""
faction = db.FACTIONS[faction_name]
if "boat" in faction:
generators = faction["boat"]
if len(generators) > 0:
gen = random.choice(generators)
if gen in SHIP_MAP.keys():
generator = SHIP_MAP[gen](game, ground_object, faction)
generator.generate()
return generator.get_generated_group()
else:
logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
if len(faction.navy_generators) > 0:
gen = random.choice(faction.navy_generators)
if gen in SHIP_MAP.keys():
generator = SHIP_MAP[gen](game, ground_object, faction)
generator.generate()
return generator.get_generated_group()
else:
logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
return None

2
gen/flights/flightplan.py
View File

@ -46,7 +46,7 @@ class FlightPlanBuilder:
faction = self.game.player_faction
else:
faction = self.game.enemy_faction
self.doctrine: Doctrine = faction.get("doctrine", MODERN_DOCTRINE)
self.doctrine: Doctrine = faction.doctrine
def populate_flight_plan(
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
"""
faction = db.FACTIONS[faction_name]
if "missiles" in faction:
generators = faction["missiles"]
if len(faction.missiles) > 0:
generators = faction.missiles
if len(generators) > 0:
gen = random.choice(generators)
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
SAM_MAP = {
AirDefence.SAM_Hawk_PCP: HawkGenerator,
AirDefence.AAA_ZU_23_Emplacement: ZU23Generator,
AirDefence.AAA_ZU_23_Closed: ZU23Generator,
AirDefence.AAA_ZU_23_on_Ural_375: ZU23UralGenerator,
AirDefence.AAA_ZU_23_Insurgent_on_Ural_375: ZU23UralInsurgentGenerator,
AirDefence.AAA_ZU_23_Insurgent_Closed: ZU23InsurgentGenerator,
AirDefence.AAA_ZU_23_Insurgent: ZU23InsurgentGenerator,
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_Patriot_EPP_III: PatriotGenerator,
AirDefence.SAM_Chaparral_M48: ChaparralGenerator,
AirDefence.AAA_Bofors_40mm: BoforsGenerator,
AirDefence.AAA_8_8cm_Flak_36: FlakGenerator,
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,
AirDefence.HQ_7_Self_Propelled_LN: HQ7Generator
"HawkGenerator": HawkGenerator,
"ZU23Generator": ZU23Generator,
"ZU23UralGenerator": ZU23UralGenerator,
"ZU23UralInsurgentGenerator": ZU23UralInsurgentGenerator,
"ZU23InsurgentGenerator": ZU23InsurgentGenerator,
"ZSU23Generator": ZSU23Generator,
"VulcanGenerator": VulcanGenerator,
"LinebackerGenerator": LinebackerGenerator,
"RapierGenerator": RapierGenerator,
"AvengerGenerator": AvengerGenerator,
"GepardGenerator": GepardGenerator,
"RolandGenerator": RolandGenerator,
"PatriotGenerator": PatriotGenerator,
"ChaparralGenerator": ChaparralGenerator,
"BoforsGenerator": BoforsGenerator,
"FlakGenerator": FlakGenerator,
"SA2Generator": SA2Generator,
"SA3Generator": SA3Generator,
"SA6Generator": SA6Generator,
"SA8Generator": SA8Generator,
"SA9Generator": SA9Generator,
"SA10Generator": SA10Generator,
"SA11Generator": SA11Generator,
"SA13Generator": SA13Generator,
"SA15Generator": SA15Generator,
"SA19Generator": SA19Generator,
"HQ7Generator": HQ7Generator
}
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]:
"""
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):
@ -126,24 +114,25 @@ def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
:param country: Owner country
:return: Nothing, but put the group reference inside the ground object
"""
possible_sams = get_faction_possible_sams_units(faction)
if len(possible_sams) > 0:
sam = random.choice(possible_sams)
possible_sams_generators = get_faction_possible_sams_generator(faction)
if len(possible_sams_generators) > 0:
sam = random.choice(possible_sams_generators)
generator = SAM_MAP[sam](game, ground_object)
generator.generate()
return generator.get_generated_group()
return None
def generate_shorad_group(game, parent_cp, ground_object, faction:str):
if("shorad") in db.FACTIONS[faction].keys():
shorad = db.FACTIONS[faction]["shorad"]
sam = random.choice(shorad)
def generate_shorad_group(game, parent_cp, ground_object, faction_name: str):
faction = db.FACTIONS[faction_name]
if len(faction.shorads) > 0:
sam = random.choice(faction.shorads)
generator = SAM_MAP[sam](game, ground_object)
generator.generate()
return generator.get_generated_group()
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",
"Paratrooper_RPG_16"
],
"shorad_units": [
"SAM_SA_9_Strela_1_9P31",
"SAM_SA_13_Strela_10M3_9A35M3",
"SPAAA_ZSU_23_4_Shilka",
"AAA_ZU_23_Closed"
"shorads": [
"SA9Generator",
"SA13Generator",
"ZSU23Generator",
"ZU23Generator"
],
"sams": [
"HQ7Generator",
@ -65,7 +65,7 @@
"Wuzhi Shan",
"Wudang Shan"
],
"destroyer": [
"destroyers": [
"Type_052B_Destroyer",
"Type_052C_Destroyer"
],

14
resources/factions/russia_1990.json
View File

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

10
resources/factions/russia_2010.json
View File

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

8
resources/factions/usa_2005.json
View File

@ -40,8 +40,8 @@
"Infantry_M4",
"Soldier_M249"
],
"shorad_units": [
"SAM_Avenger_M1097"
"shorads": [
"AvengerGenerator"
],
"sams": [
"HawkGenerator",
@ -53,10 +53,10 @@
"helicopter_carrier": [
"LHA_1_Tarawa"
],
"destroyer": [
"destroyers": [
"USS_Arleigh_Burke_IIa"
],
"cruiser": [
"cruisers": [
"Ticonderoga_class"
],
"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
for ut in uts:
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(
country=ctr,

34
theater/start_generator.py
View File

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