ogamejs 2.1.6 → 4.0.0

package/package.json

@@ -1,17 +1,68 @@
 {
   "name": "ogamejs",
-  "version": "2.1.6",
-  "description": "",
-  "main": "build/index.js",
+  "version": "4.0.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",
+  "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": {
-    "start": "babel-node index.js",
     "commit": "git-cz",
-    "build": "babel src -d build",
     "lint": "eslint .",
-    "test": "jest"
+    "types": "tsc",
+    "prepack": "npm run types",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "release": "semantic-release"
   },
   "files": [
-    "build"
+    "src",
+    "types",
+    "!src/**/*.test.js"
   ],
   "repository": {
     "type": "git",
@@ -25,36 +76,23 @@
   ],
   "author": "n.riquelmebareiro@gmail.com",
   "license": "MIT",
-  "jest": {
-    "transform": {
-      "^.+\\.jsx?$": "babel-jest"
-    }
-  },
   "devDependencies": {
-    "@babel/cli": "^7.8.4",
-    "@babel/core": "^7.9.0",
-    "@babel/node": "^7.8.7",
-    "@babel/preset-env": "^7.9.5",
-    "babel-core": "^7.0.0-bridge.0",
-    "babel-jest": "^25.3.0",
-    "cz-conventional-changelog": "^3.1.0",
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb": "^18.1.0",
-    "eslint-plugin-import": "^2.20.2",
-    "eslint-plugin-jsx-a11y": "^6.2.3",
-    "eslint-plugin-react": "^7.19.0",
-    "eslint-plugin-security": "^1.4.0",
-    "git-cz": "^4.3.1",
-    "jest": "^25.3.0",
-    "regenerator-runtime": "^0.13.5",
-    "standard-version": "^8.0.1"
-  },
-  "dependencies": {
-    "lodash": "^4.17.15"
+    "@eslint/js": "^9.19.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "cz-conventional-changelog": "^3.3.0",
+    "eslint": "^9.19.0",
+    "eslint-plugin-security": "^3.0.1",
+    "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

@@ -0,0 +1,35 @@
+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 };
+
+function getPositionFactor(pos) {
+  return POSITION_FACTOR[Number.parseInt(pos, 10)] ?? 1;
+}
+
+function getMineProduction(baseProduction, targetLevel, pos, universeSpeed) {
+  const positionFactor = getPositionFactor(pos);
+  const levelFactor = 1.1 ** targetLevel;
+
+  return Math.floor(baseProduction * targetLevel * levelFactor * universeSpeed * positionFactor);
+}
+
+/**
+ *
+ * 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 buildingInfo(
+    mine,
+    targetLevel,
+    universeSpeed,
+    (base) => getMineProduction(base.production, targetLevel, pos, universeSpeed),
+  );
+}
+
+export default getCrystalMine;

package/src/buildings/deut.js

@@ -0,0 +1,31 @@
+import buildingInfo from './info.js';
+
+// The colder the planet, the more deuterium the synthesizer draws out of it.
+function getTemperatureFactor(avg) {
+  return 0.68 - 0.002 * avg;
+}
+
+function getMineProduction(energyConsumption, avg, universeSpeed) {
+  return Math.floor(universeSpeed * energyConsumption * getTemperatureFactor(avg));
+}
+
+/**
+ *
+ * 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) {
+  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

@@ -0,0 +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);
+}
+
+/**
+ *
+ * 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 buildingInfo(
+    reactor,
+    targetLevel,
+    universeSpeed,
+    (base) => getEnergyProduction(base.production, targetLevel, energyTech),
+  );
+}
+
+export default getFusionReactor;

package/src/buildings/index.js

@@ -0,0 +1,28 @@
+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';
+
+const Buildings = {
+  getCrystalMine,
+  getDeutSynth,
+  getMetalMine,
+  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

@@ -0,0 +1,150 @@
+/**
+ * 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.
+ */
+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',
+  },
+});
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Infocompte groups thousands with dots, spaces or non breaking spaces.
+function toNumber(value = '') {
+  return Number(String(value).replace(/[^\d-]/g, ''));
+}
+
+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*(.+)`));
+
+  if (!match) {
+    throw new Error(`could not find ${what} in the report, is the language supported?`);
+  }
+
+  return match[1];
+}
+
+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);
+
+  if (!numbers || numbers.length < 3) {
+    throw new Error(`could not parse ${what} in the report`);
+  }
+
+  return numbers.slice(0, 3).map(toNumber);
+}
+
+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',
+  );
+
+  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),
+  }));
+}
+
+/**
+ *
+ * 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: hourlyMetal,
+        crystal: hourlyCrystal,
+        deut: hourlyDeut,
+      },
+      daily: {
+        metal: hourlyMetal * perDay,
+        crystal: hourlyCrystal * perDay,
+        deut: hourlyDeut * perDay,
+      },
+      weekly: {
+        metal: hourlyMetal * perWeek,
+        crystal: hourlyCrystal * perWeek,
+        deut: hourlyDeut * perWeek,
+      },
+    },
+    points: {
+      metal: metalPoint,
+      crystal: crystalPoint,
+      deut: deutPoint,
+      total: metalPoint + crystalPoint + deutPoint,
+    },
+    plasma: plasmaTechLevel,
+    universe: Number(universe),
+    lang,
+  };
+}
+
+export { LOCALES };
+export default parseInfoCompteData;

package/src/buildings/metal.js

@@ -0,0 +1,26 @@
+import buildingInfo from './info.js';
+
+function getMineProduction(baseProduction, targetLevel, universeSpeed) {
+  const levelFactor = 1.1 ** targetLevel;
+
+  return Math.floor(baseProduction * targetLevel * levelFactor * universeSpeed);
+}
+
+/**
+ *
+ * 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 buildingInfo(
+    mine,
+    targetLevel,
+    universeSpeed,
+    (base) => getMineProduction(base.production, targetLevel, universeSpeed),
+  );
+}
+
+export default getMetalMine;

package/src/buildings/production.js

@@ -0,0 +1,150 @@
+import getMetalMine from './metal.js';
+import getCrystalMine from './crystal.js';
+import getDeutSynth from './deut.js';
+import BUILDINGS from '../models/buildings.js';
+
+/**
+ * Plasma technology is worth more on metal than on crystal, and more on crystal
+ * than on deuterium.
+ */
+const PLASMA_BONUS = Object.freeze({ metal: 0.01, crystal: 0.0066, deuterium: 0.0033 });
+
+/** The geologist officer adds a flat 10% to the three mines. */
+const GEOLOGIST_BONUS = 0.1;
+
+/** The collector class adds 25% to mine production. */
+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.
+ */
+const BASE_INCOME = Object.freeze({ metal: 30, crystal: 15, deuterium: 0 });
+
+const RESOURCES = Object.freeze(['metal', 'crystal', 'deuterium']);
+
+function clampRatio(value, name) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new Error(`${name} must be a number between 0 and 1, received ${value}`);
+  }
+
+  return value;
+}
+
+/**
+ *
+ * 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
+ */
+function getProductionBonus(options = {}) {
+  const {
+    plasmaTech = 0,
+    geologist = false,
+    collectorClass = false,
+    items = {},
+  } = options;
+
+  if (!Number.isInteger(plasmaTech) || plasmaTech < 0) {
+    throw new Error(`plasmaTech must be an integer >= 0, received ${plasmaTech}`);
+  }
+
+  const flat = (geologist ? GEOLOGIST_BONUS : 0) + (collectorClass ? COLLECTOR_BONUS : 0);
+
+  return Object.fromEntries(RESOURCES.map((resource) => {
+    /* eslint-disable security/detect-object-injection -- resource comes from RESOURCES */
+    const item = clampRatio(items[resource] ?? 0, `items.${resource}`);
+
+    return [resource, 1 + PLASMA_BONUS[resource] * plasmaTech + flat + item];
+    /* eslint-enable security/detect-object-injection */
+  }));
+}
+
+/**
+ *
+ * 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
+ */
+function getPlanetProduction(planet, bonuses = {}) {
+  const {
+    metalMine,
+    crystalMine,
+    deutSynth,
+    position,
+    temperature,
+    universeSpeed = 1,
+    energyEfficiency = 1,
+  } = planet;
+
+  clampRatio(energyEfficiency, 'energyEfficiency');
+
+  for (const [name, level] of Object.entries({ metalMine, crystalMine, deutSynth })) {
+    if (!Number.isInteger(level) || level < 0) {
+      throw new Error(`${name} must be an integer >= 0, received ${level}`);
+    }
+  }
+
+  // A mine that is not built yet neither produces nor consumes anything, and
+  // has no level 0 cost to speak of.
+  const idle = { production: 0, energyConsumption: 0 };
+  const mines = {
+    metal: metalMine > 0 ? getMetalMine(BUILDINGS[1], metalMine, universeSpeed) : idle,
+    crystal: crystalMine > 0
+      ? getCrystalMine(BUILDINGS[2], crystalMine, position, universeSpeed)
+      : idle,
+    deuterium: deutSynth > 0
+      ? getDeutSynth(BUILDINGS[3], deutSynth, temperature, universeSpeed)
+      : idle,
+  };
+
+  const bonus = getProductionBonus(bonuses);
+
+  const production = Object.fromEntries(RESOURCES.map((resource) => {
+    /* eslint-disable security/detect-object-injection -- resource comes from RESOURCES */
+    const mined = mines[resource].production * bonus[resource] * energyEfficiency;
+
+    return [resource, Math.floor(mined) + BASE_INCOME[resource] * universeSpeed];
+    /* eslint-enable security/detect-object-injection */
+  }));
+
+  return {
+    ...production,
+    energyConsumption: RESOURCES
+      // eslint-disable-next-line security/detect-object-injection
+      .reduce((total, resource) => total + mines[resource].energyConsumption, 0),
+    bonus,
+  };
+}
+
+export {
+  getProductionBonus,
+  PLASMA_BONUS,
+  GEOLOGIST_BONUS,
+  COLLECTOR_BONUS,
+  BASE_INCOME,
+};
+export default getPlanetProduction;

package/src/buildings/solar-plant.js

@@ -0,0 +1,25 @@
+import buildingInfo from './info.js';
+
+function getEnergyProduction(baseProduction, targetLevel) {
+  const levelFactor = 1.1 ** targetLevel;
+
+  return Math.floor(baseProduction * targetLevel * levelFactor);
+}
+
+/**
+ *
+ * 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
+ */
+function getSolarPlant(solarPlant, targetLevel) {
+  return buildingInfo(
+    solarPlant,
+    targetLevel,
+    1,
+    (base) => getEnergyProduction(base.production, targetLevel),
+  );
+}
+
+export default getSolarPlant;