ogamejs 3.0.0 → 4.0.1

package/src/models/research.js

@@ -0,0 +1,169 @@
+const CATEGORIES = Object.freeze({
+  BASIC: 'basic',
+  DRIVE: 'drive',
+  ADVANCED: 'advanced',
+  COMBAT: 'combat',
+});
+
+/**
+ * Every technology of the game, keyed by its official OGame id.
+ *
+ * Same shape as `models/buildings.js`: `names` for the localised labels,
+ * `base` for the level 1 cost and `factor` for the per-level multiplier —
+ * cost(level) = base * factor ** (level - 1).
+ *
+ * `base.energyCost` is only non zero for Graviton technology, which is paid
+ * entirely in energy.
+ */
+const RESEARCH = Object.freeze({
+  106: {
+    ogameId: 106,
+    names: { en: 'Espionage Technology', fr: 'Technologie Espionnage' },
+    category: CATEGORIES.BASIC,
+    factor: 2,
+    base: {
+      metal: 200, crystal: 1000, deuterium: 200, energyCost: 0,
+    },
+  },
+  108: {
+    ogameId: 108,
+    names: { en: 'Computer Technology', fr: 'Technologie Ordinateur' },
+    category: CATEGORIES.BASIC,
+    factor: 2,
+    base: {
+      metal: 0, crystal: 400, deuterium: 600, energyCost: 0,
+    },
+  },
+  109: {
+    ogameId: 109,
+    names: { en: 'Weapons Technology', fr: 'Technologie Armes' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 800, crystal: 200, deuterium: 0, energyCost: 0,
+    },
+  },
+  110: {
+    ogameId: 110,
+    names: { en: 'Shielding Technology', fr: 'Technologie Bouclier' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 200, crystal: 600, deuterium: 0, energyCost: 0,
+    },
+  },
+  111: {
+    ogameId: 111,
+    names: { en: 'Armour Technology', fr: 'Technologie Protection des vaisseaux spatiaux' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 1000, crystal: 0, deuterium: 0, energyCost: 0,
+    },
+  },
+  113: {
+    ogameId: 113,
+    names: { en: 'Energy Technology', fr: 'Technologie Énergie' },
+    category: CATEGORIES.BASIC,
+    factor: 2,
+    base: {
+      metal: 0, crystal: 800, deuterium: 400, energyCost: 0,
+    },
+  },
+  114: {
+    ogameId: 114,
+    names: { en: 'Hyperspace Technology', fr: 'Technologie Hyperespace' },
+    category: CATEGORIES.ADVANCED,
+    factor: 2,
+    base: {
+      metal: 0, crystal: 4000, deuterium: 2000, energyCost: 0,
+    },
+  },
+  115: {
+    ogameId: 115,
+    names: { en: 'Combustion Drive', fr: 'Réacteur à combustion' },
+    category: CATEGORIES.DRIVE,
+    factor: 2,
+    base: {
+      metal: 400, crystal: 0, deuterium: 600, energyCost: 0,
+    },
+  },
+  117: {
+    ogameId: 117,
+    names: { en: 'Impulse Drive', fr: 'Réacteur à impulsion' },
+    category: CATEGORIES.DRIVE,
+    factor: 2,
+    base: {
+      metal: 2000, crystal: 4000, deuterium: 600, energyCost: 0,
+    },
+  },
+  118: {
+    ogameId: 118,
+    names: { en: 'Hyperspace Drive', fr: 'Propulsion hyperespace' },
+    category: CATEGORIES.DRIVE,
+    factor: 2,
+    base: {
+      metal: 10000, crystal: 20000, deuterium: 6000, energyCost: 0,
+    },
+  },
+  120: {
+    ogameId: 120,
+    names: { en: 'Laser Technology', fr: 'Technologie Laser' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 200, crystal: 100, deuterium: 0, energyCost: 0,
+    },
+  },
+  121: {
+    ogameId: 121,
+    names: { en: 'Ion Technology', fr: 'Technologie Ions' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 1000, crystal: 300, deuterium: 100, energyCost: 0,
+    },
+  },
+  122: {
+    ogameId: 122,
+    names: { en: 'Plasma Technology', fr: 'Technologie Plasma' },
+    category: CATEGORIES.COMBAT,
+    factor: 2,
+    base: {
+      metal: 2000, crystal: 4000, deuterium: 1000, energyCost: 0,
+    },
+  },
+  123: {
+    ogameId: 123,
+    names: { en: 'Intergalactic Research Network', fr: 'Réseau de recherche intergalactique' },
+    category: CATEGORIES.ADVANCED,
+    factor: 2,
+    base: {
+      metal: 240000, crystal: 400000, deuterium: 160000, energyCost: 0,
+    },
+  },
+  124: {
+    ogameId: 124,
+    names: { en: 'Astrophysics', fr: 'Astrophysique' },
+    category: CATEGORIES.ADVANCED,
+    // Astrophysics is the only technology with a non-integer factor; the game
+    // also rounds each level cost up to the nearest hundred.
+    factor: 1.75,
+    roundTo: 100,
+    base: {
+      metal: 4000, crystal: 8000, deuterium: 4000, energyCost: 0,
+    },
+  },
+  199: {
+    ogameId: 199,
+    names: { en: 'Graviton Technology', fr: 'Technologie Graviton' },
+    category: CATEGORIES.ADVANCED,
+    factor: 3,
+    base: {
+      metal: 0, crystal: 0, deuterium: 0, energyCost: 300000,
+    },
+  },
+});
+
+export { CATEGORIES };
+export default RESEARCH;

package/src/research/index.js

@@ -0,0 +1,9 @@
+import getCost from '../cost.js';
+import getResearchTime from './researchTime.js';
+
+const Research = {
+  getResearchCost: getCost,
+  getResearchTime,
+};
+
+export default Research;

package/src/research/researchTime.js

@@ -0,0 +1,25 @@
+import getCost, { assertLevel } from '../cost.js';
+
+/**
+ *
+ * Return the time needed to research a technology at a given level
+ *
+ * time = (metal + crystal) / (1000 * (1 + labs)) hours, divided by the
+ * universe research speed. `labs` is the research lab level, or the sum of
+ * every connected lab when the Intergalactic Research Network is up.
+ * @param {import('../types.js').ResearchEntry} research A models/research.js entry
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} [labLevel] The research lab level, or the sum of connected labs
+ * @param {number} [researchSpeed] The universe research speed
+ * @returns {number} The research time, in seconds
+ */
+function getResearchTime(research, targetLevel, labLevel = 0, researchSpeed = 1) {
+  assertLevel(targetLevel);
+
+  const { metal, crystal } = getCost(research, targetLevel);
+  const divider = 1000 * (1 + labLevel) * researchSpeed;
+
+  return Math.round(((metal + crystal) / divider) * 3600);
+}
+
+export default getResearchTime;

package/src/trades/parseRate.js

@@ -20,9 +20,14 @@ function extract(rate, type) {
       rateDeut: deut / crystal,
     };
   } else if (type === 'deut') {
+    // Like the two branches above: express the other terms in units of the one
+    // being sold, so its own term becomes 1. Reading `metal` and `crystal` raw
+    // here only happened to work because rates are usually written against 1
+    // deuterium — `4:3:2` is the same rate as `2:1.5:1`, but used to pay twice
+    // as much for the very same deuterium.
     res = {
-      rateMetal: metal,
-      rateCrystal: crystal,
+      rateMetal: metal / deut,
+      rateCrystal: crystal / deut,
       rateDeut: 1,
     };
   } else {

package/src/types.js

@@ -0,0 +1,146 @@
+/**
+ * Shared type definitions.
+ *
+ * This module holds no runtime code: it only exists so the JSDoc of the rest of
+ * the library — and the generated `.d.ts` files — can point at named types
+ * instead of a bare `object`.
+ *
+ * @module types
+ */
+
+/**
+ * @typedef {'en' | 'fr'} Lang A supported language
+ */
+
+/**
+ * @typedef {object} Names
+ * @property {string} en The English name
+ * @property {string} fr The French name
+ */
+
+/**
+ * @typedef {object} BuildingBase The level 1 values of a building
+ * @property {number} metal Metal paid to build it
+ * @property {number} crystal Crystal paid to build it
+ * @property {number} deuterium Deuterium paid to build it
+ * @property {number} energyCost Energy paid to build it
+ * @property {number} energyConsumption Energy it consumes once built
+ * @property {number} deuteriumConsumption Deuterium it burns once built
+ * @property {number} production What it produces, resources or energy
+ */
+
+/**
+ * @typedef {object} BuildingEntry An entry of `models/buildings.js`
+ * @property {number} ogameId The id OGame itself uses
+ * @property {Names} names The localised labels
+ * @property {string} category `resources`, `facilities` or `moon`
+ * @property {number} factor The per-level cost multiplier
+ * @property {BuildingBase} base The level 1 values
+ * @property {number} [energyFactor] A separate multiplier for the energy cost
+ * @property {string} [storage] The resource it stores, on storage buildings only
+ */
+
+/**
+ * @typedef {object} ResearchBase The level 1 cost of a technology
+ * @property {number} metal Metal cost
+ * @property {number} crystal Crystal cost
+ * @property {number} deuterium Deuterium cost
+ * @property {number} energyCost Energy cost, Graviton technology only
+ */
+
+/**
+ * @typedef {object} ResearchEntry An entry of `models/research.js`
+ * @property {number} ogameId The id OGame itself uses
+ * @property {Names} names The localised labels
+ * @property {string} category `basic`, `drive`, `advanced` or `combat`
+ * @property {number} factor The per-level cost multiplier
+ * @property {ResearchBase} base The level 1 cost
+ * @property {number} [roundTo] Rounding step, Astrophysics only
+ */
+
+/**
+ * @typedef {object} Cost The resources a level costs
+ * @property {number} metal Metal cost
+ * @property {number} crystal Crystal cost
+ * @property {number} deuterium Deuterium cost
+ * @property {number} energyCost Energy cost
+ */
+
+/**
+ * @typedef {object} BuildingInfo Everything about a building at a given level
+ * @property {number} metal Metal paid to reach that level
+ * @property {number} crystal Crystal paid to reach that level
+ * @property {number} deuterium Deuterium paid to reach that level
+ * @property {number} energyCost Energy paid to reach that level
+ * @property {number} energyConsumption Energy consumed at that level
+ * @property {number} deuteriumConsumption Deuterium burned at that level
+ * @property {number} production Resources, or energy, produced at that level
+ */
+
+/**
+ * @typedef {object} RapidFire A rapid-fire bonus against another unit
+ * @property {number} target The library id of the unit it applies to
+ * @property {number} fire How many shots it can chain
+ */
+
+/**
+ * @typedef {object} DriveUpgrade A better drive a ship switches to
+ * @property {string} drive The drive it moves to
+ * @property {number} minLevel The drive level that unlocks it
+ * @property {number} speed The new base speed
+ * @property {number} fuelConsumption The new base fuel consumption
+ */
+
+/**
+ * @typedef {object} DestroyableEntry An entry of `models/destroyable.js`
+ * @property {number} ogameId The id OGame itself uses
+ * @property {Names} names The localised labels
+ * @property {number} structure The metal plus crystal cost, hull is a tenth of it
+ * @property {number} shield The base shield
+ * @property {number} attack The base attack
+ * @property {number} speed The base speed, before any drive bonus
+ * @property {number} cargo The cargo capacity
+ * @property {number} fuelConsumption The base deuterium burned
+ * @property {string} drive The drive powering it
+ * @property {string} type `attack`, `civil` or `defense`
+ * @property {string} category `ships`, `defenses` or `missiles`
+ * @property {RapidFire[]} rapidFire Its rapid-fire table
+ * @property {{metal: number, crystal: number, deuterium: number}} cost What it costs to build
+ * @property {DriveUpgrade[]} [driveUpgrades] The drives it can switch to
+ */
+
+/**
+ * @typedef {object} Coordinates A place in the universe
+ * @property {number} galaxy The galaxy
+ * @property {number} system The system
+ * @property {number} position The position in the system
+ */
+
+/**
+ * @typedef {object} FleetEntry A group of identical ships
+ * @property {DestroyableEntry} ship The ship
+ * @property {number} count How many of them
+ */
+
+/**
+ * @typedef {object} Drives The drive technology levels
+ * @property {number} [combustion] The Combustion Drive level
+ * @property {number} [impulse] The Impulse Drive level
+ * @property {number} [hyperspace] The Hyperspace Drive level
+ */
+
+/**
+ * @typedef {object} CombatTechs The combat technology levels
+ * @property {number} [weapons] The Weapons Technology level
+ * @property {number} [shielding] The Shielding Technology level
+ * @property {number} [armour] The Armour Technology level
+ */
+
+/**
+ * @typedef {object} Resources An amount of each resource
+ * @property {number} metal Metal
+ * @property {number} crystal Crystal
+ * @property {number} deuterium Deuterium
+ */
+
+export {};

package/types/buildings/buildTime.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Return the time needed to build a building at a given level
+ *
+ * time = (metal + crystal) / (2500 * (1 + robotics) * 2 ** nanites) hours,
+ * divided by the universe economy speed.
+ * @param {import('../types.js').BuildingEntry} building A models/buildings.js entry
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} [roboticsLevel] The robotics factory level on that planet
+ * @param {number} [naniteLevel] The nanite factory level on that planet
+ * @param {number} [universeSpeed] The universe economy speed
+ * @returns {number} The build time, in seconds
+ */
+declare function getBuildTime(building: import('../types.js').BuildingEntry, targetLevel: number, roboticsLevel?: number, naniteLevel?: number, universeSpeed?: number): number;
+export default getBuildTime;
+//# sourceMappingURL=buildTime.d.ts.map

package/types/buildings/buildTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTime.d.ts","sourceRoot":"","sources":["../../src/buildings/buildTime.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,iBAAS,YAAY,CAAC,QAAQ,EAPnB,OAAO,aAAa,EAAE,aAOH,EAAE,WAAW,EANhC,MAMgC,EAAE,aAAa,AALvD,CACA,EADQ,MAKmD,EAAE,WAAW,AAJxE,CACA,EADQ,MAIoE,EAAE,aAAa,AAH3F,CACA,EADQ,MAGuF,GAFrF,MAAM,CASlB;eAEc,YAAY"}

package/types/buildings/crystal.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * Return information about the crystal mine at a given level
+ * @param {import('../types.js').BuildingEntry} mine The crystal mine entry, `Buildings[2]`
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} pos The planet position, 1, 2 and 3 produce more crystal
+ * @param {number} [universeSpeed] Production is increased on faster universes
+ * @returns {import('../types.js').BuildingInfo} Cost, consumption and production at that level
+ */
+declare function getCrystalMine(mine: import('../types.js').BuildingEntry, targetLevel: number, pos: number, universeSpeed?: number): import('../types.js').BuildingInfo;
+export default getCrystalMine;
+//# sourceMappingURL=crystal.d.ts.map

package/types/buildings/crystal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crystal.d.ts","sourceRoot":"","sources":["../../src/buildings/crystal.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,IAAI,EANjB,OAAO,aAAa,EAAE,aAML,EAAE,WAAW,EAL9B,MAK8B,EAAE,GAAG,EAJnC,MAImC,EAAE,aAAa,AAH1D,CACA,EADQ,MAGsD,GAFpD,OAAO,aAAa,EAAE,YAAY,CAS9C;eAEc,cAAc"}

package/types/buildings/deut.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * Return information about the deuterium synthesizer at a given level
+ * @param {import('../types.js').BuildingEntry} mine The deuterium synthesizer entry, `Buildings[3]`
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} avg The planet average temperature, the lower the higher the production
+ * @param {number} [universeSpeed] Production is increased on faster universes
+ * @returns {import('../types.js').BuildingInfo} Cost, consumption and production at that level
+ */
+declare function getDeutSynth(mine: import('../types.js').BuildingEntry, targetLevel: number, avg: number, universeSpeed?: number): import('../types.js').BuildingInfo;
+export default getDeutSynth;
+//# sourceMappingURL=deut.d.ts.map

package/types/buildings/deut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deut.d.ts","sourceRoot":"","sources":["../../src/buildings/deut.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,iBAAS,YAAY,CAAC,IAAI,EANf,OAAO,aAAa,EAAE,aAMP,EAAE,WAAW,EAL5B,MAK4B,EAAE,GAAG,EAJjC,MAIiC,EAAE,aAAa,AAHxD,CACA,EADQ,MAGoD,GAFlD,OAAO,aAAa,EAAE,YAAY,CAU9C;eAEc,YAAY"}

package/types/buildings/fusion-reactor.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * Return information about the fusion reactor at a given level
+ *
+ * `deuteriumConsumption` is the deuterium the reactor burns per hour, and
+ * `production` the energy it delivers.
+ * @param {import('../types.js').BuildingEntry} reactor The fusion reactor entry, `Buildings[5]`
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} energyTech The Energy Technology level
+ * @param {number} [universeSpeed] Consumption is increased on faster universes
+ * @returns {import('../types.js').BuildingInfo} Cost, deuterium consumption and energy production
+ */
+declare function getFusionReactor(reactor: import('../types.js').BuildingEntry, targetLevel: number, energyTech: number, universeSpeed?: number): import('../types.js').BuildingInfo;
+export default getFusionReactor;
+//# sourceMappingURL=fusion-reactor.d.ts.map

package/types/buildings/fusion-reactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fusion-reactor.d.ts","sourceRoot":"","sources":["../../src/buildings/fusion-reactor.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,iBAAS,gBAAgB,CAAC,OAAO,EANtB,OAAO,aAAa,EAAE,aAMA,EAAE,WAAW,EALnC,MAKmC,EAAE,UAAU,EAJ/C,MAI+C,EAAE,aAAa,AAHtE,CACA,EADQ,MAGkE,GAFhE,OAAO,aAAa,EAAE,YAAY,CAS9C;eAEc,gBAAgB"}

package/types/buildings/index.d.ts

@@ -0,0 +1,27 @@
+import getCrystalMine from './crystal.js';
+import getDeutSynth from './deut.js';
+import getMetalMine from './metal.js';
+import getSolarPlant from './solar-plant.js';
+import getFusionReactor from './fusion-reactor.js';
+import parseInfoCompteData from './infocompte.js';
+import getCost from '../cost.js';
+import getStorage, { getStorageCapacity, getStorageLevelFor } from './storage.js';
+import getBuildTime from './buildTime.js';
+import getPlanetProduction, { getProductionBonus } from './production.js';
+declare const Buildings: {
+    getCrystalMine: typeof getCrystalMine;
+    getDeutSynth: typeof getDeutSynth;
+    getMetalMine: typeof getMetalMine;
+    getSolarPlant: typeof getSolarPlant;
+    getFusionReactor: typeof getFusionReactor;
+    parseInfoCompteData: typeof parseInfoCompteData;
+    getBuildingCost: typeof getCost;
+    getBuildTime: typeof getBuildTime;
+    getStorage: typeof getStorage;
+    getStorageCapacity: typeof getStorageCapacity;
+    getStorageLevelFor: typeof getStorageLevelFor;
+    getPlanetProduction: typeof getPlanetProduction;
+    getProductionBonus: typeof getProductionBonus;
+};
+export default Buildings;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/buildings/index.js"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,cAAc,CAAC;AAC1C,OAAO,YAAY,MAAM,WAAW,CAAC;AACrC,OAAO,YAAY,MAAM,YAAY,CAAC;AACtC,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAC7C,OAAO,gBAAgB,MAAM,qBAAqB,CAAC;AACnD,OAAO,mBAAmB,MAAM,iBAAiB,CAAC;AAClD,OAAO,OAAO,MAAM,YAAY,CAAC;AACjC,OAAO,UAAU,EAAE,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,mBAAmB,EAAE,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1E,QAAA,MAAM,SAAS;;;;;;;;;;;;;;CAcd,CAAC;eAEa,SAAS"}

package/types/buildings/info.d.ts

@@ -0,0 +1,17 @@
+/**
+ *
+ * Assemble the information every building calculator returns
+ *
+ * Keeping a single shape means a caller can read `production` or
+ * `energyConsumption` without knowing which building it is looking at; the
+ * fields that do not apply are simply `0`.
+ * @param {import('../types.js').BuildingEntry} entry A models/buildings.js entry
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} universeSpeed The universe economy speed
+ * @param {(base: object, flows: object) => number} computeProduction Production of
+ *   that building, given its base stats and its already computed consumptions
+ * @returns {import('../types.js').BuildingInfo} The full picture of that building at that level
+ */
+declare function buildingInfo(entry: import('../types.js').BuildingEntry, targetLevel: number, universeSpeed: number, computeProduction: (base: object, flows: object) => number): import('../types.js').BuildingInfo;
+export default buildingInfo;
+//# sourceMappingURL=info.d.ts.map

package/types/buildings/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../src/buildings/info.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,iBAAS,YAAY,CAAC,KAAK,EAPhB,OAAO,aAAa,EAAE,aAON,EAAE,WAAW,EAN7B,MAM6B,EAAE,aAAa,EAL5C,MAK4C,EAAE,iBAAiB,EAJ/D,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAI8B,GAF7D,OAAO,aAAa,EAAE,YAAY,CAkB9C;eAEc,YAAY"}

package/types/buildings/infocompte.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Labels used by the Infocompte export, per game language.
+ *
+ * The French set is the reference one; the others are best effort. A locale can
+ * be overridden per call through the `labels` option, so an unsupported
+ * language does not require a release.
+ */
+declare const LOCALES: Readonly<{
+    fr: {
+        planet: string;
+        metalPoints: string;
+        crystalPoints: string;
+        deutPoints: string;
+        plasma: string;
+        hourly: string;
+    };
+    en: {
+        planet: string;
+        metalPoints: string;
+        crystalPoints: string;
+        deutPoints: string;
+        plasma: string;
+        hourly: string;
+    };
+}>;
+/**
+ *
+ * Parse the BBCode of an Infocompte report into a structured object
+ * @param {string} data The infocompte bb-code
+ * @param {object} [options] Parsing options
+ * @param {string} [options.locale] Force a locale instead of reading it from the report
+ * @param {object} [options.labels] Override the labels, see LOCALES for the shape
+ * @returns {Object} The parsed JSON object of infocompte
+ */
+declare function parseInfoCompteData(data: string, options?: {
+    locale?: string;
+    labels?: object;
+}): Object;
+export { LOCALES };
+export default parseInfoCompteData;
+//# sourceMappingURL=infocompte.d.ts.map

package/types/buildings/infocompte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infocompte.d.ts","sourceRoot":"","sources":["../../src/buildings/infocompte.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,QAAA,MAAM,OAAO;;QAET,MAAM;QACN,WAAW;QACX,aAAa;QACb,UAAU;QACV,MAAM;QACN,MAAM;;;QAGN,MAAM;QACN,WAAW;QACX,aAAa;QACb,UAAU;QACV,MAAM;QACN,MAAM;;EAER,CAAC;AAsDH;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,IAAI,EANtB,MAMsB,EAAE,OAAO,AALvC,CAGA,EAFA;IAAyB,MAAM,AAA/B,CACA,EADQ,MAAM,CACd;IAAyB,MAAM,AAA/B,CACA,EADQ,MAAM,CACd;CAE4C,GAFlC,MAAM,CA6DlB;AAED,OAAO,EAAE,OAAO,EAAE,CAAC;eACJ,mBAAmB"}

package/types/buildings/metal.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * Return information about the metal mine at a given level
+ * @param {import('../types.js').BuildingEntry} mine The metal mine entry, `Buildings[1]`
+ * @param {number} targetLevel The level to reach, >= 1
+ * @param {number} [universeSpeed] Production is increased on faster universes
+ * @returns {import('../types.js').BuildingInfo} Cost, consumption and production at that level
+ */
+declare function getMetalMine(mine: import('../types.js').BuildingEntry, targetLevel: number, universeSpeed?: number): import('../types.js').BuildingInfo;
+export default getMetalMine;
+//# sourceMappingURL=metal.d.ts.map

package/types/buildings/metal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metal.d.ts","sourceRoot":"","sources":["../../src/buildings/metal.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,iBAAS,YAAY,CAAC,IAAI,EALf,OAAO,aAAa,EAAE,aAKP,EAAE,WAAW,EAJ5B,MAI4B,EAAE,aAAa,AAHnD,CACA,EADQ,MAG+C,GAF7C,OAAO,aAAa,EAAE,YAAY,CAS9C;eAEc,YAAY"}

package/types/buildings/production.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Plasma technology is worth more on metal than on crystal, and more on crystal
+ * than on deuterium.
+ */
+declare const PLASMA_BONUS: Readonly<{
+    metal: 0.01;
+    crystal: 0.0066;
+    deuterium: 0.0033;
+}>;
+/** The geologist officer adds a flat 10% to the three mines. */
+declare const GEOLOGIST_BONUS = 0.1;
+/** The collector class adds 25% to mine production. */
+declare const COLLECTOR_BONUS = 0.25;
+/**
+ * Every planet produces this much per hour on its own, mines or not. It is a
+ * flat income: no bonus applies to it.
+ */
+declare const BASE_INCOME: Readonly<{
+    metal: 30;
+    crystal: 15;
+    deuterium: 0;
+}>;
+/**
+ *
+ * Return the production multiplier of each resource
+ *
+ * The multipliers add up, they are not compounded: plasma 15, a geologist and
+ * the collector class give 1 + 0.15 + 0.1 + 0.25 on metal.
+ * @param {object} [options] The bonuses that apply
+ * @param {number} [options.plasmaTech] The Plasma Technology level
+ * @param {boolean} [options.geologist] Whether the geologist officer is hired
+ * @param {boolean} [options.collectorClass] Whether the player plays collector
+ * @param {object} [options.items] Booster items in place, as fractions per
+ *   resource — a 30% metal booster is `{ metal: 0.3 }`
+ * @returns {import('../types.js').Resources} One multiplier per resource
+ */
+declare function getProductionBonus(options?: {
+    plasmaTech?: number;
+    geologist?: boolean;
+    collectorClass?: boolean;
+    items?: object;
+}): import('../types.js').Resources;
+/**
+ *
+ * Return the hourly production of a whole planet, bonuses included
+ *
+ * Mine levels, planet position and temperature give the raw mine output; the
+ * plasma, officer, class and item bonuses are then applied, and the flat planet
+ * income is added on top.
+ * @param {object} planet The planet description
+ * @param {number} planet.metalMine The metal mine level
+ * @param {number} planet.crystalMine The crystal mine level
+ * @param {number} planet.deutSynth The deuterium synthesizer level
+ * @param {number} planet.position The planet position, 1 to 3 produce more crystal
+ * @param {number} planet.temperature The planet average temperature
+ * @param {number} [planet.universeSpeed] The universe economy speed
+ * @param {number} [planet.energyEfficiency] The share of the required energy that
+ *   is actually available, between 0 and 1 — mines run at that rate when the
+ *   planet is in an energy deficit
+ * @param {object} [bonuses] Passed straight to `getProductionBonus`
+ * @returns {import('../types.js').Resources & {energyConsumption: number, bonus: import('../types.js').Resources}}
+ *   The hourly production, what it costs in energy, and the multipliers used
+ */
+declare function getPlanetProduction(planet: {
+    metalMine: number;
+    crystalMine: number;
+    deutSynth: number;
+    position: number;
+    temperature: number;
+    universeSpeed?: number;
+    energyEfficiency?: number;
+}, bonuses?: object): import('../types.js').Resources & {
+    energyConsumption: number;
+    bonus: import('../types.js').Resources;
+};
+export { getProductionBonus, PLASMA_BONUS, GEOLOGIST_BONUS, COLLECTOR_BONUS, BASE_INCOME, };
+export default getPlanetProduction;
+//# sourceMappingURL=production.d.ts.map

package/types/buildings/production.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"production.d.ts","sourceRoot":"","sources":["../../src/buildings/production.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,QAAA,MAAM,YAAY;;;;EAAqE,CAAC;AAExF,gEAAgE;AAChE,QAAA,MAAM,eAAe,MAAM,CAAC;AAE5B,uDAAuD;AACvD,QAAA,MAAM,eAAe,OAAO,CAAC;AAE7B;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;EAA0D,CAAC;AAY5E;;;;;;;;;;;;;GAaG;AACH,iBAAS,kBAAkB,CAAC,OAAO,AARhC,CAMA,EALA;IAAyB,UAAU,AAAnC,CACA,EADQ,MAAM,CACd;IAA0B,SAAS,AAAnC,CACA,EADQ,OAAO,CACf;IAA0B,cAAc,AAAxC,CACA,EADQ,OAAO,CACf;IAAyB,KAAK,AAA9B,CAEA,EAFQ,MAAM,CAEd;CAEqC,GAF3B,OAAO,aAAa,EAAE,SAAS,CAuB3C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iBAAS,mBAAmB,CAAC,MAAM,EAbhC;IAAuB,SAAS,EAAxB,MAAM,CACd;IAAuB,WAAW,EAA1B,MAAM,CACd;IAAuB,SAAS,EAAxB,MAAM,CACd;IAAuB,QAAQ,EAAvB,MAAM,CACd;IAAuB,WAAW,EAA1B,MAAM,CACd;IAAwB,aAAa,AAArC,CACA,EADQ,MAAM,CACd;IAAwB,gBAAgB,AAAxC,CAGA,EAHQ,MAAM,CAGd;CAIgC,EAAE,OAAO,AAJzC,CACA,EADQ,MAIsC,GAHpC,OAAO,aAAa,EAAE,SAAS,GAAG;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,aAAa,EAAE,SAAS,CAAA;CAAC,CAoDjH;AAED,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,WAAW,GACZ,CAAC;eACa,mBAAmB"}

package/types/buildings/solar-plant.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * Return information about the solar plant at a given level
+ * @param {import('../types.js').BuildingEntry} solarPlant The solar plant entry, `Buildings[4]`
+ * @param {number} targetLevel The level to reach, >= 1
+ * @returns {import('../types.js').BuildingInfo} Cost of the plant, and the energy it produces
+ */
+declare function getSolarPlant(solarPlant: import('../types.js').BuildingEntry, targetLevel: number): import('../types.js').BuildingInfo;
+export default getSolarPlant;
+//# sourceMappingURL=solar-plant.d.ts.map

package/types/buildings/solar-plant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solar-plant.d.ts","sourceRoot":"","sources":["../../src/buildings/solar-plant.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,iBAAS,aAAa,CAAC,UAAU,EAJtB,OAAO,aAAa,EAAE,aAIA,EAAE,WAAW,EAHnC,MAGmC,GAFjC,OAAO,aAAa,EAAE,YAAY,CAS9C;eAEc,aAAa"}