feat(core): Implement more detailed types

Also replaces some button accesses with manual model+controller
construction.

Author: oliversalzburg

Makefile

@@ -13,7 +13,7 @@ git-hook:
 	echo "make pretty" > .git/hooks/pre-commit
 
 pretty: node_modules
-	yarn biome check --write --no-errors-on-unmatched
+	yarn biome check --no-errors-on-unmatched --fix --unsafe
 	npm pkg fix
 
 lint: node_modules

source/BonfireManager.ts

@@ -14,10 +14,17 @@ import type {
   BuildingBtnModernController,
   BuildingMeta,
   BuildingsModern,
+  GatherCatnipButtonController,
   StagingBldBtnController,
   UnsafeBuilding,
+  UnsafeStagingBldButtonOptions,
+  UnsafeUnstagedBuildingButtonOptions,
 } from "./types/buildings.js";
-import type { UnsafeBuildingBtnModel } from "./types/core.js";
+import type {
+  AllBuildingStackableBtnOptions,
+  UnsafeBuildingBtnModel,
+  UnsafeBuildingBtnModernModel,
+} from "./types/core.js";
 import type { Building } from "./types/index.js";
 
 export class BonfireManager implements Automation {
@@ -327,32 +334,38 @@ export class BonfireManager implements Automation {
   }
 
   autoGather(): void {
-    const controller = new classes.game.ui.GatherCatnipButtonController(this._host.game);
+    const controller = new classes.game.ui.GatherCatnipButtonController(
+      this._host.game,
+    ) as GatherCatnipButtonController;
     for (let clicks = 0; clicks < Math.floor(this._host.engine.settings.interval / 20); ++clicks) {
       controller.buyItem(undefined, null);
     }
   }
 
-  build(name: Building, stage: number | undefined, amount: number): void {
+  build(name: Building, _stage: number | undefined, amount: number): void {
     let amountCalculated = amount;
-    const build = this.getBuild(name);
-    const button = this.getBuildButton(name, stage);
-
-    if (!button?.model) {
-      return;
-    }
-
-    if (!button.model.enabled) {
-      return;
+    const amountTemp = amountCalculated;
+    let label: string;
+    const meta = game.bld.get(name);
+    const metaExt = game.bld.getBuildingExt(name).getMeta();
+    if ("stages" in meta) {
+      const controller = new classes.ui.btn.StagingBldBtnController(
+        this._host.game,
+      ) as StagingBldBtnController<UnsafeBuildingBtnModernModel<UnsafeStagingBldButtonOptions>>;
+      const model = controller.fetchModel(metaExt);
+      amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+      label = metaExt.label ?? "";
+    } else {
+      const controller = new classes.ui.btn.BuildingBtnModernController(
+        this._host.game,
+      ) as BuildingBtnModernController<
+        UnsafeBuildingBtnModernModel<UnsafeUnstagedBuildingButtonOptions>
+      >;
+      const model = controller.fetchModel(meta);
+      amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+      label = meta.label ?? "";
     }
 
-    const amountTemp = amountCalculated;
-    const label = this._getBuildLabel(build.meta, stage);
-    amountCalculated = this._bulkManager.construct(
-      button.model,
-      button.controller,
-      amountCalculated,
-    );
     if (amountCalculated !== amountTemp) {
       cwarn(`${label} Amount ordered: ${amountTemp} Amount Constructed: ${amountCalculated}`);
     }
@@ -387,10 +400,10 @@ export class BonfireManager implements Automation {
       "stages" in meta
         ? (new classes.ui.btn.StagingBldBtnController(
             this._host.game,
-          ) as StagingBldBtnController<UnsafeBuildingBtnModel>)
+          ) as StagingBldBtnController<UnsafeBuildingBtnModernModel>)
         : (new classes.ui.btn.BuildingBtnModernController(
             this._host.game,
-          ) as BuildingBtnModernController<UnsafeBuildingBtnModel>);
+          ) as BuildingBtnModernController<UnsafeBuildingBtnModernModel>);
     const model = controller.fetchModel({
       key: name,
       name: meta.label,

source/ReligionManager.ts

@@ -1,4 +1,5 @@
 import { isNil, mustExist } from "@oliversalzburg/js-utils/data/nil.js";
+import { InvalidOperationError } from "@oliversalzburg/js-utils/errors/InvalidOperationError.js";
 import type { BonfireManager } from "./BonfireManager.js";
 import type { Automation, FrameContext } from "./Engine.js";
 import type { KittenScientists } from "./KittenScientists.js";
@@ -9,7 +10,6 @@ import { BonfireBuildingSetting } from "./settings/BonfireSettings.js";
 import { ReligionSettings, type ReligionSettingsItem } from "./settings/ReligionSettings.js";
 import { negativeOneToInfinity } from "./tools/Format.js";
 import { cdebug, cwarn } from "./tools/Log.js";
-import type { UnsafeButtonModernModel } from "./types/core.js";
 import {
   type FaithItem,
   type ReligionItem,
@@ -23,9 +23,13 @@ import {
 import type {
   CryptotheologyPanel,
   CryptotheologyWGT,
+  ReligionBtnController,
   ReligionTab,
+  TranscendenceBtnController,
   TransformBtnController,
   UnsafeReligionUpgrade,
+  UnsafeTranscendenceBtnModel,
+  UnsafeTranscendenceButtonOptions,
   UnsafeTranscendenceUpgrade,
   UnsafeTransformBtnModel,
   UnsafeZiggurathUpgrade,
@@ -335,7 +339,7 @@ export class ReligionManager implements Automation {
     // For all ziggurath upgrade buttons...
     for (const button of this.manager.tab.zgUpgradeButtons) {
       // ...that are in the "valid" buildings (are unicorn-related) and visible (unlocked)...
-      if (validBuildings.includes(button.id) && button.model?.visible) {
+      if (validBuildings.includes(button.id) && button.model.visible) {
         // Determine a price value for this building.
         let unicornPrice = 0;
         for (const price of mustExist(button.model.prices)) {
@@ -390,28 +394,38 @@ export class ReligionManager implements Automation {
 
   build(name: ReligionItem | "unicornPasture", variant: UnicornItemVariant, amount: number): void {
     let amountCalculated = amount;
-    const build = this.getBuild(name, variant);
-    if (build === null) {
-      throw new Error(`Unable to build '${name}'. Build information not available.`);
-    }
-
-    const button = this._getBuildButton(name, variant);
-
-    if (!button?.model) {
-      return;
-    }
-
-    if (!button.model.enabled) {
-      return;
+    const amountTemp = amountCalculated;
+    let label: string;
+    if (variant === UnicornItemVariant.Cryptotheology) {
+      const meta = game.religion.getTU(name as TranscendenceUpgrade);
+      const controller = new classes.ui.TranscendenceBtnController(
+        this._host.game,
+      ) as TranscendenceBtnController<
+        UnsafeTranscendenceBtnModel<UnsafeTranscendenceButtonOptions>
+      >;
+      const model = controller.fetchModel(meta);
+      amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+      label = meta.label;
+    } else if (variant === UnicornItemVariant.OrderOfTheSun) {
+      const meta = game.religion.getRU(name as ReligionUpgrade);
+      const controller = new com.nuclearunicorn.game.ui.ReligionBtnController(
+        this._host.game,
+      ) as ReligionBtnController;
+      const model = controller.fetchModel(meta);
+      amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+      label = meta.label;
+    } else if (variant === UnicornItemVariant.Ziggurat) {
+      const meta = game.religion.getZU(name as ZiggurathUpgrade);
+      const controller = new com.nuclearunicorn.game.ui.ReligionBtnController(
+        this._host.game,
+      ) as ReligionBtnController;
+      const model = controller.fetchModel(meta);
+      amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+      label = meta.label;
+    } else {
+      throw new InvalidOperationError("unsupported");
     }
 
-    const amountTemp = amountCalculated;
-    const label = build.label;
-    amountCalculated = this._bulkManager.construct(
-      button.model,
-      mustExist(button.controller),
-      amountCalculated,
-    );
     if (amountCalculated !== amountTemp) {
       cwarn(`${label} Amount ordered: ${amountTemp} Amount Constructed: ${amountCalculated}`);
     }

source/SpaceManager.ts

@@ -5,14 +5,20 @@ import { TabManager } from "./TabManager.js";
 import type { WorkshopManager } from "./WorkshopManager.js";
 import { BulkPurchaseHelper } from "./helper/BulkPurchaseHelper.js";
 import { type SpaceBuildingSetting, SpaceSettings } from "./settings/SpaceSettings.js";
-import { cdebug, cwarn } from "./tools/Log.js";
-import type { BuildingStackableBtn, UnsafeBuildingBtnModel } from "./types/core.js";
+import { cwarn } from "./tools/Log.js";
+import type {
+  BuildingStackableBtn,
+  UnsafeBuildingBtnModel,
+  UnsafeBuildingStackableBtnModel,
+} from "./types/core.js";
 import type { Mission, SpaceBuilding } from "./types/index.js";
 import type {
   PlanetBuildingBtnController,
   SpaceTab,
   UnsafePlanet,
+  UnsafePlanetBuildingButtonOptions,
   UnsafeSpaceBuilding,
+  UnsafeSpaceProgramButtonOptions,
 } from "./types/space.js";
 
 export class SpaceManager implements Automation {
@@ -129,25 +135,18 @@ export class SpaceManager implements Automation {
 
   build(name: SpaceBuilding, amount: number): number {
     let amountCalculated = amount;
-    const build = this.getBuild(name);
-
-    const button = this._getBuildButton(name);
-
-    if (!build.unlocked || !button?.model || !this.settings.buildings[name].enabled) {
-      return 0;
-    }
-
-    if (!button.model.enabled) {
-      return 0;
-    }
-
     const amountTemp = amountCalculated;
-    const label = build.label;
-    amountCalculated = this._bulkManager.construct(
-      button.model,
-      button.controller,
-      amountCalculated,
-    );
+    let label: string;
+    const meta = game.space.getBuilding(name);
+    const controller = new classes.ui.space.PlanetBuildingBtnController(
+      this._host.game,
+    ) as PlanetBuildingBtnController<
+      UnsafeBuildingStackableBtnModel<UnsafePlanetBuildingButtonOptions>
+    >;
+    const model = controller.fetchModel(meta);
+    amountCalculated = this._bulkManager.construct(model, controller, amountCalculated);
+    label = meta.label;
+
     if (amountCalculated !== amountTemp) {
       cwarn(`${label} Amount ordered: ${amountTemp} Amount Constructed: ${amountCalculated}`);
     }
@@ -177,15 +176,13 @@ export class SpaceManager implements Automation {
       return null;
     }
 
-    let button: BuildingStackableBtn<
-      {
-        id: SpaceBuilding;
-        planet: UnsafePlanet;
-        controller: PlanetBuildingBtnController;
-      },
-      PlanetBuildingBtnController,
-      SpaceBuilding
-    > | null = null;
+    let button: BuildingStackableBtn<{
+      id: SpaceBuilding;
+      planet: UnsafePlanet;
+      controller: PlanetBuildingBtnController<
+        UnsafeBuildingStackableBtnModel<UnsafeSpaceProgramButtonOptions>
+      >;
+    }> | null = null;
     for (const panel of panels) {
       button = panel.children.find(child => child.id === id) ?? null;
 

source/TimeControlManager.ts

@@ -9,39 +9,29 @@ import type { WorkshopManager } from "./WorkshopManager.js";
 import { type CycleIndices, TimeControlSettings } from "./settings/TimeControlSettings.js";
 import { objectEntries } from "./tools/Entries.js";
 import { negativeOneToInfinity } from "./tools/Format.js";
-import type { GatherCatnipButtonController, UnsafeBuildingExt } from "./types/buildings.js";
 import type {
-  BuildingBtnController,
+  BuildingMeta,
+  UnsafeBuilding,
+  UnsafeUnstagedBuildingButtonOptions,
+} from "./types/buildings.js";
+import type {
+  AllBuildingBtnOptions,
+  AllBuildingStackableBtnOptions,
+  AllButtonIds,
+  AllButtonOptions,
+  BuildingBtn,
   Button,
-  ButtonController,
-  ButtonModern,
-  ButtonModernController,
   UnsafeBuildingBtnModel,
-  UnsafeButtonModel,
-  UnsafeButtonModernModel,
-  UnsafeButtonOptions,
 } from "./types/core.js";
 import {
   type Building,
   type ChronoForgeUpgrade,
   Cycles,
+  type Price,
   TimeItemVariant,
   type VoidSpaceUpgrade,
 } from "./types/index.js";
-import type {
-  ReligionBtnController,
-  TranscendBtnController,
-  TranscendenceBtnController,
-  TransformBtnController,
-  ZigguratBtnController,
-} from "./types/religion.js";
-import type {
-  ChronoforgeBtnController,
-  ShatterTCBtn,
-  ShatterTCBtnController,
-  TimeTab,
-  VoidSpaceBtnController,
-} from "./types/time.js";
+import type { ShatterTCBtn, ShatterTCBtnController, TimeTab } from "./types/time.js";
 
 export class TimeControlManager {
   private readonly _host: KittenScientists;
@@ -103,31 +93,7 @@ export class TimeControlManager {
     // If we don't have a given item, but we *could* buy it, then we act
     // as if we already had it.
     const check = <
-      T extends Button<
-        UnsafeButtonOptions<
-          | BuildingBtnController
-          | ButtonController
-          | ButtonModernController
-          | ChronoforgeBtnController
-          | ReligionBtnController
-          | TranscendBtnController
-          | TranscendenceBtnController
-          | TransformBtnController
-          | VoidSpaceBtnController
-          | ZigguratBtnController
-        >,
-        | BuildingBtnController
-        | ButtonController
-        | ButtonModernController
-        | ChronoforgeBtnController
-        | ReligionBtnController
-        | TranscendBtnController
-        | TranscendenceBtnController
-        | TransformBtnController
-        | VoidSpaceBtnController
-        | ZigguratBtnController,
-        string | undefined
-      >,
+      T extends BuildingBtn<UnsafeBuildingBtnModel<UnsafeUnstagedBuildingButtonOptions>>,
     >(
       buttons: Array<T>,
     ) => {
@@ -137,13 +103,13 @@ export class TimeControlManager {
             continue;
           }
 
-          const model = button.model as UnsafeBuildingBtnModel<unknown, { name: Building }>;
+          const model = button.model as { metadata: { name: string }; prices: Array<Price> };
 
           const name = model.metadata.name;
           const index = checkList.indexOf(name);
           if (index !== -1) {
             checkList.splice(index, 1);
-            if (this._host.game.resPool.hasRes(mustExist(button.model.prices))) {
+            if (this._host.game.resPool.hasRes(mustExist(model.prices))) {
               return true;
             }
           }
@@ -156,7 +122,7 @@ export class TimeControlManager {
     for (const [name, entry] of objectEntries(this.settings.reset.bonfire.buildings))
       if (entry.enabled) {
         // TODO: Obvious error here. For upgraded buildings, it needs special handling.
-        let bld: UnsafeBuildingExt | null;
+        let bld: BuildingMeta<UnsafeBuilding> | null;
         try {
           // @ts-expect-error Obvious error here. For upgraded buildings, it needs special handling.
           bld = this._host.game.bld.getBuildingExt(name);