ogamejs 4.0.1 → 4.1.0

package/README.md

@@ -354,6 +354,59 @@ const winRate = runs.filter((run) => run.winner === 'attacker').length / runs.le
 
 Destroyed defenses are left out of the debris field unless you pass `defenseDebris: true`. Defense repair after a battle is not modelled.
 
+#### `getMoonbreakChance(moonSize, fleets)` / `getMoonbreakLosses(moonSize, fleets)` / `getMoonbreakWaves(rip)`
+
+A moon destruction with Deathstars. `fleets` lists each attacker's Deathstars in firing order; each attacker spreads them over 6 waves, the extra ships in the first ones, and the moon is gone as soon as one wave succeeds.
+
+```javascript
+Ogame.Fleets.getMoonbreakChance(8944, [100, 80]);
+// → 0.9409…  (94.09 %)
+Ogame.Fleets.getMoonbreakLosses(8944, [100]);
+// → { mean: 27.78…, sigma: 4.33…,
+//     bands: [{ confidence: 68, min: 23.45…, max: 32.11… }, { confidence: 95, … }, { confidence: 99, … }] }
+Ogame.Fleets.getMoonbreakWaves(100);
+// → [17, 17, 17, 17, 16, 16]
+```
+
+The values are unrounded. The loss bands are a gaussian approximation around the expected losses.
+
+#### `getExpeditionMaxFind(options)` / `getExpeditionFindBase(topScore)`
+
+The largest metal find of one expedition. A Discoverer's find is `base × (1 + explorerBonus × (1 + lifeformExplorerBonus)) × economySpeed`; other classes get `base` alone. A Pathfinder doubles it and the lifeform expedition resource bonus multiplies it.
+
+```javascript
+Ogame.Fleets.getExpeditionMaxFind({
+  topScore: 2e9,              // points of the universe's top player
+  economySpeed: 10,
+  explorer: true,             // Discoverer class
+  pathfinder: true,
+  explorerBonus: 0.5,         // serverData `explorerBonusIncreasedExpeditionOutcome`
+  lifeformExplorerBonus: 0,   // lifeform Discoverer enhancement, 0.2 for 20 %
+  lifeformResourceBonus: 0,   // lifeform expedition resource bonus, 0.2 for 20 %
+});
+// → 150000000
+```
+
+The lifeform bonuses are the totals the in-game lifeform bonus page shows, as fractions.
+
+#### `getCargoCapacity(ship, options = {})`
+
+One ship's cargo with its bonuses, all shares of the base cargo that add up: Hyperspace Technology (`hyperspaceMultiplier` %, 5 by default, per level) plus any other `bonus` (Collector class, lifeform…).
+
+```javascript
+Ogame.Fleets.getCargoCapacity(Ogame.models.Destroyable[12], { hyperspaceLevel: 20, bonus: 0.25 });
+// → 56250
+```
+
+#### `getMoonLockShips(ship, debrisFactor, threshold = 2000000)`
+
+How many ships to destroy on a position to reach the 2 000 000 debris that give a moon its maximum 20 % chance.
+
+```javascript
+Ogame.Fleets.getMoonLockShips(Ogame.models.Destroyable[1], 0.5);
+// → 1000
+```
+
 ### `Ogame.Trader`
 
 Converts one resource into the two others. Rates are a `metal:crystal:deut` string (default `'2:1.5:1'`), and the percentages split the traded amount between the two target resources. **All parameters are optional.**
@@ -366,7 +419,7 @@ Ogame.Trader.sellCrystal(10000); // → { deut, metal }
 
 #### `parseRate(rate = '2:1.5:1', type = 'deut')`
 
-Normalizes a rate relative to a reference resource (`'metal'`, `'crystal'` or `'deut'`). Throws if the rate is malformed.
+Normalizes a rate relative to a reference resource (`'metal'`, `'crystal'` or `'deut'`). Throws if the rate is malformed — that includes a term that is not a number, but also a `0`, an empty one (`'2::1'`) and a negative one, none of which describe a trade.
 
 ```javascript
 Ogame.Trader.parseRate('3:2:1', 'deut');
@@ -464,7 +517,7 @@ import type { BuildingEntry, FleetEntry, Coordinates } from 'ogamejs/types';
 
 Stated plainly, so you know what you are not getting:
 
-- **Lifeforms** (the 2021 expansion) are not modelled — neither their buildings nor their technologies. This is a data problem, not a code one: the tables run to roughly 120 entries and we would rather have them sourced than guessed.
+- **Lifeforms** (the 2021 expansion) are not modelled — neither their buildings nor their technologies. This is a data problem, not a code one: the tables run to roughly 120 entries and we would rather have them sourced than guessed. Where a formula needs a lifeform bonus (expeditions, cargo), it takes the total the in-game bonus page shows.
 - **Drive upgrade values** for the three ships that switch drive (small cargo, recycler, bomber) come from community tables rather than a first-party source. The speeds are solid; the post-switch fuel figures deserve an in-game check.
 - **Defense repair** after a battle is not simulated, and neither are moon-creation odds.
 - Officers other than the geologist, and alliance classes, are not modelled in the production bonuses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ogamejs",
-  "version": "4.0.1",
+  "version": "4.1.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/expedition.js

@@ -0,0 +1,124 @@
+/**
+ * The maximum metal an expedition can find, tiered by the score of the
+ * universe's top player. `below` is an exclusive upper bound; above the last
+ * tier every universe shares `EXPEDITION_TOP_TIER_BASE`.
+ */
+const EXPEDITION_FIND_TIERS = Object.freeze([
+  Object.freeze({ below: 1e4, base: 40000 }),
+  Object.freeze({ below: 1e5, base: 500000 }),
+  Object.freeze({ below: 1e6, base: 1200000 }),
+  Object.freeze({ below: 5e6, base: 1800000 }),
+  Object.freeze({ below: 25e6, base: 2400000 }),
+  Object.freeze({ below: 50e6, base: 3000000 }),
+  Object.freeze({ below: 75e6, base: 3600000 }),
+  Object.freeze({ below: 100e6, base: 4200000 }),
+]);
+const EXPEDITION_TOP_TIER_BASE = 5000000;
+
+/** The Discoverer class bonus on expedition finds, `explorerBonusIncreasedExpeditionOutcome` in serverData. */
+const DEFAULT_EXPLORER_BONUS = 0.5;
+
+/** The share of base cargo each Hyperspace Technology level adds, `cargoHyperspaceTechMultiplier` in serverData. */
+const DEFAULT_HYPERSPACE_MULTIPLIER = 5;
+
+function assertBonus(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${name} must be a number >= 0, received ${value}`);
+  }
+}
+
+/**
+ *
+ * Return the expedition find base of a universe, before any multiplier
+ * @param {number} topScore The points of the universe's top player
+ * @return {number} The base, in metal
+ */
+function getExpeditionFindBase(topScore) {
+  if (!Number.isFinite(topScore) || topScore < 0) {
+    throw new Error(`topScore must be a number >= 0, received ${topScore}`);
+  }
+
+  const tier = EXPEDITION_FIND_TIERS.find(({ below }) => topScore < below);
+  return tier ? tier.base : EXPEDITION_TOP_TIER_BASE;
+}
+
+/**
+ *
+ * Return the largest metal find a single expedition can bring back
+ *
+ * `base * classFactor * (pathfinder ? 2 : 1) * (1 + lifeformResourceBonus)`
+ *
+ * - a Discoverer gets `classFactor = (1 + explorerBonus * (1 + lifeformExplorerBonus)) * economySpeed`:
+ *   the lifeform class enhancement amplifies the class bonus itself, and only
+ *   the Discoverer's finds scale with the economy speed;
+ * - any other class gets `classFactor = 1`.
+ *
+ * Crystal and deuterium finds are smaller than metal finds. Every bonus is a
+ * fraction: 0.2 for the 20 % the in-game lifeform bonus page shows.
+ * @param {object} options The universe and the player's bonuses
+ * @param {number} options.topScore The points of the universe's top player
+ * @param {number} options.economySpeed The universe economy speed
+ * @param {boolean} [options.explorer] Whether the player is a Discoverer
+ * @param {boolean} [options.pathfinder] Whether the fleet holds a Pathfinder
+ * @param {number} [options.explorerBonus] The Discoverer class bonus, 0.5 by default
+ * @param {number} [options.lifeformExplorerBonus] The lifeform Discoverer enhancement
+ * @param {number} [options.lifeformResourceBonus] The lifeform expedition resource bonus
+ * @return {number} The maximum find, in metal
+ */
+function getExpeditionMaxFind({
+  topScore,
+  economySpeed,
+  explorer = false,
+  pathfinder = false,
+  explorerBonus = DEFAULT_EXPLORER_BONUS,
+  lifeformExplorerBonus = 0,
+  lifeformResourceBonus = 0,
+}) {
+  if (!(economySpeed > 0)) {
+    throw new Error(`economySpeed must be greater than 0, received ${economySpeed}`);
+  }
+  assertBonus('explorerBonus', explorerBonus);
+  assertBonus('lifeformExplorerBonus', lifeformExplorerBonus);
+  assertBonus('lifeformResourceBonus', lifeformResourceBonus);
+
+  const classFactor = explorer
+    ? (1 + explorerBonus * (1 + lifeformExplorerBonus)) * economySpeed
+    : 1;
+
+  return getExpeditionFindBase(topScore) * classFactor * (pathfinder ? 2 : 1) * (1 + lifeformResourceBonus);
+}
+
+/**
+ *
+ * Return the cargo capacity of one ship, with its bonuses
+ *
+ * `ship.cargo * (1 + hyperspaceLevel * hyperspaceMultiplier / 100 + bonus)`:
+ * every bonus is a share of the base cargo, so they add up.
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {object} [options] The bonuses
+ * @param {number} [options.hyperspaceLevel] The Hyperspace Technology level
+ * @param {number} [options.hyperspaceMultiplier] The % of base cargo per level, 5 by default
+ * @param {number} [options.bonus] Any other bonus as a fraction: class (Collector 0.25 on cargo ships), lifeform…
+ * @return {number} The capacity
+ */
+function getCargoCapacity(ship, {
+  hyperspaceLevel = 0,
+  hyperspaceMultiplier = DEFAULT_HYPERSPACE_MULTIPLIER,
+  bonus = 0,
+} = {}) {
+  if (!Number.isInteger(hyperspaceLevel) || hyperspaceLevel < 0) {
+    throw new Error(`hyperspaceLevel must be an integer >= 0, received ${hyperspaceLevel}`);
+  }
+  assertBonus('hyperspaceMultiplier', hyperspaceMultiplier);
+  assertBonus('bonus', bonus);
+
+  return ship.cargo * (1 + (hyperspaceLevel * hyperspaceMultiplier) / 100 + bonus);
+}
+
+export {
+  getExpeditionFindBase,
+  getExpeditionMaxFind,
+  getCargoCapacity,
+  EXPEDITION_FIND_TIERS,
+  EXPEDITION_TOP_TIER_BASE,
+};

package/src/fleets/index.js

@@ -3,6 +3,23 @@ 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 {
+  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';
 
 const Fleets = {
   getDebris,
@@ -14,6 +31,24 @@ const Fleets = {
   getFuelConsumption,
   getTrip,
   simulateCombat,
+  getWaveChance,
+  getMoonbreakWaves,
+  getMoonbreakChance,
+  getMoonbreakLosses,
+  getExpeditionFindBase,
+  getExpeditionMaxFind,
+  getCargoCapacity,
+  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 default Fleets;

package/src/fleets/moonLock.js

@@ -0,0 +1,31 @@
+/** The debris that gives a moon its maximum chance to appear. */
+const MOON_DEBRIS_THRESHOLD = 2000000;
+
+/** The maximum moon chance, in %, reached at `MOON_DEBRIS_THRESHOLD`. */
+const MAX_MOON_CHANCE = 20;
+
+/**
+ *
+ * Return how many ships must be destroyed on a position to reach the maximum moon chance
+ *
+ * Only metal and crystal land in the debris field here, and the universe keeps
+ * `debrisFactor` of them.
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {number} debrisFactor The universe debris factor, e.g. 0.3 for 30%
+ * @param {number} [threshold] The debris to reach, 2 000 000 by default
+ * @return {number} The number of ships
+ */
+function getMoonLockShips(ship, debrisFactor, threshold = MOON_DEBRIS_THRESHOLD) {
+  if (!(debrisFactor > 0)) {
+    throw new Error(`debrisFactor must be greater than 0, received ${debrisFactor}`);
+  }
+
+  const debris = (ship.cost.metal ?? 0) + (ship.cost.crystal ?? 0);
+  if (!(debris > 0)) {
+    throw new Error('the ship leaves no metal or crystal debris');
+  }
+
+  return Math.ceil(threshold / (debrisFactor * debris));
+}
+
+export { getMoonLockShips, MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE };

package/src/fleets/moonbreak.js

@@ -0,0 +1,133 @@
+/** A moon size, in km, can only be in this range. */
+const MIN_MOON_SIZE = 3464;
+const MAX_MOON_SIZE = 8944;
+
+/** Each attacker spreads their Deathstars over this many waves. */
+const WAVES_PER_ATTACKER = 6;
+
+function assertMoonSize(moonSize) {
+  if (!Number.isFinite(moonSize) || moonSize < MIN_MOON_SIZE || moonSize > MAX_MOON_SIZE) {
+    throw new Error(`moonSize must be between ${MIN_MOON_SIZE} and ${MAX_MOON_SIZE}, received ${moonSize}`);
+  }
+}
+
+function assertFleets(fleets) {
+  if (!Array.isArray(fleets) || fleets.length === 0) {
+    throw new Error('fleets must be a non-empty array of Deathstar counts');
+  }
+  for (const rip of fleets) {
+    if (!Number.isInteger(rip) || rip < 0) {
+      throw new Error(`each fleet must be an integer >= 0, received ${rip}`);
+    }
+  }
+}
+
+/**
+ *
+ * Return the chance that a single wave of Deathstars destroys the moon
+ *
+ * `(100 - sqrt(moonSize)) * sqrt(rip) / 100`, capped at 1
+ * @param {number} moonSize The moon diameter, in km
+ * @param {number} rip The number of Deathstars in the wave
+ * @return {number} The chance, between 0 and 1
+ */
+function getWaveChance(moonSize, rip) {
+  return Math.min(1, ((100 - Math.sqrt(moonSize)) * Math.sqrt(rip)) / 100);
+}
+
+/**
+ *
+ * Return the waves one attacker sends, in firing order
+ *
+ * The Deathstars are spread over 6 waves: when the count is not a multiple of 6,
+ * the first waves carry one extra ship. Under 6 Deathstars, the last waves are
+ * empty, which neither threaten the moon nor lose a ship.
+ * @param {number} rip The attacker's Deathstars
+ * @return {number[]} The size of each of the 6 waves
+ */
+function getMoonbreakWaves(rip) {
+  const base = Math.floor(rip / WAVES_PER_ATTACKER);
+  const remainder = rip % WAVES_PER_ATTACKER;
+
+  return Array.from({ length: WAVES_PER_ATTACKER }, (_, i) => (i < remainder ? base + 1 : base));
+}
+
+/**
+ *
+ * Return the chance that a coordinated attack destroys the moon
+ *
+ * The attackers fire one after the other and the moon is gone as soon as one
+ * wave succeeds, so the attack fails only when every wave fails.
+ * @param {number} moonSize The moon diameter, in km (3464 to 8944)
+ * @param {number[]} fleets The Deathstars of each attacker, in firing order
+ * @return {number} The chance, between 0 and 1
+ */
+function getMoonbreakChance(moonSize, fleets) {
+  assertMoonSize(moonSize);
+  assertFleets(fleets);
+
+  const failure = fleets
+    .flatMap(getMoonbreakWaves)
+    .reduce((acc, rip) => acc * (1 - getWaveChance(moonSize, rip)), 1);
+
+  return 1 - failure;
+}
+
+/**
+ *
+ * Return the expected Deathstar losses of a coordinated attack
+ *
+ * Each Deathstar of a wave is destroyed with probability `sqrt(moonSize) / 200`,
+ * and a wave only costs ships if every wave before it failed. The variance sums
+ * the per-wave binomial variances (the waves are treated as independent), and
+ * the spread is summarised as a gaussian around the mean: 1σ / 2σ / 3σ for the
+ * 68 / 95 / 99 % bands, clamped between 0 and the whole fleet.
+ * @param {number} moonSize The moon diameter, in km (3464 to 8944)
+ * @param {number[]} fleets The Deathstars of each attacker, in firing order
+ * @return {{
+ *   mean: number, sigma: number,
+ *   bands: { confidence: number, min: number, max: number }[],
+ * }} The losses, unrounded
+ */
+function getMoonbreakLosses(moonSize, fleets) {
+  assertMoonSize(moonSize);
+  assertFleets(fleets);
+
+  const destructionRate = Math.sqrt(moonSize) / 200;
+  const total = fleets.reduce((acc, rip) => acc + rip, 0);
+
+  let mean = 0;
+  let variance = 0;
+  // The chance that every wave so far has failed, so that this one fires.
+  let reached = 1;
+
+  for (const size of fleets.flatMap(getMoonbreakWaves)) {
+    const p = destructionRate * reached;
+    mean += size * p;
+    variance += size * p * (1 - p);
+    reached *= 1 - getWaveChance(moonSize, size);
+  }
+
+  const sigma = Math.sqrt(variance);
+  const band = (confidence, sigmas) => ({
+    confidence,
+    min: Math.max(mean - sigmas * sigma, 0),
+    max: Math.min(mean + sigmas * sigma, total),
+  });
+
+  return {
+    mean,
+    sigma,
+    bands: [band(68, 1), band(95, 2), band(99, 3)],
+  };
+}
+
+export {
+  getWaveChance,
+  getMoonbreakWaves,
+  getMoonbreakChance,
+  getMoonbreakLosses,
+  MIN_MOON_SIZE,
+  MAX_MOON_SIZE,
+  WAVES_PER_ATTACKER,
+};

package/src/trades/parseRate.js

@@ -1,4 +1,4 @@
-import hasNaN from './utils.js';
+import isUsableRate from './utils.js';
 
 function extract(rate, type) {
   let res = {};
@@ -46,7 +46,10 @@ export default function parseRate(rate = '2:1.5:1', type = 'deut') {
 
   const res = extract(rate, type);
 
-  if (hasNaN(Object.values(res))) {
+  // Checked after normalizing rather than on the raw terms: whatever makes a
+  // rate unusable — a term that is not a number, `0`, empty, negative — shows
+  // up here as a NaN, an Infinity, a 0 or a negative ratio.
+  if (!isUsableRate(Object.values(res))) {
     throw new Error('rate not parsed correctly');
   }
 

package/src/trades/utils.js

@@ -1,9 +1,8 @@
-export default function hasNaN(args) {
-  let response = false;
-  args.forEach((val) => {
-    if (Number.isNaN(Number(val))) {
-      response = true;
-    }
-  });
-  return response;
+// A normalized rate is usable when every term is a real, strictly positive
+// number. Checking only for `NaN` let two kinds of nonsense through as if they
+// were answers: `Infinity`, produced by dividing into a `0` term, and `0`
+// itself, which is what an empty term (`'2::1'`) parses to. A negative worth is
+// not something the game can express either.
+export default function isUsableRate(values) {
+  return values.every((value) => Number.isFinite(value) && value > 0);
 }

package/types/fleets/expedition.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The maximum metal an expedition can find, tiered by the score of the
+ * universe's top player. `below` is an exclusive upper bound; above the last
+ * tier every universe shares `EXPEDITION_TOP_TIER_BASE`.
+ */
+declare const EXPEDITION_FIND_TIERS: readonly (Readonly<{
+    below: 10000;
+    base: 40000;
+}> | Readonly<{
+    below: 100000;
+    base: 500000;
+}> | Readonly<{
+    below: 1000000;
+    base: 1200000;
+}> | Readonly<{
+    below: 5000000;
+    base: 1800000;
+}> | Readonly<{
+    below: 25000000;
+    base: 2400000;
+}> | Readonly<{
+    below: 50000000;
+    base: 3000000;
+}> | Readonly<{
+    below: 75000000;
+    base: 3600000;
+}> | Readonly<{
+    below: 100000000;
+    base: 4200000;
+}>)[];
+declare const EXPEDITION_TOP_TIER_BASE = 5000000;
+/**
+ *
+ * Return the expedition find base of a universe, before any multiplier
+ * @param {number} topScore The points of the universe's top player
+ * @return {number} The base, in metal
+ */
+declare function getExpeditionFindBase(topScore: number): number;
+/**
+ *
+ * Return the largest metal find a single expedition can bring back
+ *
+ * `base * classFactor * (pathfinder ? 2 : 1) * (1 + lifeformResourceBonus)`
+ *
+ * - a Discoverer gets `classFactor = (1 + explorerBonus * (1 + lifeformExplorerBonus)) * economySpeed`:
+ *   the lifeform class enhancement amplifies the class bonus itself, and only
+ *   the Discoverer's finds scale with the economy speed;
+ * - any other class gets `classFactor = 1`.
+ *
+ * Crystal and deuterium finds are smaller than metal finds. Every bonus is a
+ * fraction: 0.2 for the 20 % the in-game lifeform bonus page shows.
+ * @param {object} options The universe and the player's bonuses
+ * @param {number} options.topScore The points of the universe's top player
+ * @param {number} options.economySpeed The universe economy speed
+ * @param {boolean} [options.explorer] Whether the player is a Discoverer
+ * @param {boolean} [options.pathfinder] Whether the fleet holds a Pathfinder
+ * @param {number} [options.explorerBonus] The Discoverer class bonus, 0.5 by default
+ * @param {number} [options.lifeformExplorerBonus] The lifeform Discoverer enhancement
+ * @param {number} [options.lifeformResourceBonus] The lifeform expedition resource bonus
+ * @return {number} The maximum find, in metal
+ */
+declare function getExpeditionMaxFind({ topScore, economySpeed, explorer, pathfinder, explorerBonus, lifeformExplorerBonus, lifeformResourceBonus, }: {
+    topScore: number;
+    economySpeed: number;
+    explorer?: boolean;
+    pathfinder?: boolean;
+    explorerBonus?: number;
+    lifeformExplorerBonus?: number;
+    lifeformResourceBonus?: number;
+}): number;
+/**
+ *
+ * Return the cargo capacity of one ship, with its bonuses
+ *
+ * `ship.cargo * (1 + hyperspaceLevel * hyperspaceMultiplier / 100 + bonus)`:
+ * every bonus is a share of the base cargo, so they add up.
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {object} [options] The bonuses
+ * @param {number} [options.hyperspaceLevel] The Hyperspace Technology level
+ * @param {number} [options.hyperspaceMultiplier] The % of base cargo per level, 5 by default
+ * @param {number} [options.bonus] Any other bonus as a fraction: class (Collector 0.25 on cargo ships), lifeform…
+ * @return {number} The capacity
+ */
+declare function getCargoCapacity(ship: import('../types.js').DestroyableEntry, { hyperspaceLevel, hyperspaceMultiplier, bonus, }?: {
+    hyperspaceLevel?: number;
+    hyperspaceMultiplier?: number;
+    bonus?: number;
+}): number;
+export { getExpeditionFindBase, getExpeditionMaxFind, getCargoCapacity, EXPEDITION_FIND_TIERS, EXPEDITION_TOP_TIER_BASE, };
+//# sourceMappingURL=expedition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expedition.d.ts","sourceRoot":"","sources":["../../src/fleets/expedition.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;KASzB,CAAC;AACH,QAAA,MAAM,wBAAwB,UAAU,CAAC;AAczC;;;;;GAKG;AACH,iBAAS,qBAAqB,CAAC,QAAQ,EAH5B,MAG4B,GAF3B,MAAM,CASjB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,oBAAoB,CAAC,EAC5B,QAAQ,EACR,YAAY,EACZ,QAAgB,EAChB,UAAkB,EAClB,aAAsC,EACtC,qBAAyB,EACzB,qBAAyB,GAC1B,EAjBE;IAAwB,QAAQ,EAAxB,MAAM,CACd;IAAwB,YAAY,EAA5B,MAAM,CACd;IAA0B,QAAQ,AAAlC,CACA,EADQ,OAAO,CACf;IAA0B,UAAU,AAApC,CACA,EADQ,OAAO,CACf;IAAyB,aAAa,AAAtC,CACA,EADQ,MAAM,CACd;IAAyB,qBAAqB,AAA9C,CACA,EADQ,MAAM,CACd;IAAyB,qBAAqB,AAA9C,CACA,EADQ,MAAM,CACd;CAUF,GAVW,MAAM,CAuBjB;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAPnB,OAAO,aAAa,EAAE,gBAOH,EAAE,EAC9B,eAAmB,EACnB,oBAAoD,EACpD,KAAS,GACV,AAVE,CAIA,EAHA;IAAyB,eAAe,AAAxC,CACA,EADQ,MAAM,CACd;IAAyB,oBAAoB,AAA7C,CACA,EADQ,MAAM,CACd;IAAyB,KAAK,AAA9B,CACA,EADQ,MAAM,CACd;CAMG,GANM,MAAM,CAcjB;AAED,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,GACzB,CAAC"}

package/types/fleets/index.d.ts

@@ -3,6 +3,9 @@ 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 { 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';
 declare const Fleets: {
     getDebris: typeof getDebris;
     getDistance: typeof getDistance;
@@ -13,6 +16,15 @@ declare const Fleets: {
     getFuelConsumption: typeof getFuelConsumption;
     getTrip: typeof getTrip;
     simulateCombat: typeof simulateCombat;
+    getWaveChance: typeof getWaveChance;
+    getMoonbreakWaves: typeof getMoonbreakWaves;
+    getMoonbreakChance: typeof getMoonbreakChance;
+    getMoonbreakLosses: typeof getMoonbreakLosses;
+    getExpeditionFindBase: typeof getExpeditionFindBase;
+    getExpeditionMaxFind: typeof getExpeditionMaxFind;
+    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 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;AAEzC,QAAA,MAAM,MAAM;;;;;;;;;;CAUX,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,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"}

package/types/fleets/moonLock.d.ts

@@ -0,0 +1,18 @@
+/** The debris that gives a moon its maximum chance to appear. */
+declare const MOON_DEBRIS_THRESHOLD = 2000000;
+/** The maximum moon chance, in %, reached at `MOON_DEBRIS_THRESHOLD`. */
+declare const MAX_MOON_CHANCE = 20;
+/**
+ *
+ * Return how many ships must be destroyed on a position to reach the maximum moon chance
+ *
+ * Only metal and crystal land in the debris field here, and the universe keeps
+ * `debrisFactor` of them.
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {number} debrisFactor The universe debris factor, e.g. 0.3 for 30%
+ * @param {number} [threshold] The debris to reach, 2 000 000 by default
+ * @return {number} The number of ships
+ */
+declare function getMoonLockShips(ship: import('../types.js').DestroyableEntry, debrisFactor: number, threshold?: number): number;
+export { getMoonLockShips, MOON_DEBRIS_THRESHOLD, MAX_MOON_CHANCE };
+//# sourceMappingURL=moonLock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moonLock.d.ts","sourceRoot":"","sources":["../../src/fleets/moonLock.js"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,QAAA,MAAM,qBAAqB,UAAU,CAAC;AAEtC,yEAAyE;AACzE,QAAA,MAAM,eAAe,KAAK,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EALnB,OAAO,aAAa,EAAE,gBAKH,EAAE,YAAY,EAJjC,MAIiC,EAAE,SAAS,AAHpD,CACA,EADQ,MAGoE,GAFnE,MAAM,CAajB;AAED,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,CAAC"}

package/types/fleets/moonbreak.d.ts

@@ -0,0 +1,64 @@
+/** A moon size, in km, can only be in this range. */
+declare const MIN_MOON_SIZE = 3464;
+declare const MAX_MOON_SIZE = 8944;
+/** Each attacker spreads their Deathstars over this many waves. */
+declare const WAVES_PER_ATTACKER = 6;
+/**
+ *
+ * Return the chance that a single wave of Deathstars destroys the moon
+ *
+ * `(100 - sqrt(moonSize)) * sqrt(rip) / 100`, capped at 1
+ * @param {number} moonSize The moon diameter, in km
+ * @param {number} rip The number of Deathstars in the wave
+ * @return {number} The chance, between 0 and 1
+ */
+declare function getWaveChance(moonSize: number, rip: number): number;
+/**
+ *
+ * Return the waves one attacker sends, in firing order
+ *
+ * The Deathstars are spread over 6 waves: when the count is not a multiple of 6,
+ * the first waves carry one extra ship. Under 6 Deathstars, the last waves are
+ * empty, which neither threaten the moon nor lose a ship.
+ * @param {number} rip The attacker's Deathstars
+ * @return {number[]} The size of each of the 6 waves
+ */
+declare function getMoonbreakWaves(rip: number): number[];
+/**
+ *
+ * Return the chance that a coordinated attack destroys the moon
+ *
+ * The attackers fire one after the other and the moon is gone as soon as one
+ * wave succeeds, so the attack fails only when every wave fails.
+ * @param {number} moonSize The moon diameter, in km (3464 to 8944)
+ * @param {number[]} fleets The Deathstars of each attacker, in firing order
+ * @return {number} The chance, between 0 and 1
+ */
+declare function getMoonbreakChance(moonSize: number, fleets: number[]): number;
+/**
+ *
+ * Return the expected Deathstar losses of a coordinated attack
+ *
+ * Each Deathstar of a wave is destroyed with probability `sqrt(moonSize) / 200`,
+ * and a wave only costs ships if every wave before it failed. The variance sums
+ * the per-wave binomial variances (the waves are treated as independent), and
+ * the spread is summarised as a gaussian around the mean: 1σ / 2σ / 3σ for the
+ * 68 / 95 / 99 % bands, clamped between 0 and the whole fleet.
+ * @param {number} moonSize The moon diameter, in km (3464 to 8944)
+ * @param {number[]} fleets The Deathstars of each attacker, in firing order
+ * @return {{
+ *   mean: number, sigma: number,
+ *   bands: { confidence: number, min: number, max: number }[],
+ * }} The losses, unrounded
+ */
+declare function getMoonbreakLosses(moonSize: number, fleets: number[]): {
+    mean: number;
+    sigma: number;
+    bands: {
+        confidence: number;
+        min: number;
+        max: number;
+    }[];
+};
+export { getWaveChance, getMoonbreakWaves, getMoonbreakChance, getMoonbreakLosses, MIN_MOON_SIZE, MAX_MOON_SIZE, WAVES_PER_ATTACKER, };
+//# sourceMappingURL=moonbreak.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moonbreak.d.ts","sourceRoot":"","sources":["../../src/fleets/moonbreak.js"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,QAAA,MAAM,aAAa,OAAO,CAAC;AAC3B,QAAA,MAAM,aAAa,OAAO,CAAC;AAE3B,mEAAmE;AACnE,QAAA,MAAM,kBAAkB,IAAI,CAAC;AAmB7B;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,QAAQ,EAJpB,MAIoB,EAAE,GAAG,EAHzB,MAGyB,GAFxB,MAAM,CAIjB;AAED;;;;;;;;;GASG;AACH,iBAAS,iBAAiB,CAAC,GAAG,EAHnB,MAGmB,GAFlB,MAAM,EAAE,CAOnB;AAED;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CAAC,QAAQ,EAJzB,MAIyB,EAAE,MAAM,EAHjC,MAAM,EAG2B,GAFhC,MAAM,CAWjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,kBAAkB,CAAC,QAAQ,EAPzB,MAOyB,EAAE,MAAM,EANjC,MAAM,EAM2B,GALhC;IACP,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3D,CAiCH;AAED,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,CAAC"}

package/types/index.d.ts

@@ -31,6 +31,14 @@ declare const Ogame: {
         getFuelConsumption: typeof import("./fleets/flight.js").getFuelConsumption;
         getTrip: typeof import("./fleets/flight.js").getTrip;
         simulateCombat: typeof import("./fleets/combat.js").default;
+        getWaveChance: typeof import("./fleets/moonbreak.js").getWaveChance;
+        getMoonbreakWaves: typeof import("./fleets/moonbreak.js").getMoonbreakWaves;
+        getMoonbreakChance: typeof import("./fleets/moonbreak.js").getMoonbreakChance;
+        getMoonbreakLosses: typeof import("./fleets/moonbreak.js").getMoonbreakLosses;
+        getExpeditionFindBase: typeof import("./fleets/expedition.js").getExpeditionFindBase;
+        getExpeditionMaxFind: typeof import("./fleets/expedition.js").getExpeditionMaxFind;
+        getCargoCapacity: typeof import("./fleets/expedition.js").getCargoCapacity;
+        getMoonLockShips: typeof import("./fleets/moonLock.js").getMoonLockShips;
     };
     Research: {
         getResearchCost: typeof import("./cost.js").default;

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"}

package/types/trades/parseRate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseRate.d.ts","sourceRoot":"","sources":["../../src/trades/parseRate.js"],"names":[],"mappings":"AAuCA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,IAAI,SAAY,EAAE,IAAI,SAAS,MAchE"}
+{"version":3,"file":"parseRate.d.ts","sourceRoot":"","sources":["../../src/trades/parseRate.js"],"names":[],"mappings":"AAuCA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,IAAI,SAAY,EAAE,IAAI,SAAS,MAiBhE"}

package/types/trades/utils.d.ts

@@ -1,2 +1,2 @@
-export default function hasNaN(args: any): boolean;
+export default function isUsableRate(values: any): any;
 //# sourceMappingURL=utils.d.ts.map

package/types/trades/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/trades/utils.js"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,KAAA,WAQlC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/trades/utils.js"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,MAAM,KAAA,OAE1C"}