Replace enumItemProcessorTypes with ItemProcessorType

src/js/game/buildings/cutter.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
@@ -39,9 +39,7 @@ export class MetaCutterBuilding extends MetaBuilding {
      */
     getAdditionalStatistics(root, variant) {
         const speed = root.hubGoals.getProcessorBaseSpeed(
-            variant === enumCutterVariants.quad
+            variant === enumCutterVariants.quad ? "cutterQuad" : "cutter"
-                ? enumItemProcessorTypes.cutterQuad
-                : enumItemProcessorTypes.cutter
         );
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
     }
@@ -71,7 +69,7 @@ export class MetaCutterBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 1,
-                processorType: enumItemProcessorTypes.cutter,
+                processorType: "cutter",
             })
         );
         entity.addComponent(new ItemEjectorComponent({}));
@@ -101,7 +99,7 @@ export class MetaCutterBuilding extends MetaBuilding {
                     { pos: new Vector(0, 0), direction: enumDirection.top },
                     { pos: new Vector(1, 0), direction: enumDirection.top },
                 ]);
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter;
+                entity.components.ItemProcessor.type = "cutter";
                 break;
             }
             case enumCutterVariants.quad: {
@@ -111,7 +109,7 @@ export class MetaCutterBuilding extends MetaBuilding {
                     { pos: new Vector(2, 0), direction: enumDirection.top },
                     { pos: new Vector(3, 0), direction: enumDirection.top },
                 ]);
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
+                entity.components.ItemProcessor.type = "cutterQuad";
                 break;
             }
 

src/js/game/buildings/filter.js

@@ -6,7 +6,7 @@ import { GameRoot } from "../root";
 import { LeverComponent } from "../components/lever";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { ItemProcessorComponent, enumItemProcessorTypes } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 
 export class MetaFilterBuilding extends MetaBuilding {
     constructor() {
@@ -78,7 +78,7 @@ export class MetaFilterBuilding extends MetaBuilding {
 
         entity.addComponent(
             new ItemProcessorComponent({
-                processorType: enumItemProcessorTypes.filter,
+                processorType: "filter",
                 inputsPerCharge: 1,
             })
         );

src/js/game/buildings/hub.js

@@ -1,7 +1,7 @@
 import { enumDirection, Vector } from "../../core/vector";
 import { HubComponent } from "../components/hub";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
 import { WiredPinsComponent, enumPinSlotType } from "../components/wired_pins";
@@ -45,7 +45,7 @@ export class MetaHubBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 1,
-                processorType: enumItemProcessorTypes.hub,
+                processorType: "hub",
             })
         );
 

src/js/game/buildings/mixer.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
@@ -35,7 +35,7 @@ export class MetaMixerBuilding extends MetaBuilding {
      * @returns {Array<[string, string]>}
      */
     getAdditionalStatistics(root, variant) {
-        const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.mixer);
+        const speed = root.hubGoals.getProcessorBaseSpeed("mixer");
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
     }
 
@@ -47,7 +47,7 @@ export class MetaMixerBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 2,
-                processorType: enumItemProcessorTypes.mixer,
+                processorType: "mixer",
             })
         );
 

src/js/game/buildings/painter.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
@@ -44,15 +44,15 @@ export class MetaPainterBuilding extends MetaBuilding {
         switch (variant) {
             case defaultBuildingVariant:
             case enumPainterVariants.mirrored: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painter);
+                const speed = root.hubGoals.getProcessorBaseSpeed("painter");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
             }
             case enumPainterVariants.double: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterDouble);
+                const speed = root.hubGoals.getProcessorBaseSpeed("painterDouble");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed, true)]];
             }
             case enumPainterVariants.quad: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterQuad);
+                const speed = root.hubGoals.getProcessorBaseSpeed("painterQuad");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
             }
         }
@@ -84,7 +84,12 @@ export class MetaPainterBuilding extends MetaBuilding {
      * @param {Entity} entity
      */
     setupEntityComponents(entity) {
-        entity.addComponent(new ItemProcessorComponent({}));
+        entity.addComponent(
+            new ItemProcessorComponent({
+                inputsPerCharge: 1,
+                processorType: "splitter",
+            })
+        );
 
         entity.addComponent(
             new ItemEjectorComponent({
@@ -134,7 +139,7 @@ export class MetaPainterBuilding extends MetaBuilding {
                     },
                 ]);
 
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
+                entity.components.ItemProcessor.type = "painter";
                 entity.components.ItemProcessor.inputsPerCharge = 2;
                 entity.components.ItemEjector.setSlots([
                     { pos: new Vector(1, 0), direction: enumDirection.right },
@@ -160,7 +165,7 @@ export class MetaPainterBuilding extends MetaBuilding {
                     },
                 ]);
 
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
+                entity.components.ItemProcessor.type = "painterDouble";
                 entity.components.ItemProcessor.inputsPerCharge = 3;
 
                 entity.components.ItemEjector.setSlots([
@@ -197,7 +202,7 @@ export class MetaPainterBuilding extends MetaBuilding {
                     },
                 ]);
 
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.painterQuad;
+                entity.components.ItemProcessor.type = "painterQuad";
                 entity.components.ItemProcessor.inputsPerCharge = 5;
 
                 entity.components.ItemEjector.setSlots([

src/js/game/buildings/rotater.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
@@ -29,15 +29,15 @@ export class MetaRotaterBuilding extends MetaBuilding {
     getAdditionalStatistics(root, variant) {
         switch (variant) {
             case defaultBuildingVariant: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotater);
+                const speed = root.hubGoals.getProcessorBaseSpeed("rotater");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
             }
             case enumRotaterVariants.ccw: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotaterCCW);
+                const speed = root.hubGoals.getProcessorBaseSpeed("rotaterCCW");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
             }
             case enumRotaterVariants.fl: {
-                const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotaterFL);
+                const speed = root.hubGoals.getProcessorBaseSpeed("rotaterFL");
                 return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
             }
         }
@@ -73,7 +73,7 @@ export class MetaRotaterBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 1,
-                processorType: enumItemProcessorTypes.rotater,
+                processorType: "rotater",
             })
         );
 
@@ -104,15 +104,15 @@ export class MetaRotaterBuilding extends MetaBuilding {
     updateVariants(entity, rotationVariant, variant) {
         switch (variant) {
             case defaultBuildingVariant: {
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater;
+                entity.components.ItemProcessor.type = "rotater";
                 break;
             }
             case enumRotaterVariants.ccw: {
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.rotaterCCW;
+                entity.components.ItemProcessor.type = "rotaterCCW";
                 break;
             }
             case enumRotaterVariants.fl: {
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.rotaterFL;
+                entity.components.ItemProcessor.type = "rotaterFL";
                 break;
             }
             default:

src/js/game/buildings/splitter.js

@@ -1,7 +1,7 @@
 import { enumDirection, Vector } from "../../core/vector";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
 import { GameRoot } from "../root";
@@ -36,7 +36,7 @@ export class MetaSplitterBuilding extends MetaBuilding {
      * @returns {Array<[string, string]>}
      */
     getAdditionalStatistics(root, variant) {
-        const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.splitter);
+        const speed = root.hubGoals.getProcessorBaseSpeed("splitter");
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
     }
 
@@ -79,7 +79,7 @@ export class MetaSplitterBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 1,
-                processorType: enumItemProcessorTypes.splitter,
+                processorType: "splitter",
             })
         );
 

src/js/game/buildings/stacker.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { MetaBuilding } from "../meta_building";
 import { GameRoot } from "../root";
@@ -28,7 +28,7 @@ export class MetaStackerBuilding extends MetaBuilding {
      * @returns {Array<[string, string]>}
      */
     getAdditionalStatistics(root, variant) {
-        const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.stacker);
+        const speed = root.hubGoals.getProcessorBaseSpeed("stacker");
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
     }
 
@@ -47,7 +47,7 @@ export class MetaStackerBuilding extends MetaBuilding {
         entity.addComponent(
             new ItemProcessorComponent({
                 inputsPerCharge: 2,
-                processorType: enumItemProcessorTypes.stacker,
+                processorType: "stacker",
             })
         );
 

src/js/game/buildings/trash.js

@@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
 import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { StorageComponent } from "../components/storage";
 import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
 import { Entity } from "../entity";
@@ -111,7 +111,7 @@ export class MetaTrashBuilding extends MetaBuilding {
                     entity.addComponent(
                         new ItemProcessorComponent({
                             inputsPerCharge: 1,
-                            processorType: enumItemProcessorTypes.trash,
+                            processorType: "trash",
                         })
                     );
                 }
@@ -134,7 +134,7 @@ export class MetaTrashBuilding extends MetaBuilding {
                     },
                 ]);
                 entity.components.ItemEjector.setSlots([]);
-                entity.components.ItemProcessor.type = enumItemProcessorTypes.trash;
+                entity.components.ItemProcessor.type = "trash";
                 break;
             }
             case enumTrashVariants.storage: {

src/js/game/components/item_processor.js

@@ -3,24 +3,24 @@ import { BaseItem } from "../base_item";
 import { Component } from "../component";
 import { typeItemSingleton } from "../item_resolver";
 
-/** @enum {string} */
+/** @enum {ItemProcessorType[]} */
-export const enumItemProcessorTypes = {
+export const itemProcessorTypes = [
-    splitter: "splitter",
+    "splitter",
-    splitterWires: "splitterWires",
+    "splitterWires",
-    cutter: "cutter",
+    "cutter",
-    cutterQuad: "cutterQuad",
+    "cutterQuad",
-    rotater: "rotater",
+    "rotater",
-    rotaterCCW: "rotaterCCW",
+    "rotaterCCW",
-    rotaterFL: "rotaterFL",
+    "rotaterFL",
-    stacker: "stacker",
+    "stacker",
-    trash: "trash",
+    "trash",
-    mixer: "mixer",
+    "mixer",
-    painter: "painter",
+    "painter",
-    painterDouble: "painterDouble",
+    "painterDouble",
-    painterQuad: "painterQuad",
+    "painterQuad",
-    hub: "hub",
+    "hub",
-    filter: "filter",
+    "filter",
-};
+];
 
 export class ItemProcessorComponent extends Component {
     static getId() {
@@ -47,21 +47,14 @@ export class ItemProcessorComponent extends Component {
         };
     }
 
-    duplicateWithoutContents() {
-        return new ItemProcessorComponent({
-            processorType: this.type,
-            inputsPerCharge: this.inputsPerCharge,
-        });
-    }
-
     /**
      *
      * @param {object} param0
-     * @param {enumItemProcessorTypes=} param0.processorType Which type of processor this is
+     * @param {ItemProcessorType} param0.processorType Which type of processor this is
-     * @param {number=} param0.inputsPerCharge How many items this machine needs until it can start working
+     * @param {number} param0.inputsPerCharge How many items this machine needs until it can start working
      *
      */
-    constructor({ processorType = enumItemProcessorTypes.splitter, inputsPerCharge = 1 }) {
+    constructor({ processorType, inputsPerCharge }) {
         super();
 
         // Which slot to emit next, this is only a preference and if it can't emit
@@ -95,13 +88,20 @@ export class ItemProcessorComponent extends Component {
         this.secondsUntilEject = 0;
     }
 
+    duplicateWithoutContents() {
+        return new ItemProcessorComponent({
+            processorType: this.type,
+            inputsPerCharge: this.inputsPerCharge,
+        });
+    }
+
     /**
      * Tries to take the item
      * @param {BaseItem} item
      * @param {number} sourceSlot
      */
     tryTakeItem(item, sourceSlot) {
-        if (this.type === enumItemProcessorTypes.hub || this.type === enumItemProcessorTypes.trash) {
+        if (["hub", "trash"].includes(this.type)) {
             // Hub has special logic .. not really nice but efficient.
             this.inputSlots.push({ item, sourceSlot });
             return true;

src/js/game/hub_goals.js

@@ -2,7 +2,6 @@ import { globalConfig } from "../core/config";
 import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/utils";
 import { BasicSerializableObject, types } from "../savegame/serialization";
 import { enumColors } from "./colors";
-import { enumItemProcessorTypes } from "./components/item_processor";
 import { GameRoot } from "./root";
 import { enumSubShape, ShapeDefinition } from "./shape_definition";
 import { enumHubGoalRewards, tutorialGoals } from "./tutorial_goals";
@@ -391,55 +390,52 @@ export class HubGoals extends BasicSerializableObject {
 
     /**
      * Processor speed
-     * @param {enumItemProcessorTypes} processorType
+     * @param {ItemProcessorType} itemProcessorType
      * @returns {number} items / sec
      */
-    getProcessorBaseSpeed(processorType) {
+    getProcessorBaseSpeed(itemProcessorType) {
-        switch (processorType) {
+        switch (itemProcessorType) {
-            case enumItemProcessorTypes.splitterWires:
+            case "splitterWires":
                 return globalConfig.wiresSpeedItemsPerSecond * 2;
-
+            case "trash":
-            case enumItemProcessorTypes.trash:
+            case "hub":
-            case enumItemProcessorTypes.hub:
                 return 1e30;
-            case enumItemProcessorTypes.splitter:
+            case "splitter":
                 return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt * 2;
-            case enumItemProcessorTypes.filter:
+            case "filter":
                 return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
-
+            case "mixer":
-            case enumItemProcessorTypes.mixer:
+            case "painter":
-            case enumItemProcessorTypes.painter:
+            case "painterDouble":
-            case enumItemProcessorTypes.painterDouble:
+            case "painterQuad": {
-            case enumItemProcessorTypes.painterQuad: {
                 assert(
-                    globalConfig.buildingSpeeds[processorType],
+                    globalConfig.buildingSpeeds.hasOwnProperty(itemProcessorType),
-                    "Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
+                    "Processor type has no speed set in globalConfig.buildingSpeeds: " + itemProcessorType
                 );
                 return (
                     globalConfig.beltSpeedItemsPerSecond *
                     this.upgradeImprovements.painting *
-                    globalConfig.buildingSpeeds[processorType]
+                    globalConfig.buildingSpeeds[itemProcessorType]
                 );
             }
-
+            case "cutter":
-            case enumItemProcessorTypes.cutter:
+            case "cutterQuad":
-            case enumItemProcessorTypes.cutterQuad:
+            case "rotater":
-            case enumItemProcessorTypes.rotater:
+            case "rotaterCCW":
-            case enumItemProcessorTypes.rotaterCCW:
+            case "rotaterFL":
-            case enumItemProcessorTypes.rotaterFL:
+            case "stacker": {
-            case enumItemProcessorTypes.stacker: {
                 assert(
-                    globalConfig.buildingSpeeds[processorType],
+                    globalConfig.buildingSpeeds.hasOwnProperty(itemProcessorType),
-                    "Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
+                    "Processor type has no speed set in globalConfig.buildingSpeeds: " + itemProcessorType
                 );
                 return (
                     globalConfig.beltSpeedItemsPerSecond *
                     this.upgradeImprovements.processors *
-                    globalConfig.buildingSpeeds[processorType]
+                    globalConfig.buildingSpeeds[itemProcessorType]
                 );
             }
             default:
-                assertAlways(false, "invalid processor type: " + processorType);
+                assertAlways(false, "invalid processor type: " + itemProcessorType);
         }
 
         return 1 / globalConfig.beltSpeedItemsPerSecond;

src/js/game/systems/item_ejector.js

@@ -7,7 +7,6 @@ import { BaseItem } from "../base_item";
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
-import { enumItemProcessorTypes } from "../components/item_processor";
 import { MapChunkView } from "../map_chunk_view";
 
 const logger = createLogger("systems/ejector");
@@ -287,7 +286,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
         if (itemProcessorComp) {
             // @todo HACK
             // Check if there are pins, and if so if they are connected
-            if (itemProcessorComp.type === enumItemProcessorTypes.filter) {
+            if (itemProcessorComp.type === "filter") {
                 const pinsComp = receiver.components.WiredPins;
                 if (pinsComp && pinsComp.slots.length === 1) {
                     const network = pinsComp.slots[0].linkedNetwork;

src/js/game/systems/item_processor.js

@@ -1,7 +1,7 @@
 import { globalConfig } from "../../core/config";
 import { BaseItem } from "../base_item";
 import { enumColorMixingResults } from "../colors";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
 import { GameSystemWithFilter } from "../game_system_with_filter";
 import { BOOL_TRUE_SINGLETON } from "../items/boolean_item";
@@ -107,8 +107,8 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
         switch (processorComp.type) {
             // SPLITTER
-            case enumItemProcessorTypes.splitterWires:
+            case "splitterWires":
-            case enumItemProcessorTypes.splitter: {
+            case "splitter": {
                 trackProduction = false;
                 const availableSlots = entity.components.ItemEjector.slots.length;
 
@@ -123,7 +123,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // CUTTER
-            case enumItemProcessorTypes.cutter: {
+            case "cutter": {
                 const inputItem = /** @type {ShapeItem} */ (items[0].item);
                 assert(inputItem instanceof ShapeItem, "Input for cut is not a shape");
                 const inputDefinition = inputItem.definition;
@@ -144,7 +144,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // CUTTER (Quad)
-            case enumItemProcessorTypes.cutterQuad: {
+            case "cutterQuad": {
                 const inputItem = /** @type {ShapeItem} */ (items[0].item);
                 assert(inputItem instanceof ShapeItem, "Input for cut is not a shape");
                 const inputDefinition = inputItem.definition;
@@ -165,7 +165,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // ROTATER
-            case enumItemProcessorTypes.rotater: {
+            case "rotater": {
                 const inputItem = /** @type {ShapeItem} */ (items[0].item);
                 assert(inputItem instanceof ShapeItem, "Input for rotation is not a shape");
                 const inputDefinition = inputItem.definition;
@@ -178,7 +178,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // ROTATER (CCW)
-            case enumItemProcessorTypes.rotaterCCW: {
+            case "rotaterCCW": {
                 const inputItem = /** @type {ShapeItem} */ (items[0].item);
                 assert(inputItem instanceof ShapeItem, "Input for rotation is not a shape");
                 const inputDefinition = inputItem.definition;
@@ -191,7 +191,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // ROTATER (FL)
-            case enumItemProcessorTypes.rotaterFL: {
+            case "rotaterFL": {
                 const inputItem = /** @type {ShapeItem} */ (items[0].item);
                 assert(inputItem instanceof ShapeItem, "Input for rotation is not a shape");
                 const inputDefinition = inputItem.definition;
@@ -205,7 +205,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // STACKER
 
-            case enumItemProcessorTypes.stacker: {
+            case "stacker": {
                 const lowerItem = /** @type {ShapeItem} */ (itemsBySlot[0].item);
                 const upperItem = /** @type {ShapeItem} */ (itemsBySlot[1].item);
 
@@ -224,14 +224,14 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // TRASH
 
-            case enumItemProcessorTypes.trash: {
+            case "trash": {
                 // Well this one is easy .. simply do nothing with the item
                 break;
             }
 
             // MIXER
 
-            case enumItemProcessorTypes.mixer: {
+            case "mixer": {
                 // Find both colors and combine them
                 const item1 = /** @type {ColorItem} */ (items[0].item);
                 const item2 = /** @type {ColorItem} */ (items[1].item);
@@ -256,7 +256,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // PAINTER
 
-            case enumItemProcessorTypes.painter: {
+            case "painter": {
                 const shapeItem = /** @type {ShapeItem} */ (itemsBySlot[0].item);
                 const colorItem = /** @type {ColorItem} */ (itemsBySlot[1].item);
 
@@ -274,7 +274,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // PAINTER (DOUBLE)
 
-            case enumItemProcessorTypes.painterDouble: {
+            case "painterDouble": {
                 const shapeItem1 = /** @type {ShapeItem} */ (itemsBySlot[0].item);
                 const shapeItem2 = /** @type {ShapeItem} */ (itemsBySlot[1].item);
                 const colorItem = /** @type {ColorItem} */ (itemsBySlot[2].item);
@@ -305,7 +305,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // PAINTER (QUAD)
 
-            case enumItemProcessorTypes.painterQuad: {
+            case "painterQuad": {
                 const shapeItem = /** @type {ShapeItem} */ (itemsBySlot[0].item);
                 const colorItem1 = /** @type {ColorItem} */ (itemsBySlot[1].item);
                 const colorItem2 = /** @type {ColorItem} */ (itemsBySlot[2].item);
@@ -331,7 +331,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
             }
 
             // FILTER
-            case enumItemProcessorTypes.filter: {
+            case "filter": {
                 // TODO
                 trackProduction = false;
 
@@ -364,7 +364,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
 
             // HUB
 
-            case enumItemProcessorTypes.hub: {
+            case "hub": {
                 trackProduction = false;
 
                 const hubComponent = entity.components.Hub;

src/js/game/systems/logic_gate.js

@@ -3,7 +3,6 @@ import { GameSystemWithFilter } from "../game_system_with_filter";
 import { BaseItem } from "../base_item";
 import { enumPinSlotType } from "../components/wired_pins";
 import { BOOL_TRUE_SINGLETON, BOOL_FALSE_SINGLETON, BooleanItem } from "../items/boolean_item";
-import { enumItemProcessorTypes } from "../components/item_processor";
 
 export class LogicGateSystem extends GameSystemWithFilter {
     constructor(root) {

src/js/globals.d.ts

@@ -193,8 +193,24 @@ declare interface TypedSignal<T extends Array<any>> {
     removeAll();
 }
 
-declare type Layer = "regular" | "wires";
+declare type ItemProcessorType =
+    | "splitter"
+    | "splitterWires"
+    | "cutter"
+    | "cutterQuad"
+    | "rotater"
+    | "rotaterCCW"
+    | "rotaterFL"
+    | "stacker"
+    | "trash"
+    | "mixer"
+    | "painter"
+    | "painterDouble"
+    | "painterQuad"
+    | "hub"
+    | "filter";
 declare type ItemType = "shape" | "color" | "boolean";
+declare type Layer = "regular" | "wires";
 
 declare module "worker-loader?inline=true&fallback=false!*" {
     class WebpackWorker extends Worker {