ogamejs 4.1.0 → 4.2.0

package/README.md

@@ -321,7 +321,7 @@ Ogame.Fleets.getDebris(Ogame.models.Destroyable[1], 100, 0.3);
 
 #### `simulateCombat(attacker, defender, options = {})`
 
-A full battle: 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's shield bounce off, shields come back every round, and a unit under 70% hull may explode at the end of the round.
+A full battle: 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's shield bounce off, shields come back every round, and a unit hit while under 70% hull may explode. Afterwards, destroyed defenses are rebuilt (70% chance each), the debris field gives the moon chance, and a winning attacker loads what its surviving ships can carry.
 
 ```javascript
 const battle = Ogame.Fleets.simulateCombat(
@@ -333,26 +333,50 @@ const battle = Ogame.Fleets.simulateCombat(
     fleet: [{ ship: Ogame.models.Destroyable[201], count: 200 }],
     techs: { weapons: 10, shielding: 10, armour: 10 },
   },
-  { seed: 42, debrisFactor: 0.3 },
+  {
+    seed: 42,
+    debrisFactor: 0.3,
+    plunder: { resources: { metal: 500000, crystal: 200000, deuterium: 100000 }, hyperspaceLevel: 8 },
+  },
 );
 // → {
 //   winner: 'attacker' | 'defender' | 'draw',
 //   rounds: Number,
 //   seed: Number,
 //   attacker: { survivors: [{ ship, count }], losses: [{ ship, count }] },
-//   defender: { survivors: [...], losses: [...] },
+//   defender: { survivors: [...], losses: [...], rebuilt: [...] },
 //   debris: { metal, crystal, deuterium },
+//   moonChance: Number, // in %
+//   plunder: { metal, crystal, deuterium },
 // }
 ```
 
-A battle is **random**, so one run is one possible outcome. Pass a `seed` to replay the exact same fight; average several seeds to get a feel for the likely result:
+| Option | Default | |
+| --- | --- | --- |
+| `seed` | `Date.now()` | replays the exact same fight |
+| `debrisFactor` | `0.3` | share of the destroyed ships' metal and crystal left as debris |
+| `deuteriumDebrisFactor` | `0` | same for deuterium |
+| `defenseDebrisFactor` | `0` (`debrisFactor` with `defenseDebris: true`) | same for destroyed defenses |
+| `repairFactor` | `0.7` | chance for each destroyed defense to be rebuilt |
+| `plunder` | none | `{ resources, ratio = 0.5, hyperspaceLevel, hyperspaceMultiplier, bonus }`; the loot is spread like the resources on the planet |
+
+#### `simulateCombats(attacker, defender, options = {})` / `getCombatStatistics(results)`
+
+A battle is **random**, so one run is one possible outcome. `simulateCombats` runs the same battle `runs` times (100 by default, seeds `seed`, `seed + 1`…) and averages them; `getCombatStatistics` does the averaging on results you simulated yourself, for instance in batches from a Web Worker.
 
 ```javascript
-const runs = Array.from({ length: 100 }, (_, seed) => simulateCombat(a, d, { seed }));
-const winRate = runs.filter((run) => run.winner === 'attacker').length / runs.length;
+Ogame.Fleets.simulateCombats(attacker, defender, { runs: 100, seed: 1, debrisFactor: 0.3 });
+// → {
+//   runs: 100,
+//   outcomes: { attacker: 0.92, defender: 0, draw: 0.08 }, // shares, from 0 to 1
+//   rounds: 2.4,
+//   attacker: { survivors, losses, lostResources },
+//   defender: { survivors, losses, rebuilt, lostResources },
+//   debris, moonChance, plunder,
+// }
 ```
 
-Destroyed defenses are left out of the debris field unless you pass `defenseDebris: true`. Defense repair after a battle is not modelled.
+Counts are averages, so not whole numbers. `lostResources` is what the units lost for good cost: rebuilt defenses do not count.
 
 #### `getMoonbreakChance(moonSize, fleets)` / `getMoonbreakLosses(moonSize, fleets)` / `getMoonbreakWaves(rip)`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ogamejs",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "OGame formulas as a dependency-free ESM library: building and research costs, production, build times, fleet debris and marketplace rates.",
   "type": "module",
   "main": "src/index.js",

package/src/fleets/combat.js

@@ -1,5 +1,7 @@
 import DESTROYABLE, { ATTRIBUTES } from '../models/destroyable.js';
 import getDebris from './getDebris.js';
+import { getCargoCapacity } from './expedition.js';
+import { MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE } from './moonLock.js';
 
 const ROUNDS = 6;
 
@@ -12,9 +14,18 @@ const MAX_SHOTS = 10000;
 /** A shot weaker than this share of the target shield simply bounces off. */
 const BOUNCE_RATIO = 0.01;
 
-/** Below that share of its hull, a unit may explode at the end of the round. */
+/** Below that share of its hull, a unit hit by a shot may explode on the spot. */
 const EXPLOSION_THRESHOLD = 0.7;
 
+/** The share of destroyed defenses that come back after a battle, on most universes. */
+const DEFAULT_REPAIR_FACTOR = 0.7;
+
+/** The share of the defender's resources a winning attacker can carry away. */
+const DEFAULT_PLUNDER_RATIO = 0.5;
+
+/** Every 100 000 units of debris add 1% to the moon chance. */
+const MOON_DEBRIS_PER_PERCENT = MOON_DEBRIS_THRESHOLD / MAX_MOON_CHANCE;
+
 /** Rapid-fire tables point at library ids, so we need the way back. */
 const LIBRARY_ID = new Map(
   Object.entries(DESTROYABLE).map(([id, entry]) => [entry, Number(id)]),
@@ -106,6 +117,10 @@ function rapidFireAgainst(unit, target) {
 /**
  * One unit fires at a random enemy, then keeps firing while its rapid-fire
  * bonus rolls in its favour.
+ *
+ * Every shot that gets through may blow up a target left under 70% of its
+ * hull, so a unit hit several times in a round gets several rolls. A wrecked
+ * unit stays a target until the end of the round, and shots on it are wasted.
  */
 function fire(unit, enemies, random) {
   for (let shots = 0; shots < MAX_SHOTS; shots += 1) {
@@ -117,13 +132,19 @@ function fire(unit, enemies, random) {
     const damage = unit.attack;
 
     // A shot too weak to dent the shield bounces off without doing anything.
-    if (damage >= target.shield * BOUNCE_RATIO) {
+    if (target.hull > 0 && damage >= target.shield * BOUNCE_RATIO) {
       if (damage <= target.shield) {
         target.shield -= damage;
       } else {
         target.hull -= damage - target.shield;
         target.shield = 0;
       }
+
+      const integrity = target.hull / target.maxHull;
+
+      if (target.hull > 0 && integrity < EXPLOSION_THRESHOLD && random() < 1 - integrity) {
+        target.hull = 0;
+      }
     }
 
     const rapid = rapidFireAgainst(unit, target);
@@ -135,11 +156,8 @@ function fire(unit, enemies, random) {
   }
 }
 
-/**
- * Destroyed units are removed, damaged ones may explode, survivors get their
- * shield back for the next round.
- */
-function endRound(units, random) {
+/** Destroyed units are removed, survivors get their shield back for the next round. */
+function endRound(units) {
   const survivors = [];
 
   for (const unit of units) {
@@ -147,12 +165,6 @@ function endRound(units, random) {
       continue;
     }
 
-    const integrity = unit.hull / unit.maxHull;
-
-    if (integrity < EXPLOSION_THRESHOLD && random() < 1 - integrity) {
-      continue;
-    }
-
     unit.shield = unit.maxShield;
     survivors.push(unit);
   }
@@ -186,12 +198,13 @@ function summarise(units, initial) {
 }
 
 function debrisOf(losses, options) {
-  const { debrisFactor, deuteriumDebrisFactor, defenseDebris } = options;
+  const { debrisFactor, deuteriumDebrisFactor, defenseDebrisFactor } = options;
 
   return losses
-    // On most universes only ships leave debris behind.
-    .filter(({ ship }) => defenseDebris || ship.category === ATTRIBUTES.CATEGORIES.SHIPS)
-    .map(({ ship, count }) => getDebris(ship, count, debrisFactor, deuteriumDebrisFactor))
+    // On most universes only ships leave debris behind, defenses have their own factor.
+    .map(({ ship, count }) => (ship.category === ATTRIBUTES.CATEGORIES.SHIPS
+      ? getDebris(ship, count, debrisFactor, deuteriumDebrisFactor)
+      : getDebris(ship, count, defenseDebrisFactor, deuteriumDebrisFactor > 0 ? defenseDebrisFactor : 0)))
     .reduce((total, debris) => ({
       metal: total.metal + debris.metal,
       crystal: total.crystal + debris.crystal,
@@ -199,17 +212,101 @@ function debrisOf(losses, options) {
     }), { metal: 0, crystal: 0, deuterium: 0 });
 }
 
+/** Each destroyed defense is rebuilt, or not, on its own roll. */
+function rebuild(losses, repairFactor, random) {
+  const rebuilt = [];
+
+  for (const { ship, count } of losses) {
+    if (ship.category !== ATTRIBUTES.CATEGORIES.DEFENSES) {
+      continue;
+    }
+
+    let back = 0;
+
+    for (let i = 0; i < count; i += 1) {
+      if (random() < repairFactor) {
+        back += 1;
+      }
+    }
+
+    if (back > 0) {
+      rebuilt.push({ ship, count: back });
+    }
+  }
+
+  return rebuilt;
+}
+
+/**
+ * The surviving ships carry away up to `ratio` of the defender's resources,
+ * spread in proportion to what lies on the planet.
+ */
+function plunderOf(survivors, plunder) {
+  const {
+    resources, ratio = DEFAULT_PLUNDER_RATIO, hyperspaceLevel, hyperspaceMultiplier, bonus,
+  } = plunder;
+
+  const lootable = {
+    metal: (resources.metal ?? 0) * ratio,
+    crystal: (resources.crystal ?? 0) * ratio,
+    deuterium: (resources.deuterium ?? 0) * ratio,
+  };
+  const total = lootable.metal + lootable.crystal + lootable.deuterium;
+  const capacity = survivors
+    .map(({ ship, count }) => getCargoCapacity(ship, { hyperspaceLevel, hyperspaceMultiplier, bonus }) * count)
+    .reduce((sum, value) => sum + value, 0);
+
+  if (total === 0 || capacity >= total) {
+    return lootable;
+  }
+
+  const share = capacity / total;
+
+  return {
+    metal: Math.floor(lootable.metal * share),
+    crystal: Math.floor(lootable.crystal * share),
+    deuterium: Math.floor(lootable.deuterium * share),
+  };
+}
+
+function moonChanceOf(debris) {
+  const total = debris.metal + debris.crystal + debris.deuterium;
+
+  return Math.min(MAX_MOON_CHANCE, Math.floor(total / MOON_DEBRIS_PER_PERCENT));
+}
+
+/**
+ * @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
@@ -218,13 +315,16 @@ function debrisOf(losses, options) {
  * @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
  */
 function simulateCombat(attacker, defender, options = {}) {
   const {
@@ -232,6 +332,9 @@ function simulateCombat(attacker, defender, options = {}) {
     debrisFactor = 0.3,
     deuteriumDebrisFactor = 0,
     defenseDebris = false,
+    defenseDebrisFactor = defenseDebris ? debrisFactor : 0,
+    repairFactor = DEFAULT_REPAIR_FACTOR,
+    plunder,
   } = options;
 
   const random = createRandom(seed);
@@ -258,8 +361,8 @@ function simulateCombat(attacker, defender, options = {}) {
       fire(unit, attackers, random);
     }
 
-    attackers = endRound(attackers, random);
-    defenders = endRound(defenders, random);
+    attackers = endRound(attackers);
+    defenders = endRound(defenders);
   }
 
   const attackerResult = summarise(attackers, attackerFleet);
@@ -273,19 +376,25 @@ function simulateCombat(attacker, defender, options = {}) {
     winner = 'defender';
   }
 
+  const debris = debrisOf([...attackerResult.losses, ...defenderResult.losses], {
+    debrisFactor,
+    deuteriumDebrisFactor,
+    defenseDebrisFactor,
+  });
+
   return {
     winner,
     rounds,
     seed,
     attacker: attackerResult,
-    defender: defenderResult,
-    debris: debrisOf([...attackerResult.losses, ...defenderResult.losses], {
-      debrisFactor,
-      deuteriumDebrisFactor,
-      defenseDebris,
-    }),
+    defender: { ...defenderResult, rebuilt: rebuild(defenderResult.losses, repairFactor, random) },
+    debris,
+    moonChance: moonChanceOf(debris),
+    plunder: plunder && winner === 'attacker'
+      ? plunderOf(attackerResult.survivors, plunder)
+      : { metal: 0, crystal: 0, deuterium: 0 },
   };
 }
 
-export { createRandom, ROUNDS };
+export { createRandom, ROUNDS, DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO };
 export default simulateCombat;

package/src/fleets/combatStatistics.js

@@ -0,0 +1,189 @@
+import simulateCombat from './combat.js';
+
+/** Enough runs for the averages to settle, without making a big battle wait. */
+const DEFAULT_RUNS = 100;
+
+const NO_RESOURCES = Object.freeze({ metal: 0, crystal: 0, deuterium: 0 });
+
+function addResources(total, resources) {
+  return {
+    metal: total.metal + resources.metal,
+    crystal: total.crystal + resources.crystal,
+    deuterium: total.deuterium + resources.deuterium,
+  };
+}
+
+function scaleResources(resources, factor) {
+  return {
+    metal: resources.metal * factor,
+    crystal: resources.crystal * factor,
+    deuterium: resources.deuterium * factor,
+  };
+}
+
+function costOf(fleet) {
+  return fleet
+    .map(({ ship, count }) => ({
+      metal: (ship.cost.metal ?? 0) * count,
+      crystal: (ship.cost.crystal ?? 0) * count,
+      deuterium: (ship.cost.deuterium ?? ship.cost.deut ?? 0) * count,
+    }))
+    .reduce(addResources, NO_RESOURCES);
+}
+
+/** Two copies of the same model entry are the same ship. */
+function keyOf(ship) {
+  return ship.ogameId ?? ship;
+}
+
+/** Sum the counts of every run, keeping the order ships first appear in. */
+function addFleets(totals, fleet) {
+  for (const { ship, count } of fleet) {
+    const key = keyOf(ship);
+    const entry = totals.get(key);
+
+    if (entry) {
+      entry.count += count;
+    } else {
+      totals.set(key, { ship, count });
+    }
+  }
+}
+
+function averageFleet(totals, runs) {
+  return [...totals.values()].map(({ ship, count }) => ({ ship, count: count / runs }));
+}
+
+/**
+ * Take back what was rebuilt from what was lost, ship by ship.
+ * @param {import('../types.js').FleetEntry[]} losses What was destroyed
+ * @param {import('../types.js').FleetEntry[]} rebuilt What came back
+ * @returns {import('../types.js').FleetEntry[]} What is gone for good
+ */
+function subtractFleet(losses, rebuilt) {
+  return losses
+    .map(({ ship, count }) => ({
+      ship,
+      count: count - (rebuilt.find((entry) => keyOf(entry.ship) === keyOf(ship))?.count ?? 0),
+    }))
+    .filter(({ count }) => count > 0);
+}
+
+/**
+ *
+ * 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
+ */
+function getCombatStatistics(results) {
+  if (!Array.isArray(results) || results.length === 0) {
+    throw new Error('results must be a non empty array of simulateCombat results');
+  }
+
+  const runs = results.length;
+  const outcomes = { attacker: 0, defender: 0, draw: 0 };
+  const fleets = {
+    attackerSurvivors: new Map(),
+    attackerLosses: new Map(),
+    defenderSurvivors: new Map(),
+    defenderLosses: new Map(),
+    defenderRebuilt: new Map(),
+  };
+  let rounds = 0;
+  let moonChance = 0;
+  let debris = NO_RESOURCES;
+  let plunder = NO_RESOURCES;
+  let attackerLost = NO_RESOURCES;
+  let defenderLost = NO_RESOURCES;
+
+  for (const result of results) {
+    outcomes[result.winner] += 1;
+    rounds += result.rounds;
+    moonChance += result.moonChance;
+    debris = addResources(debris, result.debris);
+    plunder = addResources(plunder, result.plunder);
+    attackerLost = addResources(attackerLost, costOf(result.attacker.losses));
+    defenderLost = addResources(
+      defenderLost,
+      costOf(subtractFleet(result.defender.losses, result.defender.rebuilt)),
+    );
+
+    addFleets(fleets.attackerSurvivors, result.attacker.survivors);
+    addFleets(fleets.attackerLosses, result.attacker.losses);
+    addFleets(fleets.defenderSurvivors, result.defender.survivors);
+    addFleets(fleets.defenderLosses, result.defender.losses);
+    addFleets(fleets.defenderRebuilt, result.defender.rebuilt);
+  }
+
+  return {
+    runs,
+    outcomes: {
+      attacker: outcomes.attacker / runs,
+      defender: outcomes.defender / runs,
+      draw: outcomes.draw / runs,
+    },
+    rounds: rounds / runs,
+    attacker: {
+      survivors: averageFleet(fleets.attackerSurvivors, runs),
+      losses: averageFleet(fleets.attackerLosses, runs),
+      lostResources: scaleResources(attackerLost, 1 / runs),
+    },
+    defender: {
+      survivors: averageFleet(fleets.defenderSurvivors, runs),
+      losses: averageFleet(fleets.defenderLosses, runs),
+      rebuilt: averageFleet(fleets.defenderRebuilt, runs),
+      lostResources: scaleResources(defenderLost, 1 / runs),
+    },
+    debris: scaleResources(debris, 1 / runs),
+    moonChance: moonChance / runs,
+    plunder: scaleResources(plunder, 1 / runs),
+  };
+}
+
+/**
+ *
+ * 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`
+ */
+function simulateCombats(attacker, defender, options = {}) {
+  const { runs = DEFAULT_RUNS, seed = Date.now(), ...rest } = options;
+
+  if (!Number.isInteger(runs) || runs < 1) {
+    throw new Error(`runs must be an integer >= 1, received ${runs}`);
+  }
+
+  const results = [];
+
+  for (let i = 0; i < runs; i += 1) {
+    results.push(simulateCombat(attacker, defender, { ...rest, seed: seed + i }));
+  }
+
+  return getCombatStatistics(results);
+}
+
+export { getCombatStatistics, simulateCombats, DEFAULT_RUNS };

package/src/fleets/index.js

@@ -2,7 +2,8 @@ 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 simulateCombat, { DEFAULT_REPAIR_FACTOR, DEFAULT_PLUNDER_RATIO } from './combat.js';
+import { getCombatStatistics, simulateCombats, DEFAULT_RUNS } from './combatStatistics.js';
 import {
   getWaveChance,
   getMoonbreakWaves,
@@ -31,6 +32,8 @@ const Fleets = {
   getFuelConsumption,
   getTrip,
   simulateCombat,
+  simulateCombats,
+  getCombatStatistics,
   getWaveChance,
   getMoonbreakWaves,
   getMoonbreakChance,
@@ -49,6 +52,9 @@ export {
   EXPEDITION_TOP_TIER_BASE,
   MOON_DEBRIS_THRESHOLD,
   MAX_MOON_CHANCE,
+  DEFAULT_REPAIR_FACTOR,
+  DEFAULT_PLUNDER_RATIO,
+  DEFAULT_RUNS,
 };
 
 export default Fleets;

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/index.d.ts

@@ -2,7 +2,8 @@ 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 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, 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,EAAE,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACzE,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,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,CAAC;eAEa,MAAM"}

package/types/index.d.ts

@@ -31,6 +31,8 @@ declare const Ogame: {
         getFuelConsumption: typeof import("./fleets/flight.js").getFuelConsumption;
         getTrip: typeof import("./fleets/flight.js").getTrip;
         simulateCombat: typeof import("./fleets/combat.js").default;
+        simulateCombats: typeof import("./fleets/combatStatistics.js").simulateCombats;
+        getCombatStatistics: typeof import("./fleets/combatStatistics.js").getCombatStatistics;
         getWaveChance: typeof import("./fleets/moonbreak.js").getWaveChance;
         getMoonbreakWaves: typeof import("./fleets/moonbreak.js").getMoonbreakWaves;
         getMoonbreakChance: typeof import("./fleets/moonbreak.js").getMoonbreakChance;

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAS,MAAM,WAAW,CAAC;AAEvD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBV,CAAC;eAEa,KAAK"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAS,MAAM,WAAW,CAAC;AAEvD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBV,CAAC;eAEa,KAAK"}