refactor(core): Move most settings to real classes

Part 1 of a series of refactorings to create a more useful, decoupled
settings landscape.
We no longer want to rely on object hashes and a global settings object.

packages/userscript/source/Engine.ts

@@ -1,7 +1,7 @@
 import { BonfireManager } from "./BonfireManager";
 import { CacheManager } from "./CacheManager";
 import { BonfireItem, BonfireSettingsItem } from "./options/BonfireSettings";
-import { SpaceItem, SpaceSettingsItem } from "./options/SpaceSettings";
+import { SettingMax } from "./options/Settings";
 import { CraftSettingsItem } from "./options/WorkshopSettings";
 import { ReligionManager } from "./ReligionManager";
 import { ScienceManager } from "./ScienceManager";
@@ -10,7 +10,7 @@ import { TimeManager } from "./TimeManager";
 import { objectEntries } from "./tools/Entries";
 import { mustExist } from "./tools/Maybe";
 import { TradeManager } from "./TradeManager";
-import { ResourceCraftable } from "./types";
+import { ResourceCraftable, SpaceBuildings } from "./types";
 import { UserScript } from "./UserScript";
 import { VillageManager } from "./VillageManager";
 import { WorkshopManager } from "./WorkshopManager";
@@ -329,7 +329,7 @@ export class Engine {
    * @param builds The buildings to build.
    */
   buildSpace(
-    builds: Partial<Record<SpaceItem, SpaceSettingsItem>> = this._host.options.auto.space.items
+    builds: Partial<Record<SpaceBuildings, SettingMax>> = this._host.options.auto.space.items
   ): void {
     this._spaceManager.autoBuild(builds);
 

packages/userscript/source/ReligionManager.ts

@@ -1,5 +1,6 @@
 import { BonfireManager } from "./BonfireManager";
 import { BulkManager } from "./BulkManager";
+import { BonfireSettingsItem } from "./options/BonfireSettings";
 import { FaithItem, ReligionSettingsItem } from "./options/ReligionSettings";
 import { TabManager } from "./TabManager";
 import { objectEntries } from "./tools/Entries";
@@ -108,7 +109,7 @@ export class ReligionManager {
       // Now we build a unicorn pasture if possible.
       if (this._host.options.auto.religion.items.unicornPasture.enabled) {
         this._bonfireManager.autoBuild({
-          unicornPasture: { require: false, enabled: true, max: -1 },
+          unicornPasture: new BonfireSettingsItem(true, false, -1),
         });
       }
       // And then we build all other possible religion buildings.

packages/userscript/source/SpaceManager.ts

@@ -1,5 +1,5 @@
 import { BulkManager } from "./BulkManager";
-import { SpaceItem, SpaceSettingsItem } from "./options/SpaceSettings";
+import { SettingMax } from "./options/Settings";
 import { TabManager } from "./TabManager";
 import { objectEntries } from "./tools/Entries";
 import { BuildButton, SpaceBuildingInfo, SpaceBuildings, SpaceTab } from "./types";
@@ -27,7 +27,7 @@ export class SpaceManager {
    * @param builds The buildings to build.
    */
   autoBuild(
-    builds: Partial<Record<SpaceItem, SpaceSettingsItem>> = this._host.options.auto.space.items
+    builds: Partial<Record<SpaceBuildings, SettingMax>> = this._host.options.auto.space.items
   ) {
     // TODO: Refactor. See BonfireManager.autoBuild
     const bulkManager = this._bulkManager;
@@ -38,7 +38,7 @@ export class SpaceManager {
     this.manager.render();
 
     // Get the current metadata for all the referenced buildings.
-    const metaData: Partial<Record<SpaceItem, SpaceBuildingInfo>> = {};
+    const metaData: Partial<Record<SpaceBuildings, SpaceBuildingInfo>> = {};
     for (const [name] of objectEntries(builds)) {
       metaData[name] = this.getBuild(name);
     }
@@ -94,7 +94,7 @@ export class SpaceManager {
     }
   }
 
-  build(name: SpaceItem, amount: number): void {
+  build(name: SpaceBuildings, amount: number): void {
     const build = this.getBuild(name);
     const button = this.getBuildButton(name);
 
@@ -122,7 +122,7 @@ export class SpaceManager {
     }
   }
 
-  getBuild(name: SpaceItem): SpaceBuildingInfo {
+  getBuild(name: SpaceBuildings): SpaceBuildingInfo {
     return this._host.gamePage.space.getBuilding(name);
   }
 

packages/userscript/source/options/BonfireSettings.ts

@@ -2,7 +2,8 @@ import { objectEntries } from "../tools/Entries";
 import { Building } from "../types";
 import { BuildingUpgradeSettings } from "./BuildingUpgradeSettings";
 import { Requirement } from "./Options";
-import { SettingMax, SettingsSection, SettingToggle, SettingTrigger } from "./SettingsSection";
+import { Setting, SettingMax } from "./Settings";
+import { SettingsSectionTrigger } from "./SettingsSection";
 import { KittenStorageType } from "./SettingsStorage";
 
 /**
@@ -12,93 +13,111 @@ import { KittenStorageType } from "./SettingsStorage";
  */
 export type BonfireItem = Building | "broadcastTower" | "dataCenter" | "hydroPlant" | "solarFarm";
 
-export type BonfireSettingsItem = SettingToggle &
-  SettingMax & {
-    /**
-     * In case this is an upgrade of another building, this is the name of the
-     * base building.
-     */
-    name?: Building;
-
-    /**
-     * A resource that you must have unlocked to build this.
-     */
-    require: Requirement;
-
-    /**
-     * In case this is an upgradable building, this indicates the level of
-     * the stage.
-     */
-    stage?: number;
-  };
-
-export type BonfireAdditionSettings = {
-  turnOnSteamworks: SettingToggle;
-  upgradeBuildings: BuildingUpgradeSettings;
+export class BonfireSettingsItem extends SettingMax {
+  /**
+   * In case this is an upgrade of another building, this is the name of the
+   * base building.
+   */
+  name: Building | undefined = undefined;
+
+  /**
+   * A resource that you must have unlocked to build this.
+   */
+  require: Requirement = false;
+
+  /**
+   * In case this is an upgradable building, this indicates the level of
+   * the stage.
+   */
+  stage = 0;
+
+  constructor(enabled = false, require: Requirement = false, max = -1, baseStage?: Building) {
+    super(enabled, max);
+
+    this.require = require;
+    if (baseStage) {
+      this.stage = 1;
+      this.name = baseStage;
+    }
+  }
+}
+
+export class BonfireAdditionSettings {
+  turnOnSteamworks = new Setting(true);
+  upgradeBuildings = new BuildingUpgradeSettings();
+}
+
+export type BonfirSettingsItems = {
+  // unicornPasture is handled in the Religion section.
+  [item in Exclude<BonfireItem, "unicornPasture">]: BonfireSettingsItem;
 };
 
-export class BonfireSettings extends SettingsSection implements SettingTrigger {
-  trigger = 0;
-  $trigger?: JQuery<HTMLElement>;
-
-  addition: BonfireAdditionSettings = {
-    turnOnSteamworks: { enabled: true },
-    upgradeBuildings: new BuildingUpgradeSettings(),
-  };
-
-  items: {
-    // unicornPasture is handled in the Religion section.
-    [item in Exclude<BonfireItem, "unicornPasture">]: BonfireSettingsItem;
-  } = {
-    hut: { enabled: false, max: -1, require: "wood" },
-    logHouse: { enabled: false, max: -1, require: "minerals" },
-    mansion: { enabled: false, max: -1, require: "titanium" },
-
-    workshop: { enabled: true, max: -1, require: "minerals" },
-    factory: { enabled: true, max: -1, require: "titanium" },
-
-    field: { enabled: true, max: -1, require: "catnip" },
-    pasture: { enabled: true, max: -1, stage: 0, require: "catnip" },
-    solarFarm: { enabled: true, max: -1, stage: 1, name: "pasture", require: "titanium" },
-    mine: { enabled: true, max: -1, require: "wood" },
-    lumberMill: { enabled: true, max: -1, require: "minerals" },
-    aqueduct: { enabled: true, max: -1, stage: 0, require: "minerals" },
-    hydroPlant: { enabled: true, max: -1, stage: 1, name: "aqueduct", require: "titanium" },
-    oilWell: { enabled: true, max: -1, require: "coal" },
-    quarry: { enabled: true, max: -1, require: "coal" },
-
-    smelter: { enabled: true, max: -1, require: "minerals" },
-    biolab: { enabled: false, max: -1, require: "science" },
-    calciner: { enabled: false, max: -1, require: "titanium" },
-    reactor: { enabled: false, max: -1, require: "titanium" },
-    accelerator: { enabled: false, max: -1, require: "titanium" },
-    steamworks: { enabled: false, max: -1, require: false },
-    magneto: { enabled: false, max: -1, require: false },
-
-    library: { enabled: true, max: -1, stage: 0, require: "wood" },
-    dataCenter: { enabled: true, max: -1, stage: 1, name: "library", require: false },
-    academy: { enabled: true, max: -1, require: "wood" },
-    observatory: { enabled: true, max: -1, require: "iron" },
-
-    amphitheatre: { enabled: true, max: -1, stage: 0, require: "minerals" },
-    broadcastTower: { enabled: true, max: -1, stage: 1, name: "amphitheatre", require: "titanium" },
-    tradepost: { enabled: true, max: -1, require: "gold" },
-    chapel: { enabled: true, max: -1, require: "minerals" },
-    temple: { enabled: true, max: -1, require: "gold" },
-    mint: { enabled: false, max: -1, require: false },
-    ziggurat: { enabled: true, max: -1, require: false },
-    chronosphere: { enabled: true, max: -1, require: "unobtainium" },
-    aiCore: { enabled: false, max: -1, require: false },
-    brewery: { enabled: false, max: -1, require: false },
-
-    barn: { enabled: true, max: -1, require: "wood" },
-    harbor: { enabled: false, max: -1, require: false },
-    warehouse: { enabled: false, max: -1, require: false },
-
-    zebraOutpost: { enabled: true, max: -1, require: "bloodstone" },
-    zebraWorkshop: { enabled: false, max: -1, require: "bloodstone" },
-    zebraForge: { enabled: false, max: -1, require: "bloodstone" },
-  };
+export class BonfireSettings extends SettingsSectionTrigger {
+  addition = new BonfireAdditionSettings();
+
+  items: BonfirSettingsItems;
+
+  constructor(
+    enabled = false,
+    trigger = 0,
+    items: BonfirSettingsItems = {
+      hut: new BonfireSettingsItem(false, "wood"),
+      logHouse: new BonfireSettingsItem(false, "minerals"),
+      mansion: new BonfireSettingsItem(false, "titanium"),
+
+      workshop: new BonfireSettingsItem(true, "minerals"),
+      factory: new BonfireSettingsItem(true, "titanium"),
+
+      field: new BonfireSettingsItem(true, "catnip"),
+      pasture: new BonfireSettingsItem(true, "catnip"),
+      solarFarm: new BonfireSettingsItem(true, "titanium", -1, "pasture"),
+      mine: new BonfireSettingsItem(true, "wood"),
+      lumberMill: new BonfireSettingsItem(true, "minerals"),
+      aqueduct: new BonfireSettingsItem(true, "minerals"),
+      hydroPlant: new BonfireSettingsItem(true, "titanium", -1, "aqueduct"),
+      oilWell: new BonfireSettingsItem(true, "coal"),
+      quarry: new BonfireSettingsItem(true, "coal"),
+
+      smelter: new BonfireSettingsItem(true, "minerals"),
+      biolab: new BonfireSettingsItem(false, "science"),
+      calciner: new BonfireSettingsItem(false, "titanium"),
+      reactor: new BonfireSettingsItem(false, "titanium"),
+      accelerator: new BonfireSettingsItem(false, "titanium"),
+      steamworks: new BonfireSettingsItem(),
+      magneto: new BonfireSettingsItem(),
+
+      library: new BonfireSettingsItem(true, "wood"),
+      dataCenter: new BonfireSettingsItem(true, false, -1, "library"),
+      academy: new BonfireSettingsItem(true, "wood"),
+      observatory: new BonfireSettingsItem(true, "iron"),
+
+      amphitheatre: new BonfireSettingsItem(true, "minerals"),
+      broadcastTower: new BonfireSettingsItem(true, "titanium", -1, "amphitheatre"),
+      tradepost: new BonfireSettingsItem(true, "gold"),
+      chapel: new BonfireSettingsItem(true, "minerals"),
+      temple: new BonfireSettingsItem(true, "gold"),
+      mint: new BonfireSettingsItem(),
+      ziggurat: new BonfireSettingsItem(true),
+      chronosphere: new BonfireSettingsItem(true, "unobtainium"),
+      aiCore: new BonfireSettingsItem(),
+      brewery: new BonfireSettingsItem(),
+
+      barn: new BonfireSettingsItem(true, "wood"),
+      harbor: new BonfireSettingsItem(),
+      warehouse: new BonfireSettingsItem(),
+
+      zebraOutpost: new BonfireSettingsItem(true, "bloodstone"),
+      zebraWorkshop: new BonfireSettingsItem(false, "bloodstone"),
+      zebraForge: new BonfireSettingsItem(false, "bloodstone"),
+    },
+    turnOnSteamworks = new Setting(true),
+    upgradeBuildings = new BuildingUpgradeSettings()
+  ) {
+    super(enabled, trigger);
+    this.items = items;
+    this.addition.turnOnSteamworks = turnOnSteamworks;
+    this.addition.upgradeBuildings = upgradeBuildings;
+  }
 
   static toLegacyOptions(settings: BonfireSettings, subject: KittenStorageType) {
     subject.toggles.build = settings.enabled;

packages/userscript/source/options/BuildingUpgradeSettings.ts

@@ -1,14 +1,14 @@
 import { StagedBuilding } from "../types";
-import { SettingsSection, SettingToggle } from "./SettingsSection";
+import { Setting } from "./Settings";
+import { SettingsSection } from "./SettingsSection";
 
-export type BuildingUpgradeSettingsItem = SettingToggle;
 export class BuildingUpgradeSettings extends SettingsSection {
   items: {
-    [item in StagedBuilding]: BuildingUpgradeSettingsItem;
+    [item in StagedBuilding]: Setting;
   } = {
-    broadcasttower: { enabled: true },
-    dataCenter: { enabled: true },
-    hydroplant: { enabled: true },
-    solarfarm: { enabled: true },
+    broadcasttower: new Setting(true),
+    dataCenter: new Setting(true),
+    hydroplant: new Setting(true),
+    solarfarm: new Setting(true),
   };
 }

packages/userscript/source/options/FilterSettings.ts

@@ -1,5 +1,6 @@
 import { objectEntries } from "../tools/Entries";
-import { SettingsSection, SettingToggle } from "./SettingsSection";
+import { Setting } from "./Settings";
+import { SettingsSection } from "./SettingsSection";
 import { KittenStorageType } from "./SettingsStorage";
 
 export enum FilterItemVariant {
@@ -41,31 +42,47 @@ export type FilterItem =
   | "transcendFilter"
   | "upgradeFilter";
 
-export type FilterSettingsItem = SettingToggle & {
+export class FilterSettingsItem extends Setting {
   variant: FilterItemVariant;
+
+  constructor(variant: FilterItemVariant) {
+    super();
+    this.variant = variant;
+  }
+}
+
+export type FilterSettingsItems = {
+  [item in FilterItem]: FilterSettingsItem;
 };
+
 export class FilterSettings extends SettingsSection {
-  items: {
-    [item in FilterItem]: FilterSettingsItem;
-  } = {
-    buildFilter: { enabled: false, variant: FilterItemVariant.Build },
-    craftFilter: { enabled: false, variant: FilterItemVariant.Craft },
-    upgradeFilter: { enabled: false, variant: FilterItemVariant.Upgrade },
-    researchFilter: { enabled: false, variant: FilterItemVariant.Research },
-    tradeFilter: { enabled: false, variant: FilterItemVariant.Trade },
-    huntFilter: { enabled: false, variant: FilterItemVariant.Hunt },
-    praiseFilter: { enabled: false, variant: FilterItemVariant.Praise },
-    adoreFilter: { enabled: false, variant: FilterItemVariant.Adore },
-    transcendFilter: { enabled: false, variant: FilterItemVariant.Transcend },
-    faithFilter: { enabled: false, variant: FilterItemVariant.Faith },
-    accelerateFilter: { enabled: false, variant: FilterItemVariant.Accelerate },
-    timeSkipFilter: { enabled: false, variant: FilterItemVariant.TimeSkip },
-    festivalFilter: { enabled: false, variant: FilterItemVariant.Festival },
-    starFilter: { enabled: false, variant: FilterItemVariant.Star },
-    distributeFilter: { enabled: false, variant: FilterItemVariant.Distribute },
-    promoteFilter: { enabled: false, variant: FilterItemVariant.Promote },
-    miscFilter: { enabled: false, variant: FilterItemVariant.Misc },
-  };
+  items: FilterSettingsItems;
+
+  constructor(
+    enabled = false,
+    items: FilterSettingsItems = {
+      buildFilter: new FilterSettingsItem(FilterItemVariant.Build),
+      craftFilter: new FilterSettingsItem(FilterItemVariant.Craft),
+      upgradeFilter: new FilterSettingsItem(FilterItemVariant.Upgrade),
+      researchFilter: new FilterSettingsItem(FilterItemVariant.Research),
+      tradeFilter: new FilterSettingsItem(FilterItemVariant.Trade),
+      huntFilter: new FilterSettingsItem(FilterItemVariant.Hunt),
+      praiseFilter: new FilterSettingsItem(FilterItemVariant.Praise),
+      adoreFilter: new FilterSettingsItem(FilterItemVariant.Adore),
+      transcendFilter: new FilterSettingsItem(FilterItemVariant.Transcend),
+      faithFilter: new FilterSettingsItem(FilterItemVariant.Faith),
+      accelerateFilter: new FilterSettingsItem(FilterItemVariant.Accelerate),
+      timeSkipFilter: new FilterSettingsItem(FilterItemVariant.TimeSkip),
+      festivalFilter: new FilterSettingsItem(FilterItemVariant.Festival),
+      starFilter: new FilterSettingsItem(FilterItemVariant.Star),
+      distributeFilter: new FilterSettingsItem(FilterItemVariant.Distribute),
+      promoteFilter: new FilterSettingsItem(FilterItemVariant.Promote),
+      miscFilter: new FilterSettingsItem(FilterItemVariant.Misc),
+    }
+  ) {
+    super(enabled);
+    this.items = items;
+  }
 
   static toLegacyOptions(settings: FilterSettings, subject: KittenStorageType) {
     subject.toggles.filter = settings.enabled;