Merge branch 'remove-enum-layer' of github.com:bjornstar/shapez.io into enum-removal-super-branch

src/js/game/base_item.js

@@ -1,35 +1,28 @@
 import { DrawParameters } from "../core/draw_parameters";
 import { BasicSerializableObject } from "../savegame/serialization";
-import { enumLayer } from "./root";
 
-/** @enum {string} */
+/**
-export const enumItemType = {
+ * @typedef {import("./root").Layer} Layer
-    shape: "shape",
+ *
-    color: "color",
+ * @typedef {"shape" | "color" | "positiveEnergy" | "negativeEnergy" | "genericEnergy"} ItemType
-    positiveEnergy: "positiveEnergy",
+ */
-    negativeEnergy: "negativeEnergy",
 
-    // Can be used for filters
+/** @type {ItemType[]} **/
-    genericEnergy: "genericEnergy",
+export const itemTypes = ["shape", "color", "positiveEnergy", "negativeEnergy", "genericEnergy"];
-};
 
-/** @enum {enumLayer} */
+/** @type {Record<ItemType, Layer>} **/
-export const enumItemTypeToLayer = {
+export const itemTypeLayerMap = {
-    [enumItemType.shape]: enumLayer.regular,
+    shape: "regular",
-    [enumItemType.color]: enumLayer.regular,
+    color: "regular",
-    [enumItemType.positiveEnergy]: enumLayer.wires,
+    positiveEnergy: "wires",
-    [enumItemType.negativeEnergy]: enumLayer.wires,
+    negativeEnergy: "wires",
-    [enumItemType.genericEnergy]: enumLayer.wires,
+    genericEnergy: "wires",
 };
 
 /**
  * Class for items on belts etc. Not an entity for performance reasons
  */
 export class BaseItem extends BasicSerializableObject {
-    constructor() {
-        super();
-    }
-
     static getId() {
         return "base_item";
     }
@@ -39,10 +32,10 @@ export class BaseItem extends BasicSerializableObject {
         return {};
     }
 
-    /** @returns {enumItemType} */
+    /** @abstract @returns {ItemType} **/
     getItemType() {
         abstract;
-        return "";
+        return "shape";
     }
 
     /**

src/js/game/belt_path.js

@@ -5,11 +5,15 @@ import { epsilonCompare, round4Digits } from "../core/utils";
 import { Vector } from "../core/vector";
 import { BaseItem } from "./base_item";
 import { Entity } from "./entity";
-import { GameRoot, enumLayer } from "./root";
 import { Rectangle } from "../core/rectangle";
 import { BasicSerializableObject, types } from "../savegame/serialization";
 import { gItemRegistry } from "../core/global_registries";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 const logger = createLogger("belt_path");
 
 // Helpers for more semantic access into interleaved arrays
@@ -127,7 +131,7 @@ export class BeltPath extends BasicSerializableObject {
 
     /**
      * Returns the layer of the this path
-     * @returns {enumLayer}
+     * @returns {Layer}
      */
     getLayer() {
         return this.entityPath[0].layer;

src/js/game/blueprint.js

@@ -3,11 +3,15 @@ import { Loader } from "../core/loader";
 import { createLogger } from "../core/logging";
 import { clockwiseAngleMap, counterClockwiseAngleMap, Vector } from "../core/vector";
 import { Entity } from "./entity";
-import { GameRoot, enumLayer } from "./root";
 import { findNiceIntegerValue } from "../core/utils";
 import { blueprintShape } from "./upgrades";
 import { globalConfig } from "../core/config";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 const logger = createLogger("blueprint");
 
 export class Blueprint {
@@ -20,11 +24,11 @@ export class Blueprint {
 
     /**
      * Returns the layer of this blueprint
-     * @returns {enumLayer}
+     * @returns {Layer}
      */
     get layer() {
         if (this.entities.length === 0) {
-            return enumLayer.regular;
+            return "regular";
         }
         return this.entities[0].layer;
     }

src/js/game/buildings/advanced_processor.js

@@ -1,7 +1,6 @@
 import { formatItemsPerSecond } from "../../core/utils";
 import { Vector } from "../../core/vector";
 import { T } from "../../translations";
-import { enumItemType } from "../base_item";
 import { EnergyConsumerComponent } from "../components/energy_consumer";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
@@ -9,7 +8,11 @@ import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/it
 import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
-import { enumLayer, GameRoot } from "../root";
+
+/**
+ * @typedef {import("../root").GameRoot} GameRoot
+ * @typedef {import("../root").Layer} Layer
+ */
 
 export class MetaAdvancedProcessorBuilding extends MetaBuilding {
     constructor() {
@@ -58,7 +61,7 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
             new ItemEjectorComponent({
                 slots: [
                     { pos: new Vector(1, 0), direction: "right" },
-                    { pos: new Vector(1, 0), direction: "top", layer: enumLayer.wires },
+                    { pos: new Vector(1, 0), direction: "top", layer: "wires" },
                 ],
             })
         );
@@ -98,8 +101,8 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["top"],
-                        filter: enumItemType.positiveEnergy,
+                        filter: "positiveEnergy",
-                        layer: enumLayer.wires,
+                        layer: "wires",
                     },
                 ],
             })

src/js/game/buildings/belt_base.js

@@ -14,9 +14,10 @@ import { ItemEjectorComponent } from "../components/item_ejector";
 import { ReplaceableMapEntityComponent } from "../components/replaceable_map_entity";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
-import { GameRoot, enumLayer } from "../root";
 
 /**
+ * @typedef {import("../root").GameRoot} GameRoot
+ * @typedef {import("../root").Layer} Layer
  * @typedef {import("../../core/vector").Angle} Angle
  * @typedef {import("../../core/vector").Direction} Direction
  */
@@ -35,7 +36,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
      * @returns {Array<[string, string]>}
      */
     getAdditionalStatistics(root, variant) {
-        const beltSpeed = root.hubGoals.getBeltBaseSpeed(enumLayer.regular);
+        const beltSpeed = root.hubGoals.getBeltBaseSpeed("regular");
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
     }
 
@@ -112,10 +113,10 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
      * @param {Vector} param0.tile
      * @param {Angle} param0.rotation
      * @param {string} param0.variant
-     * @param {string} param0.layer
+     * @param {Layer} param0.layer
      * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
      */
-    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, layer }) {
         const topDirection = angleDirectionMap[rotation];
         const rightDirection = angleDirectionMap[clockwiseAngleMap[rotation]];
         const bottomDirection = angleDirectionMap[inverseAngleMap[rotation]];

src/js/game/buildings/cutter.js

@@ -8,7 +8,6 @@ import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
-import { enumItemType } from "../base_item";
 
 /** @enum {string} */
 export const enumCutterVariants = { quad: "quad" };
@@ -82,7 +81,7 @@ export class MetaCutterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                 ],
             })

src/js/game/buildings/energy_generator.js

@@ -1,14 +1,16 @@
 import { Vector } from "../../core/vector";
-import { enumItemType } from "../base_item";
 import { EnergyGeneratorComponent } from "../components/energy_generator";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
-import { enumLayer, GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
 
+/**
+ * @typedef {import("../root").GameRoot} GameRoot
+ */
+
 export class MetaEnergyGenerator extends MetaBuilding {
     constructor() {
         super("energy_generator");
@@ -51,18 +53,18 @@ export class MetaEnergyGenerator extends MetaBuilding {
                     {
                         pos: new Vector(0, 1),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 1),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["top"],
-                        layer: enumLayer.wires,
+                        layer: "wires",
-                        filter: enumItemType.negativeEnergy,
+                        filter: "negativeEnergy",
                     },
                 ],
             })
@@ -74,7 +76,7 @@ export class MetaEnergyGenerator extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         direction: "top",
-                        layer: enumLayer.wires,
+                        layer: "wires",
                     },
                 ],
                 instantEject: true,

src/js/game/buildings/hub.js

@@ -1,5 +1,4 @@
 import { Vector } from "../../core/vector";
-import { enumItemType } from "../base_item";
 import { HubComponent } from "../components/hub";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@@ -53,72 +52,72 @@ export class MetaHubBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["top", "left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["top"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(2, 0),
                         directions: ["top"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(3, 0),
                         directions: ["top", "right"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 3),
                         directions: ["bottom", "left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 3),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(2, 3),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(3, 3),
                         directions: ["bottom", "right"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 1),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 2),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 3),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(3, 1),
                         directions: ["right"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(3, 2),
                         directions: ["right"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(3, 3),
                         directions: ["right"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                 ],
             })

src/js/game/buildings/mixer.js

@@ -1,7 +1,6 @@
 import { formatItemsPerSecond } from "../../core/utils";
 import { Vector } from "../../core/vector";
 import { T } from "../../translations";
-import { enumItemType } from "../base_item";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@@ -63,12 +62,12 @@ export class MetaMixerBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                 ],
             })

src/js/game/buildings/painter.js

@@ -8,7 +8,6 @@ import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
-import { enumItemType } from "../base_item";
 
 /** @enum {string} */
 export const enumPainterVariants = { mirrored: "mirrored", double: "double", quad: "quad" };
@@ -98,12 +97,12 @@ export class MetaPainterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["top"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                 ],
             })
@@ -124,12 +123,12 @@ export class MetaPainterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: [variant === defaultBuildingVariant ? "top" : "bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                 ]);
 
@@ -143,17 +142,17 @@ export class MetaPainterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 1),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["top"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                 ]);
 
@@ -167,27 +166,27 @@ export class MetaPainterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["left"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                     {
                         pos: new Vector(2, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                     {
                         pos: new Vector(3, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.color,
+                        filter: "color",
                     },
                 ]);
 

src/js/game/buildings/rotater.js

@@ -8,7 +8,6 @@ import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
-import { enumItemType } from "../base_item";
 
 /** @enum {string} */
 export const enumRotaterVariants = { ccw: "ccw", fl: "fl" };
@@ -89,7 +88,7 @@ export class MetaRotaterBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                 ],
             })

src/js/game/buildings/splitter.js

@@ -5,11 +5,14 @@ import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot, enumLayer } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
 import { T } from "../../translations";
 import { formatItemsPerSecond } from "../../core/utils";
 
+/**
+ * @typedef {import("../root").GameRoot} GameRoot
+ */
+
 /** @enum {string} */
 export const enumSplitterVariants = { compact: "compact", compactInverse: "compact-inverse" };
 
@@ -116,8 +119,8 @@ export class MetaSplitterBuilding extends MetaBuilding {
                 ]);
 
                 entity.components.ItemAcceptor.beltUnderlays = [
-                    { pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
+                    { pos: new Vector(0, 0), direction: "top", layer: "regular" },
-                    { pos: new Vector(1, 0), direction: "top", layer: enumLayer.regular },
+                    { pos: new Vector(1, 0), direction: "top", layer: "regular" },
                 ];
 
                 break;
@@ -138,7 +141,7 @@ export class MetaSplitterBuilding extends MetaBuilding {
                 entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: "top" }]);
 
                 entity.components.ItemAcceptor.beltUnderlays = [
-                    { pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
+                    { pos: new Vector(0, 0), direction: "top", layer: "regular" },
                 ];
 
                 break;

src/js/game/buildings/stacker.js

@@ -8,7 +8,6 @@ import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
-import { enumItemType } from "../base_item";
 
 export class MetaStackerBuilding extends MetaBuilding {
     constructor() {
@@ -63,12 +62,12 @@ export class MetaStackerBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                     {
                         pos: new Vector(1, 0),
                         directions: ["bottom"],
-                        filter: enumItemType.shape,
+                        filter: "shape",
                     },
                 ],
             })

src/js/game/buildings/underground_belt.js

@@ -5,13 +5,16 @@ import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
 import { Entity } from "../entity";
 import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot, enumLayer } from "../root";
 import { globalConfig } from "../../core/config";
 import { enumHubGoalRewards } from "../tutorial_goals";
 import { formatItemsPerSecond } from "../../core/utils";
 import { T } from "../../translations";
 
-/** @typedef {import("../../core/vector").Angle} Angle **/
+/**
+ * @typedef {import("../../core/vector").Angle} Angle
+ * @typedef {import("../root").GameRoot} GameRoot
+ * @typedef {import("../root").Layer} Layer
+ */
 
 /** @enum {string} */
 export const arrayUndergroundRotationVariantToMode = [
@@ -155,10 +158,9 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
      * @param {Vector} param0.tile
      * @param {Angle} param0.rotation
      * @param {string} param0.variant
-     * @param {string} param0.layer
      * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
      */
-    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant }) {
         const searchDirection = angleDirectionMap[rotation];
         const searchVector = directionVectorMap[searchDirection];
         const tier = enumUndergroundBeltVariantToTier[variant];
@@ -174,7 +176,7 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
             tile = tile.addScalars(searchVector.x, searchVector.y);
 
             /* WIRES: FIXME */
-            const contents = root.map.getTileContent(tile, enumLayer.regular);
+            const contents = root.map.getTileContent(tile, "regular");
             if (contents) {
                 const undergroundComp = contents.components.UndergroundBelt;
                 if (undergroundComp && undergroundComp.tier === tier) {

src/js/game/buildings/wire_base.js

@@ -1,5 +1,4 @@
 import { Loader } from "../../core/loader";
-import { enumLayer } from "../root";
 import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base";
 
 export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
@@ -11,8 +10,9 @@ export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
         return "#c425d7";
     }
 
+    /** @returns {"wires"} **/
     getLayer() {
-        return enumLayer.wires;
+        return "wires";
     }
 
     getPreviewSprite(rotationVariant) {

src/js/game/buildings/wire_crossings.js

@@ -1,11 +1,10 @@
 import { Vector } from "../../core/vector";
-import { enumItemType } from "../base_item";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { enumLayer, GameRoot } from "../root";
+import { GameRoot } from "../root";
 
 /** @enum {string} */
 export const enumWireCrossingVariants = {
@@ -26,8 +25,9 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
         return "#c425d7";
     }
 
+    /** @returns {"wires"} **/
     getLayer() {
-        return enumLayer.wires;
+        return "wires";
     }
 
     /**
@@ -83,13 +83,13 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["bottom"],
-                        layer: enumLayer.wires,
+                        layer: "wires",
                     },
                 ]);
 
                 entity.components.ItemEjector.setSlots([
-                    { pos: new Vector(0, 0), direction: "top", layer: enumLayer.wires },
+                    { pos: new Vector(0, 0), direction: "top", layer: "wires" },
-                    { pos: new Vector(0, 0), direction: "right", layer: enumLayer.wires },
+                    { pos: new Vector(0, 0), direction: "right", layer: "wires" },
                 ]);
 
                 break;
@@ -99,17 +99,17 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
                     {
                         pos: new Vector(0, 0),
                         directions: ["top"],
-                        layer: enumLayer.wires,
+                        layer: "wires",
                     },
                     {
                         pos: new Vector(0, 0),
                         directions: ["right"],
-                        layer: enumLayer.wires,
+                        layer: "wires",
                     },
                 ]);
 
                 entity.components.ItemEjector.setSlots([
-                    { pos: new Vector(0, 0), direction: "bottom", layer: enumLayer.wires },
+                    { pos: new Vector(0, 0), direction: "bottom", layer: "wires" },
                 ]);
                 break;
             }

src/js/game/components/belt.js

@@ -3,7 +3,10 @@ import { types } from "../../savegame/serialization";
 import { BeltPath } from "../belt_path";
 import { Component } from "../component";
 import { Entity } from "../entity";
-import { enumLayer } from "../root";
+
+/**
+ * @typedef {import("../root").Layer} Layer
+ **/
 
 /** @typedef {import("../../core/vector").Direction} Direction **/
 
@@ -47,12 +50,12 @@ export class BeltComponent extends Component {
 
     /**
      * Returns the effective length of this belt in tile space
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {number}
      */
     getEffectiveLengthTiles(layer) {
         assert(layer, "no layer given");
-        if (layer === enumLayer.wires) {
+        if (layer === "wires") {
             return 1.0;
         }
         return this.direction === "top" ? 1.0 : curvedBeltLength;
@@ -62,14 +65,14 @@ export class BeltComponent extends Component {
      * Converts from belt space (0 = start of belt ... 1 = end of belt) to the local
      * belt coordinates (-0.5|-0.5 to 0.5|0.5)
      * @param {number} progress
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {Vector}
      */
     transformBeltToLocalSpace(progress, layer) {
         assert(progress >= 0.0, "Invalid progress ( < 0): " + progress);
 
         switch (layer) {
-            case enumLayer.regular: {
+            case "regular": {
                 switch (this.direction) {
                     case "top":
                         assert(progress <= 1.02, "Invalid progress: " + progress);
@@ -96,7 +99,7 @@ export class BeltComponent extends Component {
                         return new Vector(0, 0);
                 }
             }
-            case enumLayer.wires: {
+            case "wires": {
                 const pow = 0.5;
                 switch (this.direction) {
                     case "top":

src/js/game/components/energy_consumer.js

@@ -1,7 +1,7 @@
 import { Component } from "../component";
 import { types } from "../../savegame/serialization";
 import { Vector } from "../../core/vector";
-import { BaseItem, enumItemTypeToLayer, enumItemType } from "../base_item";
+import { BaseItem, itemTypes } from "../base_item";
 
 export class EnergyConsumerComponent extends Component {
     static getId() {
@@ -13,8 +13,8 @@ export class EnergyConsumerComponent extends Component {
             bufferSize: types.float,
             perCharge: types.float,
             batteryPosition: types.vector,
-            energyType: types.enum(enumItemType),
+            energyType: types.enum(itemTypes),
-            wasteType: types.enum(enumItemType),
+            wasteType: types.enum(itemTypes),
             acceptorSlotIndex: types.uint,
             ejectorSlotIndex: types.uint,
 
@@ -54,8 +54,10 @@ export class EnergyConsumerComponent extends Component {
         this.bufferSize = bufferSize;
         this.perCharge = perCharge;
         this.batteryPosition = batteryPosition;
-        this.energyType = enumItemType.positiveEnergy;
+        /** @type {"positiveEnergy"} **/
-        this.wasteType = enumItemType.negativeEnergy;
+        this.energyType = "positiveEnergy";
+        /** @type {"negativeEnergy"} **/
+        this.wasteType = "negativeEnergy";
         this.acceptorSlotIndex = acceptorSlotIndex;
         this.ejectorSlotIndex = ejectorSlotIndex;
 

src/js/game/components/energy_generator.js

@@ -1,5 +1,5 @@
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 import { Component } from "../component";
 import { ShapeItem } from "../items/shape_item";
 
@@ -59,7 +59,7 @@ export class EnergyGeneratorComponent extends Component {
             // just destroy it
             return true;
         } else {
-            if (item.getItemType() !== enumItemType.shape) {
+            if (item.getItemType() !== "shape") {
                 // This shouldn't happen since we have a filter - still, it doesn't hurt
                 // to check either
                 assertAlways(

src/js/game/components/item_acceptor.js

@@ -1,18 +1,20 @@
 import { directions, invertedDirectionMap } from "../../core/vector";
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem, itemTypes } from "../base_item";
 import { Component } from "../component";
-import { enumLayer } from "../root";
+import { layers } from "../root";
 
 /**
  * @typedef {import("../../core/vector").Direction} Direction
  * @typedef {import("../../core/vector").Vector} Vector
+ * @typedef {import("../root").Layer} Layer
+ * @typedef {import ("../base_item").ItemType} ItemType
  *
  * @typedef {{
  *   pos: Vector,
  *   directions: Direction[],
- *   layer: enumLayer,
+ *   layer: Layer,
- *   filter?: enumItemType
+ *   filter?: ItemType
  * }} ItemAcceptorSlot
  *
  * Contains information about a slot plus its location
@@ -25,10 +27,10 @@ import { enumLayer } from "../root";
  * @typedef {{
  *   pos: Vector,
  *   directions: Direction[],
- *   layer?: enumLayer,
+ *   layer?: Layer,
- *  filter?: enumItemType
+ *   filter?: ItemType
  * }} ItemAcceptorSlotConfig
- */
+ **/
 
 export class ItemAcceptorComponent extends Component {
     static getId() {
@@ -41,10 +43,10 @@ export class ItemAcceptorComponent extends Component {
                 types.structured({
                     pos: types.vector,
                     directions: types.array(types.enum(directions)),
-                    filter: types.nullable(types.enum(enumItemType)),
+                    filter: types.nullable(types.enum(itemTypes)),
 
                     // TODO: MIGRATE
-                    layer: types.enum(enumLayer),
+                    layer: types.enum(layers),
                 })
             ),
             animated: types.bool,
@@ -54,7 +56,7 @@ export class ItemAcceptorComponent extends Component {
                     direction: types.enum(directions),
 
                     // TODO: MIGRATE
-                    layer: types.enum(enumLayer),
+                    layer: types.enum(layers),
                 })
             ),
         };
@@ -94,7 +96,7 @@ export class ItemAcceptorComponent extends Component {
      * @param {object} param0
      * @param {Array<ItemAcceptorSlotConfig>} param0.slots The slots from which we accept items
      * @param {boolean=} param0.animated Whether to animate item consumption
-     * @param {Array<{pos: Vector, direction: Direction, layer: enumLayer}>=} param0.beltUnderlays Where to render belt underlays
+     * @param {Array<{pos: Vector, direction: Direction, layer: Layer}>=} param0.beltUnderlays Where to render belt underlays
      */
     constructor({ slots = [], beltUnderlays = [], animated = true }) {
         super();
@@ -125,9 +127,9 @@ export class ItemAcceptorComponent extends Component {
             this.slots.push({
                 pos: slot.pos,
                 directions: slot.directions,
-                layer: slot.layer || enumLayer.regular,
+                layer: slot.layer || "regular",
 
-                // Which type of item to accept (shape | color | all) @see enumItemType
+                // Which type of item to accept (shape | color | all) @see ItemType
                 filter: slot.filter,
             });
         }
@@ -145,7 +147,7 @@ export class ItemAcceptorComponent extends Component {
 
     /**
      * Returns if the given filter matches
-     * @param {enumItemType|null} filter
+     * @param {ItemType|null} filter
      * @param {BaseItem} item
      */
     filterMatches(filter, item) {
@@ -154,8 +156,8 @@ export class ItemAcceptorComponent extends Component {
         }
 
         const itemType = item.getItemType();
-        if (filter === enumItemType.genericEnergy) {
+        if (filter === "genericEnergy") {
-            return itemType === enumItemType.positiveEnergy || itemType === enumItemType.negativeEnergy;
+            return itemType === "positiveEnergy" || itemType === "negativeEnergy";
         }
 
         return itemType === filter;
@@ -182,7 +184,7 @@ export class ItemAcceptorComponent extends Component {
      * Tries to find a slot which accepts the current item
      * @param {Vector} targetLocalTile
      * @param {Direction} fromLocalDirection
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {ItemAcceptorLocatedSlot|null}
      */
     findMatchingSlot(targetLocalTile, fromLocalDirection, layer) {

src/js/game/components/item_ejector.js

@@ -4,16 +4,18 @@ import { Component } from "../component";
 import { types } from "../../savegame/serialization";
 import { gItemRegistry } from "../../core/global_registries";
 import { Entity } from "../entity";
-import { enumLayer } from "../root";
+import { layers } from "../root";
 
 /**
+ * @typedef {import("../root").Layer} Layer
  * @typedef {import("../../core/vector").Direction} Direction
  * @typedef {import("./item_acceptor").ItemAcceptorLocatedSlot} ItemAcceptorLocatedSlot
+ *
  * @typedef {{
  *    pos: Vector,
  *    direction: Direction,
  *    item: BaseItem,
- *    layer: enumLayer,
+ *    layer: Layer,
  *    progress: number?,
  *    cachedDestSlot?: ItemAcceptorLocatedSlot,
  *    cachedTargetEntity?: Entity
@@ -38,7 +40,7 @@ export class ItemEjectorComponent extends Component {
                     progress: types.float,
 
                     // TODO: Migrate
-                    layer: types.enum(enumLayer),
+                    layer: types.enum(layers),
                 })
             ),
         };
@@ -64,7 +66,7 @@ export class ItemEjectorComponent extends Component {
     /**
      *
      * @param {object} param0
-     * @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>=} param0.slots The slots to eject on
+     * @param {Array<{pos: Vector, direction: Direction, layer?: Layer}>=} param0.slots The slots to eject on
      * @param {boolean=} param0.instantEject If the ejection is instant
      */
     constructor({ slots = [], instantEject = false }) {
@@ -85,7 +87,7 @@ export class ItemEjectorComponent extends Component {
     }
 
     /**
-     * @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>} slots The slots to eject on
+     * @param {Array<{pos: Vector, direction: Direction, layer?: Layer}>} slots The slots to eject on
      */
     setSlots(slots) {
         /** @type {Array<ItemEjectorSlot>} */
@@ -97,7 +99,7 @@ export class ItemEjectorComponent extends Component {
                 direction: slot.direction,
                 item: null,
                 progress: 0,
-                layer: slot.layer || enumLayer.regular,
+                layer: slot.layer || "regular",
                 cachedDestSlot: null,
                 cachedTargetEntity: null,
             });
@@ -118,7 +120,7 @@ export class ItemEjectorComponent extends Component {
     /**
      * Returns whether any slot ejects to the given local tile
      * @param {Vector} tile
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     anySlotEjectsToLocalTile(tile, layer) {
         for (let i = 0; i < this.slots.length; ++i) {
@@ -141,7 +143,7 @@ export class ItemEjectorComponent extends Component {
 
     /**
      * Returns the first free slot on this ejector or null if there is none
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {number?}
      */
     getFirstFreeSlot(layer) {

src/js/game/components/storage.js

@@ -1,7 +1,7 @@
 import { Component } from "../component";
 import { types } from "../../savegame/serialization";
 import { gItemRegistry } from "../../core/global_registries";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 import { ColorItem } from "../items/color_item";
 import { ShapeItem } from "../items/shape_item";
 
@@ -67,11 +67,11 @@ export class StorageComponent extends Component {
             return false;
         }
 
-        if (itemType === enumItemType.color) {
+        if (itemType === "color") {
             return /** @type {ColorItem} */ (this.storedItem).color === /** @type {ColorItem} */ (item).color;
         }
 
-        if (itemType === enumItemType.shape) {
+        if (itemType === "shape") {
             return (
                 /** @type {ShapeItem} */ (this.storedItem).definition.getHash() ===
                 /** @type {ShapeItem} */ (item).definition.getHash()

src/js/game/components/underground_belt.js

@@ -4,7 +4,6 @@ import { globalConfig } from "../../core/config";
 import { types } from "../../savegame/serialization";
 import { gItemRegistry } from "../../core/global_registries";
 import { Entity } from "../entity";
-import { enumLayer } from "../root";
 
 /** @enum {string} */
 export const enumUndergroundBeltMode = {
@@ -103,8 +102,7 @@ export class UndergroundBeltComponent extends Component {
         }
 
         // Notice: We assume that for all items the travel distance is the same
-        const maxItemsInTunnel =
+        const maxItemsInTunnel = (2 + travelDistance) / globalConfig.beltItemSpacingByLayer.regular;
-            (2 + travelDistance) / globalConfig.beltItemSpacingByLayer[enumLayer.regular];
         if (this.pendingItems.length >= maxItemsInTunnel) {
             // Simulate a real belt which gets full at some point
             return false;
@@ -115,7 +113,7 @@ export class UndergroundBeltComponent extends Component {
         // So instead of adding 1 we add 0.5 only.
         // Additionally it takes 1 tile for the acceptor which we just add on top.
         const travelDuration =
-            (travelDistance + 1.5) / beltSpeed / globalConfig.beltItemSpacingByLayer[enumLayer.regular];
+            (travelDistance + 1.5) / beltSpeed / globalConfig.beltItemSpacingByLayer.regular;
 
         this.pendingItems.push([item, travelDuration]);
 

src/js/game/core.js

@@ -23,7 +23,7 @@ import { GameHUD } from "./hud/hud";
 import { KeyActionMapper } from "./key_action_mapper";
 import { GameLogic } from "./logic";
 import { MapView } from "./map_view";
-import { GameRoot, enumLayer } from "./root";
+import { GameRoot } from "./root";
 import { ShapeDefinitionManager } from "./shape_definition_manager";
 import { SoundProxy } from "./sound_proxy";
 import { GameTime } from "./time/game_time";
@@ -32,6 +32,10 @@ import { randomInt } from "../core/utils";
 import { defaultBuildingVariant } from "./meta_building";
 import { DynamicTickrate } from "./dynamic_tickrate";
 
+/**
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 const logger = createLogger("ingame/core");
 
 // Store the canvas so we can reuse it later
@@ -398,14 +402,14 @@ export class GameCore {
 
         if (!this.root.camera.getIsMapOverlayActive()) {
             // Underlays for splitters / balancers
-            systems.itemAcceptor.drawUnderlays(params, enumLayer.regular);
+            systems.itemAcceptor.drawUnderlays(params, "regular");
 
             // Belt items
-            systems.belt.drawLayerBeltItems(params, enumLayer.regular);
+            systems.belt.drawLayerBeltItems(params, "regular");
 
             // Items being ejected / accepted currently (animations)
-            systems.itemEjector.drawLayer(params, enumLayer.regular);
+            systems.itemEjector.drawLayer(params, "regular");
-            systems.itemAcceptor.drawLayer(params, enumLayer.regular);
+            systems.itemAcceptor.drawLayer(params, "regular");
         }
 
         // Miner & Static map entities
@@ -428,14 +432,14 @@ export class GameCore {
         // Green wires overlay (not within the if because it can fade)
         root.hud.parts.wiresOverlay.draw(params);
 
-        if (this.root.currentLayer === enumLayer.wires && !this.root.camera.getIsMapOverlayActive()) {
+        if (this.root.currentLayer === "wires" && !this.root.camera.getIsMapOverlayActive()) {
             // Belt sprites & Static map entities
             root.map.drawWiresLayer(params);
 
             // Belt items as well as accepted / ejected items
-            systems.belt.drawLayerBeltItems(params, enumLayer.wires);
+            systems.belt.drawLayerBeltItems(params, "wires");
-            systems.itemEjector.drawLayer(params, enumLayer.wires);
+            systems.itemEjector.drawLayer(params, "wires");
-            systems.itemAcceptor.drawLayer(params, enumLayer.wires);
+            systems.itemAcceptor.drawLayer(params, "wires");
 
             root.map.drawWiresForegroundLayer(params);
 

src/js/game/entity.js

@@ -3,15 +3,20 @@ import { DrawParameters } from "../core/draw_parameters";
 import { Component } from "./component";
 /* typehints:end */
 
-import { GameRoot, enumLayer } from "./root";
 import { globalConfig } from "../core/config";
 import { directionAngleMap, directionVectorMap } from "../core/vector";
 import { BasicSerializableObject, types } from "../savegame/serialization";
 import { EntityComponentStorage } from "./entity_components";
+import { layers } from "./root";
 import { Loader } from "../core/loader";
 import { drawRotatedSprite } from "../core/draw_utils";
 import { gComponentRegistry } from "../core/global_registries";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 export class Entity extends BasicSerializableObject {
     /**
      * @param {GameRoot} root
@@ -36,8 +41,9 @@ export class Entity extends BasicSerializableObject {
 
         /**
          * On which layer this entity is
+         * @type {Layer}
          */
-        this.layer = enumLayer.regular;
+        this.layer = "regular";
 
         /**
          * Internal entity unique id, set by the @see EntityManager
@@ -77,7 +83,7 @@ export class Entity extends BasicSerializableObject {
         return {
             uid: types.uint,
             components: types.keyValueMap(types.objData(gComponentRegistry)),
-            layer: types.enum(enumLayer),
+            layer: types.enum(layers),
         };
     }
 

src/js/game/game_system_with_filter.js

@@ -3,11 +3,16 @@ import { Component } from "./component";
 import { Entity } from "./entity";
 /* typehints:end */
 
-import { GameRoot, enumLayer } from "./root";
 import { GameSystem } from "./game_system";
 import { arrayDelete, arrayDeleteValue } from "../core/utils";
 import { DrawParameters } from "../core/draw_parameters";
 import { globalConfig } from "../core/config";
+
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 export class GameSystemWithFilter extends GameSystem {
     /**
      * Constructs a new game system with the given component filter. It will process
@@ -39,7 +44,7 @@ export class GameSystemWithFilter extends GameSystem {
      * Calls a function for each matching entity on the screen, useful for drawing them
      * @param {DrawParameters} parameters
      * @param {function} callback
-     * @param {enumLayer=} layerFilter Can be null for no filter
+     * @param {Layer=} layerFilter Can be null for no filter
      */
     forEachMatchingEntityOnScreen(parameters, callback, layerFilter = null) {
         const cullRange = parameters.visibleRect.toTileCullRectangle();

src/js/game/hub_goals.js

@@ -4,11 +4,15 @@ import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/ut
 import { BasicSerializableObject, types } from "../savegame/serialization";
 import { colors } from "./colors";
 import { enumItemProcessorTypes } from "./components/item_processor";
-import { GameRoot, enumLayer } from "./root";
 import { enumSubShape, ShapeDefinition } from "./shape_definition";
 import { enumHubGoalRewards, tutorialGoals } from "./tutorial_goals";
 import { UPGRADES, blueprintShape } from "./upgrades";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ **/
+
 export class HubGoals extends BasicSerializableObject {
     static getId() {
         return "HubGoals";
@@ -369,11 +373,11 @@ export class HubGoals extends BasicSerializableObject {
 
     /**
      * Belt speed
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {number} items / sec
      */
     getBeltBaseSpeed(layer) {
-        if (layer === enumLayer.wires) {
+        if (layer === "wires") {
             return globalConfig.wiresSpeedItemsPerSecond;
         }
         return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;

src/js/game/hud/parts/blueprint_placer.js

@@ -11,7 +11,10 @@ import { BaseHUDPart } from "../base_hud_part";
 import { DynamicDomAttach } from "../dynamic_dom_attach";
 import { Blueprint } from "../../blueprint";
 import { SOUNDS } from "../../../platform/sound";
-import { enumLayer } from "../../root";
+
+/**
+ * @typedef {import("../../root").Layer} Layer
+ **/
 
 export class HUDBlueprintPlacer extends BaseHUDPart {
     createElements(parent) {
@@ -60,7 +63,7 @@ export class HUDBlueprintPlacer extends BaseHUDPart {
 
     /**
      * Called when the layer was changed
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     onEditModeChanged(layer) {
         // Check if the layer of the blueprint differs and thus we have to deselect it

src/js/game/hud/parts/building_placer.js

@@ -8,13 +8,17 @@ import { directionVectorMap, directionAngleMap, invertedDirectionMap, Vector } f
 import { T } from "../../../translations";
 import { KEYMAPPINGS } from "../../key_action_mapper";
 import { defaultBuildingVariant } from "../../meta_building";
+import { layers } from "../../root";
 import { THEME } from "../../theme";
 import { DynamicDomAttach } from "../dynamic_dom_attach";
 import { HUDBuildingPlacerLogic } from "./building_placer_logic";
 import { makeOffscreenBuffer } from "../../../core/buffer_utils";
-import { enumLayer } from "../../root";
 import { getCodeFromBuildingData } from "../../building_codes";
 
+/**
+ * @typedef {import("../../root").Layer} Layer
+ **/
+
 export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
     /**
      * @param {HTMLElement} parent
@@ -55,9 +59,9 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
         this.currentInterpolatedCornerTile = new Vector();
 
         this.lockIndicatorSprites = {};
-        for (const layerId in enumLayer) {
+        layers.forEach(layer => {
-            this.lockIndicatorSprites[layerId] = this.makeLockIndicatorSprite(layerId);
+            this.lockIndicatorSprites[layer] = this.makeLockIndicatorSprite(layer);
-        }
+        });
 
         //
 
@@ -70,7 +74,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
 
     /**
      * Makes the lock indicator sprite for the given layer
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     makeLockIndicatorSprite(layer) {
         const dims = 48;

src/js/game/hud/parts/building_placer_logic.js

@@ -18,11 +18,14 @@ import { BaseHUDPart } from "../base_hud_part";
 import { SOUNDS } from "../../../platform/sound";
 import { MetaMinerBuilding, enumMinerVariants } from "../../buildings/miner";
 import { enumHubGoalRewards } from "../../tutorial_goals";
-import { enumLayer } from "../../root";
 import { getBuildingDataFromCode, getCodeFromBuildingData } from "../../building_codes";
 
 /** @typedef {import("../../../core/vector").Angle} Angle **/
 
+/**
+ * @typedef {import("../../root").Layer} Layer
+ **/
+
 /**
  * Contains all logic for the building placer - this doesn't include the rendering
  * of info boxes or drawing.
@@ -140,12 +143,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
 
     /**
      * Called when the edit mode got changed
-     * @param {enumLayer} editMode
+     * @param {Layer} layer
      */
-    onEditModeChanged(editMode) {
+    onEditModeChanged(layer) {
         const metaBuilding = this.currentMetaBuilding.get();
         if (metaBuilding) {
-            if (metaBuilding.getLayer() !== editMode) {
+            if (metaBuilding.getLayer() !== layer) {
                 // This layer doesn't fit the edit mode anymore
                 this.currentMetaBuilding.set(null);
             }

src/js/game/hud/parts/buildings_toolbar.js

@@ -9,7 +9,6 @@ import { MetaSplitterBuilding } from "../../buildings/splitter";
 import { MetaStackerBuilding } from "../../buildings/stacker";
 import { MetaTrashBuilding } from "../../buildings/trash";
 import { MetaUndergroundBeltBuilding } from "../../buildings/underground_belt";
-import { enumLayer } from "../../root";
 import { HUDBaseToolbar } from "./base_toolbar";
 import { MetaAdvancedProcessorBuilding } from "../../buildings/advanced_processor";
 
@@ -34,7 +33,7 @@ export class HUDBuildingsToolbar extends HUDBaseToolbar {
         super(root, {
             supportedBuildings,
             visibilityCondition: () =>
-                !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.regular,
+                !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "regular",
             htmlElementId: "ingame_HUD_buildings_toolbar",
         });
     }

src/js/game/hud/parts/color_blind_helper.js

@@ -6,8 +6,6 @@ import { DrawParameters } from "../../../core/draw_parameters";
 import { THEME } from "../../theme";
 import { globalConfig } from "../../../core/config";
 import { T } from "../../../translations";
-import { enumItemType } from "../../base_item";
-import { enumLayer } from "../../root";
 
 /**
  * @typedef {import("../../colors").Color} Color
@@ -44,7 +42,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
             return null;
         }
 
-        if (this.root.currentLayer !== enumLayer.regular) {
+        if (this.root.currentLayer !== "regular") {
             // Not in regular mode
             return null;
         }
@@ -59,7 +57,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
             // Check if the belt has a color item
             if (beltComp) {
                 const item = beltComp.assignedPath.findItemAtTile(tile);
-                if (item && item.getItemType() === enumItemType.color) {
+                if (item && item.getItemType() === "color") {
                     return /** @type {ColorItem} */ (item).color;
                 }
             }
@@ -72,7 +70,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
                     if (slot.layer !== this.root.currentLayer) {
                         continue;
                     }
-                    if (slot.item && slot.item.getItemType() === enumItemType.color) {
+                    if (slot.item && slot.item.getItemType() === "color") {
                         return /** @type {ColorItem} */ (slot.item).color;
                     }
                 }
@@ -80,7 +78,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
         } else {
             // We hovered a lower layer, show the color there
             const lowerLayer = this.root.map.getLowerLayerContentXY(tile.x, tile.y);
-            if (lowerLayer && lowerLayer.getItemType() === enumItemType.color) {
+            if (lowerLayer && lowerLayer.getItemType() === "color") {
                 return /** @type {ColorItem} */ (lowerLayer).color;
             }
         }

src/js/game/hud/parts/wires_overlay.js

@@ -2,7 +2,6 @@ import { makeOffscreenBuffer } from "../../../core/buffer_utils";
 import { globalConfig } from "../../../core/config";
 import { DrawParameters } from "../../../core/draw_parameters";
 import { KEYMAPPINGS } from "../../key_action_mapper";
-import { enumLayer } from "../../root";
 import { THEME } from "../../theme";
 import { BaseHUDPart } from "../base_hud_part";
 import { Loader } from "../../../core/loader";
@@ -26,10 +25,10 @@ export class HUDWiresOverlay extends BaseHUDPart {
      * Switches between layers
      */
     switchLayers() {
-        if (this.root.currentLayer === enumLayer.regular) {
+        if (this.root.currentLayer === "regular") {
-            this.root.currentLayer = enumLayer.wires;
+            this.root.currentLayer = "wires";
         } else {
-            this.root.currentLayer = enumLayer.regular;
+            this.root.currentLayer = "regular";
         }
         this.root.signals.editModeChanged.dispatch(this.root.currentLayer);
     }
@@ -50,7 +49,7 @@ export class HUDWiresOverlay extends BaseHUDPart {
     }
 
     update() {
-        const desiredAlpha = this.root.currentLayer === enumLayer.wires ? 1.0 : 0.0;
+        const desiredAlpha = this.root.currentLayer === "wires" ? 1.0 : 0.0;
         this.currentAlpha = lerp(this.currentAlpha, desiredAlpha, 0.12);
     }
 

src/js/game/hud/parts/wires_toolbar.js

@@ -1,5 +1,4 @@
 import { MetaWireBaseBuilding } from "../../buildings/wire_base";
-import { enumLayer } from "../../root";
 import { HUDBaseToolbar } from "./base_toolbar";
 import { MetaWireCrossingsBuilding } from "../../buildings/wire_crossings";
 
@@ -10,7 +9,7 @@ export class HUDWiresToolbar extends HUDBaseToolbar {
         super(root, {
             supportedBuildings,
             visibilityCondition: () =>
-                !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.wires,
+                !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "wires",
             htmlElementId: "ingame_HUD_wires_toolbar",
         });
     }

src/js/game/hud/trailer_maker.js

@@ -1,4 +1,3 @@
-import { GameRoot, enumLayer } from "../root";
 import { globalConfig } from "../../core/config";
 import { Vector, mixVector } from "../../core/vector";
 import { lerp } from "../../core/utils";
@@ -9,6 +8,10 @@ import { gMetaBuildingRegistry } from "../../core/global_registries";
 import { MetaBeltBaseBuilding } from "../buildings/belt_base";
 import { MinerComponent } from "../components/miner";
 
+/**
+ * @typedef {import("../root").GameRoot} GameRoot
+ **/
+
 const tickrate = 1 / 165;
 
 export class TrailerMaker {
@@ -92,7 +95,7 @@ export class TrailerMaker {
             const speed =
                 globalConfig.tileSize *
                 globalConfig.beltSpeedItemsPerSecond *
-                globalConfig.beltItemSpacingByLayer[enumLayer.regular];
+                globalConfig.beltItemSpacingByLayer.regular;
             // let time =
             //     this.currentPlaybackOrigin.distance(Vector.fromSerializedObject(nextMarker.pos)) / speed;
             const time = nextMarker.time;

src/js/game/items/color_item.js

@@ -2,7 +2,7 @@ import { globalConfig } from "../../core/config";
 import { smoothenDpi } from "../../core/dpi_manager";
 import { DrawParameters } from "../../core/draw_parameters";
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 import { colors, colorHexColorMap } from "../colors";
 import { THEME } from "../theme";
 
@@ -28,8 +28,9 @@ export class ColorItem extends BaseItem {
         this.color = data;
     }
 
+    /** @returns {"color"} **/
     getItemType() {
-        return enumItemType.color;
+        return "color";
     }
 
     /**

src/js/game/items/negative_energy_item.js

@@ -1,7 +1,7 @@
 import { DrawParameters } from "../../core/draw_parameters";
 import { Loader } from "../../core/loader";
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 
 export class NegativeEnergyItem extends BaseItem {
     static getId() {
@@ -18,8 +18,9 @@ export class NegativeEnergyItem extends BaseItem {
 
     deserialize(data) {}
 
+    /** @returns {"negativeEnergy"} **/
     getItemType() {
-        return enumItemType.negativeEnergy;
+        return "negativeEnergy";
     }
 
     /**

src/js/game/items/positive_energy_item.js

@@ -1,7 +1,7 @@
 import { DrawParameters } from "../../core/draw_parameters";
 import { Loader } from "../../core/loader";
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 
 export class PositiveEnergyItem extends BaseItem {
     static getId() {
@@ -18,8 +18,9 @@ export class PositiveEnergyItem extends BaseItem {
 
     deserialize(data) {}
 
+    /** @returns {"positiveEnergy"} **/
     getItemType() {
-        return enumItemType.positiveEnergy;
+        return "positiveEnergy";
     }
 
     /**

src/js/game/items/shape_item.js

@@ -1,6 +1,6 @@
 import { DrawParameters } from "../../core/draw_parameters";
 import { types } from "../../savegame/serialization";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 import { ShapeDefinition } from "../shape_definition";
 import { THEME } from "../theme";
 
@@ -21,8 +21,9 @@ export class ShapeItem extends BaseItem {
         this.definition = ShapeDefinition.fromShortKey(data);
     }
 
+    /** @returns {"shape"} **/
     getItemType() {
-        return enumItemType.shape;
+        return "shape";
     }
 
     /**

src/js/game/logic.js

@@ -3,7 +3,6 @@ import { round2Digits } from "../core/utils";
 import { directionVectorMap, Vector } from "../core/vector";
 import { Entity } from "./entity";
 import { MetaBuilding } from "./meta_building";
-import { enumLayer, GameRoot } from "./root";
 import { STOP_PROPAGATION } from "../core/signal";
 
 const logger = createLogger("ingame/logic");
@@ -13,6 +12,8 @@ const logger = createLogger("ingame/logic");
  * @typedef {import("./components/item_acceptor").ItemAcceptorSlot} ItemAcceptorSlot
  * @typedef {import("../core/vector").Angle} Angle
  * @typedef {import("../core/vector").Direction} Direction
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
  *
  * @typedef {Array<{
  *  entity: Entity,
@@ -177,7 +178,7 @@ export class GameLogic {
     /**
      * Returns the acceptors and ejectors which affect the current tile
      * @param {Vector} tile
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {AcceptorsAndEjectorsAffectingTile}
      */
     getEjectorsAndAcceptorsAtTile(tile, layer) {

src/js/game/map.js

@@ -1,4 +1,3 @@
-import { GameRoot, enumLayer } from "./root";
 import { globalConfig } from "../core/config";
 import { Vector } from "../core/vector";
 import { Entity } from "./entity";
@@ -8,6 +7,11 @@ import { MapChunkView } from "./map_chunk_view";
 import { randomInt } from "../core/utils";
 import { BasicSerializableObject, types } from "../savegame/serialization";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ */
+
 const logger = createLogger("map");
 
 export class BaseMap extends BasicSerializableObject {
@@ -98,7 +102,7 @@ export class BaseMap extends BasicSerializableObject {
     /**
      * Returns the tile content of a given tile
      * @param {Vector} tile
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {Entity} Entity or null
      */
     getTileContent(tile, layer) {
@@ -123,7 +127,7 @@ export class BaseMap extends BasicSerializableObject {
      * Returns the tile content of a given tile
      * @param {number} x
      * @param {number} y
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {Entity} Entity or null
      */
     getLayerContentXY(x, y, layer) {
@@ -148,7 +152,7 @@ export class BaseMap extends BasicSerializableObject {
     /**
      * Checks if the tile is used
      * @param {Vector} tile
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {boolean}
      */
     isTileUsed(tile, layer) {
@@ -163,7 +167,7 @@ export class BaseMap extends BasicSerializableObject {
      * Checks if the tile is used
      * @param {number} x
      * @param {number} y
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {boolean}
      */
     isTileUsedXY(x, y, layer) {

src/js/game/map_chunk.js

@@ -1,4 +1,3 @@
-import { GameRoot, enumLayer } from "./root";
 import { globalConfig } from "../core/config";
 import { createLogger } from "../core/logging";
 import { clamp, fastArrayDeleteValueIfContained, make2DUndefinedArray } from "../core/utils";
@@ -10,6 +9,11 @@ import { ShapeItem } from "./items/shape_item";
 import { enumSubShape } from "./shape_definition";
 import { RandomNumberGenerator } from "../core/rng";
 
+/**
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ */
+
 const logger = createLogger("map_chunk");
 
 /** @typedef {import("./colors").Color} Color **/
@@ -334,7 +338,7 @@ export class MapChunk {
      * Returns the contents of this chunk from the given world space coordinates
      * @param {number} worldX
      * @param {number} worldY
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @returns {Entity=}
      */
     getLayerContentFromWorldCoords(worldX, worldY, layer) {
@@ -344,7 +348,7 @@ export class MapChunk {
         assert(localY >= 0, "Local Y is < 0");
         assert(localX < globalConfig.mapChunkSize, "Local X is >= chunk size");
         assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
-        if (layer === enumLayer.regular) {
+        if (layer === "regular") {
             return this.contents[localX][localY] || null;
         } else {
             return this.wireContents[localX][localY] || null;
@@ -397,7 +401,7 @@ export class MapChunk {
      * @param {number} tileX
      * @param {number} tileY
      * @param {Entity=} contents
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     setLayerContentFromWorldCords(tileX, tileY, contents, layer) {
         const localX = tileX - this.tileX;
@@ -408,7 +412,7 @@ export class MapChunk {
         assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
 
         let oldContents;
-        if (layer === enumLayer.regular) {
+        if (layer === "regular") {
             oldContents = this.contents[localX][localY];
         } else {
             oldContents = this.wireContents[localX][localY];
@@ -421,7 +425,7 @@ export class MapChunk {
             fastArrayDeleteValueIfContained(this.containedEntities, oldContents);
         }
 
-        if (layer === enumLayer.regular) {
+        if (layer === "regular") {
             this.contents[localX][localY] = contents;
         } else {
             this.wireContents[localX][localY] = contents;

src/js/game/meta_building.js

@@ -4,10 +4,13 @@ import { Vector } from "../core/vector";
 import { SOUNDS } from "../platform/sound";
 import { StaticMapEntityComponent } from "./components/static_map_entity";
 import { Entity } from "./entity";
-import { enumLayer, GameRoot } from "./root";
 import { getCodeFromBuildingData } from "./building_codes";
 
-/** @typedef {import("../core/vector").Angle} Angle **/
+/**
+ * @typedef {import("../core/vector").Angle} Angle
+ * @typedef {import("./root").GameRoot} GameRoot
+ * @typedef {import("./root").Layer} Layer
+ */
 
 export const defaultBuildingVariant = "default";
 
@@ -29,10 +32,10 @@ export class MetaBuilding {
 
     /**
      * Returns the edit layer of the building
-     * @returns {enumLayer}
+     * @returns {Layer}
      */
     getLayer() {
-        return enumLayer.regular;
+        return "regular";
     }
 
     /**
@@ -196,10 +199,10 @@ export class MetaBuilding {
      * @param {Vector} param0.tile
      * @param {Angle} param0.rotation
      * @param {string} param0.variant
-     * @param {string} param0.layer
+     * @param {Layer} param0.layer
      * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
      */
-    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+    computeOptimalDirectionAndRotationVariantAtTile({ rotation, variant }) {
         if (!this.isRotateable(variant)) {
             return {
                 rotation: 0,

src/js/game/production_analytics.js

@@ -1,7 +1,7 @@
 import { GameRoot } from "./root";
 import { ShapeDefinition } from "./shape_definition";
 import { globalConfig } from "../core/config";
-import { BaseItem, enumItemType } from "./base_item";
+import { BaseItem } from "./base_item";
 import { ShapeItem } from "./items/shape_item";
 import { BasicSerializableObject } from "../savegame/serialization";
 
@@ -53,7 +53,7 @@ export class ProductionAnalytics extends BasicSerializableObject {
      * @param {BaseItem} item
      */
     onItemProduced(item) {
-        if (item.getItemType() === enumItemType.shape) {
+        if (item.getItemType() === "shape") {
             const definition = /** @type {ShapeItem} */ (item).definition;
             const key = definition.getHash();
             const entry = this.history[enumAnalyticsDataSource.produced];

src/js/game/root.js

@@ -1,10 +1,7 @@
-/* eslint-disable no-unused-vars */
-
 import { Signal } from "../core/signal";
 import { RandomNumberGenerator } from "../core/rng";
 import { createLogger } from "../core/logging";
 
-// Type hints
 /* typehints:start */
 import { GameTime } from "./time/game_time";
 import { EntityManager } from "./entity_manager";
@@ -32,14 +29,10 @@ import { Vector } from "../core/vector";
 
 const logger = createLogger("game/root");
 
-/** @enum {string} */
+/** @typedef {"regular" | "wires"} Layer **/
-export const enumLayer = {
-    regular: "regular",
-    wires: "wires",
-};
 
-/** @type {Array<enumLayer>} */
+/** @type {Array<Layer>} */
-export const arrayLayers = [enumLayer.regular, enumLayer.wires];
+export const layers = ["regular", "wires"];
 
 /**
  * The game root is basically the whole game state at a given point,
@@ -134,8 +127,8 @@ export class GameRoot {
         /** @type {DynamicTickrate} */
         this.dynamicTickrate = null;
 
-        /** @type {enumLayer} */
+        /** @type {Layer} */
-        this.currentLayer = enumLayer.regular;
+        this.currentLayer = "regular";
 
         this.signals = {
             // Entities
@@ -170,7 +163,7 @@ export class GameRoot {
 
             bulkOperationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),
 
-            editModeChanged: /** @type {TypedSignal<[enumLayer]>} */ (new Signal()),
+            editModeChanged: /** @type {TypedSignal<[Layer]>} */ (new Signal()),
 
             // Called to check if an entity can be placed, second parameter is an additional offset.
             // Use to introduce additional placement checks

src/js/game/systems/belt.js

@@ -13,9 +13,8 @@ import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
 import { MapChunkView } from "../map_chunk_view";
 import { defaultBuildingVariant } from "../meta_building";
-import { enumLayer } from "../root";
+
-import { MetaWireBaseBuilding } from "../buildings/wire_base";
+/** @typedef {import("../root").Layer} Layer **/
-import { enumItemType } from "../base_item";
 
 export const BELT_ANIM_COUNT = 28;
 
@@ -310,7 +309,7 @@ export class BeltSystem extends GameSystemWithFilter {
     /**
      * Draws all belt paths
      * @param {DrawParameters} parameters
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     drawLayerBeltItems(parameters, layer) {
         for (let i = 0; i < this.beltPaths.length; ++i) {
@@ -510,13 +509,13 @@ export class BeltSystem extends GameSystemWithFilter {
         }
 
         // Limit speed to avoid belts going backwards
-        const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(enumLayer.regular), 10);
+        const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed("regular"), 10);
 
         // SYNC with systems/item_acceptor.js:drawEntityUnderlays!
         // 126 / 42 is the exact animation speed of the png animation
         const animationIndex = Math.floor(
             ((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
-                globalConfig.beltItemSpacingByLayer[enumLayer.regular]
+                globalConfig.beltItemSpacingByLayer.regular
         );
         const contents = chunk.contents;
         for (let y = 0; y < globalConfig.mapChunkSize; ++y) {

src/js/game/systems/energy_consumer.js

@@ -1,13 +1,14 @@
 import { DrawParameters } from "../../core/draw_parameters";
 import { Loader } from "../../core/loader";
 import { clamp } from "../../core/utils";
-import { enumItemType } from "../base_item";
 import { EnergyConsumerComponent } from "../components/energy_consumer";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
 import { NEGATIVE_ENERGY_ITEM_SINGLETON } from "../items/negative_energy_item";
 import { POSITIVE_ENERGY_ITEM_SINGLETON } from "../items/positive_energy_item";
 
+/** @typedef {import("../base_item").ItemType} ItemType **/
+
 export class EnergyConsumerSystem extends GameSystemWithFilter {
     constructor(root) {
         super(root, [EnergyConsumerComponent]);
@@ -42,13 +43,13 @@ export class EnergyConsumerSystem extends GameSystemWithFilter {
 
     /**
      *
-     * @param {enumItemType} itemType
+     * @param {ItemType} itemType
      */
     getItemSingletonByType(itemType) {
         switch (itemType) {
-            case enumItemType.positiveEnergy:
+            case "positiveEnergy":
                 return POSITIVE_ENERGY_ITEM_SINGLETON;
-            case enumItemType.negativeEnergy:
+            case "negativeEnergy":
                 return NEGATIVE_ENERGY_ITEM_SINGLETON;
             default:
                 assertAlways(false, "Bad item type: " + itemType);

src/js/game/systems/item_acceptor.js

@@ -8,7 +8,10 @@ import { Loader } from "../../core/loader";
 import { drawRotatedSprite } from "../../core/draw_utils";
 import { BELT_ANIM_COUNT } from "./belt";
 import { fastArrayDelete } from "../../core/utils";
-import { enumLayer } from "../root";
+
+/**
+ * @typedef {import("../root").Layer} Layer
+ **/
 
 export class ItemAcceptorSystem extends GameSystemWithFilter {
     constructor(root) {
@@ -53,7 +56,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
     /**
      * Draws the acceptor items
      * @param {DrawParameters} parameters
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     drawLayer(parameters, layer) {
         this.forEachMatchingEntityOnScreen(parameters, this.drawEntityRegularLayer.bind(this, layer));
@@ -62,14 +65,14 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
     /**
      * Draws the acceptor underlays
      * @param {DrawParameters} parameters
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     drawUnderlays(parameters, layer) {
         this.forEachMatchingEntityOnScreen(parameters, this.drawEntityUnderlays.bind(this, layer));
     }
 
     /**
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @param {DrawParameters} parameters
      * @param {Entity} entity
      */
@@ -107,7 +110,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
     }
 
     /**
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @param {DrawParameters} parameters
      * @param {Entity} entity
      */

src/js/game/systems/item_ejector.js

@@ -3,11 +3,12 @@ import { DrawParameters } from "../../core/draw_parameters";
 import { createLogger } from "../../core/logging";
 import { Rectangle } from "../../core/rectangle";
 import { directionRotationMap, directionVectorMap } from "../../core/vector";
-import { BaseItem, enumItemType, enumItemTypeToLayer } from "../base_item";
+import { BaseItem, itemTypeLayerMap } from "../base_item";
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
-import { enumLayer } from "../root";
+
+/** @typedef {import("../root").Layer} Layer **/
 
 const logger = createLogger("systems/ejector");
 
@@ -257,7 +258,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
         // TODO: Kinda hacky. How to solve this properly? Don't want to go through inheritance hell.
         // Also its just a few cases (hope it stays like this .. :x).
 
-        const itemLayer = enumItemTypeToLayer[item.getItemType()];
+        const itemLayer = itemTypeLayerMap[item.getItemType()];
 
         const beltComp = receiver.components.Belt;
         if (beltComp) {
@@ -338,14 +339,14 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
     /**
      * Draws the given layer
      * @param {DrawParameters} parameters
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      */
     drawLayer(parameters, layer) {
         this.forEachMatchingEntityOnScreen(parameters, this.drawSingleEntity.bind(this, layer));
     }
 
     /**
-     * @param {enumLayer} layer
+     * @param {Layer} layer
      * @param {DrawParameters} parameters
      * @param {Entity} entity
      */

src/js/game/systems/item_processor.js

@@ -1,5 +1,5 @@
 import { globalConfig } from "../../core/config";
-import { BaseItem, enumItemType } from "../base_item";
+import { BaseItem } from "../base_item";
 import { colorInvertedMap, colorMixingMap } from "../colors";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
@@ -355,14 +355,14 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             case enumItemProcessorTypes.advancedProcessor: {
                 const item = items[0].item;
 
-                if (item.getItemType() === enumItemType.color) {
+                if (item.getItemType() === "color") {
                     const colorItem = /** @type {ColorItem} */ (items[0].item);
                     const newColor = colorInvertedMap[colorItem.color];
                     outItems.push({
                         item: new ColorItem(newColor),
                         requiredSlot: 0,
                     });
-                } else if (item.getItemType() === enumItemType.shape) {
+                } else if (item.getItemType() === "shape") {
                     const shapeItem = /** @type {ShapeItem} */ (items[0].item);
                     const newItem = this.root.shapeDefinitionMgr.shapeActionInvertColors(
                         shapeItem.definition

src/js/game/systems/miner.js

@@ -6,7 +6,6 @@ import { MinerComponent } from "../components/miner";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
 import { MapChunkView } from "../map_chunk_view";
-import { enumLayer } from "../root";
 
 export class MinerSystem extends GameSystemWithFilter {
     constructor(root) {
@@ -75,7 +74,7 @@ export class MinerSystem extends GameSystemWithFilter {
             const ejectingDirection = staticComp.localDirectionToWorld(ejectingSlot.direction);
 
             const targetTile = ejectingPos.add(directionVectorMap[ejectingDirection]);
-            const targetContents = this.root.map.getTileContent(targetTile, enumLayer.regular);
+            const targetContents = this.root.map.getTileContent(targetTile, "regular");
 
             // Check if we are connected to another miner and thus do not eject directly
             if (targetContents) {

src/js/game/systems/static_map_entity.js

@@ -3,7 +3,6 @@ import { DrawParameters } from "../../core/draw_parameters";
 import { globalConfig } from "../../core/config";
 import { MapChunkView } from "../map_chunk_view";
 import { Loader } from "../../core/loader";
-import { enumLayer } from "../root";
 
 export class StaticMapEntitySystem extends GameSystem {
     constructor(root) {

src/js/game/systems/storage.js

@@ -4,7 +4,6 @@ import { Entity } from "../entity";
 import { DrawParameters } from "../../core/draw_parameters";
 import { formatBigNumber, lerp } from "../../core/utils";
 import { Loader } from "../../core/loader";
-import { enumLayer } from "../root";
 
 export class StorageSystem extends GameSystemWithFilter {
     constructor(root) {
@@ -23,7 +22,7 @@ export class StorageSystem extends GameSystemWithFilter {
                 const ejectorComp = entity.components.ItemEjector;
 
                 /* FIXME: WIRES */
-                const nextSlot = ejectorComp.getFirstFreeSlot(enumLayer.regular);
+                const nextSlot = ejectorComp.getFirstFreeSlot("regular");
                 if (nextSlot !== null) {
                     if (ejectorComp.tryEject(nextSlot, storageComp.storedItem)) {
                         storageComp.storedCount--;

src/js/game/systems/underground_belt.js

@@ -12,7 +12,6 @@ import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
 import { fastArrayDelete } from "../../core/utils";
-import { enumLayer } from "../root";
 
 const logger = createLogger("tunnels");
 
@@ -297,7 +296,7 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
         ) {
             currentTile = currentTile.add(searchVector);
 
-            const potentialReceiver = this.root.map.getTileContent(currentTile, enumLayer.regular);
+            const potentialReceiver = this.root.map.getTileContent(currentTile, "regular");
             if (!potentialReceiver) {
                 // Empty tile
                 continue;

src/js/game/systems/wired_pins.js

@@ -5,7 +5,6 @@ import { Vector } from "../../core/vector";
 import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
-import { enumLayer } from "../root";
 import { STOP_PROPAGATION } from "../../core/signal";
 import { drawRotatedSprite } from "../../core/draw_utils";
 
@@ -43,7 +42,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
 
         // If this entity is placed on the wires layer, make sure we don't
         // place it above a pin
-        if (entity.layer === enumLayer.wires) {
+        if (entity.layer === "wires") {
             for (let x = rect.x; x < rect.x + rect.w; ++x) {
                 for (let y = rect.y; y < rect.y + rect.h; ++y) {
                     // Find which entities are in same tiles of both layers
@@ -108,7 +107,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
             }
 
             // Check if there is any entity on that tile (Wired pins are always on the wires layer)
-            const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, enumLayer.wires);
+            const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, "wires");
 
             // If there's an entity, and it can't get removed -> That's a collision
             if (collidingEntity && !collidingEntity.components.ReplaceableMapEntity) {
@@ -133,7 +132,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
         for (let i = 0; i < pinsComp.slots.length; ++i) {
             const slot = pinsComp.slots[i];
             const worldPos = entity.components.StaticMapEntity.localTileToWorld(slot.pos);
-            const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, enumLayer.wires);
+            const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, "wires");
             if (collidingEntity) {
                 assertAlways(
                     collidingEntity.components.ReplaceableMapEntity,

src/js/savegame/serializer_internal.js

@@ -1,6 +1,6 @@
 import { gComponentRegistry } from "../core/global_registries";
 import { Entity } from "../game/entity";
-import { enumLayer, GameRoot } from "../game/root";
+import { GameRoot, layers } from "../game/root";
 
 // Internal serializer methods
 export class SerializerInternal {
@@ -41,7 +41,7 @@ export class SerializerInternal {
         this.deserializeComponents(entity, payload.components);
         entity.layer = payload.layer;
 
-        if (!enumLayer[payload.layer]) {
+        if (!layers.includes(payload.layer)) {
             assert(false, "Invalid layer: " + payload.layer);
         }