ogamejs 3.0.0 → 4.0.1

package/package.json

@@ -1,22 +1,67 @@
 {
   "name": "ogamejs",
-  "version": "3.0.0",
-  "description": "",
+  "version": "4.0.1",
+  "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",
-  "exports": "./src/index.js",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./buildings": {
+      "types": "./types/buildings/index.d.ts",
+      "default": "./src/buildings/index.js"
+    },
+    "./fleets": {
+      "types": "./types/fleets/index.d.ts",
+      "default": "./src/fleets/index.js"
+    },
+    "./research": {
+      "types": "./types/research/index.d.ts",
+      "default": "./src/research/index.js"
+    },
+    "./trades": {
+      "types": "./types/trades/index.d.ts",
+      "default": "./src/trades/index.js"
+    },
+    "./i18n": {
+      "types": "./types/i18n.d.ts",
+      "default": "./src/i18n.js"
+    },
+    "./types": {
+      "types": "./types/types.d.ts",
+      "default": "./src/types.js"
+    },
+    "./models/buildings": {
+      "types": "./types/models/buildings.d.ts",
+      "default": "./src/models/buildings.js"
+    },
+    "./models/destroyable": {
+      "types": "./types/models/destroyable.d.ts",
+      "default": "./src/models/destroyable.js"
+    },
+    "./models/research": {
+      "types": "./types/models/research.d.ts",
+      "default": "./src/models/research.js"
+    }
+  },
   "engines": {
     "node": ">=24"
   },
   "scripts": {
     "commit": "git-cz",
     "lint": "eslint .",
+    "types": "tsc",
+    "prepack": "npm run types",
     "test": "vitest run",
     "test:watch": "vitest",
     "release": "semantic-release"
   },
   "files": [
     "src",
+    "types",
     "!src/**/*.test.js"
   ],
   "repository": {
@@ -41,11 +86,13 @@
     "git-cz": "^4.9.0",
     "globals": "^15.14.0",
     "semantic-release": "^25.0.8",
+    "typescript": "^7.0.2",
     "vitest": "^3.0.4"
   },
   "config": {
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
-  }
+  },
+  "types": "./types/index.d.ts"
 }

package/src/buildings/buildTime.js

@@ -0,0 +1,25 @@
+import getCost, { assertLevel } from '../cost.js';
+
+/**
+ *
+ * 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
+ */
+function getBuildTime(building, targetLevel, roboticsLevel = 0, naniteLevel = 0, universeSpeed = 1) {
+  assertLevel(targetLevel);
+
+  const { metal, crystal } = getCost(building, targetLevel);
+  const divider = 2500 * (1 + roboticsLevel) * 2 ** naniteLevel * universeSpeed;
+
+  return Math.round(((metal + crystal) / divider) * 3600);
+}
+
+export default getBuildTime;

package/src/buildings/crystal.js

@@ -1,11 +1,10 @@
-function getPositionFactor(pos) {
-  const factor = {
-    1: 1.3,
-    2: 1.225,
-    3: 1.15,
-  };
+import buildingInfo from './info.js';
+
+// Positions 1, 2 and 3 give a 30%, 22.5% and 15% crystal production bonus.
+const POSITION_FACTOR = { 1: 1.3, 2: 1.225, 3: 1.15 };
 
-  return factor[Number.parseInt(pos, 10)] ? factor[Number.parseInt(pos, 10)] : 1;
+function getPositionFactor(pos) {
+  return POSITION_FACTOR[Number.parseInt(pos, 10)] ?? 1;
 }
 
 function getMineProduction(baseProduction, targetLevel, pos, universeSpeed) {
@@ -15,39 +14,22 @@ function getMineProduction(baseProduction, targetLevel, pos, universeSpeed) {
   return Math.floor(baseProduction * targetLevel * levelFactor * universeSpeed * positionFactor);
 }
 
-function getEnergyCost(baseEnergyCost, targetLevel) {
-  const level = targetLevel;
-  const levelFactor = 1.1 ** level;
-  return Math.floor(baseEnergyCost * level * levelFactor);
-}
-
-function getMetalCost(baseMetalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseMetalCost * 1.6 ** level);
-}
-
-function getCrystalCost(baseCrystalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseCrystalCost * 1.6 ** level);
-}
-
 /**
  *
- * Return information about the crystal mine given a specific level
- * @param {object} mine The crystal mine base information
- * @param {number} targetLevel the crystal mine target level
- * @param {number} pos pos 1/2/3 have a 15/10/5%
- * @param {number} universeSpeed production factor is increased for some universe
- * @returns {Object} informations about the crystal mine at this specific level
+ * 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
  */
 function getCrystalMine(mine, targetLevel, pos, universeSpeed = 1) {
-  return {
-    crystal: getCrystalCost(mine.crystal, targetLevel),
-    deuterium: 0,
-    energy: getEnergyCost(mine.energy, targetLevel),
-    metal: getMetalCost(mine.metal, targetLevel),
-    production: getMineProduction(mine.production, targetLevel, pos, universeSpeed),
-  };
+  return buildingInfo(
+    mine,
+    targetLevel,
+    universeSpeed,
+    (base) => getMineProduction(base.production, targetLevel, pos, universeSpeed),
+  );
 }
 
 export default getCrystalMine;

package/src/buildings/deut.js

@@ -1,46 +1,31 @@
-function getPositionFactor(avg) {
-  return 0.68 - 0.002 * avg;
-}
-
-function getMineProduction(energyCost, avg, universeSpeed) {
-  const factor = getPositionFactor(avg);
-  return Math.floor(universeSpeed * energyCost * factor);
-}
+import buildingInfo from './info.js';
 
-function getEnergyCost(baseEnergyCost, targetLevel) {
-  const level = targetLevel;
-  const levelFactor = 1.1 ** level;
-  return Math.floor(baseEnergyCost * level * levelFactor);
-}
-
-function getMetalCost(baseMetalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseMetalCost * 1.5 ** level);
+// The colder the planet, the more deuterium the synthesizer draws out of it.
+function getTemperatureFactor(avg) {
+  return 0.68 - 0.002 * avg;
 }
 
-function getCrystalCost(baseCrystalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseCrystalCost * 1.5 ** level);
+function getMineProduction(energyConsumption, avg, universeSpeed) {
+  return Math.floor(universeSpeed * energyConsumption * getTemperatureFactor(avg));
 }
 
 /**
  *
- * Return information about the deuterium synth given a specific level
- * @param {object} mine The deut synth base information
- * @param {number} targetLevel the deuterieum synth target level
- * @param {number} avg planet average temperature - The lower the higher the prod is
- * @param {number} universeSpeed production factor is increased for some universe
- * @returns {Object} informations about the deut synth at this specific level
+ * 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
  */
 function getDeutSynth(mine, targetLevel, avg, universeSpeed = 1) {
-  const energyCost = getEnergyCost(mine.energy, targetLevel);
-  return {
-    crystal: getCrystalCost(mine.crystal, targetLevel),
-    energy: energyCost,
-    deuterium: 0,
-    metal: getMetalCost(mine.metal, targetLevel),
-    production: getMineProduction(energyCost, avg, universeSpeed),
-  };
+  return buildingInfo(
+    mine,
+    targetLevel,
+    universeSpeed,
+    // The synthesizer production is driven by the energy it consumes.
+    (base, flows) => getMineProduction(flows.energyConsumption, avg, universeSpeed),
+  );
 }
 
 export default getDeutSynth;

package/src/buildings/fusion-reactor.js

@@ -1,50 +1,35 @@
+import buildingInfo from './info.js';
+
+// Energy technology makes each reactor level a little more efficient.
 function getEnergyFactor(energyTech) {
   return 1.05 + 0.01 * energyTech;
 }
 
 function getEnergyProduction(baseProduction, targetLevel, energyTech) {
   const factor = getEnergyFactor(energyTech) ** targetLevel;
-  return Math.floor(baseProduction * targetLevel * factor);
-}
 
-function getMetalCost(baseMetalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseMetalCost * 1.8 ** level);
-}
-
-function getCrystalCost(baseCrystalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseCrystalCost * 1.8 ** level);
-}
-
-function getDeuteriumCost(baseDeuteriumCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseDeuteriumCost * 1.8 ** level);
-}
-
-function getConsumption(baseConsumption, targetLevel, universeSpeed) {
-  const levelFactor = 1.1 ** targetLevel;
-  return Math.floor(baseConsumption * targetLevel * levelFactor * universeSpeed);
+  return Math.floor(baseProduction * targetLevel * factor);
 }
 
 /**
  *
- * Return information about the fusion reactor given a specific level
- * @param {object} reactor The fusion react base information
- * @param {number} targetLevel
- * @param {number} energyTech The technology energy level
- * @param {number} universeSpeed production factor is increased for some universe
- * @returns {Object} informations about the fusion reactor at this specific level
+ * 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
  */
 function getFusionReactor(reactor, targetLevel, energyTech, universeSpeed = 1) {
-  return {
-    crystal: getCrystalCost(reactor.crystal, targetLevel),
-    energy: 0,
-    consumption: getConsumption(reactor.consumption, targetLevel, universeSpeed),
-    deuterium: getDeuteriumCost(reactor.deutrium, targetLevel),
-    metal: getMetalCost(reactor.metal, targetLevel),
-    production: getEnergyProduction(reactor.production, targetLevel, energyTech),
-  };
+  return buildingInfo(
+    reactor,
+    targetLevel,
+    universeSpeed,
+    (base) => getEnergyProduction(base.production, targetLevel, energyTech),
+  );
 }
 
 export default getFusionReactor;

package/src/buildings/index.js

@@ -4,6 +4,10 @@ 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';
 
 const Buildings = {
   getCrystalMine,
@@ -12,6 +16,13 @@ const Buildings = {
   getSolarPlant,
   getFusionReactor,
   parseInfoCompteData,
+  getBuildingCost: getCost,
+  getBuildTime,
+  getStorage,
+  getStorageCapacity,
+  getStorageLevelFor,
+  getPlanetProduction,
+  getProductionBonus,
 };
 
 export default Buildings;

package/src/buildings/info.js

@@ -0,0 +1,42 @@
+import getCost, { assertEntry } from '../cost.js';
+
+/**
+ * Energy and deuterium flows both grow the same way: base * level * 1.1 ** level.
+ */
+function flow(baseValue, targetLevel, universeSpeed = 1) {
+  return Math.floor(baseValue * targetLevel * 1.1 ** targetLevel * universeSpeed);
+}
+
+/**
+ *
+ * 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
+ */
+function buildingInfo(entry, targetLevel, universeSpeed, computeProduction) {
+  assertEntry(entry, targetLevel);
+
+  const { base } = entry;
+  const flows = {
+    // The energy a building consumes does not depend on the universe speed,
+    // the deuterium a fusion reactor burns does.
+    energyConsumption: flow(base.energyConsumption, targetLevel),
+    deuteriumConsumption: flow(base.deuteriumConsumption, targetLevel, universeSpeed),
+  };
+
+  return {
+    ...getCost(entry, targetLevel),
+    ...flows,
+    production: computeProduction(base, flows),
+  };
+}
+
+export default buildingInfo;

package/src/buildings/infocompte.js

@@ -1,64 +1,137 @@
-function toNumber(number = '') {
-  return Number(number.split('.').join(''));
-}
-
 /**
+ * Labels used by the Infocompte export, per game language.
  *
- * Return information about the crystal mine given a specific level
- * @param {object} data The infocompte bb-code
- * @returns {Object} The parsed JSON object of infocompte
+ * 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.
  */
-function parseInfoCompteData(data) {
-  const universeDataRe = new RegExp('([0-9]{3}-[a-z]{2})');
-  const [universe, lang] = data.match(universeDataRe)[1].split('-');
+const LOCALES = Object.freeze({
+  fr: {
+    planet: 'Planète',
+    metalPoints: 'Points dans les mines de métal',
+    crystalPoints: 'Points dans les mines de cristal',
+    deutPoints: 'Points dans les mines de deut',
+    plasma: 'Technologie Plasma',
+    hourly: 'Par heure',
+  },
+  en: {
+    planet: 'Planet',
+    metalPoints: 'Points in metal mines',
+    crystalPoints: 'Points in crystal mines',
+    deutPoints: 'Points in deut mines',
+    plasma: 'Plasma Technology',
+    hourly: 'Per hour',
+  },
+});
 
-  // eslint-disable-next-line security/detect-unsafe-regex
-  const planetsRe = new RegExp('(?:Planète [0-9]+(.+))(?:s+(?:Planète [0-9]+))*', 'g');
-  const planets = data.matchAll(planetsRe);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
-  const metalPointRe = new RegExp('Points dans les mines de métal : (.+)');
-  const metalPoint = toNumber(data.match(metalPointRe)[1]);
+// Infocompte groups thousands with dots, spaces or non breaking spaces.
+function toNumber(value = '') {
+  return Number(String(value).replace(/[^\d-]/g, ''));
+}
 
-  const crystalPointRe = new RegExp('Points dans les mines de cristal : (.+)');
-  const crystalPoint = toNumber(data.match(crystalPointRe)[1]);
+function matchOne(data, label, what) {
+  // The label is escaped just above, so it cannot inject a pattern.
+  // eslint-disable-next-line security/detect-non-literal-regexp
+  const match = data.match(new RegExp(`${escapeRegExp(label)}\\s*:\\s*(.+)`));
 
-  const deutRe = new RegExp('Points dans les mines de deut : (.+)');
-  const deutPoint = toNumber(data.match(deutRe)[1]);
+  if (!match) {
+    throw new Error(`could not find ${what} in the report, is the language supported?`);
+  }
 
-  const plasmaRe = new RegExp('Technologie Plasma : (.+)');
-  const plasmaTechLevel = toNumber(data.match(plasmaRe)[1]);
+  return match[1];
+}
 
-  const hourlyRe = new RegExp('Par heure : (.+)');
-  const hourly = data.match(hourlyRe);
+function parseTriplet(line, what) {
+  // Digits, plus the dot, space, non breaking space and narrow no-break space
+  // Infocompte may use as a thousands separator.
+  const numbers = line.match(/\d[\d.\u0020\u00A0\u202F]*/g);
 
-  const [hourlyMetal, hourlyCristal, hourlyDeut] = hourly[1].split('/');
+  if (!numbers || numbers.length < 3) {
+    throw new Error(`could not parse ${what} in the report`);
+  }
 
-  const [hourlyMetalValue] = hourlyMetal.split(' ');
-  const hourlyMetalNumber = toNumber(hourlyMetalValue);
+  return numbers.slice(0, 3).map(toNumber);
+}
 
-  const [hourlyCristalValue] = hourlyCristal.split(' ').filter(Boolean);
-  const hourlyCristalNumber = toNumber(hourlyCristalValue);
+function parsePlanets(data, labels) {
+  // Matches `Planète 01 : Métal 36 / Cristal 31 / Deutérium 31 / -94°C` without
+  // depending on the resource names, only on the shape of the line.
+  // eslint-disable-next-line security/detect-non-literal-regexp
+  const planetRe = new RegExp(
+    `^[^\\S\\n]*(${escapeRegExp(labels.planet)}\\s+\\d+)\\s*:`
+    + '[^\\d]*(\\d+)\\s*/[^\\d-]*(\\d+)\\s*/[^\\d-]*(\\d+)\\s*/\\s*(-?\\d+)\\s*°',
+    'gm',
+  );
 
-  const [hourlyDeutValue] = hourlyDeut.split(' ').filter(Boolean);
-  const hourlyDeutNumber = toNumber(hourlyDeutValue);
+  return [...data.matchAll(planetRe)].map(([, planet, metal, crystal, deut, temperature]) => ({
+    planet: planet.trim(),
+    metal: Number(metal),
+    crystal: Number(crystal),
+    deut: Number(deut),
+    temperature: Number(temperature),
+  }));
+}
 
-  const response = {
-    planets: [],
+/**
+ *
+ * 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
+ */
+function parseInfoCompteData(data, options = {}) {
+  if (typeof data !== 'string' || data.trim() === '') {
+    throw new Error('data must be a non empty string');
+  }
+
+  const universeData = data.match(/([0-9]{3}-[a-z]{2})/);
+
+  if (!universeData) {
+    throw new Error('could not find the universe and language header in the report');
+  }
+
+  const [universe, lang] = universeData[1].split('-');
+  const locale = options.locale ?? lang;
+  // eslint-disable-next-line security/detect-object-injection
+  const knownLocale = Object.hasOwn(LOCALES, locale) ? LOCALES[locale] : undefined;
+  const labels = options.labels ?? knownLocale ?? LOCALES.fr;
+
+  const metalPoint = toNumber(matchOne(data, labels.metalPoints, 'the metal mine points'));
+  const crystalPoint = toNumber(matchOne(data, labels.crystalPoints, 'the crystal mine points'));
+  const deutPoint = toNumber(matchOne(data, labels.deutPoints, 'the deuterium mine points'));
+  const plasmaTechLevel = toNumber(matchOne(data, labels.plasma, 'the plasma technology level'));
+
+  const [hourlyMetal, hourlyCrystal, hourlyDeut] = parseTriplet(
+    matchOne(data, labels.hourly, 'the hourly production'),
+    'the hourly production',
+  );
+
+  const perDay = 24;
+  const perWeek = 24 * 7;
+
+  return {
+    planets: parsePlanets(data, labels),
     production: {
       hourly: {
-        metal: hourlyMetalNumber,
-        crystal: hourlyCristalNumber,
-        deut: hourlyDeutNumber,
+        metal: hourlyMetal,
+        crystal: hourlyCrystal,
+        deut: hourlyDeut,
       },
       daily: {
-        metal: hourlyMetalNumber * 24,
-        crystal: hourlyCristalNumber * 24,
-        deut: hourlyDeutNumber * 24,
+        metal: hourlyMetal * perDay,
+        crystal: hourlyCrystal * perDay,
+        deut: hourlyDeut * perDay,
       },
       weekly: {
-        metal: hourlyMetalNumber * 24 * 7,
-        crystal: hourlyCristalNumber * 24 * 7,
-        deut: hourlyDeutNumber * 24 * 7,
+        metal: hourlyMetal * perWeek,
+        crystal: hourlyCrystal * perWeek,
+        deut: hourlyDeut * perWeek,
       },
     },
     points: {
@@ -71,21 +144,7 @@ function parseInfoCompteData(data) {
     universe: Number(universe),
     lang,
   };
-
-  for (const planet of planets) {
-    const [planetMetal, crystal, deut, temperatureText] = planet[0].split('/');
-    const [temperature] = temperatureText.split('°');
-    const [thePlanet, metal] = planetMetal.split(':');
-
-    response.planets.push({
-      planet: thePlanet.trim(),
-      metal: metal.trim().split(' ')[1],
-      crystal: crystal.trim().split(' ')[1],
-      deut: deut.trim().split(' ')[1],
-      temperature: Number.parseInt(temperature.trim(), 10),
-    });
-  }
-
-  return response;
 }
+
+export { LOCALES };
 export default parseInfoCompteData;

package/src/buildings/metal.js

@@ -1,41 +1,26 @@
+import buildingInfo from './info.js';
+
 function getMineProduction(baseProduction, targetLevel, universeSpeed) {
   const levelFactor = 1.1 ** targetLevel;
 
   return Math.floor(baseProduction * targetLevel * levelFactor * universeSpeed);
 }
 
-function getEnergyCost(baseEnergyCost, targetLevel) {
-  const level = targetLevel;
-  const levelFactor = 1.1 ** level;
-  return Math.floor(baseEnergyCost * level * levelFactor);
-}
-
-function getMetalCost(baseMetalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseMetalCost * 1.5 ** level);
-}
-
-function getCrystalCost(baseCrystalCost, targetLevel) {
-  const level = targetLevel - 1;
-  return Math.floor(baseCrystalCost * 1.5 ** level);
-}
-
 /**
  *
- * Return information about the metal mine given a specific level
- * @param {object} mine The metal mine base information
- * @param {number} targetLevel
- * @param {number} universeSpeed production factor is increased for some universe
- * @returns {Object} informations about the metal mine at this specific level
+ * 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
  */
 function getMetalMine(mine, targetLevel, universeSpeed = 1) {
-  return {
-    crystal: getCrystalCost(mine.crystal, targetLevel),
-    deuterium: 0,
-    energy: getEnergyCost(mine.energy, targetLevel),
-    metal: getMetalCost(mine.metal, targetLevel),
-    production: getMineProduction(mine.production, targetLevel, universeSpeed),
-  };
+  return buildingInfo(
+    mine,
+    targetLevel,
+    universeSpeed,
+    (base) => getMineProduction(base.production, targetLevel, universeSpeed),
+  );
 }
 
 export default getMetalMine;