ogamejs 2.1.6 → 4.0.0

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/crystal.js

@@ -0,0 +1,16 @@
+import parseRate from './parseRate.js';
+
+function sellCrystal(crystal = 0, percentD = 40, percentM = 60, rate = '2:1.5:1') {
+  const pDeut = percentD / 100;
+  const pMetal = percentM / 100;
+  const { rateDeut, rateMetal } = parseRate(rate, 'crystal');
+  const deut = pDeut * rateDeut * crystal;
+  const metal = pMetal * rateMetal * crystal;
+
+  return {
+    deut: Math.round(deut),
+    metal: Math.round(metal),
+  };
+}
+
+export default sellCrystal;

package/src/trades/deut.js

@@ -0,0 +1,16 @@
+import parseRate from './parseRate.js';
+
+function sellDeut(deut = 0, percentM = 60, percentC = 40, rate = '2:1.5:1') {
+  const pMetal = percentM / 100;
+  const pCrystal = percentC / 100;
+  const { rateMetal, rateCrystal } = parseRate(rate, 'deut');
+  const metal = pMetal * rateMetal * deut;
+  const crystal = pCrystal * rateCrystal * deut;
+
+  return {
+    metal: Math.round(metal),
+    crystal: Math.round(crystal),
+  };
+}
+
+export default sellDeut;

package/src/trades/index.js

@@ -0,0 +1,13 @@
+import parseRate from './parseRate.js';
+import sellDeut from './deut.js';
+import sellCrystal from './crystal.js';
+import sellMetal from './metal.js';
+
+const Trader = {
+  parseRate,
+  sellDeut,
+  sellCrystal,
+  sellMetal,
+};
+
+export default Trader;

package/src/trades/metal.js

@@ -0,0 +1,16 @@
+import parseRate from './parseRate.js';
+
+function sellMetal(metal = 0, percentD = 40, percentC = 60, rate = '2:1.5:1') {
+  const pDeut = percentD / 100;
+  const pCrystal = percentC / 100;
+  const { rateDeut, rateCrystal } = parseRate(rate, 'metal');
+  const deut = pDeut * rateDeut * metal;
+  const crystal = pCrystal * rateCrystal * metal;
+
+  return {
+    deut: Math.round(deut),
+    crystal: Math.round(crystal),
+  };
+}
+
+export default sellMetal;

package/src/trades/parseRate.js

@@ -0,0 +1,49 @@
+import hasNaN from './utils.js';
+
+function extract(rate, type) {
+  let res = {};
+  const split = rate.split(':').map(Number);
+  const metal = split[0];
+  const crystal = split[1];
+  const deut = split[2];
+
+  if (type === 'metal') {
+    res = {
+      rateMetal: 1,
+      rateCrystal: crystal / metal,
+      rateDeut: deut / metal,
+    };
+  } else if (type === 'crystal') {
+    res = {
+      rateMetal: metal / crystal,
+      rateCrystal: 1,
+      rateDeut: deut / crystal,
+    };
+  } else if (type === 'deut') {
+    res = {
+      rateMetal: metal,
+      rateCrystal: crystal,
+      rateDeut: 1,
+    };
+  } else {
+    throw new Error(`${type} is not part of the game, try one of metal, crystal, deut`);
+  }
+
+  return res;
+}
+
+export default function parseRate(rate = '2:1.5:1', type = 'deut') {
+  const split = rate.split(':');
+
+  if (split.length !== 3) {
+    throw new Error('rate not parsed correctly');
+  }
+
+  const res = extract(rate, type);
+
+  if (hasNaN(Object.values(res))) {
+    throw new Error('rate not parsed correctly');
+  }
+
+  return res;
+}

package/src/trades/utils.js

@@ -0,0 +1,9 @@
+export default function hasNaN(args) {
+  let response = false;
+  args.forEach((val) => {
+    if (Number.isNaN(Number(val))) {
+      response = true;
+    }
+  });
+  return response;
+}

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