MarketFault (renamed from SchematicFault) refuses a product bin whose line is neither an unbinned shipped product nor an unbinned product of the same package, which the catalog read would crash boot on, and which let an offered hull with no lines pass through a cross-package bin. The carve-out guard is gone: IsOffered now has an overload taking a line resolver, so it judges package-own lines too. Tests pin bin-derived offeredness, any-vs-all products, null SchematicLines and the exclusion of bad bins with the derived catalog still opening. The LFS staging derivation includes tests/fixtures/mods. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
489 lines
28 KiB
C#
489 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using GameCult.Caching;
|
|
using CultMath;
|
|
using static CultMath.math;
|
|
using Random = CultMath.Random;
|
|
|
|
public class LoadoutGenerator
|
|
{
|
|
public Random Random;
|
|
public ItemManager ItemManager { get; }
|
|
public Galaxy Galaxy { get; }
|
|
public GalaxyZone Zone { get; }
|
|
public Faction Faction { get; }
|
|
public float PriceExponent { get; }
|
|
|
|
// Consumables are scarce (operator, 2026-10-09): a quarter of stations stock one product, one ship in ten carries
|
|
// one unit, and a carried consumable becomes loot when its ship dies. The units are the most a roll can stock; a
|
|
// station draws 1 to the maximum.
|
|
public const float StationConsumableChance = .25f;
|
|
public const int StationConsumableUnits = 2;
|
|
public const float ShipConsumableChance = .1f;
|
|
public const int ShipConsumableUnits = 1;
|
|
|
|
// Ammunition-fed weapons reload from cargo (ruling ballistics-real-ammo), so a generated ship carries this many crates of every
|
|
// distinct AmmoType its weapons draw: enough to fight on past the first magazine, few enough to leave the rest of the hold.
|
|
public const int AmmunitionCrates = 3;
|
|
|
|
public LoadoutGenerator(
|
|
ref Random random,
|
|
ItemManager itemManager,
|
|
Galaxy galaxy,
|
|
GalaxyZone zone,
|
|
Faction faction,
|
|
float priceExponent)
|
|
{
|
|
Random = random;
|
|
ItemManager = itemManager;
|
|
Galaxy = galaxy;
|
|
Zone = zone;
|
|
Faction = faction;
|
|
PriceExponent = priceExponent;
|
|
}
|
|
|
|
public EntityPack GenerateShipLoadout(Predicate<HullData> hullFilter = null)
|
|
{
|
|
var (hullProduct, hullData) = RandomHull(HullType.Ship, hullFilter);
|
|
if(hullData==null)
|
|
{
|
|
ItemManager.Log("Unable to generate ship loadout: no compatible hull found!");
|
|
return null;
|
|
}
|
|
var hull = ItemManager.CreateInstance(hullProduct) as EquippableItem;
|
|
if(hull==null)
|
|
ItemManager.Log("WHAT???");
|
|
var entity = new Ship(ItemManager, null, hull, ItemManager.GameplaySettings.DefaultEntitySettings);
|
|
entity.Faction = Faction;
|
|
OutfitEntity(entity);
|
|
EquipPickup(entity);
|
|
StockConsumables(entity, ShipConsumableChance, ShipConsumableUnits);
|
|
Loadouts.StockAmmunition(ItemManager, entity);
|
|
return EntitySerializer.Pack(entity);
|
|
}
|
|
|
|
public OrbitalEntityPack GenerateTurretLoadout()
|
|
{
|
|
var (hullProduct, hullData) = RandomHull(HullType.Turret);
|
|
if(hullData==null)
|
|
{
|
|
ItemManager.Log("Unable to generate turret loadout: no compatible hull found!");
|
|
return null;
|
|
}
|
|
var hull = ItemManager.CreateInstance(hullProduct) as EquippableItem;
|
|
var entity = new OrbitalEntity(ItemManager, null, hull, default, ItemManager.GameplaySettings.DefaultEntitySettings);
|
|
entity.Faction = Faction;
|
|
OutfitEntity(entity);
|
|
Loadouts.StockAmmunition(ItemManager, entity);
|
|
return EntitySerializer.Pack(entity) as OrbitalEntityPack;
|
|
}
|
|
|
|
// A station of one kind: the hull is drawn among the station hulls the kind calls for in this faction's hands
|
|
// (StationKinds.HullKindFor), so a faction with no model of the kind builds its stand-in's hull and keeps the kind.
|
|
public OrbitalEntityPack GenerateStationLoadout(CultRecordRef<StationKindData> kind)
|
|
{
|
|
var hullKind = StationKinds.HullKindFor(ItemManager.ItemData, Faction, kind);
|
|
var (hullProduct, hullData) = RandomHull(HullType.Station, hull => hull.Kind.Key.Equals(hullKind.Key));
|
|
if(hullData==null)
|
|
{
|
|
ItemManager.Log("Unable to generate station loadout: no compatible hull found!");
|
|
return null;
|
|
}
|
|
var hull = ItemManager.CreateInstance(hullProduct) as EquippableItem;
|
|
var entity = new OrbitalEntity(ItemManager, null, hull, default, ItemManager.GameplaySettings.DefaultEntitySettings);
|
|
entity.Faction = Faction;
|
|
entity.Kind = kind;
|
|
// A stand-in hull keeps its own model but not its own name: the station is what its kind says it is.
|
|
if (!hullData.Kind.Key.Equals(kind.Key) && ItemManager.ItemData.Get(kind) is { } kindData) entity.Name = kindData.Name;
|
|
|
|
// Hardpoint gear goes in first so the docking bay can only take space that gear left free
|
|
EquipHardpoints(entity);
|
|
|
|
var emptyShape = entity.UnoccupiedSpace;
|
|
|
|
var (dockingBayProduct, dockingBayData) = RandomProduct<DockingBayData>(2, item => item.Shape.FitsWithin(emptyShape, out _, out _), required: true);
|
|
if (dockingBayData == null) throw new InvalidLoadoutException("No compatible docking bay found for station!");
|
|
|
|
dockingBayData.Shape.FitsWithin(emptyShape, out var cargoRotation, out var cargoPosition);
|
|
var dockingBay = ItemManager.CreateInstance(dockingBayProduct) as EquippableItem;
|
|
dockingBay.Rotation = cargoRotation;
|
|
if (!entity.TryEquip(dockingBay, cargoPosition))
|
|
{
|
|
throw new InvalidLoadoutException("Failed to equip selected docking bay!");
|
|
}
|
|
|
|
// Every station carries a heater (operator, 2026-09-30): an idle station has no other heat source and cools
|
|
// toward freezing and invisibility. A heater is general gear whose thermostat runs its heat only below a
|
|
// target, the composition a cockpit uses: a low-pass Thermotoggle, then Heat, in its behaviours.
|
|
emptyShape = entity.UnoccupiedSpace;
|
|
var (heaterProduct, heaterData) = RandomProduct<GearData>(2, item => IsHeater(item) && item.Shape.FitsWithin(emptyShape, out _, out _), required: true);
|
|
if (heaterData == null) throw new InvalidLoadoutException("No compatible heater found for station!");
|
|
|
|
heaterData.Shape.FitsWithin(emptyShape, out var heaterRotation, out var heaterPosition);
|
|
var heater = ItemManager.CreateInstance(heaterProduct) as EquippableItem;
|
|
heater.Rotation = heaterRotation;
|
|
if (!entity.TryEquip(heater, heaterPosition))
|
|
throw new InvalidLoadoutException("Failed to equip selected heater!");
|
|
|
|
FillInterior(entity);
|
|
|
|
// The consumable goes in before the gear stock: sixteen gear picks drawn with replacement can fill a real hold,
|
|
// and a roll that hit must leave the entity holding one (the ruled rate is the rule). With no consumable on
|
|
// offer nothing is drawn here, so the gear draws are exactly what they were.
|
|
StockConsumables(entity, StationConsumableChance, StationConsumableUnits);
|
|
|
|
var cargo = entity.CargoBays.First();
|
|
var inventory = RandomProducts<EquippableItemData>(16, 1,
|
|
data => !(data is HullData hull && hull.HullType != HullType.Ship) && !(data is CargoBayData))
|
|
.OrderByDescending(entry => entry.design.Shape.Coordinates.Length);
|
|
foreach (var entry in inventory)
|
|
{
|
|
var instance = ItemManager.CreateInstance(entry.product);
|
|
cargo.TryStore(instance);
|
|
}
|
|
|
|
entity.CanTow = hullData.CanTow;
|
|
|
|
return EntitySerializer.Pack(entity) as OrbitalEntityPack;
|
|
}
|
|
|
|
// A loadout's one consumable step. With no consumable on offer, or no hold to put one in, nothing is drawn, so a
|
|
// catalog without consumables generates exactly what it did before them. Otherwise one roll decides whether the
|
|
// entity has any, and a hit stocks 1 to maxUnits instances of one product, stopping when no hold takes another.
|
|
private void StockConsumables(Entity entity, float chance, int maxUnits)
|
|
{
|
|
var (available, _) = AvailableProducts<ConsumableItemData>(null, false);
|
|
if (available.Length == 0 || !entity.CargoBays.Any()) return;
|
|
if (Random.NextFloat() >= chance) return;
|
|
|
|
var (product, design) = RandomProducts<ConsumableItemData>(1, 0).FirstOrDefault();
|
|
if (design == null) return;
|
|
var units = Random.NextInt(1, maxUnits + 1);
|
|
for (var i = 0; i < units; i++)
|
|
{
|
|
var instance = ItemManager.CreateInstance(product);
|
|
if (!entity.CargoBays.Any(bay => bay.TryStore(instance))) break;
|
|
}
|
|
}
|
|
|
|
private static bool IsHeater(GearData item) =>
|
|
item.HardpointType == HardpointType.Tool &&
|
|
item.Behaviors.Any(b => b is ThermotoggleData { HighPass: false }) &&
|
|
item.Behaviors.Any(b => b is HeatData);
|
|
|
|
// Every entity needs a hull, so hulls are always required
|
|
public (FactionProductData product, HullData design) RandomHull(HullType type, Predicate<HullData> hullFilter = null)
|
|
{
|
|
return RandomProduct<HullData>(0, item =>
|
|
(hullFilter?.Invoke(item) ?? true) &&
|
|
item.HullType == type, required: true);
|
|
}
|
|
|
|
// What a faction makes is which products it has, so generation selects branded products rather than designs.
|
|
// Products normally come only from manufacturers present in the galaxy and known to the zone's faction; a
|
|
// required item falls back to any manufacturer when none of those make one, which means the product table
|
|
// lacks variety, so it is logged rather than hidden.
|
|
public (FactionProductData product, T design)[] RandomProducts<T>(int count, float sizeExponent, Predicate<T> filter = null, bool required = false) where T : CraftedItemData
|
|
{
|
|
var (available, preferManufacturers) = AvailableProducts(filter, required);
|
|
var shares = BinShares();
|
|
return available.WeightedRandomElements(ref Random, entry =>
|
|
Weight(entry.product, shares, preferManufacturers) *
|
|
pow(entry.design.Shape.Coordinates.Length, sizeExponent) / // Prioritize larger items
|
|
pow(entry.design.Price, PriceExponent), // Penalize item price to a controllable degree
|
|
count);
|
|
}
|
|
|
|
// An item is on offer only through a product, so a design no product makes is never drawn, stocked or chosen; it reaches a ship
|
|
// only through a Loadout (ruling off-market-is-general).
|
|
// The products this faction can be offered for a design kind (only gear needs a home), and whether manufacturer preference applies (it does
|
|
// not once a required item has fallen back to any manufacturer). The one availability rule for every selection.
|
|
private ((FactionProductData product, T design)[] available, bool preferManufacturers) AvailableProducts<T>(Predicate<T> filter, bool required) where T : CraftedItemData
|
|
{
|
|
var hulls = SoldHulls(ItemManager.ItemData);
|
|
var candidates = ItemManager.ItemData.GetAll<FactionProductData>()
|
|
.Select(product => (product, design: ItemManager.ItemData.Get(product.Design) as T))
|
|
.Where(entry =>
|
|
// A not-offered product is never a candidate, so the any-manufacturer fallback below cannot reach it either.
|
|
IsDrawable(ItemManager.ItemData, entry.product, entry.design) &&
|
|
(!(entry.design is EquippableItemData equippable) || HasHome(equippable, hulls)) &&
|
|
(filter?.Invoke(entry.design) ?? true))
|
|
.ToArray();
|
|
var available = candidates.Where(entry => IsAvailable(entry.product)).ToArray();
|
|
var preferManufacturers = true;
|
|
if (available.Length == 0 && required && candidates.Length > 0)
|
|
{
|
|
ItemManager.Log($"No {typeof(T).Name} product available from manufacturers known to {Faction?.Name ?? "this galaxy"}; using any manufacturer. The product table needs more variety.");
|
|
available = candidates;
|
|
preferManufacturers = false;
|
|
}
|
|
|
|
return (available, preferManufacturers);
|
|
}
|
|
|
|
// Hardpoint gear that no hull in the catalog can mount has no home (operator, 2026-09-30: "we'll need to author a
|
|
// bunch more hulls before all the gear variety in the game has a home"): generation never offers it, so no station
|
|
// stocks it. It gains one the moment a hull with a hardpoint that takes it exists. Tool gear goes in any interior.
|
|
// Only a hull some product sells gives gear a home: a hull no faction builds (the Smoke Test Hull) is a test fixture, so its
|
|
// hardpoints never put gear on a shelf. An off-market hull gives no gear a home either: only its pinned Loadout flies it.
|
|
// The one definition of the hulls HasHome considers.
|
|
public static HullData[] SoldHulls(CultCache items) =>
|
|
items.GetAll<FactionProductData>().Where(product => IsOffered(items, product)).Select(product => items.Get(product.Design)).OfType<HullData>().Distinct().ToArray();
|
|
|
|
public static bool HasHome(EquippableItemData design, HullData[] hulls) =>
|
|
design.HardpointType == HardpointType.Tool || design.HardpointType == HardpointType.Hull ||
|
|
hulls.Any(hull => hull.Hardpoints.Any(hardpoint => hardpoint.Takes(design)));
|
|
|
|
// No galaxy, or no faction, means no allegiance to filter by: every product is on offer. A fixture generates
|
|
// loadouts that way, so a test can exercise placement and products without standing up a whole galaxy; a scenario
|
|
// stage has no faction and reaches every maker. Loadouts.Materialize takes a chooser and ChooseProduct is the game's,
|
|
// so presets and generation share this one availability rule. A faction
|
|
// always reaches its own manufacturer's gear, and otherwise gear made by a manufacturer its allegiance names
|
|
// (operator, 2026-09-30: allegiance lists only other factions). Whether that manufacturer is present in the galaxy
|
|
// does not matter (operator, 2026-10-06: a faction need not be present for its gear to be available).
|
|
// A not-offered product is available to nobody, a stage with no faction included.
|
|
public bool IsAvailable(FactionProductData product) =>
|
|
IsOffered(ItemManager.ItemData, product) && (
|
|
Galaxy == null || Faction == null ||
|
|
ItemManager.ItemData.Get(product.Manufacturer) == Faction || Faction.Allegiance.ContainsKey(product.Manufacturer));
|
|
|
|
// Whether a product can be drawn for its design at all: the design resolves, has a price, the product names a maker and is
|
|
// offered. The one definition of 'a maker offers this design'; AvailableProducts selects by it and StationKinds decides which
|
|
// station kinds a hull can be drawn for by it, so a kind is kept exactly when a hull of it can be drawn.
|
|
public static bool IsDrawable(CultCache items, FactionProductData product, CraftedItemData design) =>
|
|
design != null && design.Price > 0 && product.Manufacturer.IsSet() && IsOffered(items, product);
|
|
|
|
// Whether a product is on the market at all (ruling off-market-is-unoffered-product). The one reader of NotOffered. A bin is
|
|
// offered only if both it and its line are (ruling bin-inherits-line-offered); the catalog read guarantees a bin's line exists.
|
|
public static bool IsOffered(CultCache items, FactionProductData product) => IsOffered(product, line => items.Get(line));
|
|
|
|
// The same reader for a caller whose bin lines are not all in one catalog yet (ShipModCatalog.MarketFault, over a package's own products).
|
|
public static bool IsOffered(FactionProductData product, Func<CultRecordRef<FactionProductData>, FactionProductData> lineOf) =>
|
|
!product.NotOffered && (product.Bin == null || !lineOf(product.Bin.Line).NotOffered);
|
|
|
|
// How much this outfitter favors a product: its maker's preference times the product's share of it. The one weight of
|
|
// generation and of ChooseProduct. A bin takes the share of its maker's stock that would pass its floor and its line takes
|
|
// the rest (ruling bin-share-by-floor), so binning never changes a maker's presence for the design.
|
|
public float ProductWeight(FactionProductData product) => Weight(product, BinShares(), true);
|
|
|
|
// The one weight, with the share of the stock computed from shares (BinShares, once per weighting pass). A draw that has
|
|
// fallen back to any manufacturer weighs by share alone: the maker's preference no longer applies, its bins' shares still do.
|
|
private float Weight(FactionProductData product, Dictionary<string, float> shares, bool preferManufacturers) =>
|
|
(preferManufacturers ? ManufacturerPreference(product.Manufacturer) : 1) * Share(product, shares);
|
|
|
|
// 1 - Phi(floor): the fraction of a normal draw that lies at least floor deviations above its mean.
|
|
private static float PassFraction(float floor) => .5f * (1 - erf(floor / sqrt(2f)));
|
|
|
|
// Each line's key to the sum of its offered bins' pass fractions: read from the catalog once per weighting pass, never kept. An
|
|
// off-market bin takes no share, so its line keeps the whole weight.
|
|
private Dictionary<string, float> BinShares() => ItemManager.ItemData.GetAll<FactionProductData>()
|
|
.Where(product => product.Bin != null && IsOffered(ItemManager.ItemData, product))
|
|
.GroupBy(product => product.Bin.Line.Key.Value)
|
|
.ToDictionary(group => group.Key, group => group.Sum(bin => PassFraction(bin.Bin.Floor)));
|
|
|
|
private float Share(FactionProductData product, Dictionary<string, float> shares)
|
|
{
|
|
if (product.Bin != null) return PassFraction(product.Bin.Floor);
|
|
return max(0f, 1 - shares.GetValueOrDefault(ItemManager.ItemData.RefOf(product).Key.Value));
|
|
}
|
|
|
|
// The product a design named without one is built as (ruling loadout-product-optional-context-chooses): among the
|
|
// products of the design this outfitter can get, one draw from the run's seeded Random weighted by ProductWeight;
|
|
// null when none, and by share alone when every weight is 0. Candidates are ordered by name so the draw's
|
|
// enumeration, and so its result, never depends on record keys. All of the policy is this body.
|
|
public FactionProductData ChooseProduct(CraftedItemData design)
|
|
{
|
|
var key = ItemManager.ItemData.RefOf(design).Key;
|
|
var candidates = ItemManager.ItemData.GetAll<FactionProductData>()
|
|
.Where(product => product.Design.Key.Equals(key) && IsAvailable(product))
|
|
.OrderBy(product => product.Name, StringComparer.Ordinal)
|
|
.ToArray();
|
|
if (candidates.Length == 0) return null;
|
|
var shares = BinShares();
|
|
var uniform = candidates.All(product => Weight(product, shares, true) <= 0);
|
|
return candidates.WeightedRandomElements(ref Random, product => Weight(product, shares, !uniform), 1)[0];
|
|
}
|
|
|
|
// Prioritize products from the zone faction and its allies, penalizing distance to the manufacturer's headquarters.
|
|
// A manufacturer with no home zone in this galaxy weighs as if its headquarters lay one jump beyond the farthest
|
|
// zone this zone reaches: reachable through allegiance, least preferred.
|
|
public float ManufacturerPreference(CultRecordRef<Faction> manufacturer)
|
|
{
|
|
if (Faction == null || Galaxy == null) return 1;
|
|
var maker = ItemManager.ItemData.Get(manufacturer);
|
|
var allegiance = maker == Faction ? 1 :
|
|
Faction.Allegiance.TryGetValue(manufacturer, out var a) ? a : 0;
|
|
var home = maker != null && Galaxy.HomeZones.TryGetValue(maker, out var h) ? h : null;
|
|
var distance = Zone?.Distance == null ? 0 :
|
|
home != null && Zone.Distance.TryGetValue(home, out var d) ? d :
|
|
home == null && Zone.Distance.Count > 0 ? Zone.Distance.Values.Max() + 1 : 0;
|
|
return allegiance / (1 + distance);
|
|
}
|
|
|
|
public (FactionProductData product, T design) RandomProduct<T>(float sizeExponent, Predicate<T> filter = null, bool required = false) where T : EquippableItemData
|
|
{
|
|
return RandomProducts(1, sizeExponent, filter, required).FirstOrDefault();
|
|
}
|
|
|
|
public (FactionProductData product, T design) RandomProduct<T>(HardpointData hardpoint, float sizeExponent, Predicate<T> filter = null, bool required = false) where T : EquippableItemData
|
|
{
|
|
// Every candidate passes the one fit rule, HardpointData.Takes. Generation prefers gear that fills the hardpoint
|
|
// and falls back to anything that fits only when nothing that fills it is on offer.
|
|
var filling = RandomProduct<T>(sizeExponent, item => hardpoint.IsFilledBy(item) && (filter?.Invoke(item) ?? true));
|
|
if (filling.design != null) return filling;
|
|
return RandomProduct<T>(sizeExponent, item => hardpoint.Takes(item) && (filter?.Invoke(item) ?? true), required);
|
|
}
|
|
|
|
private void OutfitEntity(Entity entity)
|
|
{
|
|
EquipHardpoints(entity);
|
|
FillInterior(entity);
|
|
}
|
|
|
|
// Every ship carries a tractor beam: picking up needs a pickup behaviour (scenarios ruling, "everyone gets tractor
|
|
// beams"). It goes in after the shared outfitting, which stations and turrets also run and which adds none, into
|
|
// whatever interior the hull has left; a hull with no cell for one cannot be generated.
|
|
private void EquipPickup(Entity entity)
|
|
{
|
|
var emptyShape = entity.UnoccupiedSpace;
|
|
var (product, design) = RandomProduct<GearData>(2, item =>
|
|
item.Behaviors.Any(b => b is PickupData) &&
|
|
item.Shape.FitsWithin(emptyShape, out _, out _), required: true);
|
|
if (design == null) throw new InvalidLoadoutException("No compatible tractor beam found for ship!");
|
|
|
|
design.Shape.FitsWithin(emptyShape, out var rotation, out var position);
|
|
var beam = ItemManager.CreateInstance(product) as EquippableItem;
|
|
beam.Rotation = rotation;
|
|
if (!entity.TryEquip(beam, position))
|
|
throw new InvalidLoadoutException("Failed to equip selected tractor beam!");
|
|
}
|
|
|
|
private void EquipHardpoints(Entity entity)
|
|
{
|
|
var hullData = ItemManager.GetData(entity.Hull) as HullData;
|
|
foreach (var v in hullData.Shape.Coordinates) entity.HullConductivity[v.x, v.y] = true;
|
|
var previousProducts = new List<(FactionProductData product, GearData design)>();
|
|
foreach (var hardpoint in hullData.Hardpoints.OrderByDescending(h=>h.Shape.Coordinates.Length))
|
|
{
|
|
if (hardpoint.Type == HardpointType.ControlModule)
|
|
{
|
|
var (controllerProduct, controllerData) = RandomProduct<GearData>(hardpoint, 2,
|
|
item => item.Behaviors.Any(b => entity is Ship && b is CockpitData || entity is OrbitalEntity && b is TurretControllerData), required: true);
|
|
if (controllerData == null)
|
|
throw new InvalidLoadoutException("No compatible controller found for entity!");
|
|
var controller = ItemManager.CreateInstance(controllerProduct) as EquippableItem;
|
|
if (!entity.TryEquip(controller))
|
|
{
|
|
throw new InvalidLoadoutException($"Failed to equip selected {Enum.GetName(typeof(HardpointType), hardpoint.Type)}!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If a previously selected product fits, use that one (this is why we must process larger hardpoints first)
|
|
var entry = previousProducts
|
|
.FirstOrDefault(e => hardpoint.Takes(e.design));
|
|
var previousItem = entity.Equipment.FirstOrDefault(item => item.Data == entry.design);
|
|
if (entry.design == null) entry = RandomProduct<GearData>(hardpoint, 2);
|
|
if (entry.design == null) ItemManager.Log($"No compatible item found for entity {Enum.GetName(typeof(HardpointType), hardpoint.Type)} hardpoint!");
|
|
else
|
|
{
|
|
// Matching hardpoints carry matching units: same lot
|
|
var item = (previousItem != null
|
|
? ItemManager.CreateInstance(previousItem.EquippableItem.Lot)
|
|
: ItemManager.CreateInstance(entry.product)) as EquippableItem;
|
|
if (!entity.TryEquip(item))
|
|
{
|
|
throw new InvalidLoadoutException($"Failed to equip selected {Enum.GetName(typeof(HardpointType), hardpoint.Type)}!");
|
|
}
|
|
previousProducts.Add(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Interior gear may use any free interior cell, including empty hardpoint cells
|
|
private void FillInterior(Entity entity)
|
|
{
|
|
var emptyShape = entity.UnoccupiedSpace;
|
|
|
|
var (cargoProduct, cargoData) = RandomProduct<CargoBayData>(3, item =>
|
|
!(item is DockingBayData) &&
|
|
item.Shape.FitsWithin(emptyShape, out _, out _), required: true);
|
|
if (cargoData == null) throw new InvalidLoadoutException("No compatible cargo bay found for entity!");
|
|
|
|
cargoData.Shape.FitsWithin(emptyShape, out var cargoRotation, out var cargoPosition);
|
|
var cargo = ItemManager.CreateInstance(cargoProduct) as EquippableItem;
|
|
cargo.Rotation = cargoRotation;
|
|
if (!entity.TryEquip(cargo, cargoPosition))
|
|
throw new InvalidLoadoutException("Failed to equip selected cargo bay!");
|
|
|
|
emptyShape = entity.UnoccupiedSpace;
|
|
|
|
var (capacitorProduct, capacitorData) = RandomProduct<GearData>(2, item =>
|
|
item.Behaviors.Any(b => b is CapacitorData) &&
|
|
item.Shape.FitsWithin(emptyShape, out _, out _), required: true);
|
|
if (capacitorData == null) throw new InvalidLoadoutException("No compatible capacitor found for entity!");
|
|
|
|
capacitorData.Shape.FitsWithin(emptyShape, out var capacitorRotation, out var capacitorPosition);
|
|
var capacitor = ItemManager.CreateInstance(capacitorProduct) as EquippableItem;
|
|
capacitor.Rotation = capacitorRotation;
|
|
if (!entity.TryEquip(capacitor, capacitorPosition))
|
|
throw new InvalidLoadoutException("Failed to equip selected capacitor!");
|
|
|
|
// Cut 2 (docs/fire-control-cut.md, Q4): required equipment for anything that can fire -- unaided
|
|
// fire is a last resort, not an alternative loadout choice. EquipHardpoints runs before FillInterior
|
|
// (OutfitEntity), so entity.Weapons is already populated here. Zenith and anything else with no
|
|
// weapon hardpoints gets none.
|
|
//
|
|
// Cut 6c, 6c.2: this used to be `required: true` and throw InvalidLoadoutException when no seller was
|
|
// available -- a galaxy that happened not to draw a targeting design's manufacturer failed entity
|
|
// generation outright, a single point of failure the ten-seed smoke never sampled. It degrades instead:
|
|
// required: false, so RandomProducts' own manufacturer-widening fallback never fires and an unmet
|
|
// requirement returns null quietly rather than searching outside the galaxy for one. An entity that
|
|
// ends up with no targeting system fires through FireControl's unaided fallback
|
|
// (GameplaySettings.UnaidedTracking, Cut 5.1) rather than not firing at all -- that floor is what makes
|
|
// this degrade safe. The gap is logged so it surfaces as content debt (AetherDb loadout reports it per
|
|
// seed) instead of vanishing silently.
|
|
if (entity.Weapons.Any())
|
|
{
|
|
emptyShape = entity.UnoccupiedSpace;
|
|
|
|
var (targetingProduct, targetingData) = RandomProduct<GearData>(2, item =>
|
|
item.Behaviors.Any(b => b is TargetingSystemData) &&
|
|
item.Shape.FitsWithin(emptyShape, out _, out _));
|
|
if (targetingData == null)
|
|
{
|
|
ItemManager.Log("No targeting system available for armed entity; it will fire unaided.");
|
|
}
|
|
else
|
|
{
|
|
targetingData.Shape.FitsWithin(emptyShape, out var targetingRotation, out var targetingPosition);
|
|
var targetingSystem = ItemManager.CreateInstance(targetingProduct) as EquippableItem;
|
|
targetingSystem.Rotation = targetingRotation;
|
|
if (!entity.TryEquip(targetingSystem, targetingPosition))
|
|
throw new InvalidLoadoutException("Failed to equip selected targeting system!");
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public class InvalidLoadoutException : Exception
|
|
{
|
|
public InvalidLoadoutException()
|
|
{
|
|
}
|
|
|
|
public InvalidLoadoutException(string message)
|
|
: base(message)
|
|
{
|
|
}
|
|
|
|
public InvalidLoadoutException(string message, Exception inner)
|
|
: base(message, inner)
|
|
{
|
|
}
|
|
}
|