ogamejs 4.1.0 → 4.3.0

package/src/fleets/flight.js

@@ -1,6 +1,9 @@
 import getDistance from './distance.js';
 import { getFleetSpeed, getActiveDrive } from './speed.js';
 
+/** The game stops the fuel discounts here, however many add up. */
+const MAX_FUEL_REDUCTION = 0.9;
+
 function assertSpeedPercent(speedPercent) {
   if (!Number.isFinite(speedPercent) || speedPercent <= 0 || speedPercent > 100) {
     throw new Error(`speedPercent must be between 1 and 100, received ${speedPercent}`);
@@ -11,7 +14,9 @@ function assertSpeedPercent(speedPercent) {
  *
  * Return the one way flight time of a fleet
  *
- * `(10 + 35000 / speedPercent * sqrt(distance * 10 / fleetSpeed)) / universeFleetSpeed`
+ * `(10 + 350000 / speedPercent * sqrt(distance * 10 / fleetSpeed)) / universeFleetSpeed`
+ *
+ * At 100% that is the well known `10 + 3500 * sqrt(distance * 10 / fleetSpeed)`.
  * @param {number} distance The distance to cross, from `getDistance`
  * @param {number} fleetSpeed The speed of the slowest ship, from `getFleetSpeed`
  * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
@@ -25,7 +30,7 @@ function getFlightTime(distance, fleetSpeed, speedPercent = 100, universeFleetSp
     throw new Error(`fleetSpeed must be greater than 0, received ${fleetSpeed}`);
   }
 
-  const seconds = 10 + (35000 / speedPercent) * Math.sqrt((distance * 10) / fleetSpeed);
+  const seconds = 10 + (350000 / speedPercent) * Math.sqrt((distance * 10) / fleetSpeed);
 
   return Math.round(seconds / universeFleetSpeed);
 }
@@ -34,31 +39,57 @@ function getFlightTime(distance, fleetSpeed, speedPercent = 100, universeFleetSp
  *
  * Return the deuterium a fleet burns for a one way trip
  *
- * `1 + round(sum(consumption * count) * distance / 35000 * (speedPercent / 100 + 1) ** 2)`
+ * Each ship type is billed on its own, then the bills add up:
+ * `max(1, round(consumption * count * distance / 35000 * (shipSpeedValue / 10 + 1) ** 2))`
+ *
+ * `shipSpeedValue` is the speed the ship really flies at, on the game's 1 to 10
+ * scale: `speedPercent / 10` for the slowest ship, less for the faster ones held
+ * back by it, `speedPercent / 10 * sqrt(fleetSpeed / shipSpeed)`. A faster ship
+ * flying slower than it could burns less than at full throttle.
+ *
+ * `consumption` is the ship's own, after the universe deuterium factor and the
+ * entry's `fuelReduction` (General, life forms), each rounded down and never
+ * below one unit.
  * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
  * @param {number} distance The distance to cross, from `getDistance`
  * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
  * @param {import('../types.js').Drives} [drives] Drive levels, needed because a
  *   ship that switched drive also changed its consumption
+ * @param {object} [options] Universe settings
+ * @param {number} [options.deuteriumFactor] The universe deuterium consumption
+ *   factor (`globalDeuteriumSaveFactor` in the API), 1 when left out
  * @returns {number} The fuel needed, in deuterium
  */
-function getFuelConsumption(fleet, distance, speedPercent = 100, drives = {}) {
+function getFuelConsumption(fleet, distance, speedPercent = 100, drives = {}, options = {}) {
   assertSpeedPercent(speedPercent);
 
-  if (!Array.isArray(fleet) || fleet.length === 0) {
-    throw new Error('fleet must be a non empty array of { ship, count }');
+  const { deuteriumFactor = 1 } = options;
+
+  if (!Number.isFinite(deuteriumFactor) || deuteriumFactor <= 0) {
+    throw new Error(`deuteriumFactor must be greater than 0, received ${deuteriumFactor}`);
   }
 
-  const speedFactor = (speedPercent / 100 + 1) ** 2;
+  const fleetSpeed = getFleetSpeed(fleet, drives);
 
-  const consumption = fleet.reduce((total, { ship, count }) => {
-    // A ship that switched drive also changed how much it burns.
-    const { fuelConsumption } = getActiveDrive(ship, drives);
+  const total = fleet
+    .filter(({ count }) => count > 0)
+    .reduce((sum, {
+      ship, count, speedBonus = 0, fuelReduction = 0,
+    }) => {
+      // A ship that switched drive also changed how much it burns.
+      const { speed, fuelConsumption } = getActiveDrive(ship, drives, speedBonus);
+      const speedValue = (speedPercent / 10) * Math.sqrt(fleetSpeed / speed);
+      // Kept in percent until the end: 1 - 0.9 lands just under 0.1 in binary.
+      const saved = Math.round(Math.min(Math.max(fuelReduction, 0), MAX_FUEL_REDUCTION) * 10000);
+      const perShip = Math.max(1, Math.floor(
+        (Math.floor(fuelConsumption * deuteriumFactor) * (10000 - saved)) / 10000,
+      ));
+      const base = Math.max(1, Math.round(perShip * count));
 
-    return total + fuelConsumption * count;
-  }, 0);
+      return sum + Math.max(1, Math.round((base * distance) / 35000 * (speedValue / 10 + 1) ** 2));
+    }, 0);
 
-  return 1 + Math.round((consumption * distance) / 35000 * speedFactor);
+  return Math.max(1, total);
 }
 
 /**
@@ -70,6 +101,9 @@ function getFuelConsumption(fleet, distance, speedPercent = 100, drives = {}) {
  * @param {object} [options] Trip options
  * @param {number} [options.speedPercent] The fleet speed slider, 10 to 100 in game
  * @param {number} [options.universeFleetSpeed] The universe fleet speed
+ * @param {number} [options.deuteriumFactor] The universe deuterium consumption factor
+ * @param {import('../types.js').UniverseShape} [options.universe] How the universe
+ *   wraps, for the distance
  * @param {import('../types.js').Drives} [options.drives] The drive technology levels
  * @param {boolean} [options.roundTrip] Whether to account for the way back too
  * @returns {{
@@ -82,14 +116,17 @@ function getTrip(fleet, origin, target, options = {}) {
   const {
     speedPercent = 100,
     universeFleetSpeed = 1,
+    deuteriumFactor = 1,
+    universe = {},
     drives = {},
     roundTrip = false,
   } = options;
 
-  const distance = getDistance(origin, target);
+  const distance = getDistance(origin, target, universe);
   const fleetSpeed = getFleetSpeed(fleet, drives);
   const oneWay = getFlightTime(distance, fleetSpeed, speedPercent, universeFleetSpeed);
-  const fuel = getFuelConsumption(fleet, distance, speedPercent, drives) * (roundTrip ? 2 : 1);
+  const fuel = getFuelConsumption(fleet, distance, speedPercent, drives, { deuteriumFactor })
+    * (roundTrip ? 2 : 1);
   const cargo = fleet.reduce((total, { ship, count }) => total + ship.cargo * count, 0);
 
   return {
@@ -102,4 +139,6 @@ function getTrip(fleet, origin, target, options = {}) {
   };
 }
 
-export { getFlightTime, getFuelConsumption, getTrip };
+export {
+  getFlightTime, getFuelConsumption, getTrip, MAX_FUEL_REDUCTION,
+};

package/src/fleets/index.js

@@ -1,8 +1,11 @@
 import getDebris from './getDebris.js';
 import getDistance from './distance.js';
 import getShipSpeed, { getActiveDrive, getFleetSpeed } from './speed.js';
-import { getFlightTime, getFuelConsumption, getTrip } from './flight.js';
-import simulateCombat from './combat.js';
+import {
+  getFlightTime, getFuelConsumption, getTrip, MAX_FUEL_REDUCTION,
+} from './flight.js';
+import simulateCombat, { DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO } from './combat.js';
+import { getCombatStatistics, simulateCombats, DEFAULT_RUNS } from './combatStatistics.js';
 import {
   getWaveChance,
   getMoonbreakWaves,
@@ -31,6 +34,8 @@ const Fleets = {
   getFuelConsumption,
   getTrip,
   simulateCombat,
+  simulateCombats,
+  getCombatStatistics,
   getWaveChance,
   getMoonbreakWaves,
   getMoonbreakChance,
@@ -49,6 +54,10 @@ export {
   EXPEDITION_TOP_TIER_BASE,
   MOON_DEBRIS_THRESHOLD,
   MAX_MOON_CHANCE,
+  MAX_FUEL_REDUCTION,
+  DEFAULT_REPAIR_FACTOR,
+  DEFAULT_PLUNDER_RATIO,
+  DEFAULT_RUNS,
 };
 
 export default Fleets;

package/src/fleets/speed.js

@@ -32,9 +32,15 @@ function driveLevel(drives, drive) {
   return level;
 }
 
-function speedWith(baseSpeed, drive, drives) {
+function assertBonus(bonus) {
+  if (!Number.isFinite(bonus) || bonus < 0) {
+    throw new Error(`speed bonus must be a number >= 0, received ${bonus}`);
+  }
+}
+
+function speedWith(baseSpeed, drive, drives, bonus) {
   // eslint-disable-next-line security/detect-object-injection -- drive is a known key
-  return Math.floor(baseSpeed * (1 + DRIVE_BONUS[drive] * driveLevel(drives, drive)));
+  return Math.floor(baseSpeed * (1 + DRIVE_BONUS[drive] * driveLevel(drives, drive) + bonus));
 }
 
 /**
@@ -44,15 +50,21 @@ function speedWith(baseSpeed, drive, drives) {
  * A few ships switch to a better drive once the matching technology is high
  * enough — a small cargo moves to the impulse drive at Impulse 5. When several
  * drives are available the ship uses whichever ends up fastest.
+ *
+ * `bonus` adds to the drive bonus, as a share of the base speed: the class
+ * bonus that doubles a ship's speed is 1, a 5% life form bonus 0.05.
  * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
  * @param {import('../types.js').Drives} [drives] Drive levels
+ * @param {number} [bonus] Extra speed, as a share of the base speed
  * @returns {{drive: string, speed: number, fuelConsumption: number}} The active drive
  */
-function getActiveDrive(ship, drives = {}) {
+function getActiveDrive(ship, drives = {}, bonus = 0) {
   if (!ship || !ship.drive) {
     throw new Error('expected an entry of models/destroyable.js');
   }
 
+  assertBonus(bonus);
+
   const candidates = [
     { drive: ship.drive, speed: ship.speed, fuelConsumption: ship.fuelConsumption },
     ...(ship.driveUpgrades ?? [])
@@ -62,7 +74,7 @@ function getActiveDrive(ship, drives = {}) {
   return candidates
     .map(({ drive, speed, fuelConsumption }) => ({
       drive,
-      speed: speedWith(speed, drive, drives),
+      speed: speedWith(speed, drive, drives, bonus),
       fuelConsumption,
     }))
     .reduce((best, candidate) => (candidate.speed > best.speed ? candidate : best));
@@ -73,15 +85,18 @@ function getActiveDrive(ship, drives = {}) {
  * Return the speed of a ship, drive technologies included
  * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
  * @param {import('../types.js').Drives} [drives] Drive levels
+ * @param {number} [bonus] Extra speed, as a share of the base speed (class, life forms)
  * @returns {number} The speed the ship flies at
  */
-function getShipSpeed(ship, drives = {}) {
-  return getActiveDrive(ship, drives).speed;
+function getShipSpeed(ship, drives = {}, bonus = 0) {
+  return getActiveDrive(ship, drives, bonus).speed;
 }
 
 /**
  *
  * Return the speed of a whole fleet, which is the speed of its slowest ship
+ *
+ * Each entry may carry its own `speedBonus` (class, life forms).
  * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
  * @param {import('../types.js').Drives} [drives] Drive levels
  * @returns {number} The fleet speed
@@ -93,7 +108,7 @@ function getFleetSpeed(fleet, drives = {}) {
 
   const speeds = fleet
     .filter(({ count }) => count > 0)
-    .map(({ ship }) => getShipSpeed(ship, drives));
+    .map(({ ship, speedBonus = 0 }) => getShipSpeed(ship, drives, speedBonus));
 
   if (speeds.length === 0) {
     throw new Error('fleet must hold at least one ship with a count above 0');

package/src/types.js

@@ -120,6 +120,19 @@
  * @typedef {object} FleetEntry A group of identical ships
  * @property {DestroyableEntry} ship The ship
  * @property {number} count How many of them
+ * @property {number} [speedBonus] Extra speed, as a share of the ship's base
+ *   speed: 1 for the class bonus that doubles it, 0.05 for a 5% life form bonus,
+ *   summed
+ * @property {number} [fuelReduction] Deuterium saved, as a share: the General's
+ *   class discount plus the life form one, capped at 0.9 like the game does
+ */
+
+/**
+ * @typedef {object} UniverseShape How the universe wraps around
+ * @property {number} [galaxies] The number of galaxies
+ * @property {number} [systems] The number of systems per galaxy
+ * @property {boolean} [donutGalaxy] Whether the last galaxy touches the first
+ * @property {boolean} [donutSystem] Whether the last system touches the first
  */
 
 /**

package/types/fleets/combat.d.ts

@@ -1,19 +1,84 @@
 declare const ROUNDS = 6;
+/** The share of destroyed defenses that come back after a battle, on most universes. */
+declare const DEFAULT_REPAIR_FACTOR = 0.7;
+/** The share of the defender's resources a winning attacker can carry away. */
+declare const DEFAULT_PLUNDER_RATIO = 0.5;
 /**
  * A tiny deterministic PRNG (mulberry32), so a battle can be replayed.
  */
 declare function createRandom(seed: any): () => number;
+export type CombatResult = {
+    /**
+     * Who won
+     */
+    winner: 'attacker' | 'defender' | 'draw';
+    /**
+     * How many rounds it lasted
+     */
+    rounds: number;
+    /**
+     * The PRNG seed it ran with
+     */
+    seed: number;
+    /**
+     *   What is left of the attacker, and what it lost
+     */
+    attacker: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+    };
+    /**
+     * What is left of the defender, what it lost, and which of its lost defenses come back
+     */
+    defender: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+        rebuilt: import('../types.js').FleetEntry[];
+    };
+    /**
+     * The debris field
+     */
+    debris: import('../types.js').Resources;
+    /**
+     * The moon chance it gives, in %
+     */
+    moonChance: number;
+    /**
+     * What the attacker carries away
+     */
+    plunder: import('../types.js').Resources;
+};
+/**
+ * @typedef {object} CombatResult One simulated battle
+ * @property {'attacker'|'defender'|'draw'} winner Who won
+ * @property {number} rounds How many rounds it lasted
+ * @property {number} seed The PRNG seed it ran with
+ * @property {{survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[]}} attacker
+ *   What is left of the attacker, and what it lost
+ * @property {{
+ *   survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[],
+ *   rebuilt: import('../types.js').FleetEntry[],
+ * }} defender What is left of the defender, what it lost, and which of its lost defenses come back
+ * @property {import('../types.js').Resources} debris The debris field
+ * @property {number} moonChance The moon chance it gives, in %
+ * @property {import('../types.js').Resources} plunder What the attacker carries away
+ */
 /**
  *
  * Simulate a battle between two fleets
  *
  * Follows the game rules: up to six rounds, every unit fires once per round at a
  * random enemy, rapid fire grants extra shots, shots below 1% of the target
- * shield bounce off, shields come back every round, and a unit under 70% hull
- * may explode at the end of the round.
+ * shield bounce off, shields come back every round, and a unit hit while under
+ * 70% hull may explode.
+ *
+ * Afterwards, each destroyed defense is rebuilt with a `repairFactor` chance,
+ * the debris field gives the moon chance (1% per 100 000, up to 20%), and a
+ * winning attacker loads what it can of the defender's resources when
+ * `plunder` says what lies on the planet.
  *
  * A battle is random, so one run is one possible outcome. The `seed` makes a run
- * reproducible; average several seeds to get a feel for the likely result.
+ * reproducible; `getCombatStatistics` averages several of them.
  * @param {object} attacker The attacking side
  * @param {import('../types.js').FleetEntry[]} attacker.fleet Its ships
  * @param {import('../types.js').CombatTechs} [attacker.techs] Its combat technology levels
@@ -22,13 +87,16 @@ declare function createRandom(seed: any): () => number;
  * @param {number} [options.seed] The PRNG seed, for a reproducible battle
  * @param {number} [options.debrisFactor] The universe debris factor
  * @param {number} [options.deuteriumDebrisFactor] The universe deuterium debris factor
- * @param {boolean} [options.defenseDebris] Whether destroyed defenses leave debris
- * @returns {{
- *   winner: 'attacker'|'defender'|'draw', rounds: number, seed: number,
- *   attacker: {survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[]},
- *   defender: {survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[]},
- *   debris: import('../types.js').Resources,
- * }} Who won, how long it took, what is left on each side, and the debris field
+ * @param {boolean} [options.defenseDebris] Whether destroyed defenses leave debris, at `debrisFactor`
+ * @param {number} [options.defenseDebrisFactor] The universe defense debris factor, overrides `defenseDebris`
+ * @param {number} [options.repairFactor] The chance for a destroyed defense to be rebuilt, 0.7 by default
+ * @param {object} [options.plunder] What the attacker may carry away if it wins
+ * @param {import('../types.js').Resources} options.plunder.resources The resources on the planet
+ * @param {number} [options.plunder.ratio] The share of them up for grabs, 0.5 by default
+ * @param {number} [options.plunder.hyperspaceLevel] The attacker's Hyperspace Technology level
+ * @param {number} [options.plunder.hyperspaceMultiplier] The % of base cargo per level, 5 by default
+ * @param {number} [options.plunder.bonus] Any other cargo bonus, as a fraction
+ * @returns {CombatResult} Who won, how long it took, what is left on each side, and what the battle left behind
  */
 declare function simulateCombat(attacker: {
     fleet: import('../types.js').FleetEntry[];
@@ -38,20 +106,16 @@ declare function simulateCombat(attacker: {
     debrisFactor?: number;
     deuteriumDebrisFactor?: number;
     defenseDebris?: boolean;
-}): {
-    winner: 'attacker' | 'defender' | 'draw';
-    rounds: number;
-    seed: number;
-    attacker: {
-        survivors: import('../types.js').FleetEntry[];
-        losses: import('../types.js').FleetEntry[];
+    defenseDebrisFactor?: number;
+    repairFactor?: number;
+    plunder?: {
+        resources: import('../types.js').Resources;
+        ratio?: number;
+        hyperspaceLevel?: number;
+        hyperspaceMultiplier?: number;
+        bonus?: number;
     };
-    defender: {
-        survivors: import('../types.js').FleetEntry[];
-        losses: import('../types.js').FleetEntry[];
-    };
-    debris: import('../types.js').Resources;
-};
-export { createRandom, ROUNDS };
+}): CombatResult;
+export { createRandom, ROUNDS, DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO };
 export default simulateCombat;
 //# sourceMappingURL=combat.d.ts.map

package/types/fleets/combat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combat.d.ts","sourceRoot":"","sources":["../../src/fleets/combat.js"],"names":[],"mappings":"AAGA,QAAA,MAAM,MAAM,IAAI,CAAC;AAmCjB;;GAEG;AACH,iBAAS,YAAY,CAAC,IAAI,KAAA,gBAWzB;AAqJD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iBAAS,cAAc,CAAC,QAAQ,EAf7B;IAAqD,KAAK,EAAlD,OAAO,aAAa,EAAE,UAAU,EAAE,CAC1C;IAAqD,KAAK,AAA1D,CACA,EADQ,OAAO,aAAa,EAAE,WAAW,CACzC;CAa6B,EAAE,QAAQ,EAb/B,MAa+B,EAAE,OAAO,AAZhD,CAKA,EAJA;IAAyB,IAAI,AAA7B,CACA,EADQ,MAAM,CACd;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,qBAAqB,AAA9C,CACA,EADQ,MAAM,CACd;IAA0B,aAAa,AAAvC,CACA,EADQ,OAAO,CACf;CAOqD,GAP3C;IACR,MAAM,EAAE,UAAU,GAAC,UAAU,GAAC,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACnE,QAAQ,EAAE;QAAC,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAA;KAAC,CAAC;IACtG,QAAQ,EAAE;QAAC,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAA;KAAC,CAAC;IACtG,MAAM,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;CACzC,CA6DH;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;eACjB,cAAc"}
+{"version":3,"file":"combat.d.ts","sourceRoot":"","sources":["../../src/fleets/combat.js"],"names":[],"mappings":"AAKA,QAAA,MAAM,MAAM,IAAI,CAAC;AAcjB,wFAAwF;AACxF,QAAA,MAAM,qBAAqB,MAAM,CAAC;AAElC,+EAA+E;AAC/E,QAAA,MAAM,qBAAqB,MAAM,CAAC;AA0BlC;;GAEG;AACH,iBAAS,YAAY,CAAC,IAAI,KAAA,gBAWzB;AAuNE,YAAkB,YAAY,GAC9B;;;;IAAyC,MAAM,EAApC,UAAU,GAAC,UAAU,GAAC,MAAM,CACvC;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAAmB,IAAI,EAAZ,MAAM,CACjB;;;;IAAwG,QAAQ,EAArG;QAAC,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAA;KAAC,CAEtG;;;;IAGG,QAAQ,EAHA;QACT,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAC1F,OAAO,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;KAC7C,CACD;;;;IAA4C,MAAM,EAAvC,OAAO,aAAa,EAAE,SAAS,CAC1C;;;;IAAmB,UAAU,EAAlB,MAAM,CACjB;;;;IAA4C,OAAO,EAAxC,OAAO,aAAa,EAAE,SAAS,CAC5C;CAAA,CAAA;AAdD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iBAAS,cAAc,CAAC,QAAQ,EAlB7B;IAAqD,KAAK,EAAlD,OAAO,aAAa,EAAE,UAAU,EAAE,CAC1C;IAAqD,KAAK,AAA1D,CACA,EADQ,OAAO,aAAa,EAAE,WAAW,CACzC;CAgB6B,EAAE,QAAQ,EAhB/B,MAgB+B,EAAE,OAAO,AAfhD,CAaA,EAZA;IAAyB,IAAI,AAA7B,CACA,EADQ,MAAM,CACd;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,qBAAqB,AAA9C,CACA,EADQ,MAAM,CACd;IAA0B,aAAa,AAAvC,CACA,EADQ,OAAO,CACf;IAAyB,mBAAmB,AAA5C,CACA,EADQ,MAAM,CACd;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,OAAO,AAAhC,CAMA,EALA;QAAyD,SAAS,EAA1D,OAAO,aAAa,EAAE,SAAS,CACvC;QAAiC,KAAK,AAAtC,CACA,EADQ,MAAM,CACd;QAAiC,eAAe,AAAhD,CACA,EADQ,MAAM,CACd;QAAiC,oBAAoB,AAArD,CACA,EADQ,MAAM,CACd;QAAiC,KAAK,AAAtC,CACA,EADQ,MAAM,CACd;KAAA,CAAA;CAEqD,GAF3C,YAAY,CAsExB;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;eAC/D,cAAc"}

package/types/fleets/combatStatistics.d.ts

@@ -0,0 +1,67 @@
+import simulateCombat from './combat.js';
+/** Enough runs for the averages to settle, without making a big battle wait. */
+declare const DEFAULT_RUNS = 100;
+/**
+ *
+ * Average a set of simulated battles
+ *
+ * Counts are averages, so they are not whole numbers. `lostResources` is what
+ * the units lost for good would cost to build again: every loss for the
+ * attacker, the defender's losses minus its rebuilt defenses.
+ * @param {import('./combat.js').CombatResult[]} results Battles from `simulateCombat`
+ * @returns {{
+ *   runs: number,
+ *   outcomes: {attacker: number, defender: number, draw: number},
+ *   rounds: number,
+ *   attacker: {
+ *     survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[],
+ *     lostResources: import('../types.js').Resources,
+ *   },
+ *   defender: {
+ *     survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[],
+ *     rebuilt: import('../types.js').FleetEntry[], lostResources: import('../types.js').Resources,
+ *   },
+ *   debris: import('../types.js').Resources,
+ *   moonChance: number,
+ *   plunder: import('../types.js').Resources,
+ * }} The share of battles each side won (from 0 to 1), and the average of everything else
+ */
+declare function getCombatStatistics(results: import('./combat.js').CombatResult[]): {
+    runs: number;
+    outcomes: {
+        attacker: number;
+        defender: number;
+        draw: number;
+    };
+    rounds: number;
+    attacker: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+        lostResources: import('../types.js').Resources;
+    };
+    defender: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+        rebuilt: import('../types.js').FleetEntry[];
+        lostResources: import('../types.js').Resources;
+    };
+    debris: import('../types.js').Resources;
+    moonChance: number;
+    plunder: import('../types.js').Resources;
+};
+/**
+ *
+ * Simulate the same battle many times and average the outcomes
+ *
+ * Run `i` uses the seed `seed + i`, so the whole set is reproducible.
+ * @param {Parameters<typeof simulateCombat>[0]} attacker The attacking side, as for `simulateCombat`
+ * @param {Parameters<typeof simulateCombat>[1]} defender The defending side, as for `simulateCombat`
+ * @param {Parameters<typeof simulateCombat>[2] & {runs?: number}} [options] The `simulateCombat`
+ *   options, plus `runs`, how many battles to simulate (100 by default)
+ * @returns {ReturnType<typeof getCombatStatistics>} The averaged outcome, see `getCombatStatistics`
+ */
+declare function simulateCombats(attacker: Parameters<typeof simulateCombat>[0], defender: Parameters<typeof simulateCombat>[1], options?: Parameters<typeof simulateCombat>[2] & {
+    runs?: number;
+}): ReturnType<typeof getCombatStatistics>;
+export { getCombatStatistics, simulateCombats, DEFAULT_RUNS };
+//# sourceMappingURL=combatStatistics.d.ts.map

package/types/fleets/combatStatistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combatStatistics.d.ts","sourceRoot":"","sources":["../../src/fleets/combatStatistics.js"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,aAAa,CAAC;AAEzC,gFAAgF;AAChF,QAAA,MAAM,YAAY,MAAM,CAAC;AAoEzB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAlBzB,OAAO,aAAa,EAAE,YAAY,EAkBT,GAjBvB;IACR,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE;QACR,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAC1F,aAAa,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;KAChD,CAAC;IACF,QAAQ,EAAE;QACR,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAC1F,OAAO,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,aAAa,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;KAC7F,CAAC;IACF,MAAM,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;CAC1C,CAiEH;AAED;;;;;;;;;;GAUG;AACH,iBAAS,eAAe,CAAC,QAAQ,EANtB,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAMb,EAAE,QAAQ,EALhC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAKH,EAAE,OAAO,AAJjD,CAEA,EAFQ,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAIP,GAF5C,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAgBlD;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC"}

package/types/fleets/distance.d.ts

@@ -3,11 +3,15 @@
  * Return the distance between two coordinates, in OGame distance units
  *
  * The scale is not linear: crossing a galaxy costs far more than crossing a
- * system, which costs far more than moving inside one.
+ * system, which costs far more than moving inside one. Most universes are
+ * donuts: the last galaxy (or system) touches the first, and the fleet takes the
+ * shorter way round.
  * @param {import('../types.js').Coordinates} origin Where the fleet leaves from
  * @param {import('../types.js').Coordinates} target Where it goes
+ * @param {import('../types.js').UniverseShape} [universe] How the universe wraps,
+ *   flat when left out
  * @returns {number} The distance
  */
-declare function getDistance(origin: import('../types.js').Coordinates, target: import('../types.js').Coordinates): number;
+declare function getDistance(origin: import('../types.js').Coordinates, target: import('../types.js').Coordinates, universe?: import('../types.js').UniverseShape): number;
 export default getDistance;
 //# sourceMappingURL=distance.d.ts.map

package/types/fleets/distance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../../src/fleets/distance.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,MAAM,EAJhB,OAAO,aAAa,EAAE,WAIN,EAAE,MAAM,EAHxB,OAAO,aAAa,EAAE,WAGE,GAFtB,MAAM,CAoBlB;eAEc,WAAW"}
+{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../../src/fleets/distance.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;GAaG;AACH,iBAAS,WAAW,CAAC,MAAM,EANhB,OAAO,aAAa,EAAE,WAMN,EAAE,MAAM,EALxB,OAAO,aAAa,EAAE,WAKE,EAAE,QAAQ,AAJ1C,CAEA,EAFQ,OAAO,aAAa,EAAE,aAIiB,GAFrC,MAAM,CAwBlB;eAEc,WAAW"}

package/types/fleets/flight.d.ts

@@ -1,8 +1,12 @@
+/** The game stops the fuel discounts here, however many add up. */
+declare const MAX_FUEL_REDUCTION = 0.9;
 /**
  *
  * Return the one way flight time of a fleet
  *
- * `(10 + 35000 / speedPercent * sqrt(distance * 10 / fleetSpeed)) / universeFleetSpeed`
+ * `(10 + 350000 / speedPercent * sqrt(distance * 10 / fleetSpeed)) / universeFleetSpeed`
+ *
+ * At 100% that is the well known `10 + 3500 * sqrt(distance * 10 / fleetSpeed)`.
  * @param {number} distance The distance to cross, from `getDistance`
  * @param {number} fleetSpeed The speed of the slowest ship, from `getFleetSpeed`
  * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
@@ -14,15 +18,30 @@ declare function getFlightTime(distance: number, fleetSpeed: number, speedPercen
  *
  * Return the deuterium a fleet burns for a one way trip
  *
- * `1 + round(sum(consumption * count) * distance / 35000 * (speedPercent / 100 + 1) ** 2)`
+ * Each ship type is billed on its own, then the bills add up:
+ * `max(1, round(consumption * count * distance / 35000 * (shipSpeedValue / 10 + 1) ** 2))`
+ *
+ * `shipSpeedValue` is the speed the ship really flies at, on the game's 1 to 10
+ * scale: `speedPercent / 10` for the slowest ship, less for the faster ones held
+ * back by it, `speedPercent / 10 * sqrt(fleetSpeed / shipSpeed)`. A faster ship
+ * flying slower than it could burns less than at full throttle.
+ *
+ * `consumption` is the ship's own, after the universe deuterium factor and the
+ * entry's `fuelReduction` (General, life forms), each rounded down and never
+ * below one unit.
  * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
  * @param {number} distance The distance to cross, from `getDistance`
  * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
  * @param {import('../types.js').Drives} [drives] Drive levels, needed because a
  *   ship that switched drive also changed its consumption
+ * @param {object} [options] Universe settings
+ * @param {number} [options.deuteriumFactor] The universe deuterium consumption
+ *   factor (`globalDeuteriumSaveFactor` in the API), 1 when left out
  * @returns {number} The fuel needed, in deuterium
  */
-declare function getFuelConsumption(fleet: import('../types.js').FleetEntry[], distance: number, speedPercent?: number, drives?: import('../types.js').Drives): number;
+declare function getFuelConsumption(fleet: import('../types.js').FleetEntry[], distance: number, speedPercent?: number, drives?: import('../types.js').Drives, options?: {
+    deuteriumFactor?: number;
+}): number;
 /**
  *
  * Return everything about a trip: distance, duration, fuel and cargo left
@@ -32,6 +51,9 @@ declare function getFuelConsumption(fleet: import('../types.js').FleetEntry[], d
  * @param {object} [options] Trip options
  * @param {number} [options.speedPercent] The fleet speed slider, 10 to 100 in game
  * @param {number} [options.universeFleetSpeed] The universe fleet speed
+ * @param {number} [options.deuteriumFactor] The universe deuterium consumption factor
+ * @param {import('../types.js').UniverseShape} [options.universe] How the universe
+ *   wraps, for the distance
  * @param {import('../types.js').Drives} [options.drives] The drive technology levels
  * @param {boolean} [options.roundTrip] Whether to account for the way back too
  * @returns {{
@@ -43,6 +65,8 @@ declare function getFuelConsumption(fleet: import('../types.js').FleetEntry[], d
 declare function getTrip(fleet: import('../types.js').FleetEntry[], origin: import('../types.js').Coordinates, target: import('../types.js').Coordinates, options?: {
     speedPercent?: number;
     universeFleetSpeed?: number;
+    deuteriumFactor?: number;
+    universe?: import('../types.js').UniverseShape;
     drives?: import('../types.js').Drives;
     roundTrip?: boolean;
 }): {
@@ -53,5 +77,5 @@ declare function getTrip(fleet: import('../types.js').FleetEntry[], origin: impo
     cargo: number;
     cargoAfterFuel: number;
 };
-export { getFlightTime, getFuelConsumption, getTrip };
+export { getFlightTime, getFuelConsumption, getTrip, MAX_FUEL_REDUCTION, };
 //# sourceMappingURL=flight.d.ts.map

package/types/fleets/flight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flight.d.ts","sourceRoot":"","sources":["../../src/fleets/flight.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,iBAAS,aAAa,CAAC,QAAQ,EANpB,MAMoB,EAAE,UAAU,EALhC,MAKgC,EAAE,YAAY,AAJtD,CACA,EADQ,MAIoD,EAAE,kBAAkB,AAHhF,CACA,EADQ,MAG4E,GAF1E,MAAM,CAYlB;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,kBAAkB,CAAC,KAAK,EAPtB,OAAO,aAAa,EAAE,UAAU,EAOV,EAAE,QAAQ,EANhC,MAMgC,EAAE,YAAY,AALtD,CACA,EADQ,MAKoD,EAAE,MAAM,AAJpE,CAEA,EAFQ,OAAO,aAAa,EAAE,MAI2C,GAF/D,MAAM,CAmBlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,iBAAS,OAAO,CAAC,KAAK,EAdX,OAAO,aAAa,EAAE,UAAU,EAcrB,EAAE,MAAM,EAbnB,OAAO,aAAa,EAAE,WAaH,EAAE,MAAM,EAZ3B,OAAO,aAAa,EAAE,WAYK,EAAE,OAAO,AAX5C,CAKA,EAJA;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,kBAAkB,AAA3C,CACA,EADQ,MAAM,CACd;IAA+C,MAAM,AAArD,CACA,EADQ,OAAO,aAAa,EAAE,MAAM,CACpC;IAA0B,SAAS,AAAnC,CACA,EADQ,OAAO,CACf;CAMiD,GANvC;IACR,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACrE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;CACvC,CAyBH;AAED,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"flight.d.ts","sourceRoot":"","sources":["../../src/fleets/flight.js"],"names":[],"mappings":"AAGA,mEAAmE;AACnE,QAAA,MAAM,kBAAkB,MAAM,CAAC;AAQ/B;;;;;;;;;;;;GAYG;AACH,iBAAS,aAAa,CAAC,QAAQ,EANpB,MAMoB,EAAE,UAAU,EALhC,MAKgC,EAAE,YAAY,AAJtD,CACA,EADQ,MAIoD,EAAE,kBAAkB,AAHhF,CACA,EADQ,MAG4E,GAF1E,MAAM,CAYlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iBAAS,kBAAkB,CAAC,KAAK,EAVtB,OAAO,aAAa,EAAE,UAAU,EAUV,EAAE,QAAQ,EAThC,MASgC,EAAE,YAAY,AARtD,CACA,EADQ,MAQoD,EAAE,MAAM,AAPpE,CAEA,EAFQ,OAAO,aAAa,EAAE,MAO2C,EAAE,OAAO,AALlF,CAGA,EAFA;IAAyB,eAAe,AAAxC,CAEA,EAFQ,MAAM,CAEd;CAEuF,GAF7E,MAAM,CAgClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iBAAS,OAAO,CAAC,KAAK,EAjBX,OAAO,aAAa,EAAE,UAAU,EAiBrB,EAAE,MAAM,EAhBnB,OAAO,aAAa,EAAE,WAgBH,EAAE,MAAM,EAf3B,OAAO,aAAa,EAAE,WAeK,EAAE,OAAO,AAd5C,CAQA,EAPA;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,kBAAkB,AAA3C,CACA,EADQ,MAAM,CACd;IAAyB,eAAe,AAAxC,CACA,EADQ,MAAM,CACd;IAAsD,QAAQ,AAA9D,CAEA,EAFQ,OAAO,aAAa,EAAE,aAAa,CAE3C;IAA+C,MAAM,AAArD,CACA,EADQ,OAAO,aAAa,EAAE,MAAM,CACpC;IAA0B,SAAS,AAAnC,CACA,EADQ,OAAO,CACf;CAMiD,GANvC;IACR,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACrE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;CACvC,CA4BH;AAED,OAAO,EACL,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,kBAAkB,GAC/D,CAAC"}

package/types/fleets/index.d.ts

@@ -1,8 +1,9 @@
 import getDebris from './getDebris.js';
 import getDistance from './distance.js';
 import getShipSpeed, { getActiveDrive, getFleetSpeed } from './speed.js';
-import { getFlightTime, getFuelConsumption, getTrip } from './flight.js';
-import simulateCombat from './combat.js';
+import { getFlightTime, getFuelConsumption, getTrip, MAX_FUEL_REDUCTION } from './flight.js';
+import simulateCombat, { DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO } from './combat.js';
+import { getCombatStatistics, simulateCombats, DEFAULT_RUNS } from './combatStatistics.js';
 import { getWaveChance, getMoonbreakWaves, getMoonbreakChance, getMoonbreakLosses, MIN_MOON_SIZE, MAX_MOON_SIZE, WAVES_PER_ATTACKER } from './moonbreak.js';
 import { getExpeditionFindBase, getExpeditionMaxFind, getCargoCapacity, EXPEDITION_FIND_TIERS, EXPEDITION_TOP_TIER_BASE } from './expedition.js';
 import { getMoonLockShips, MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE } from './moonLock.js';
@@ -16,6 +17,8 @@ declare const Fleets: {
     getFuelConsumption: typeof getFuelConsumption;
     getTrip: typeof getTrip;
     simulateCombat: typeof simulateCombat;
+    simulateCombats: typeof simulateCombats;
+    getCombatStatistics: typeof getCombatStatistics;
     getWaveChance: typeof getWaveChance;
     getMoonbreakWaves: typeof getMoonbreakWaves;
     getMoonbreakChance: typeof getMoonbreakChance;
@@ -25,6 +28,6 @@ declare const Fleets: {
     getCargoCapacity: typeof getCargoCapacity;
     getMoonLockShips: typeof getMoonLockShips;
 };
-export { MIN_MOON_SIZE, MAX_MOON_SIZE, WAVES_PER_ATTACKER, EXPEDITION_FIND_TIERS, EXPEDITION_TOP_TIER_BASE, MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE, };
+export { MIN_MOON_SIZE, MAX_MOON_SIZE, WAVES_PER_ATTACKER, EXPEDITION_FIND_TIERS, EXPEDITION_TOP_TIER_BASE, MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE, MAX_FUEL_REDUCTION, DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO, DEFAULT_RUNS, };
 export default Fleets;
 //# sourceMappingURL=index.d.ts.map

package/types/fleets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fleets/index.js"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,WAAW,MAAM,eAAe,CAAC;AACxC,OAAO,YAAY,EAAE,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,cAAc,MAAM,aAAa,CAAC;AACzC,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEzF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;CAkBX,CAAC;AAEF,OAAO,EACL,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,GAChB,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fleets/index.js"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,WAAW,MAAM,eAAe,CAAC;AACxC,OAAO,YAAY,EAAE,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EACL,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,kBAAkB,EAC/D,MAAM,aAAa,CAAC;AACrB,OAAO,cAAc,EAAE,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAC3F,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC3F,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEzF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;CAoBX,CAAC;AAEF,OAAO,EACL,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,CAAC;eAEa,MAAM"}